diff --git a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.cpp b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.cpp
index 43e32282a7..f437cccdf5 100644
--- a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.cpp
+++ b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.cpp
@@ -1,864 +1,864 @@
 /*===================================================================
 
 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 "mitkConnectomicsNetworkCreator.h"
 
 #include <sstream>
 #include <vector>
 
 #include "mitkConnectomicsConstantsManager.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageStatisticsHolder.h"
 #include "mitkImageCast.h"
 
 #include "itkImageRegionIteratorWithIndex.h"
 
 // VTK
 #include <vtkPolyData.h>
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 
 mitk::ConnectomicsNetworkCreator::ConnectomicsNetworkCreator()
 : m_FiberBundle()
 , m_Segmentation()
 , m_ConNetwork( mitk::ConnectomicsNetwork::New() )
 , idCounter(0)
 , m_LabelToVertexMap()
 , m_LabelToNodePropertyMap()
 , allowLoops( false )
 , m_UseCoMCoordinates( false )
 , m_LabelsToCoordinatesMap()
 , m_MappingStrategy( EndElementPositionAvoidingWhiteMatter )
 , m_EndPointSearchRadius( 10.0 )
 , m_ZeroLabelInvalid( true )
 , m_AbortConnection( false )
 {
 }
 
-mitk::ConnectomicsNetworkCreator::ConnectomicsNetworkCreator( mitk::Image::Pointer segmentation, mitk::FiberBundleX::Pointer fiberBundle )
+mitk::ConnectomicsNetworkCreator::ConnectomicsNetworkCreator( mitk::Image::Pointer segmentation, mitk::FiberBundle::Pointer fiberBundle )
 : m_FiberBundle(fiberBundle)
 , m_Segmentation(segmentation)
 , m_ConNetwork( mitk::ConnectomicsNetwork::New() )
 , idCounter(0)
 , m_LabelToVertexMap()
 , m_LabelToNodePropertyMap()
 , allowLoops( false )
 , m_LabelsToCoordinatesMap()
 , m_MappingStrategy( EndElementPositionAvoidingWhiteMatter )
 , m_EndPointSearchRadius( 10.0 )
 , m_ZeroLabelInvalid( true )
 , m_AbortConnection( false )
 {
   mitk::CastToItkImage( segmentation, m_SegmentationItk );
 }
 
 mitk::ConnectomicsNetworkCreator::~ConnectomicsNetworkCreator()
 {
 }
 
-void mitk::ConnectomicsNetworkCreator::SetFiberBundle(mitk::FiberBundleX::Pointer fiberBundle)
+void mitk::ConnectomicsNetworkCreator::SetFiberBundle(mitk::FiberBundle::Pointer fiberBundle)
 {
   m_FiberBundle = fiberBundle;
 }
 
 void mitk::ConnectomicsNetworkCreator::SetSegmentation(mitk::Image::Pointer segmentation)
 {
   m_Segmentation = segmentation;
   mitk::CastToItkImage( segmentation, m_SegmentationItk );
 }
 
 itk::Point<float, 3> mitk::ConnectomicsNetworkCreator::GetItkPoint(double point[3])
 {
   itk::Point<float, 3> itkPoint;
   itkPoint[0] = point[0];
   itkPoint[1] = point[1];
   itkPoint[2] = point[2];
   return itkPoint;
 }
 
 void mitk::ConnectomicsNetworkCreator::CreateNetworkFromFibersAndSegmentation()
 {
 
   //empty graph
   m_ConNetwork = mitk::ConnectomicsNetwork::New();
   m_LabelToVertexMap.clear();
   m_LabelToNodePropertyMap.clear();
   idCounter = 0;
 
   vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
   vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
   vLines->InitTraversal();
 
   int numFibers = m_FiberBundle->GetNumFibers();
   for( int fiberID( 0 ); fiberID < numFibers; fiberID++ )
   {
     vtkIdType   numPointsInCell(0);
     vtkIdType*  pointsInCell(NULL);
     vLines->GetNextCell ( numPointsInCell, pointsInCell );
 
     TractType::Pointer singleTract = TractType::New();
     for( int pointInCellID( 0 ); pointInCellID < numPointsInCell ; pointInCellID++)
     {
       // push back point
       PointType point = GetItkPoint( fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] ) );
       singleTract->InsertElement( singleTract->Size(), point );
     }
 
     if ( singleTract && ( singleTract->Size() > 0 ) )
     {
       AddConnectionToNetwork(
         ReturnAssociatedVertexPairForLabelPair(
         ReturnLabelForFiberTract( singleTract, m_MappingStrategy )
         )
         );
       m_AbortConnection = false;
     }
   }
 
   // Prune unconnected nodes
   //m_ConNetwork->PruneUnconnectedSingleNodes();
 
   // provide network with geometry
   m_ConNetwork->SetGeometry( dynamic_cast<mitk::BaseGeometry*>(m_Segmentation->GetGeometry()->Clone().GetPointer()) );
   m_ConNetwork->UpdateBounds();
   m_ConNetwork->SetIsModified( true );
 
   MBI_INFO << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_INFO_NETWORK_CREATED;
 }
 
 void mitk::ConnectomicsNetworkCreator::AddConnectionToNetwork(ConnectionType newConnection)
 {
   if( m_AbortConnection )
   {
     MITK_DEBUG << "Connection aborted";
     return;
   }
 
   VertexType vertexA = newConnection.first;
   VertexType vertexB = newConnection.second;
 
   // check for loops (if they are not allowed)
   if( allowLoops || !( vertexA == vertexB ) )
   {
     // If the connection already exists, increment weight, else create connection
     if ( m_ConNetwork->EdgeExists( vertexA, vertexB ) )
     {
       m_ConNetwork->IncreaseEdgeWeight( vertexA, vertexB );
     }
     else
     {
       m_ConNetwork->AddEdge( vertexA, vertexB );
     }
   }
 }
 
 
 mitk::ConnectomicsNetworkCreator::VertexType mitk::ConnectomicsNetworkCreator::ReturnAssociatedVertexForLabel( ImageLabelType label )
 {
   if( m_ZeroLabelInvalid && ( label == 0 ) )
   {
     m_AbortConnection = true;
     return ULONG_MAX;
   }
 
   // if label is not known, create entry
   if( ! ( m_LabelToVertexMap.count( label ) > 0 ) )
   {
     VertexType newVertex = m_ConNetwork->AddVertex( idCounter );
     idCounter++;
     SupplyVertexWithInformation(label, newVertex);
     m_LabelToVertexMap.insert( std::pair< ImageLabelType, VertexType >( label, newVertex ) );
   }
 
   //return associated vertex
   return m_LabelToVertexMap.find( label )->second;
 }
 
 mitk::ConnectomicsNetworkCreator::ConnectionType mitk::ConnectomicsNetworkCreator::ReturnAssociatedVertexPairForLabelPair( ImageLabelPairType labelpair )
 {
   //hand both labels through to the single label function
   ConnectionType connection( ReturnAssociatedVertexForLabel(labelpair.first), ReturnAssociatedVertexForLabel(labelpair.second) );
 
   return connection;
 }
 
 mitk::ConnectomicsNetworkCreator::ImageLabelPairType mitk::ConnectomicsNetworkCreator::ReturnLabelForFiberTract( TractType::Pointer singleTract, mitk::ConnectomicsNetworkCreator::MappingStrategy strategy)
 {
   switch( strategy )
   {
   case EndElementPosition:
     {
       return EndElementPositionLabel( singleTract );
     }
   case JustEndPointVerticesNoLabel:
     {
       return JustEndPointVerticesNoLabelTest( singleTract );
     }
   case EndElementPositionAvoidingWhiteMatter:
     {
       return EndElementPositionLabelAvoidingWhiteMatter( singleTract );
     }
   case PrecomputeAndDistance:
     {
       return PrecomputeVertexLocationsBySegmentation( singleTract );
     }
   }
 
   // To remove warnings, this code should never be reached
   MBI_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_INVALID_MAPPING;
   ImageLabelPairType nullPair( 0,0 );
   return nullPair;
 }
 
 mitk::ConnectomicsNetworkCreator::ImageLabelPairType mitk::ConnectomicsNetworkCreator::EndElementPositionLabel( TractType::Pointer singleTract )
 {
   ImageLabelPairType labelpair;
 
   {// Note: .fib image tracts are safed using index coordinates
     mitk::Point3D firstElementFiberCoord, lastElementFiberCoord;
     mitk::Point3D firstElementSegCoord, lastElementSegCoord;
     itk::Index<3> firstElementSegIndex, lastElementSegIndex;
 
     if( singleTract->front().Size() != 3 )
     {
       MBI_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_INVALID_DIMENSION_NEED_3;
     }
     for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
     {
       firstElementFiberCoord.SetElement( index, singleTract->front().GetElement( index ) );
       lastElementFiberCoord.SetElement( index, singleTract->back().GetElement( index ) );
     }
 
     // convert from fiber index coordinates to segmentation index coordinates
     FiberToSegmentationCoords( firstElementFiberCoord, firstElementSegCoord );
     FiberToSegmentationCoords( lastElementFiberCoord, lastElementSegCoord );
 
     for( int index = 0; index < 3; index++ )
     {
       firstElementSegIndex.SetElement( index, firstElementSegCoord.GetElement( index ) );
       lastElementSegIndex.SetElement( index, lastElementSegCoord.GetElement( index ) );
     }
 
     int firstLabel = m_SegmentationItk->GetPixel(firstElementSegIndex);
     int lastLabel = m_SegmentationItk->GetPixel(lastElementSegIndex );
 
     labelpair.first = firstLabel;
     labelpair.second = lastLabel;
 
     // Add property to property map
     CreateNewNode( firstLabel, firstElementSegIndex, m_UseCoMCoordinates );
     CreateNewNode( lastLabel, lastElementSegIndex, m_UseCoMCoordinates );
   }
 
   return labelpair;
 }
 
 mitk::ConnectomicsNetworkCreator::ImageLabelPairType mitk::ConnectomicsNetworkCreator::PrecomputeVertexLocationsBySegmentation( TractType::Pointer /*singleTract*/ )
 {
   ImageLabelPairType labelpair;
 
   return labelpair;
 }
 
 mitk::ConnectomicsNetworkCreator::ImageLabelPairType mitk::ConnectomicsNetworkCreator::EndElementPositionLabelAvoidingWhiteMatter( TractType::Pointer singleTract )
 {
   ImageLabelPairType labelpair;
 
   {// Note: .fib image tracts are safed using index coordinates
     mitk::Point3D firstElementFiberCoord, lastElementFiberCoord;
     mitk::Point3D firstElementSegCoord, lastElementSegCoord;
     itk::Index<3> firstElementSegIndex, lastElementSegIndex;
 
     if( singleTract->front().Size() != 3 )
     {
       MBI_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_INVALID_DIMENSION_NEED_3;
     }
     for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
     {
       firstElementFiberCoord.SetElement( index, singleTract->front().GetElement( index ) );
       lastElementFiberCoord.SetElement( index, singleTract->back().GetElement( index ) );
     }
 
     // convert from fiber index coordinates to segmentation index coordinates
     FiberToSegmentationCoords( firstElementFiberCoord, firstElementSegCoord );
     FiberToSegmentationCoords( lastElementFiberCoord, lastElementSegCoord );
 
     for( int index = 0; index < 3; index++ )
     {
       firstElementSegIndex.SetElement( index, firstElementSegCoord.GetElement( index ) );
       lastElementSegIndex.SetElement( index, lastElementSegCoord.GetElement( index ) );
     }
 
     int firstLabel = m_SegmentationItk->GetPixel(firstElementSegIndex);
     int lastLabel = m_SegmentationItk->GetPixel(lastElementSegIndex );
 
     // Check whether the labels belong to the white matter (which means, that the fibers ended early)
     bool extendFront(false), extendEnd(false), retractFront(false), retractEnd(false);
     extendFront = !IsNonWhiteMatterLabel( firstLabel );
     extendEnd = !IsNonWhiteMatterLabel( lastLabel );
     retractFront = IsBackgroundLabel( firstLabel );
     retractEnd = IsBackgroundLabel( lastLabel );
 
     //if( extendFront || extendEnd )
     //{
     //MBI_INFO << "Before Start: " << firstLabel << " at " << firstElementSegIndex[ 0 ] << " " << firstElementSegIndex[ 1 ] << " " << firstElementSegIndex[ 2 ] << " End: " << lastLabel << " at " << lastElementSegIndex[ 0 ] << " " << lastElementSegIndex[ 1 ] << " " << lastElementSegIndex[ 2 ];
     //}
     if ( extendFront )
     {
       std::vector< int > indexVectorOfPointsToUse;
 
       //Use first two points for direction
       indexVectorOfPointsToUse.push_back( 1 );
       indexVectorOfPointsToUse.push_back( 0 );
 
       // label and coordinate temp storage
       int tempLabel( firstLabel );
       itk::Index<3> tempIndex = firstElementSegIndex;
 
       LinearExtensionUntilGreyMatter( indexVectorOfPointsToUse, singleTract, tempLabel, tempIndex );
 
       firstLabel = tempLabel;
       firstElementSegIndex = tempIndex;
 
     }
 
     if ( extendEnd )
     {
       std::vector< int > indexVectorOfPointsToUse;
 
       //Use last two points for direction
       indexVectorOfPointsToUse.push_back( singleTract->Size() - 2 );
       indexVectorOfPointsToUse.push_back( singleTract->Size() - 1 );
 
       // label and coordinate temp storage
       int tempLabel( lastLabel );
       itk::Index<3> tempIndex = lastElementSegIndex;
 
       LinearExtensionUntilGreyMatter( indexVectorOfPointsToUse, singleTract, tempLabel, tempIndex );
 
       lastLabel = tempLabel;
       lastElementSegIndex = tempIndex;
     }
         if ( retractFront )
     {
       // label and coordinate temp storage
       int tempLabel( firstLabel );
       itk::Index<3> tempIndex = firstElementSegIndex;
 
       RetractionUntilBrainMatter( true, singleTract, tempLabel, tempIndex );
 
       firstLabel = tempLabel;
       firstElementSegIndex = tempIndex;
 
     }
 
     if ( retractEnd )
     {
       // label and coordinate temp storage
       int tempLabel( lastLabel );
       itk::Index<3> tempIndex = lastElementSegIndex;
 
       RetractionUntilBrainMatter( false, singleTract, tempLabel, tempIndex );
 
       lastLabel = tempLabel;
       lastElementSegIndex = tempIndex;
     }
     //if( extendFront || extendEnd )
     //{
     //    MBI_INFO << "After Start: " << firstLabel << " at " << firstElementSegIndex[ 0 ] << " " << firstElementSegIndex[ 1 ] << " " << firstElementSegIndex[ 2 ] << " End: " << lastLabel << " at " << lastElementSegIndex[ 0 ] << " " << lastElementSegIndex[ 1 ] << " " << lastElementSegIndex[ 2 ];
     //}
 
     labelpair.first = firstLabel;
     labelpair.second = lastLabel;
 
     // Add property to property map
     CreateNewNode( firstLabel, firstElementSegIndex, m_UseCoMCoordinates );
     CreateNewNode( lastLabel, lastElementSegIndex, m_UseCoMCoordinates );
   }
 
   return labelpair;
 }
 
 mitk::ConnectomicsNetworkCreator::ImageLabelPairType mitk::ConnectomicsNetworkCreator::JustEndPointVerticesNoLabelTest( TractType::Pointer singleTract )
 {
   ImageLabelPairType labelpair;
 
    {// Note: .fib image tracts are safed using index coordinates
     mitk::Point3D firstElementFiberCoord, lastElementFiberCoord;
     mitk::Point3D firstElementSegCoord, lastElementSegCoord;
     itk::Index<3> firstElementSegIndex, lastElementSegIndex;
 
     if( singleTract->front().Size() != 3 )
     {
       MBI_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_INVALID_DIMENSION_NEED_3;
     }
     for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
     {
       firstElementFiberCoord.SetElement( index, singleTract->front().GetElement( index ) );
       lastElementFiberCoord.SetElement( index, singleTract->back().GetElement( index ) );
     }
 
     // convert from fiber index coordinates to segmentation index coordinates
     FiberToSegmentationCoords( firstElementFiberCoord, firstElementSegCoord );
     FiberToSegmentationCoords( lastElementFiberCoord, lastElementSegCoord );
 
     for( int index = 0; index < 3; index++ )
     {
       firstElementSegIndex.SetElement( index, firstElementSegCoord.GetElement( index ) );
       lastElementSegIndex.SetElement( index, lastElementSegCoord.GetElement( index ) );
     }
 
     int firstLabel = 1 * firstElementSegIndex[ 0 ] + 1000 * firstElementSegIndex[ 1 ] + 1000000 * firstElementSegIndex[ 2 ];
     int lastLabel = 1 * firstElementSegIndex[ 0 ] + 1000 * firstElementSegIndex[ 1 ] + 1000000 * firstElementSegIndex[ 2 ];
 
     labelpair.first = firstLabel;
     labelpair.second = lastLabel;
 
     // Add property to property map
     CreateNewNode( firstLabel, firstElementSegIndex, m_UseCoMCoordinates );
     CreateNewNode( lastLabel, lastElementSegIndex, m_UseCoMCoordinates );
   }
 
   return labelpair;
 }
 
 void mitk::ConnectomicsNetworkCreator::SupplyVertexWithInformation( ImageLabelType& label, VertexType& vertex )
 { // supply a vertex with the additional information belonging to the label
 
   // TODO: Implement additional information acquisition
 
   m_ConNetwork->SetLabel( vertex, m_LabelToNodePropertyMap.find( label )->second.label );
   m_ConNetwork->SetCoordinates( vertex, m_LabelToNodePropertyMap.find( label )->second.coordinates );
 
 }
 
 std::string mitk::ConnectomicsNetworkCreator::LabelToString( ImageLabelType& label )
 {
   int tempInt = (int) label;
   std::stringstream ss;//create a stringstream
   std::string tempString;
   ss << tempInt;//add number to the stream
   tempString = ss.str();
   return tempString;//return a string with the contents of the stream
 }
 
 mitk::ConnectomicsNetwork::Pointer mitk::ConnectomicsNetworkCreator::GetNetwork()
 {
   return m_ConNetwork;
 }
 
 void mitk::ConnectomicsNetworkCreator::FiberToSegmentationCoords( mitk::Point3D& fiberCoord, mitk::Point3D& segCoord )
 {
   mitk::Point3D tempPoint;
 
   // convert from fiber index coordinates to segmentation index coordinates
   m_FiberBundle->GetGeometry()->IndexToWorld( fiberCoord, tempPoint );
   m_Segmentation->GetGeometry()->WorldToIndex( tempPoint, segCoord );
 }
 
 void mitk::ConnectomicsNetworkCreator::SegmentationToFiberCoords( mitk::Point3D& segCoord, mitk::Point3D& fiberCoord )
 {
   mitk::Point3D tempPoint;
 
   // convert from fiber index coordinates to segmentation index coordinates
   m_Segmentation->GetGeometry()->IndexToWorld( segCoord, tempPoint );
   m_FiberBundle->GetGeometry()->WorldToIndex( tempPoint, fiberCoord );
 }
 
 bool mitk::ConnectomicsNetworkCreator::IsNonWhiteMatterLabel( int labelInQuestion )
 {
   bool isWhite( false );
 
   isWhite = (
     ( labelInQuestion == freesurfer_Left_Cerebral_White_Matter )   ||
     ( labelInQuestion == freesurfer_Left_Cerebellum_White_Matter ) ||
     ( labelInQuestion == freesurfer_Right_Cerebral_White_Matter )  ||
     ( labelInQuestion == freesurfer_Right_Cerebellum_White_Matter )||
     ( labelInQuestion == freesurfer_Left_Cerebellum_Cortex )       ||
     ( labelInQuestion == freesurfer_Right_Cerebellum_Cortex )      ||
     ( labelInQuestion == freesurfer_Brain_Stem )
     );
 
   return !isWhite;
 }
 
 bool mitk::ConnectomicsNetworkCreator::IsBackgroundLabel( int labelInQuestion )
 {
   bool isBackground( false );
 
   isBackground = ( labelInQuestion == 0 );
 
   return isBackground;
 }
 
 void mitk::ConnectomicsNetworkCreator::LinearExtensionUntilGreyMatter(
   std::vector<int> & indexVectorOfPointsToUse,
   TractType::Pointer singleTract,
   int & label,
   itk::Index<3> & mitkIndex )
 {
   if( indexVectorOfPointsToUse.size() > singleTract->Size() )
   {
     MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_MORE_POINTS_THAN_PRESENT;
     return;
   }
 
   if( indexVectorOfPointsToUse.size() < 2 )
   {
     MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_ESTIMATING_LESS_THAN_2;
     return;
   }
 
   for( unsigned int index( 0 ); index < indexVectorOfPointsToUse.size(); index++ )
   {
     if( indexVectorOfPointsToUse[ index ] < 0 )
     {
       MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_ESTIMATING_BEYOND_START;
       return;
     }
     if( (unsigned int)indexVectorOfPointsToUse[ index ] > singleTract->Size() )
     {
       MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_ESTIMATING_BEYOND_END;
       return;
     }
   }
 
   mitk::Point3D startPoint, endPoint;
   std::vector< double > differenceVector;
   differenceVector.resize( singleTract->front().Size() );
 
   {
     // which points to use, currently only last two //TODO correct using all points
     int endPointIndex = indexVectorOfPointsToUse.size() - 1;
     int startPointIndex = indexVectorOfPointsToUse.size() - 2;
 
     // convert to segmentation coords
     mitk::Point3D startFiber, endFiber;
     for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
     {
       endFiber.SetElement( index, singleTract->GetElement( indexVectorOfPointsToUse[ endPointIndex ] ).GetElement( index ) );
       startFiber.SetElement( index, singleTract->GetElement( indexVectorOfPointsToUse[ startPointIndex ] ).GetElement( index ) );
     }
 
     FiberToSegmentationCoords( endFiber, endPoint );
     FiberToSegmentationCoords( startFiber, startPoint );
 
     // calculate straight line
 
     for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
     {
       differenceVector[ index ] = endPoint.GetElement( index ) - startPoint.GetElement( index );
     }
 
     // normalizing direction vector
 
     double length( 0.0 );
     double sum( 0.0 );
 
     for( unsigned int index = 0; index < differenceVector.size() ; index++ )
     {
       sum = sum + differenceVector[ index ] * differenceVector[ index ];
     }
 
     length = std::sqrt( sum );
 
     for( unsigned int index = 0; index < differenceVector.size() ; index++ )
     {
       differenceVector[ index ] = differenceVector[ index ] / length;
     }
 
     // follow line until first non white matter label
     itk::Index<3> tempIndex;
     int tempLabel( label );
 
     bool keepOn( true );
 
     itk::ImageRegion<3> itkRegion = m_SegmentationItk->GetLargestPossibleRegion();
 
     for( int parameter( 0 ) ; keepOn ; parameter++ )
     {
       if( parameter > 1000 )
       {
         MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_DID_NOT_FIND_WHITE;
         break;
       }
 
       for( int index( 0 ); index < 3; index++ )
       {
         tempIndex.SetElement( index, endPoint.GetElement( index ) + parameter * differenceVector[ index ] );
       }
 
       if( itkRegion.IsInside( tempIndex ) )
       {
         tempLabel = m_SegmentationItk->GetPixel( tempIndex );
       }
       else
       {
         tempLabel = -1;
       }
 
       if( IsNonWhiteMatterLabel( tempLabel ) )
       {
         if( tempLabel < 1 )
         {
           keepOn = false;
           //MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_NOT_EXTEND_TO_WHITE;
         }
         else
         {
           label = tempLabel;
           mitkIndex = tempIndex;
           keepOn = false;
         }
       }
     }
 
   }
 }
 
 void mitk::ConnectomicsNetworkCreator::RetractionUntilBrainMatter( bool retractFront, TractType::Pointer singleTract,
                                                                   int & label, itk::Index<3> & mitkIndex )
 {
   int retractionStartIndex( singleTract->Size() - 1 );
   int retractionStepIndexSize( -1 );
   int retractionTerminationIndex( 0 );
 
   if( retractFront )
   {
     retractionStartIndex = 0;
     retractionStepIndexSize = 1;
     retractionTerminationIndex = singleTract->Size() - 1;
   }
 
   int currentRetractionIndex = retractionStartIndex;
 
   bool keepRetracting( true );
 
   mitk::Point3D currentPoint, nextPoint;
   std::vector< double > differenceVector;
   differenceVector.resize( singleTract->front().Size() );
 
   while( keepRetracting && ( currentRetractionIndex != retractionTerminationIndex ) )
   {
     // convert to segmentation coords
     mitk::Point3D currentPointFiberCoord, nextPointFiberCoord;
     for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
     {
       currentPointFiberCoord.SetElement( index, singleTract->GetElement( currentRetractionIndex ).GetElement( index ) );
       nextPointFiberCoord.SetElement( index, singleTract->GetElement( currentRetractionIndex + retractionStepIndexSize ).GetElement( index ) );
     }
 
     FiberToSegmentationCoords( currentPointFiberCoord, currentPoint );
     FiberToSegmentationCoords( nextPointFiberCoord, nextPoint );
 
     // calculate straight line
 
     for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
     {
       differenceVector[ index ] = nextPoint.GetElement( index ) - currentPoint.GetElement( index );
     }
 
     // calculate length of direction vector
 
     double length( 0.0 );
     double sum( 0.0 );
 
     for( unsigned int index = 0; index < differenceVector.size() ; index++ )
     {
       sum = sum + differenceVector[ index ] * differenceVector[ index ];
     }
 
     length = std::sqrt( sum );
 
     // retract
     itk::Index<3> tempIndex;
     int tempLabel( label );
 
     for( int parameter( 0 ) ; parameter < length ; parameter++ )
     {
 
       for( int index( 0 ); index < 3; index++ )
       {
         tempIndex.SetElement( index,
           currentPoint.GetElement( index ) + ( 1.0 + parameter ) / ( 1.0 + length ) * differenceVector[ index ] );
       }
 
       tempLabel = m_SegmentationItk->GetPixel( tempIndex );
 
       if( !IsBackgroundLabel( tempLabel ) )
       {
         // check whether result is within the search space
         {
           mitk::Point3D endPoint, foundPointSegmentation, foundPointFiber;
           for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
           {
             // this is in fiber (world) coordinates
             endPoint.SetElement( index, singleTract->GetElement( retractionStartIndex ).GetElement( index ) );
           }
 
           for( int index( 0 ); index < 3; index++ )
           {
             foundPointSegmentation.SetElement( index,
               currentPoint.GetElement( index ) + ( 1.0 + parameter ) / ( 1.0 + length ) * differenceVector[ index ] );
           }
 
           SegmentationToFiberCoords( foundPointSegmentation, foundPointFiber );
 
           std::vector< double > finalDistance;
           finalDistance.resize( singleTract->front().Size() );
           for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
           {
             finalDistance[ index ] = foundPointFiber.GetElement( index ) - endPoint.GetElement( index );
           }
 
           // calculate length of direction vector
 
           double finalLength( 0.0 );
           double finalSum( 0.0 );
 
           for( unsigned int index = 0; index < finalDistance.size() ; index++ )
           {
             finalSum = finalSum + finalDistance[ index ] * finalDistance[ index ];
           }
           finalLength = std::sqrt( finalSum );
 
           if( finalLength > m_EndPointSearchRadius )
           {
             // the found point was not within the search space
             return;
           }
         }
 
         label = tempLabel;
         mitkIndex = tempIndex;
         return;
       }
       // hit next point without finding brain matter
       currentRetractionIndex = currentRetractionIndex + retractionStepIndexSize;
       if( ( currentRetractionIndex < 1 ) || ( (unsigned int)currentRetractionIndex > ( singleTract->Size() - 2 ) ) )
       {
         keepRetracting = false;
       }
     }
   }
 }
 
 void mitk::ConnectomicsNetworkCreator::CalculateCenterOfMass()
 {
 
   const int dimensions = 3;
   int max = m_Segmentation->GetStatistics()->GetScalarValueMax();
   int min = m_Segmentation->GetStatistics()->GetScalarValueMin();
 
   int range = max - min +1;
 
   // each label owns a vector of coordinates
   std::vector< std::vector< std::vector< double> > > coordinatesPerLabelVector;
   coordinatesPerLabelVector.resize( range );
 
   itk::ImageRegionIteratorWithIndex<ITKImageType> it_itkImage( m_SegmentationItk, m_SegmentationItk->GetLargestPossibleRegion() );
 
   for( it_itkImage.GoToBegin(); !it_itkImage.IsAtEnd(); ++it_itkImage )
   {
     std::vector< double > coordinates;
     coordinates.resize(dimensions);
 
     itk::Index< dimensions > index = it_itkImage.GetIndex();
 
     for( int loop(0); loop < dimensions; loop++)
     {
       coordinates.at( loop ) = index.GetElement( loop );
     }
 
     // add the coordinates to the corresponding label vector
     coordinatesPerLabelVector.at( it_itkImage.Value() - min ).push_back( coordinates );
   }
 
   for(int currentIndex(0), currentLabel( min ); currentIndex < range; currentIndex++, currentLabel++ )
   {
     std::vector< double > currentCoordinates;
     currentCoordinates.resize(dimensions);
 
     int numberOfPoints = coordinatesPerLabelVector.at( currentIndex ).size();
 
     std::vector< double > sumCoords;
     sumCoords.resize( dimensions );
 
     for( int loop(0); loop < numberOfPoints; loop++ )
     {
       for( int loopDimension( 0 ); loopDimension < dimensions; loopDimension++ )
       {
         sumCoords.at( loopDimension ) += coordinatesPerLabelVector.at( currentIndex ).at( loop ).at( loopDimension );
       }
     }
 
     for( int loopDimension( 0 ); loopDimension < dimensions; loopDimension++ )
     {
       currentCoordinates.at( loopDimension ) = sumCoords.at( loopDimension ) / numberOfPoints;
     }
 
     m_LabelsToCoordinatesMap.insert( std::pair< int, std::vector<double> >( currentLabel, currentCoordinates ) );
   }
 
   //can now use center of mass coordinates
   m_UseCoMCoordinates = true;
 }
 
 std::vector< double >  mitk::ConnectomicsNetworkCreator::GetCenterOfMass( int label )
 {
   // if label is not known, warn
   if( ! ( m_LabelsToCoordinatesMap.count( label ) > 0 ) )
   {
     MITK_ERROR << "Label " << label << " not found. Could not return coordinates.";
     std::vector< double > nullVector;
     nullVector.resize(3);
     return nullVector;
   }
 
   //return associated coordinates
   return m_LabelsToCoordinatesMap.find( label )->second;
 }
 
 void mitk::ConnectomicsNetworkCreator::CreateNewNode( int label, itk::Index<3> index, bool useCoM )
 {
   // Only create node if it does not exist yet
 
   if( ! ( m_LabelToNodePropertyMap.count( label ) > 0 ) )
   {
     NetworkNode newNode;
 
     newNode.coordinates.resize( 3 );
     if( !useCoM )
     {
       for( unsigned int loop = 0; loop < newNode.coordinates.size() ; loop++ )
       {
         newNode.coordinates[ loop ] = index[ loop ] ;
       }
     }
     else
     {
       std::vector<double> labelCoords = GetCenterOfMass( label );
       for( unsigned int loop = 0; loop < newNode.coordinates.size() ; loop++ )
       {
         newNode.coordinates[ loop ] = labelCoords.at( loop ) ;
       }
     }
 
     newNode.label = LabelToString( label );
 
     m_LabelToNodePropertyMap.insert( std::pair< ImageLabelType, NetworkNode >( label, newNode ) );
   }
 }
diff --git a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.h b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.h
index 8a956f4c8b..4856ee80f1 100644
--- a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.h
+++ b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.h
@@ -1,249 +1,249 @@
 /*===================================================================
 
 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 mitkConnectomicsNetworkCreator_h
 #define mitkConnectomicsNetworkCreator_h
 
 #include <itkObject.h>
 #include <itkObjectFactory.h>
 #include <itkMacro.h>
 
 #include "mitkCommon.h"
 #include "mitkImage.h"
 
-#include "mitkFiberBundleX.h"
+#include "mitkFiberBundle.h"
 #include "mitkConnectomicsNetwork.h"
 
 #include <MitkConnectomicsExports.h>
 
 namespace mitk
 {
 
   /**
     * \brief Creates connectomics networks from fibers and parcellation
     *
     * This class needs a parcellation image and a fiber image to be set. Then you can create
     * a connectomics network from the two, using different strategies.
     */
 
   class MitkConnectomics_EXPORT ConnectomicsNetworkCreator : public itk::Object
   {
   public:
 
     /** Enum for different ways to create the mapping from fibers to network */
 
     enum MappingStrategy
     {
       EndElementPosition,
       EndElementPositionAvoidingWhiteMatter,
       JustEndPointVerticesNoLabel,
       PrecomputeAndDistance
     };
 
     /** Standard class typedefs. */
     /** Method for creation through the object factory. */
 
     mitkClassMacro(ConnectomicsNetworkCreator, itk::Object);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
 
     /** Type for Images **/
     typedef itk::Image<int, 3 > ITKImageType;
 
     /** Types for the standardized Tract **/
     typedef itk::Point<float,3>                                          PointType;
     typedef itk::VectorContainer<unsigned int, PointType>                TractType;
     typedef itk::VectorContainer< unsigned int, TractType::Pointer >     TractContainerType; //init via smartpointer
 
 
     /** Types for Network **/
     typedef mitk::ConnectomicsNetwork::VertexDescriptorType VertexType;
     typedef mitk::ConnectomicsNetwork::EdgeDescriptorType EdgeType;
     typedef mitk::ConnectomicsNetwork::NetworkNode NetworkNode;
     typedef std::pair< VertexType, VertexType >       ConnectionType;
 
     /** Types for labels **/
     typedef int                                             ImageLabelType;
     typedef std::pair< ImageLabelType, ImageLabelType >     ImageLabelPairType;
 
     /** Given a fiber bundle and a parcellation are set, this will create a network from both */
     void CreateNetworkFromFibersAndSegmentation();
-    void SetFiberBundle(mitk::FiberBundleX::Pointer fiberBundle);
+    void SetFiberBundle(mitk::FiberBundle::Pointer fiberBundle);
     void SetSegmentation(mitk::Image::Pointer segmentation);
 
     mitk::ConnectomicsNetwork::Pointer GetNetwork();
 
     itkSetMacro(MappingStrategy, MappingStrategy);
     itkSetMacro(EndPointSearchRadius, double);
     itkSetMacro(ZeroLabelInvalid, bool);
 
     /** \brief Calculate the locations of vertices
      *
      * Calculate the center of mass for each label and store the information. This will need a set parcellation image.
      * Unless this function is called the first location where a label is encountered will be used. After calling this function
      * the center of mass will be used instead.
      */
     void CalculateCenterOfMass();
 
   protected:
 
     //////////////////// Functions ///////////////////////
     ConnectomicsNetworkCreator();
-    ConnectomicsNetworkCreator( mitk::Image::Pointer segmentation, mitk::FiberBundleX::Pointer fiberBundle );
+    ConnectomicsNetworkCreator( mitk::Image::Pointer segmentation, mitk::FiberBundle::Pointer fiberBundle );
     ~ConnectomicsNetworkCreator();
 
     /** Add a connection to the network */
     void AddConnectionToNetwork(ConnectionType newConnection);
 
     /** Determine if a label is already identified with a vertex, otherwise create a new one */
     VertexType ReturnAssociatedVertexForLabel( ImageLabelType label );
 
     /** Return the vertexes associated with a pair of labels */
     ConnectionType ReturnAssociatedVertexPairForLabelPair( ImageLabelPairType labelpair );
 
     /** Return the pair of labels which identify the areas connected by a single fiber */
     ImageLabelPairType ReturnLabelForFiberTract( TractType::Pointer singleTract, MappingStrategy strategy );
 
     /** Assign the additional information which should be part of the vertex */
     void SupplyVertexWithInformation( ImageLabelType& label, VertexType& vertex );
 
     /** Create a string from the label */
     std::string LabelToString( ImageLabelType& label );
 
     /** Check whether the label in question belongs to white matter according to the freesurfer table */
     bool IsNonWhiteMatterLabel( int labelInQuestion );
 
     /** Check whether the label in question belongs to background according to the freesurfer table */
     bool IsBackgroundLabel( int labelInQuestion );
 
     /** Extend a straight line through the given points and look for the first non white matter label
 
     It will try extend in the direction of the points in the vector so a vector {B,C} will result in
     extending from C in the direction C-B */
     void LinearExtensionUntilGreyMatter( std::vector<int> & indexVectorOfPointsToUse, TractType::Pointer singleTract,
       int & label, itk::Index<3> & mitkIndex );
 
     /** Retract fiber until the first brain matter label is hit
 
     The bool parameter controls whether the front or the end is retracted */
     void RetractionUntilBrainMatter( bool retractFront, TractType::Pointer singleTract,
       int & label, itk::Index<3> & mitkIndex );
 
     /** \brief Get the location of the center of mass for a specific label
      * This can throw an exception if the label is not found.
      */
     std::vector< double > GetCenterOfMass( int label );
 
     /** Convert point to itk point */
     itk::Point<float, 3> GetItkPoint(double point[3]);
 
     /** \brief Creates a new node
      *
      * A new node will be created, using the label and either the supplied coordinates
      * or the center of mass coordinates, depending on the supplied bool.
      */
     void CreateNewNode( int label, itk::Index<3>, bool useIndex );
 
     ///////// Mapping strategies //////////
 
     /** Use the position of the end and starting element only to map to labels
 
     Map a fiber to a vertex by taking the value of the parcellation image at the same world coordinates as the last
     and first element of the tract.*/
     ImageLabelPairType EndElementPositionLabel( TractType::Pointer singleTract );
 
     /** Map by distance between elements and vertices depending on their volume
 
     First go through the parcellation and compute the coordinates of the future vertices. Assign a radius according on their volume.
     Then map an edge to a label by considering the nearest vertices and comparing the distance to them to their radii. */
     ImageLabelPairType PrecomputeVertexLocationsBySegmentation( TractType::Pointer singleTract );
 
         /** Use the position of the end and starting element only to map to labels
 
     Just take first and last position, no labelling, nothing */
     ImageLabelPairType JustEndPointVerticesNoLabelTest( TractType::Pointer singleTract );
 
     /** Use the position of the end and starting element unless it is in white matter, then search for nearby parcellation to map to labels
 
     Map a fiber to a vertex by taking the value of the parcellation image at the same world coordinates as the last
     and first element of the tract. If this happens to be white matter, then try to extend the fiber in a line and
     take the first non-white matter parcel, that is intersected. */
     ImageLabelPairType EndElementPositionLabelAvoidingWhiteMatter( TractType::Pointer singleTract );
 
     ///////// Conversions //////////
     /** Convert fiber index to segmentation index coordinates */
     void FiberToSegmentationCoords( mitk::Point3D& fiberCoord, mitk::Point3D& segCoord );
     /** Convert segmentation index to fiber index coordinates */
     void SegmentationToFiberCoords( mitk::Point3D& segCoord, mitk::Point3D& fiberCoord );
 
     /////////////////////// Variables ////////////////////////
-    mitk::FiberBundleX::Pointer m_FiberBundle;
+    mitk::FiberBundle::Pointer m_FiberBundle;
     mitk::Image::Pointer m_Segmentation;
     ITKImageType::Pointer m_SegmentationItk;
 
     // the graph itself
     mitk::ConnectomicsNetwork::Pointer m_ConNetwork;
 
     // the id counter
     int idCounter;
 
     // the map mapping labels to vertices
     std::map< ImageLabelType, VertexType > m_LabelToVertexMap;
 
     // mapping labels to additional information
     std::map< ImageLabelType, NetworkNode > m_LabelToNodePropertyMap;
 
     // toggles whether edges between a node and itself can exist
     bool allowLoops;
 
     // toggles whether to use the center of mass coordinates
     bool m_UseCoMCoordinates;
 
     // stores the coordinates of labels
     std::map< int, std::vector< double> > m_LabelsToCoordinatesMap;
 
     // the straty to use for mapping
     MappingStrategy m_MappingStrategy;
 
     // search radius for finding a non white matter/background area. Should be in mm
     double m_EndPointSearchRadius;
 
     // toggles whether a node with the label 0 may be present
     bool m_ZeroLabelInvalid;
 
     // used internally to communicate a connection should not be added if the a problem
     // is encountered while adding it
     bool m_AbortConnection;
 
     //////////////////////// IDs ////////////////////////////
 
     // These IDs are the freesurfer ids used in parcellation
 
     static const int freesurfer_Left_Cerebral_White_Matter = 2;
     static const int freesurfer_Left_Cerebellum_White_Matter = 7;
     static const int freesurfer_Left_Cerebellum_Cortex = 8;
     static const int freesurfer_Brain_Stem = 16;
     static const int freesurfer_Right_Cerebral_White_Matter = 41;
     static const int freesurfer_Right_Cerebellum_White_Matter = 46;
     static const int freesurfer_Right_Cerebellum_Cortex = 47;
 
 
   };
 
 }// end namespace mitk
 
 #endif // _mitkConnectomicsNetworkCreator_H_INCLUDED
diff --git a/Modules/DiffusionImaging/Connectomics/Testing/mitkConnectomicsNetworkCreationTest.cpp b/Modules/DiffusionImaging/Connectomics/Testing/mitkConnectomicsNetworkCreationTest.cpp
index 010261f01e..1af41ca778 100644
--- a/Modules/DiffusionImaging/Connectomics/Testing/mitkConnectomicsNetworkCreationTest.cpp
+++ b/Modules/DiffusionImaging/Connectomics/Testing/mitkConnectomicsNetworkCreationTest.cpp
@@ -1,113 +1,113 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Testing
 #include "mitkTestingMacros.h"
 #include "mitkTestFixture.h"
 
 // std includes
 #include <string>
 
 // MITK includes
 #include "mitkConnectomicsNetworkCreator.h"
 #include "mitkIOUtil.h"
 
 // VTK includes
 #include <vtkDebugLeaks.h>
 
 class mitkConnectomicsNetworkCreationTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkConnectomicsNetworkCreationTestSuite);
 
   /// \todo Fix VTK memory leaks. Bug 18097.
   vtkDebugLeaks::SetExitError(0);
 
   MITK_TEST(CreateNetworkFromFibersAndParcellation);
   CPPUNIT_TEST_SUITE_END();
 
 private:
 
   std::string m_ParcellationPath;
   std::string m_FiberPath;
   std::string m_ReferenceNetworkPath;
 
 public:
 
   /**
   * @brief Setup Always call this method before each Test-case to ensure correct and new intialization of the used members for a new test case. (If the members are not used in a test, the method does not need to be called).
   */
   void setUp()
   {
     m_ReferenceNetworkPath = GetTestDataFilePath("DiffusionImaging/Connectomics/reference.cnf");
     m_ParcellationPath = GetTestDataFilePath("DiffusionImaging/Connectomics/parcellation.nrrd");
     m_FiberPath = GetTestDataFilePath("DiffusionImaging/Connectomics/fiberBundle.fib");
   }
 
   void tearDown()
   {
     m_ReferenceNetworkPath = "";
     m_ParcellationPath = "";
     m_FiberPath = "";
   }
 
   void CreateNetworkFromFibersAndParcellation()
   {
     // load fiber image
     std::vector<mitk::BaseData::Pointer> fiberInfile = mitk::IOUtil::Load( m_FiberPath );
     if( fiberInfile.empty() )
     {
       std::string errorMessage = "Fiber Image at " + m_FiberPath + " could not be read. Aborting.";
       CPPUNIT_ASSERT_MESSAGE( errorMessage, false );
     }
     mitk::BaseData* fiberBaseData = fiberInfile.at(0);
-    mitk::FiberBundleX* fiberBundle = dynamic_cast<mitk::FiberBundleX*>( fiberBaseData );
+    mitk::FiberBundle* fiberBundle = dynamic_cast<mitk::FiberBundle*>( fiberBaseData );
 
     // load parcellation
     std::vector<mitk::BaseData::Pointer> parcellationInFile = mitk::IOUtil::Load( m_ParcellationPath );
     if( parcellationInFile.empty() )
     {
       std::string errorMessage = "Parcellation at " + m_ParcellationPath + " could not be read. Aborting.";
       CPPUNIT_ASSERT_MESSAGE( errorMessage, false );
     }
     mitk::BaseData* parcellationBaseData = parcellationInFile.at(0);
     mitk::Image* parcellationImage = dynamic_cast<mitk::Image*>( parcellationBaseData );
 
     // do creation
     mitk::ConnectomicsNetworkCreator::Pointer connectomicsNetworkCreator = mitk::ConnectomicsNetworkCreator::New();
     connectomicsNetworkCreator->SetSegmentation( parcellationImage );
     connectomicsNetworkCreator->SetFiberBundle( fiberBundle );
     connectomicsNetworkCreator->CalculateCenterOfMass();
     connectomicsNetworkCreator->SetEndPointSearchRadius( 15 );
     connectomicsNetworkCreator->CreateNetworkFromFibersAndSegmentation();
 
     // load network
     std::vector<mitk::BaseData::Pointer> referenceFile = mitk::IOUtil::Load( m_ReferenceNetworkPath );
     if( referenceFile.empty() )
     {
       std::string errorMessage = "Reference Network at " + m_ReferenceNetworkPath + " could not be read. Aborting.";
       CPPUNIT_ASSERT_MESSAGE( errorMessage, false );
     }
     mitk::BaseData* referenceBaseData = referenceFile.at(0);
     mitk::ConnectomicsNetwork* referenceNetwork = dynamic_cast<mitk::ConnectomicsNetwork*>( referenceBaseData );
 
     mitk::ConnectomicsNetwork::Pointer network = connectomicsNetworkCreator->GetNetwork();
 
     CPPUNIT_ASSERT_MESSAGE( "Comparing created and reference network.", mitk::Equal( network.GetPointer(), referenceNetwork, mitk::eps, true) );
 
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkConnectomicsNetworkCreation)
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.h
index c619d12ab4..0641de02ce 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.h
@@ -1,102 +1,102 @@
 /*===================================================================
 
 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 __itkDiffusionTensorPrincipalDirectionImageFilter_h_
 #define __itkDiffusionTensorPrincipalDirectionImageFilter_h_
 
 #include <MitkDiffusionCoreExports.h>
 #include <itkImageToImageFilter.h>
 #include <vnl/vnl_vector_fixed.h>
 #include <vnl/vnl_matrix.h>
 #include <vnl/algo/vnl_svd.h>
 #include <itkVectorContainer.h>
 #include <itkVectorImage.h>
 #include <itkDiffusionTensor3D.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 
 namespace itk{
 /** \brief Extracts principal eigenvectors of the input tensors
  */
 
 template< class TTensorPixelType, class TPDPixelType=float>
 class DiffusionTensorPrincipalDirectionImageFilter :
         public ImageToImageFilter< Image< DiffusionTensor3D<TTensorPixelType>, 3 >, Image< Vector< TPDPixelType, 3 >, 3 > >
 {
 
 public:
 
     typedef DiffusionTensorPrincipalDirectionImageFilter Self;
     typedef SmartPointer<Self>                      Pointer;
     typedef SmartPointer<const Self>                ConstPointer;
     typedef ImageToImageFilter< Image< DiffusionTensor3D<TTensorPixelType>, 3 >, Image< Vector< TPDPixelType, 3 >, 3 > >
     Superclass;
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     /** Runtime information support. */
     itkTypeMacro(DiffusionTensorPrincipalDirectionImageFilter, ImageToImageFilter)
 
     typedef TTensorPixelType                            TensorComponentType;
     typedef TPDPixelType                                DirectionPixelType;
     typedef typename Superclass::InputImageType         InputImageType;
     typedef typename Superclass::OutputImageType        OutputImageType;
     typedef typename Superclass::OutputImageRegionType  OutputImageRegionType;
     typedef itk::Image<unsigned char, 3>                ItkUcharImgType;
     typedef vnl_vector_fixed< double, 3 >               DirectionType;
 
     void SetImage( const InputImageType *image );
 
     // input
     itkSetMacro( MaskImage, ItkUcharImgType::Pointer)
     itkSetMacro( NormalizeVectors, bool)
 
     // output
-    itkGetMacro( OutputFiberBundle, mitk::FiberBundleX::Pointer)
+    itkGetMacro( OutputFiberBundle, mitk::FiberBundle::Pointer)
     itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer)
 
     protected:
         DiffusionTensorPrincipalDirectionImageFilter();
     ~DiffusionTensorPrincipalDirectionImageFilter() {}
     void PrintSelf(std::ostream& os, Indent indent) const;
 
     void BeforeThreadedGenerateData();
     void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType );
     void AfterThreadedGenerateData();
 
 private:
 
     bool                                m_NormalizeVectors;     ///< Normalizes the output vector to length 1
-    mitk::FiberBundleX::Pointer         m_OutputFiberBundle;    ///< Vector field representation of the output vectors
+    mitk::FiberBundle::Pointer         m_OutputFiberBundle;    ///< Vector field representation of the output vectors
     ItkUcharImgType::Pointer            m_NumDirectionsImage;   ///< Image containing the number of fiber directions per voxel
     ItkUcharImgType::Pointer            m_MaskImage;            ///< Extraction is only performed inside of the binary mask
     float                               m_MaxEigenvalue;
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkDiffusionTensorPrincipalDirectionImageFilter.txx"
 #endif
 
 #endif //__itkDiffusionTensorPrincipalDirectionImageFilter_h_
 
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.txx
index ff06a24936..e7abe7c63a 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.txx
@@ -1,235 +1,235 @@
 /*===================================================================
 
 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 __itkDiffusionTensorPrincipalDirectionImageFilter_txx
 #define __itkDiffusionTensorPrincipalDirectionImageFilter_txx
 
 #include <time.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "itkDiffusionTensorPrincipalDirectionImageFilter.h"
 #include "itkImageRegionConstIterator.h"
 #include "itkImageRegionConstIteratorWithIndex.h"
 #include "itkImageRegionIterator.h"
 #include "itkArray.h"
 #include "vnl/vnl_vector.h"
 #include <boost/progress.hpp>
 
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 namespace itk {
 
 //#define QBALL_RECON_PI       M_PI
 
 template< class TTensorPixelType, class TPDPixelType>
 DiffusionTensorPrincipalDirectionImageFilter< TTensorPixelType,
 TPDPixelType>
 ::DiffusionTensorPrincipalDirectionImageFilter()
     : m_NormalizeVectors(true)
     , m_MaxEigenvalue(0.0)
 {
     this->SetNumberOfRequiredInputs( 1 );
 }
 
 template< class TTensorPixelType,
           class TPDPixelType>
 void DiffusionTensorPrincipalDirectionImageFilter< TTensorPixelType,
 TPDPixelType>
 ::BeforeThreadedGenerateData()
 {
     typename InputImageType::Pointer inputImagePointer = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );
     Vector<double,3> spacing = inputImagePointer->GetSpacing();
     mitk::Point3D origin = inputImagePointer->GetOrigin();
     itk::Matrix<double, 3, 3> direction = inputImagePointer->GetDirection();
     ImageRegion<3> imageRegion = inputImagePointer->GetLargestPossibleRegion();
 
     if (m_MaskImage.IsNull())
     {
         m_MaskImage = ItkUcharImgType::New();
         m_MaskImage->SetSpacing( spacing );
         m_MaskImage->SetOrigin( origin );
         m_MaskImage->SetDirection( direction );
         m_MaskImage->SetRegions( imageRegion );
         m_MaskImage->Allocate();
         m_MaskImage->FillBuffer(1);
     }
     m_NumDirectionsImage = ItkUcharImgType::New();
     m_NumDirectionsImage->SetSpacing( spacing );
     m_NumDirectionsImage->SetOrigin( origin );
     m_NumDirectionsImage->SetDirection( direction );
     m_NumDirectionsImage->SetRegions( imageRegion );
     m_NumDirectionsImage->Allocate();
     m_NumDirectionsImage->FillBuffer(0);
 
     itk::Vector< TPDPixelType, 3 > nullVec; nullVec.Fill(0.0);
     typename OutputImageType::Pointer outputImage = OutputImageType::New();
     outputImage->SetSpacing( spacing );
     outputImage->SetOrigin( origin );
     outputImage->SetDirection( direction );
     outputImage->SetRegions( imageRegion );
     outputImage->Allocate();
     outputImage->FillBuffer(nullVec);
     this->SetNthOutput(0, outputImage);
 }
 
 template< class TTensorPixelType,
           class TPDPixelType>
 void DiffusionTensorPrincipalDirectionImageFilter< TTensorPixelType,
 TPDPixelType>
 ::AfterThreadedGenerateData()
 {
     vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints>    m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
 
     typename OutputImageType::Pointer directionImage = static_cast< OutputImageType* >( this->ProcessObject::GetPrimaryOutput() );
     ImageRegionConstIterator< OutputImageType > it(directionImage, directionImage->GetLargestPossibleRegion() );
 
     mitk::Vector3D spacing = directionImage->GetSpacing();
     double minSpacing = spacing[0];
     if (spacing[1]<minSpacing)
         minSpacing = spacing[1];
     if (spacing[2]<minSpacing)
         minSpacing = spacing[2];
 
     while( !it.IsAtEnd() )
     {
         typename OutputImageType::IndexType index = it.GetIndex();
         if (m_MaskImage->GetPixel(index)==0)
         {
             ++it;
             continue;
         }
 
         itk::Vector< float, 3 > pixel = directionImage->GetPixel(index);
         DirectionType dir; dir[0] = pixel[0]; dir[1] = pixel[1]; dir[2] = pixel[2];
 
         if (!m_NormalizeVectors && m_MaxEigenvalue>0)
             dir /= m_MaxEigenvalue;
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         itk::ContinuousIndex<double, 3> center;
         center[0] = index[0];
         center[1] = index[1];
         center[2] = index[2];
         itk::Point<double> worldCenter;
         directionImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
 
         itk::Point<double> worldStart;
         worldStart[0] = worldCenter[0]-dir[0]/2 * minSpacing;
         worldStart[1] = worldCenter[1]-dir[1]/2 * minSpacing;
         worldStart[2] = worldCenter[2]-dir[2]/2 * minSpacing;
         vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
         container->GetPointIds()->InsertNextId(id);
         itk::Point<double> worldEnd;
         worldEnd[0] = worldCenter[0]+dir[0]/2 * minSpacing;
         worldEnd[1] = worldCenter[1]+dir[1]/2 * minSpacing;
         worldEnd[2] = worldCenter[2]+dir[2]/2 * minSpacing;
         id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
         container->GetPointIds()->InsertNextId(id);
         m_VtkCellArray->InsertNextCell(container);
 
         ++it;
     }
 
     vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
     directionsPolyData->SetPoints(m_VtkPoints);
     directionsPolyData->SetLines(m_VtkCellArray);
-    m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
+    m_OutputFiberBundle = mitk::FiberBundle::New(directionsPolyData);
 }
 
 template< class TTensorPixelType,
           class TPDPixelType>
 void DiffusionTensorPrincipalDirectionImageFilter< TTensorPixelType,
 TPDPixelType>
 ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, ThreadIdType )
 {
 
     typedef itk::DiffusionTensor3D<TTensorPixelType>    TensorType;
     typedef ImageRegionConstIterator< InputImageType >  InputIteratorType;
     typename InputImageType::Pointer inputImagePointer = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );
 
     typename OutputImageType::Pointer outputImage = static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
 
     ImageRegionIterator< OutputImageType > outIt(outputImage, outputRegionForThread);
     InputIteratorType inIt(inputImagePointer, outputRegionForThread );
     ImageRegionIterator< ItkUcharImgType > nIt(m_NumDirectionsImage, outputRegionForThread );
 
     while( !inIt.IsAtEnd() )
     {
         typename InputImageType::IndexType index = inIt.GetIndex();
         if (m_MaskImage->GetPixel(index)==0)
         {
             ++inIt;
             ++nIt;
             ++outIt;
             continue;
         }
 
         typename InputImageType::PixelType b = inIt.Get();
         TensorType tensor = b.GetDataPointer();
 
         typename OutputImageType::PixelType dir;
         typename TensorType::EigenValuesArrayType eigenvalues;
         typename TensorType::EigenVectorsMatrixType eigenvectors;
         if(tensor.GetTrace()!=0)
         {
             tensor.ComputeEigenAnalysis(eigenvalues, eigenvectors);
 
             vnl_vector_fixed<double,3> vec;
             vec[0] = eigenvectors(2,0);
             vec[1] = eigenvectors(2,1);
             vec[2] = eigenvectors(2,2);
 
             if (!m_NormalizeVectors)
                 vec *= eigenvalues[2];
 
             if (eigenvalues[2]>m_MaxEigenvalue)
                 m_MaxEigenvalue = eigenvalues[2];
 
             dir[0] = (TPDPixelType)vec[0];
             dir[1] = (TPDPixelType)vec[1];
             dir[2] = (TPDPixelType)vec[2];
 
             outIt.Set( dir );
             m_NumDirectionsImage->SetPixel(index, 1);
         }
 
         ++outIt;
         ++inIt;
         ++nIt;
     }
 
     std::cout << "One Thread finished extraction" << std::endl;
 }
 
 template< class TTensorPixelType,
           class TPDPixelType>
 void DiffusionTensorPrincipalDirectionImageFilter< TTensorPixelType,
 TPDPixelType>
 ::PrintSelf(std::ostream& os, Indent indent) const
 {
 }
 
 }
 #endif // __itkDiffusionQballPrincipleDirectionsImageFilter_txx
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.cpp
index 65e1842d1e..82ec7eb936 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.cpp
@@ -1,388 +1,388 @@
 /*===================================================================
 
 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 __itkDwiPhantomGenerationFilter_cpp
 #define __itkDwiPhantomGenerationFilter_cpp
 
 #include <time.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "itkDwiPhantomGenerationFilter.h"
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionIterator.h>
 #include <itkOrientationDistributionFunction.h>
 
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 
 #include <boost/progress.hpp>
 
 namespace itk {
 
 //#define QBALL_RECON_PI       3.14159265358979323846
 
 template< class TOutputScalarType >
 DwiPhantomGenerationFilter< TOutputScalarType >
 ::DwiPhantomGenerationFilter()
     : m_BValue(1000)
     , m_SignalScale(1000)
     , m_BaselineImages(0)
     , m_MaxBaseline(0)
     , m_MeanBaseline(0)
     , m_NoiseVariance(0.004)
     , m_GreyMatterAdc(0.01)
     , m_SimulateBaseline(true)
     , m_DefaultBaseline(1000)
 {
     this->SetNumberOfRequiredOutputs (1);
     m_Spacing.Fill(2.5); m_Origin.Fill(0.0);
     m_DirectionMatrix.SetIdentity();
     m_ImageRegion.SetSize(0, 10);
     m_ImageRegion.SetSize(1, 10);
     m_ImageRegion.SetSize(2, 10);
 
     typename OutputImageType::Pointer outImage = OutputImageType::New();
 
     outImage->SetSpacing( m_Spacing );   // Set the image spacing
     outImage->SetOrigin( m_Origin );     // Set the image origin
     outImage->SetDirection( m_DirectionMatrix );  // Set the image direction
     outImage->SetLargestPossibleRegion( m_ImageRegion );
     outImage->SetBufferedRegion( m_ImageRegion );
     outImage->SetRequestedRegion( m_ImageRegion );
     outImage->SetVectorLength(QBALL_ODFSIZE);
     outImage->Allocate();
     // ITKv4 migration fix : removing OutputImageType::PixelType(0.0)
     // the conversion is handled internally by the itk::Image
     typename OutputImageType::PixelType fillValue(0.0);
     outImage->FillBuffer( fillValue );
 
     this->SetNthOutput (0, outImage);
 
 }
 
 template< class TOutputScalarType >
 void DwiPhantomGenerationFilter< TOutputScalarType >
 ::GenerateTensors()
 {
     MITK_INFO << "Generating tensors";
 
     for (int i=0; i<m_SignalRegions.size(); i++)
     {
         float ADC = m_TensorADC.at(i);
         float FA = m_TensorFA.at(i);
         itk::DiffusionTensor3D<float> kernel;
         kernel.Fill(0);
         float e1=ADC*(1+2*FA/sqrt(3-2*FA*FA));
         float e2=ADC*(1-FA/sqrt(3-2*FA*FA));
         float e3=e2;
         kernel.SetElement(0,e1);
         kernel.SetElement(3,e2);
         kernel.SetElement(5,e3);
 
         if (m_SimulateBaseline)
         {
             double l2 = GetTensorL2Norm(kernel);
             if (l2>m_MaxBaseline)
                 m_MaxBaseline = l2;
         }
 
         MITK_INFO << "Kernel FA: " << kernel.GetFractionalAnisotropy();
         vnl_vector_fixed<double, 3> kernelDir; kernelDir[0]=1; kernelDir[1]=0; kernelDir[2]=0;
 
         itk::DiffusionTensor3D<float> tensor;
         vnl_vector_fixed<double, 3> dir = m_TensorDirection.at(i);
         MITK_INFO << "Tensor direction: " << dir;
 
         dir.normalize();
 
         vnl_vector_fixed<double, 3> axis = vnl_cross_3d(kernelDir, dir); axis.normalize();
         vnl_quaternion<double> rotation(axis, acos(dot_product(kernelDir, dir)));
         rotation.normalize();
         vnl_matrix_fixed<double, 3, 3> matrix = rotation.rotation_matrix_transpose();
 
         vnl_matrix_fixed<double, 3, 3> tensorMatrix;
         tensorMatrix[0][0] = kernel[0]; tensorMatrix[0][1] = kernel[1]; tensorMatrix[0][2] = kernel[2];
         tensorMatrix[1][0] = kernel[1]; tensorMatrix[1][1] = kernel[3]; tensorMatrix[1][2] = kernel[4];
         tensorMatrix[2][0] = kernel[2]; tensorMatrix[2][1] = kernel[4]; tensorMatrix[2][2] = kernel[5];
 
         tensorMatrix = matrix.transpose()*tensorMatrix*matrix;
         tensor[0] = tensorMatrix[0][0]; tensor[1] = tensorMatrix[0][1]; tensor[2] = tensorMatrix[0][2];
         tensor[3] = tensorMatrix[1][1]; tensor[4] = tensorMatrix[1][2]; tensor[5] = tensorMatrix[2][2];
 
         m_TensorList.push_back(tensor);
     }
 }
 
 template< class TOutputScalarType >
 void DwiPhantomGenerationFilter< TOutputScalarType >::AddNoise(typename OutputImageType::PixelType& pix)
 {
     for( unsigned int i=0; i<m_GradientList.size(); i++)
     {
         float signal = pix[i];
         float val = sqrt(pow(signal + m_SignalScale*m_RandGen->GetNormalVariate(0.0, m_NoiseVariance), 2) +  pow(m_SignalScale*m_RandGen->GetNormalVariate(0.0, m_NoiseVariance),2));
         pix[i] += val;
     }
 }
 
 template< class TOutputScalarType >
 typename DwiPhantomGenerationFilter< TOutputScalarType >::OutputImageType::PixelType
 DwiPhantomGenerationFilter< TOutputScalarType >::SimulateMeasurement(itk::DiffusionTensor3D<float>& T, float weight)
 {
     typename OutputImageType::PixelType out;
     out.SetSize(m_GradientList.size());
     out.Fill(0);
 
     TOutputScalarType s0 = m_DefaultBaseline;
     if (m_SimulateBaseline)
         s0 = (GetTensorL2Norm(T)/m_MaxBaseline)*m_SignalScale;
 
     for( unsigned int i=0; i<m_GradientList.size(); i++)
     {
         GradientType g = m_GradientList[i];
 
         if (g.GetNorm()>0.0001)
         {
             itk::DiffusionTensor3D<float> S;
             S[0] = g[0]*g[0];
             S[1] = g[1]*g[0];
             S[2] = g[2]*g[0];
             S[3] = g[1]*g[1];
             S[4] = g[2]*g[1];
             S[5] = g[2]*g[2];
 
             double D = T[0]*S[0] + T[1]*S[1] + T[2]*S[2] +
                        T[1]*S[1] + T[3]*S[3] + T[4]*S[4] +
                        T[2]*S[2] + T[4]*S[4] + T[5]*S[5];
 
             // check for corrupted tensor and generate signal
             if (D>=0)
             {
                 D = weight*s0*exp ( -m_BValue * D );
                 out[i] = static_cast<TOutputScalarType>( D );
             }
         }
         else
             out[i] = s0;
     }
 
     return out;
 }
 
 template< class TOutputScalarType >
 void DwiPhantomGenerationFilter< TOutputScalarType >
 ::GenerateData()
 {
     if (m_NoiseVariance < 0)
         m_NoiseVariance = 0.001;
 
     if (!m_SimulateBaseline)
     {
         MITK_INFO << "Baseline image values are set to default. Noise variance value is treated as SNR!";
         if (m_NoiseVariance <= 0)
             m_NoiseVariance = 0.0001;
         if (m_NoiseVariance>99)
             m_NoiseVariance = 0;
         else
         {
             m_NoiseVariance = m_DefaultBaseline/(m_NoiseVariance*m_SignalScale);
             m_NoiseVariance *= m_NoiseVariance;
         }
     }
 
     m_RandGen = Statistics::MersenneTwisterRandomVariateGenerator::New();
     m_RandGen->SetSeed();
 
     typename OutputImageType::Pointer outImage = OutputImageType::New();
     outImage->SetSpacing( m_Spacing );
     outImage->SetOrigin( m_Origin );
     outImage->SetDirection( m_DirectionMatrix );
     outImage->SetLargestPossibleRegion( m_ImageRegion );
     outImage->SetBufferedRegion( m_ImageRegion );
     outImage->SetRequestedRegion( m_ImageRegion );
     outImage->SetVectorLength(m_GradientList.size());
     outImage->Allocate();
     typename OutputImageType::PixelType pix;
     pix.SetSize(m_GradientList.size());
     pix.Fill(0.0);
     outImage->FillBuffer(pix);
     this->SetNthOutput (0, outImage);
 
     double minSpacing = m_Spacing[0];
     if (m_Spacing[1]<minSpacing)
         minSpacing = m_Spacing[1];
     if (m_Spacing[2]<minSpacing)
         minSpacing = m_Spacing[2];
 
     m_DirectionImageContainer = ItkDirectionImageContainer::New();
     for (int i=0; i<m_SignalRegions.size(); i++)
     {
         itk::Vector< float, 3 > nullVec; nullVec.Fill(0.0);
         ItkDirectionImage::Pointer img = ItkDirectionImage::New();
         img->SetSpacing( m_Spacing );
         img->SetOrigin( m_Origin );
         img->SetDirection( m_DirectionMatrix );
         img->SetRegions( m_ImageRegion );
         img->Allocate();
         img->FillBuffer(nullVec);
         m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), img);
     }
     m_NumDirectionsImage = ItkUcharImgType::New();
     m_NumDirectionsImage->SetSpacing( m_Spacing );
     m_NumDirectionsImage->SetOrigin( m_Origin );
     m_NumDirectionsImage->SetDirection( m_DirectionMatrix );
     m_NumDirectionsImage->SetRegions( m_ImageRegion );
     m_NumDirectionsImage->Allocate();
     m_NumDirectionsImage->FillBuffer(0);
 
     m_SNRImage = ItkFloatImgType::New();
     m_SNRImage->SetSpacing( m_Spacing );
     m_SNRImage->SetOrigin( m_Origin );
     m_SNRImage->SetDirection( m_DirectionMatrix );
     m_SNRImage->SetRegions( m_ImageRegion );
     m_SNRImage->Allocate();
     m_SNRImage->FillBuffer(0);
 
     vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints>    m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
 
     m_BaselineImages = 0;
     for( unsigned int i=0; i<m_GradientList.size(); i++)
         if (m_GradientList[i].GetNorm()<=0.0001)
             m_BaselineImages++;
 
     typedef ImageRegionIterator<OutputImageType>      IteratorOutputType;
     IteratorOutputType it (outImage, m_ImageRegion);
 
     // isotropic tensor
     itk::DiffusionTensor3D<float> isoTensor;
     isoTensor.Fill(0);
     float e1 = m_GreyMatterAdc;
     float e2 = m_GreyMatterAdc;
     float e3 = m_GreyMatterAdc;
     isoTensor.SetElement(0,e1);
     isoTensor.SetElement(3,e2);
     isoTensor.SetElement(5,e3);
     m_MaxBaseline = GetTensorL2Norm(isoTensor);
 
     GenerateTensors();
 
     // simulate measurement
     m_MeanBaseline = 0;
     double noiseStdev = sqrt(m_NoiseVariance);
     while(!it.IsAtEnd())
     {
         pix = it.Get();
         typename OutputImageType::IndexType index = it.GetIndex();
 
         int numDirs = 0;
         for (int i=0; i<m_SignalRegions.size(); i++)
         {
             ItkUcharImgType::Pointer region = m_SignalRegions.at(i);
 
             if (region->GetPixel(index)!=0)
             {
                 numDirs++;
                 pix += SimulateMeasurement(m_TensorList[i], m_TensorWeight[i]);
 
                 // set direction image pixel
                 ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
                 itk::Vector< float, 3 > pixel = img->GetPixel(index);
                 vnl_vector_fixed<double, 3> dir = m_TensorDirection.at(i);
                 dir.normalize();
                 dir *= m_TensorWeight.at(i);
                 pixel.SetElement(0, dir[0]);
                 pixel.SetElement(1, dir[1]);
                 pixel.SetElement(2, dir[2]);
                 img->SetPixel(index, pixel);
 
                 vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
                 itk::ContinuousIndex<double, 3> center;
                 center[0] = index[0];
                 center[1] = index[1];
                 center[2] = index[2];
                 itk::Point<double> worldCenter;
                 outImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
                 itk::Point<double> worldStart;
                 worldStart[0] = worldCenter[0]-dir[0]/2 * minSpacing;
                 worldStart[1] = worldCenter[1]-dir[1]/2 * minSpacing;
                 worldStart[2] = worldCenter[2]-dir[2]/2 * minSpacing;
                 vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
                 container->GetPointIds()->InsertNextId(id);
                 itk::Point<double> worldEnd;
                 worldEnd[0] = worldCenter[0]+dir[0]/2 * minSpacing;
                 worldEnd[1] = worldCenter[1]+dir[1]/2 * minSpacing;
                 worldEnd[2] = worldCenter[2]+dir[2]/2 * minSpacing;
                 id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
                 container->GetPointIds()->InsertNextId(id);
                 m_VtkCellArray->InsertNextCell(container);
             }
         }
 
         if (numDirs>1)
         {
             for (int i=0; i<m_GradientList.size(); i++)
                 pix[i] /= numDirs;
         }
         else if (numDirs==0)
         {
             if (m_SimulateBaseline)
                 pix = SimulateMeasurement(isoTensor, 1.0);
             else
                 pix.Fill(0.0);
         }
 
         m_MeanBaseline += pix[0];
         it.Set(pix);
         m_NumDirectionsImage->SetPixel(index, numDirs);
         if (m_NoiseVariance>0)
             m_SNRImage->SetPixel(index, pix[0]/(noiseStdev*m_SignalScale));
         ++it;
     }
     m_MeanBaseline /= m_ImageRegion.GetNumberOfPixels();
     if (m_NoiseVariance>0)
         MITK_INFO << "Mean SNR: " << m_MeanBaseline/(noiseStdev*m_SignalScale);
     else
         MITK_INFO << "No noise added";
 
     // add rician noise
     it.GoToBegin();
     while(!it.IsAtEnd())
     {
         pix = it.Get();
         AddNoise(pix);
         it.Set(pix);
         ++it;
     }
 
     // generate fiber bundle
     vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
     directionsPolyData->SetPoints(m_VtkPoints);
     directionsPolyData->SetLines(m_VtkCellArray);
-    m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
+    m_OutputFiberBundle = mitk::FiberBundle::New(directionsPolyData);
 }
 template< class TOutputScalarType >
 double DwiPhantomGenerationFilter< TOutputScalarType >::GetTensorL2Norm(itk::DiffusionTensor3D<float>& T)
 {
     return sqrt(T[0]*T[0] + T[3]*T[3] + T[5]*T[5] + T[1]*T[2]*2.0 + T[2]*T[4]*2.0 + T[1]*T[4]*2.0);
 }
 
 }
 
 #endif // __itkDwiPhantomGenerationFilter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.h
index ced3a05ce8..67788a323a 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.h
@@ -1,152 +1,152 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 /*=========================================================================
 
   Program:   Insight Segmentation & Registration Toolkit
   Module:    $RCSfile: itkDiffusionTensor3DReconstructionImageFilter.h,v $
   Language:  C++
   Date:      $Date: 2006-03-27 17:01:06 $
   Version:   $Revision: 1.12 $
 
   Copyright (c) Insight Software Consortium. All rights reserved.
   See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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 __itkDwiPhantomGenerationFilter_h_
 #define __itkDwiPhantomGenerationFilter_h_
 
 #include <itkImageSource.h>
 #include <itkVectorImage.h>
 #include <itkDiffusionTensor3D.h>
 #include <itkMersenneTwisterRandomVariateGenerator.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 
 namespace itk{
 
 /**
 * \brief Generation of synthetic diffusion weighted images using a second rank tensor model.   */
 
 template< class TOutputScalarType >
 class DwiPhantomGenerationFilter : public ImageSource< itk::VectorImage<TOutputScalarType,3> >
 {
 
 public:
 
     typedef DwiPhantomGenerationFilter Self;
     typedef SmartPointer<Self>                      Pointer;
     typedef SmartPointer<const Self>                ConstPointer;
     typedef ImageSource< itk::VectorImage<TOutputScalarType,3> > Superclass;
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     /** Runtime information support. */
     itkTypeMacro(DwiPhantomGenerationFilter, ImageSource)
 
     typedef typename Superclass::OutputImageType        OutputImageType;
     typedef typename Superclass::OutputImageRegionType  OutputImageRegionType;
     typedef itk::VectorContainer< int, double >         AnglesContainerType;
     typedef Vector<double,3>                            GradientType;
     typedef std::vector<GradientType>                   GradientListType;
     typedef itk::Matrix<double, 3, 3>                   MatrixType;
     typedef itk::Image<unsigned char, 3>                ItkUcharImgType;
     typedef itk::Image<float, 3>                        ItkFloatImgType;
 
     typedef Image< Vector< float, 3 >, 3>                                 ItkDirectionImage;
     typedef VectorContainer< unsigned int, ItkDirectionImage::Pointer >   ItkDirectionImageContainer;
 
     void SetGradientList(GradientListType gradientList){m_GradientList = gradientList;}
     void SetSignalRegions(std::vector< ItkUcharImgType::Pointer > signalRegions){m_SignalRegions = signalRegions;}
     void SetTensorFA(std::vector< float > faList){m_TensorFA = faList;}
     void SetTensorADC(std::vector< float > adcList){m_TensorADC = adcList;}
     void SetTensorWeight(std::vector< float > weightList){m_TensorWeight = weightList;}
     void SetTensorDirection(std::vector< vnl_vector_fixed<double, 3> > directionList){m_TensorDirection = directionList;}
 
     // input parameters
     itkSetMacro( BValue, float )                ///< signal parameter
     itkSetMacro( SignalScale, float )           ///< scaling factor for signal
     itkSetMacro( NoiseVariance, double )        ///< variance of rician noise
     itkSetMacro( GreyMatterAdc, float )         ///< ADC of isotropic diffusion tensor
     itkSetMacro( Spacing, mitk::Vector3D )      ///< parameter of output image
     itkSetMacro( Origin, mitk::Point3D )        ///< parameter of output image
     itkSetMacro( DirectionMatrix, MatrixType )  ///< parameter of output image
     itkSetMacro( ImageRegion, ImageRegion<3> )  ///< parameter of output image
     itkSetMacro( SimulateBaseline, bool )       ///< generate baseline image values as the l2 norm of the corresponding tensor used for the diffusion signal generation
 
     // output
     itkGetMacro( DirectionImageContainer, ItkDirectionImageContainer::Pointer)  ///< contains one vectorimage for each input ROI
     itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer)                  ///< contains number of directions per voxel
     itkGetMacro( SNRImage, ItkFloatImgType::Pointer)                            ///< contains local SNR values
-    itkGetMacro( OutputFiberBundle, mitk::FiberBundleX::Pointer)                ///< output vector field
+    itkGetMacro( OutputFiberBundle, mitk::FiberBundle::Pointer)                ///< output vector field
 
     protected:
     DwiPhantomGenerationFilter();
     ~DwiPhantomGenerationFilter(){}
 
     void GenerateData();
 
 private:
 
     // image variables
     itk::Vector<double>                             m_Spacing;
     mitk::Point3D                                   m_Origin;
     itk::Matrix<double, 3, 3>                       m_DirectionMatrix;
     ImageRegion<3>                                  m_ImageRegion;
     ItkDirectionImageContainer::Pointer             m_DirectionImageContainer;  ///< contains one vectorimage for each input ROI
     ItkUcharImgType::Pointer                        m_NumDirectionsImage;       ///< contains number of directions per voxel
     ItkFloatImgType::Pointer                        m_SNRImage;                 ///< contains local SNR values
-    mitk::FiberBundleX::Pointer                     m_OutputFiberBundle;        ///< output vector field
+    mitk::FiberBundle::Pointer                     m_OutputFiberBundle;        ///< output vector field
 
     // signal regions
     std::vector< ItkUcharImgType::Pointer >         m_SignalRegions;    ///< binary images defining the regions for the signal generation
     std::vector< float >                            m_TensorFA;         ///< kernel tensor parameter
     std::vector< float >                            m_TensorADC;        ///< kernel tensor parameter
     std::vector< float >                            m_TensorWeight;     ///< weight factor of the signal
     std::vector< vnl_vector_fixed<double, 3> >      m_TensorDirection;  ///< principal direction of the kernel tensor in the different ROIs
 
     // signal related variable
     GradientListType                                m_GradientList;     ///< list of used diffusion gradient directions
     std::vector< itk::DiffusionTensor3D<float> >    m_TensorList;       ///< kernel tensor rotated in the different directions
     float                                           m_BValue;           ///< signal parameter
     float                                           m_SignalScale;      ///< scaling factor for signal
     Statistics::MersenneTwisterRandomVariateGenerator::Pointer m_RandGen;
     int                                             m_BaselineImages;   ///< number of simulated baseline images
     double                                          m_MaxBaseline;      ///< maximum value of the baseline image
     double                                          m_MeanBaseline;     ///< mean value of the baseline image
     double                                          m_NoiseVariance;    ///< variance of rician noise
     float                                           m_GreyMatterAdc;    ///< ADC of isotropic diffusion tensor
     bool                                            m_SimulateBaseline; ///< generate baseline image values as the l2 norm of the corresponding tensor used for the diffusion signal generation
     TOutputScalarType                               m_DefaultBaseline;  ///< default value for baseline image
 
     double GetTensorL2Norm(itk::DiffusionTensor3D<float>& T);
     void GenerateTensors();     ///< rotates kernel tensor in the direction of the input direction vectors
     typename OutputImageType::PixelType SimulateMeasurement(itk::DiffusionTensor3D<float>& tensor, float weight);
     void AddNoise(typename OutputImageType::PixelType& pix);    ///< Adds rician noise to the input pixel
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkDwiPhantomGenerationFilter.cpp"
 #endif
 
 #endif //__itkDwiPhantomGenerationFilter_h_
 
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.cpp
index 5d6d751d14..b2f8429ad2 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.cpp
@@ -1,520 +1,520 @@
 /*===================================================================
 
 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 __itkFiniteDiffOdfMaximaExtractionFilter_cpp
 #define __itkFiniteDiffOdfMaximaExtractionFilter_cpp
 
 #include "itkFiniteDiffOdfMaximaExtractionFilter.h"
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionIterator.h>
 #include <vnl/vnl_vector.h>
 #include <itkOrientationDistributionFunction.h>
 #include <itkContinuousIndex.h>
 
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 
 #include <boost/math/special_functions.hpp>
 #include <boost/progress.hpp>
 
 
 using namespace boost::math;
 
 namespace itk {
 
 
 static bool CompareVectors(const vnl_vector_fixed< double, 3 >& v1, const vnl_vector_fixed< double, 3 >& v2)
 {
     return (v1.magnitude()>v2.magnitude());
 }
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::FiniteDiffOdfMaximaExtractionFilter()
     : m_NormalizationMethod(MAX_VEC_NORM)
     , m_MaxNumPeaks(2)
     , m_PeakThreshold(0.4)
     , m_AbsolutePeakThreshold(0)
     , m_ClusteringThreshold(0.9)
     , m_AngularThreshold(0.7)
     , m_NumCoeffs((ShOrder*ShOrder + ShOrder + 2)/2 + ShOrder)
     , m_Toolkit(FSL)
 {
     this->SetNumberOfRequiredInputs(1);
 }
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::FindCandidatePeaks(OdfType& odf, double thr, std::vector< DirectionType >& container)
 {
     double gfa = odf.GetGeneralizedFractionalAnisotropy();
     //Find the peaks using a finite difference method
     bool flag = true;
     vnl_vector_fixed< bool, NrOdfDirections > used; used.fill(false);
     //Find the peaks
     for (int i=0; i<NrOdfDirections; i++)
     {
         if (used[i])
             continue;
 
         double val = odf.GetElement(i);
         if (val>thr && val*gfa>m_AbsolutePeakThreshold)  // limit to one hemisphere ???
         {
             flag = true;
             std::vector< int > neighbours = odf.GetNeighbors(i);
             for (unsigned int j=0; j<neighbours.size(); j++)
                 if (val<=odf.GetElement(neighbours.at(j)))
                 {
                     flag = false;
                     break;
                 }
             if (flag)   // point is a peak
             {
                 container.push_back(odf.GetDirection(i).normalize());
                 used[i] = true;
                 for (unsigned int j=0; j<neighbours.size(); j++)
                     used[neighbours.at(j)] = true;
             }
         }
     }
 }
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 std::vector< vnl_vector_fixed< double, 3 > >  FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>::MeanShiftClustering(std::vector< vnl_vector_fixed< double, 3 > >& inDirs)
 {
     std::vector< DirectionType > outDirs;
     if (inDirs.empty())
         return inDirs;
 
     DirectionType oldMean, currentMean, workingMean;
     std::vector< int > touched;
 
     // initialize
     touched.resize(inDirs.size(), 0);
     bool free = true;
     currentMean = inDirs[0];  // initialize first seed
     while (free)
     {
         oldMean.fill(0.0);
 
         // start mean-shift clustering
         float angle = 0.0;
         int counter = 0;
         while ((currentMean-oldMean).magnitude()>0.0001)
         {
             counter = 0;
             oldMean = currentMean;
             workingMean = oldMean;
             workingMean.normalize();
             currentMean.fill(0.0);
             for (unsigned int i=0; i<inDirs.size(); i++)
             {
                 angle = dot_product(workingMean, inDirs[i]);
                 if (angle>=m_ClusteringThreshold)
                 {
                     currentMean += inDirs[i];
                     touched[i] = 1;
                     counter++;
                 }
                 else if (-angle>=m_ClusteringThreshold)
                 {
                     currentMean -= inDirs[i];
                     touched[i] = 1;
                     counter++;
                 }
             }
         }
 
         // found stable mean
         if (counter>0)
         {
             float mag = currentMean.magnitude();
             if (mag>0)
             {
                 currentMean /= mag;
                 outDirs.push_back(currentMean);
             }
         }
 
         // find next unused seed
         free = false;
         for (unsigned int i=0; i<touched.size(); i++)
             if (touched[i]==0)
             {
                 currentMean = inDirs[i];
                 free = true;
             }
     }
 
     if (inDirs.size()==outDirs.size())
     {
         return outDirs;
     }
     else
         return MeanShiftClustering(outDirs);
 }
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::BeforeThreadedGenerateData()
 {
     typename CoefficientImageType::Pointer ShCoeffImage = static_cast< CoefficientImageType* >( this->ProcessObject::GetInput(0) );
     itk::Vector<double,3> spacing = ShCoeffImage->GetSpacing();
     double minSpacing = spacing[0];
     if (spacing[1]<minSpacing)
         minSpacing = spacing[1];
     if (spacing[2]<minSpacing)
         minSpacing = spacing[2];
 
     mitk::Point3D origin = ShCoeffImage->GetOrigin();
     itk::Matrix<double, 3, 3> direction = ShCoeffImage->GetDirection();
     ImageRegion<3> imageRegion = ShCoeffImage->GetLargestPossibleRegion();
 
     if (m_MaskImage.IsNotNull())
     {
         origin = m_MaskImage->GetOrigin();
         direction = m_MaskImage->GetDirection();
         imageRegion = m_MaskImage->GetLargestPossibleRegion();
     }
 
     m_DirectionImageContainer = ItkDirectionImageContainer::New();
     for (unsigned int i=0; i<m_MaxNumPeaks; i++)
     {
         itk::Vector< float, 3 > nullVec; nullVec.Fill(0.0);
         ItkDirectionImage::Pointer img = ItkDirectionImage::New();
         img->SetSpacing( spacing );
         img->SetOrigin( origin );
         img->SetDirection( direction );
         img->SetRegions( imageRegion );
         img->Allocate();
         img->FillBuffer(nullVec);
         m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), img);
     }
     if (m_MaskImage.IsNull())
     {
         m_MaskImage = ItkUcharImgType::New();
         m_MaskImage->SetSpacing( spacing );
         m_MaskImage->SetOrigin( origin );
         m_MaskImage->SetDirection( direction );
         m_MaskImage->SetRegions( imageRegion );
         m_MaskImage->Allocate();
         m_MaskImage->FillBuffer(1);
     }
     m_NumDirectionsImage = ItkUcharImgType::New();
     m_NumDirectionsImage->SetSpacing( spacing );
     m_NumDirectionsImage->SetOrigin( origin );
     m_NumDirectionsImage->SetDirection( direction );
     m_NumDirectionsImage->SetRegions( imageRegion );
     m_NumDirectionsImage->Allocate();
     m_NumDirectionsImage->FillBuffer(0);
 
     this->SetNumberOfIndexedOutputs(m_MaxNumPeaks);
 
     // calculate SH basis
     OdfType odf;
     vnl_matrix_fixed<double, 3, NrOdfDirections>* directions = odf.GetDirections();
     vnl_matrix< double > sphCoords;
     std::vector< DirectionType > dirs;
     for (int i=0; i<NrOdfDirections; i++)
         dirs.push_back(directions->get_column(i));
     Cart2Sph(dirs, sphCoords);                          // convert candidate peaks to spherical angles
     m_ShBasis = CalcShBasis(sphCoords);                // evaluate spherical harmonics at each peak
 
     MITK_INFO << "Starting finite differences maximum extraction";
     MITK_INFO << "ODF sampling points: " << NrOdfDirections;
     MITK_INFO << "SH order: " << ShOrder;
     MITK_INFO << "Maximum peaks: " << m_MaxNumPeaks;
     MITK_INFO << "Relative threshold: " << m_PeakThreshold;
     MITK_INFO << "Absolute threshold: " << m_AbsolutePeakThreshold;
     MITK_INFO << "Clustering threshold: " << m_ClusteringThreshold;
     MITK_INFO << "Angular threshold: " << m_AngularThreshold;
 }
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::AfterThreadedGenerateData()
 {
     MITK_INFO << "Generating vector field";
     vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints>    m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
 
     typename CoefficientImageType::Pointer ShCoeffImage = static_cast< CoefficientImageType* >( this->ProcessObject::GetInput(0) );
     ImageRegionConstIterator< CoefficientImageType > cit(ShCoeffImage, ShCoeffImage->GetLargestPossibleRegion() );
 
     mitk::Vector3D spacing = ShCoeffImage->GetSpacing();
     double minSpacing = spacing[0];
     if (spacing[1]<minSpacing)
         minSpacing = spacing[1];
     if (spacing[2]<minSpacing)
         minSpacing = spacing[2];
 
     int maxProgress = ShCoeffImage->GetLargestPossibleRegion().GetSize()[0]*ShCoeffImage->GetLargestPossibleRegion().GetSize()[1]*ShCoeffImage->GetLargestPossibleRegion().GetSize()[2];
     boost::progress_display disp(maxProgress);
 
     while( !cit.IsAtEnd() )
     {
         ++disp;
 
         typename CoefficientImageType::IndexType index = cit.GetIndex();
         if (m_MaskImage->GetPixel(index)==0)
         {
             ++cit;
             continue;
         }
 
         for (unsigned int i=0; i<m_DirectionImageContainer->Size(); i++)
         {
             ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
             itk::Vector< float, 3 > pixel = img->GetPixel(index);
             DirectionType dir; dir[0] = pixel[0]; dir[1] = pixel[1]; dir[2] = pixel[2];
 
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             itk::ContinuousIndex<double, 3> center;
             center[0] = index[0];
             center[1] = index[1];
             center[2] = index[2];
             itk::Point<double> worldCenter;
             m_MaskImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
 
             itk::Point<double> worldStart;
             worldStart[0] = worldCenter[0]-dir[0]/2 * minSpacing;
             worldStart[1] = worldCenter[1]-dir[1]/2 * minSpacing;
             worldStart[2] = worldCenter[2]-dir[2]/2 * minSpacing;
             vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
             container->GetPointIds()->InsertNextId(id);
             itk::Point<double> worldEnd;
             worldEnd[0] = worldCenter[0]+dir[0]/2 * minSpacing;
             worldEnd[1] = worldCenter[1]+dir[1]/2 * minSpacing;
             worldEnd[2] = worldCenter[2]+dir[2]/2 * minSpacing;
             id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
             container->GetPointIds()->InsertNextId(id);
             m_VtkCellArray->InsertNextCell(container);
         }
         ++cit;
     }
 
     vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
     directionsPolyData->SetPoints(m_VtkPoints);
     directionsPolyData->SetLines(m_VtkCellArray);
-    m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
+    m_OutputFiberBundle = mitk::FiberBundle::New(directionsPolyData);
 
     for (unsigned int i=0; i<m_DirectionImageContainer->Size(); i++)
     {
         ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
         this->SetNthOutput(i, img);
     }
 }
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, ThreadIdType threadID )
 {
     typename CoefficientImageType::Pointer ShCoeffImage = static_cast< CoefficientImageType* >( this->ProcessObject::GetInput(0) );
 
     ImageRegionConstIterator< CoefficientImageType > cit(ShCoeffImage, outputRegionForThread );
 
     OdfType odf;
     while( !cit.IsAtEnd() )
     {
         typename CoefficientImageType::IndexType index = cit.GetIndex();
         if (m_MaskImage->GetPixel(index)==0)
         {
             ++cit;
             continue;
         }
 
         CoefficientPixelType c = cit.Get();
 
         // calculate ODF
         double max = 0;
         odf.Fill(0.0);
         for (int i=0; i<NrOdfDirections; i++)
         {
             for (int j=0; j<m_NumCoeffs; j++)
                 odf[i] += c[j]*m_ShBasis(i,j);
             if (odf[i]>max)
                 max = odf[i];
         }
         if (max<0.0001)
         {
             ++cit;
             continue;
         }
 
         std::vector< DirectionType > candidates, peaks, temp;
         peaks.clear();
         max *= m_PeakThreshold;                         // relative threshold
         FindCandidatePeaks(odf, max, candidates);       // find all local maxima
         candidates = MeanShiftClustering(candidates);   // cluster maxima
 
         vnl_matrix< double > shBasis, sphCoords;
         Cart2Sph(candidates, sphCoords);                // convert candidate peaks to spherical angles
         shBasis = CalcShBasis(sphCoords);            // evaluate spherical harmonics at each peak
         max = 0.0;
         for (unsigned int i=0; i<candidates.size(); i++)         // scale peaks according to ODF value
         {
             double val = 0;
             for (int j=0; j<m_NumCoeffs; j++)
                 val += c[j]*shBasis(i,j);
             if (val>max)
                 max = val;
             peaks.push_back(candidates[i]*val);
         }
         std::sort( peaks.begin(), peaks.end(), CompareVectors );  // sort peaks
 
         // kick out directions to close to a larger direction (too far away to cluster but too close to keep)
         unsigned int m = peaks.size();
         if ( m>m_DirectionImageContainer->Size() )
             m = m_DirectionImageContainer->Size();
         for (unsigned int i=0; i<m; i++)
         {
             DirectionType v1 = peaks.at(i);
             double val = v1.magnitude();
             if (val<max*m_PeakThreshold || val<m_AbsolutePeakThreshold)
                 break;
 
             bool flag = true;
             for (unsigned int j=0; j<peaks.size(); j++)
                 if (i!=j)
                 {
                     DirectionType v2 = peaks.at(j);
                     double val2 = v2.magnitude();
                     double angle = fabs(dot_product(v1,v2)/(val*val2));
                     if (angle>m_AngularThreshold && val<val2)
                     {
                         flag = false;
                         break;
                     }
                 }
 
             if (flag)
                 temp.push_back(v1);
         }
         peaks = temp;
 
         // fill output image
         unsigned int num = peaks.size();
         if ( num>m_DirectionImageContainer->Size() )
             num = m_DirectionImageContainer->Size();
         for (unsigned int i=0; i<num; i++)
         {
             vnl_vector<double> dir = peaks.at(i);
 
             ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
 
             switch (m_NormalizationMethod)
             {
             case NO_NORM:
                 break;
             case SINGLE_VEC_NORM:
                 dir.normalize();
                 break;
             case MAX_VEC_NORM:
                 dir /= max;
                 break;
             }
 
             dir = m_MaskImage->GetDirection()*dir;
             itk::Vector< float, 3 > pixel;
             pixel.SetElement(0, -dir[0]);
             pixel.SetElement(1, dir[1]);
             pixel.SetElement(2, dir[2]);
             img->SetPixel(index, pixel);
         }
         m_NumDirectionsImage->SetPixel(index, num);
         ++cit;
     }
     MITK_INFO << "Thread " << threadID << " finished extraction";
 }
 
 // convert cartesian to spherical coordinates
 template< class PixelType, int ShOrder, int NrOdfDirections >
 void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::Cart2Sph(const std::vector< DirectionType >& dir, vnl_matrix<double>& sphCoords)
 {
     sphCoords.set_size(dir.size(), 2);
 
     for (unsigned int i=0; i<dir.size(); i++)
     {
         double mag = dir[i].magnitude();
 
         if( mag<0.0001 )
         {
             sphCoords(i,0) = M_PI/2; // theta
             sphCoords(i,1) = M_PI/2; // phi
         }
         else
         {
             sphCoords(i,0) = acos(dir[i](2)/mag); // theta
             sphCoords(i,1) = atan2(dir[i](1), dir[i](0)); // phi
         }
     }
 }
 
 // generate spherical harmonic values of the desired order for each input direction
 template< class PixelType, int ShOrder, int NrOdfDirections >
 vnl_matrix<double> FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::CalcShBasis(vnl_matrix<double>& sphCoords)
 {
     int M = sphCoords.rows();
     int j, m; double mag, plm;
     vnl_matrix<double> shBasis;
     shBasis.set_size(M, m_NumCoeffs);
 
     for (int p=0; p<M; p++)
     {
         j=0;
         for (int l=0; l<=ShOrder; l=l+2)
             for (m=-l; m<=l; m++)
             {
                 switch (m_Toolkit)
                 {
                 case FSL:
                 plm = legendre_p<double>(l,abs(m),cos(sphCoords(p,0)));
                 mag = sqrt((double)(2*l+1)/(4.0*M_PI)*factorial<double>(l-abs(m))/factorial<double>(l+abs(m)))*plm;
 
                 if (m<0)
                     shBasis(p,j) = sqrt(2.0)*mag*cos(fabs((double)m)*sphCoords(p,1));
                 else if (m==0)
                     shBasis(p,j) = mag;
                 else
                     shBasis(p,j) = pow(-1.0, m)*sqrt(2.0)*mag*sin(m*sphCoords(p,1));
                     break;
                 case MRTRIX:
 
                 plm = legendre_p<double>(l,abs(m),-cos(sphCoords(p,0)));
                 mag = sqrt((double)(2*l+1)/(4.0*M_PI)*factorial<double>(l-abs(m))/factorial<double>(l+abs(m)))*plm;
                 if (m>0)
                     shBasis(p,j) = mag*cos(m*sphCoords(p,1));
                 else if (m==0)
                     shBasis(p,j) = mag;
                 else
                     shBasis(p,j) = mag*sin(-m*sphCoords(p,1));
                     break;
                 }
 
                 j++;
             }
     }
     return shBasis;
 }
 
 }
 
 #endif // __itkFiniteDiffOdfMaximaExtractionFilter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.h
index d5b274a4c0..85e715b5e6 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.h
@@ -1,145 +1,145 @@
 /*=========================================================================
 
   Program:   Insight Segmentation & Registration Toolkit
   Module:    $RCSfile: itkDiffusionTensor3DReconstructionImageFilter.h,v $
   Language:  C++
   Date:      $Date: 2006-03-27 17:01:06 $
   Version:   $Revision: 1.12 $
 
   Copyright (c) Insight Software Consortium. All rights reserved.
   See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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 __itkFiniteDiffOdfMaximaExtractionFilter_h_
 #define __itkFiniteDiffOdfMaximaExtractionFilter_h_
 
 #include "itkImageToImageFilter.h"
 #include "vnl/vnl_vector_fixed.h"
 #include "vnl/vnl_matrix.h"
 #include "vnl/algo/vnl_svd.h"
 #include "itkVectorContainer.h"
 #include "itkVectorImage.h"
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <itkOrientationDistributionFunction.h>
 
 namespace itk{
 
 /**
 * \brief Extract ODF peaks by searching all local maxima on a densely sampled ODF und clustering these maxima to get the underlying fiber direction.
 * NrOdfDirections: number of sampling points on the ODF surface (about 20000 is a good value)
 */
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 class FiniteDiffOdfMaximaExtractionFilter :
         public ImageToImageFilter< Image< Vector< PixelType, (ShOrder*ShOrder + ShOrder + 2)/2 + ShOrder >, 3 >,
 Image< Vector< PixelType, 3 >, 3 > >
 {
 
     public:
 
     enum Toolkit {  ///< SH coefficient convention (depends on toolkit)
         FSL,
         MRTRIX
     };
 
     enum NormalizationMethods {
         NO_NORM,            ///< no length normalization of the output peaks
         SINGLE_VEC_NORM,    ///< normalize the single peaks to length 1
         MAX_VEC_NORM        ///< normalize all peaks according to their length in comparison to the largest peak (0-1)
     };
 
     typedef FiniteDiffOdfMaximaExtractionFilter Self;
     typedef SmartPointer<Self>                      Pointer;
     typedef SmartPointer<const Self>                ConstPointer;
     typedef ImageToImageFilter< Image< Vector< PixelType, (ShOrder*ShOrder + ShOrder + 2)/2 + ShOrder >, 3 >,
             Image< Vector< PixelType, 3 >, 3 > > Superclass;
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
             /** Runtime information support. */
             itkTypeMacro(FiniteDiffOdfMaximaExtractionFilter, ImageToImageFilter)
 
             typedef typename Superclass::InputImageType           CoefficientImageType;
     typedef typename CoefficientImageType::RegionType     CoefficientImageRegionType;
     typedef typename CoefficientImageType::PixelType      CoefficientPixelType;
 
     typedef typename Superclass::OutputImageType          OutputImageType;
     typedef typename Superclass::OutputImageRegionType    OutputImageRegionType;
 
     typedef OrientationDistributionFunction<PixelType, NrOdfDirections>   OdfType;
     typedef itk::Image<unsigned char, 3>                                  ItkUcharImgType;
 
     typedef vnl_vector_fixed< double, 3 >                                 DirectionType;
     typedef Image< Vector< float, 3 >, 3>                                 ItkDirectionImage;
     typedef VectorContainer< unsigned int, ItkDirectionImage::Pointer >   ItkDirectionImageContainer;
 
     // input
     itkSetMacro( MaxNumPeaks, unsigned int)                 ///< maximum number of peaks per voxel. if more peaks are detected, only the largest are kept.
     itkSetMacro( PeakThreshold, double)                     ///< threshold on the peak length relative to the largest peak inside the current voxel
     itkSetMacro( AbsolutePeakThreshold, double)             ///< hard threshold on the peak length of all local maxima
     itkSetMacro( ClusteringThreshold, double)               ///< directions closer together than the specified angular threshold will be clustered (in rad)
     itkSetMacro( AngularThreshold, double)                  ///< directions closer together than the specified threshold that remain after clustering are discarded (largest is kept) (in rad)
     itkSetMacro( MaskImage, ItkUcharImgType::Pointer)       ///< only voxels inside the binary mask are processed
     itkSetMacro( NormalizationMethod, NormalizationMethods) ///< normalization method of ODF peaks
 
     // output
-    itkGetMacro( OutputFiberBundle, mitk::FiberBundleX::Pointer)                ///< vector field (peak sizes rescaled for visualization purposes)
+    itkGetMacro( OutputFiberBundle, mitk::FiberBundle::Pointer)                ///< vector field (peak sizes rescaled for visualization purposes)
     itkGetMacro( DirectionImageContainer, ItkDirectionImageContainer::Pointer)  ///< container for output peaks
     itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer)                  ///< number of peaks per voxel
 
     itkSetMacro( Toolkit, Toolkit)  ///< define SH coefficient convention (depends on toolkit)
     itkGetMacro( Toolkit, Toolkit)  ///< SH coefficient convention (depends on toolkit)
 
     protected:
     FiniteDiffOdfMaximaExtractionFilter();
     ~FiniteDiffOdfMaximaExtractionFilter(){}
 
     void BeforeThreadedGenerateData();
     void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType threadID );
     void AfterThreadedGenerateData();
 
     /** Extract all local maxima from the densely sampled ODF surface. Thresholding possible. **/
     void FindCandidatePeaks(OdfType& odf, double odfMax, std::vector< DirectionType >& inDirs);
 
     /** Cluster input directions within a certain angular threshold **/
     std::vector< DirectionType > MeanShiftClustering(std::vector< DirectionType >& inDirs);
 
     /** Convert cartesian to spherical coordinates **/
     void Cart2Sph(const std::vector< DirectionType >& dir, vnl_matrix<double>& sphCoords);
 
     /** Calculate spherical harmonic basis of the defined order **/
     vnl_matrix<double> CalcShBasis(vnl_matrix<double>& sphCoords);
 
     private:
 
     NormalizationMethods                        m_NormalizationMethod;  ///< normalization method of ODF peaks
     unsigned int                                m_MaxNumPeaks;          ///< maximum number of peaks per voxel. if more peaks are detected, only the largest are kept.
     double                                      m_PeakThreshold;        ///< threshold on the peak length relative to the largest peak inside the current voxel
     double                                      m_AbsolutePeakThreshold;///< hard threshold on the peak length of all local maxima
     vnl_matrix< double >                        m_ShBasis;              ///< container for evaluated SH base functions
     double                                      m_ClusteringThreshold;  ///< directions closer together than the specified angular threshold will be clustered (in rad)
     double                                      m_AngularThreshold;     ///< directions closer together than the specified threshold that remain after clustering are discarded (largest is kept) (in rad)
     const int                                   m_NumCoeffs;            ///< number of spherical harmonics coefficients
 
-    mitk::FiberBundleX::Pointer               m_OutputFiberBundle;      ///< vector field (peak sizes rescaled for visualization purposes)
+    mitk::FiberBundle::Pointer               m_OutputFiberBundle;      ///< vector field (peak sizes rescaled for visualization purposes)
     ItkDirectionImageContainer::Pointer       m_DirectionImageContainer;///< container for output peaks
     ItkUcharImgType::Pointer                  m_NumDirectionsImage;     ///< number of peaks per voxel
     ItkUcharImgType::Pointer                  m_MaskImage;              ///< only voxels inside the binary mask are processed
 
     Toolkit                                   m_Toolkit;
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkFiniteDiffOdfMaximaExtractionFilter.cpp"
 #endif
 
 #endif //__itkFiniteDiffOdfMaximaExtractionFilter_h_
 
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.cpp
index 357ed381e4..e582ffefc5 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.cpp
@@ -1,171 +1,171 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #ifndef __itkFslPeakImageConverter_cpp
 #define __itkFslPeakImageConverter_cpp
 
 #include <time.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "itkFslPeakImageConverter.h"
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionIterator.h>
 #include <itkContinuousIndex.h>
 
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 
 
 namespace itk {
 
 template< class PixelType >
 FslPeakImageConverter< PixelType >::FslPeakImageConverter():
     m_NormalizationMethod(NO_NORM)
 {
 
 }
 
 template< class PixelType >
 void FslPeakImageConverter< PixelType >
 ::GenerateData()
 {
     // output vector field
     vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints>    m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
 
     Vector<float, 4> spacing4 = m_InputImages->GetElement(0)->GetSpacing();
     Point<float, 4> origin4 = m_InputImages->GetElement(0)->GetOrigin();
     Matrix<double, 4, 4> direction4 = m_InputImages->GetElement(0)->GetDirection();
     ImageRegion<4> imageRegion4 = m_InputImages->GetElement(0)->GetLargestPossibleRegion();
 
     itk::Vector<double,3> spacing3;
     Point<float, 3> origin3;
     Matrix<double, 3, 3> direction3;
     ImageRegion<3> imageRegion3;
 
     spacing3[0] = spacing4[0]; spacing3[1] = spacing4[1]; spacing3[2] = spacing4[2];
     origin3[0] = origin4[0]; origin3[1] = origin4[1]; origin3[2] = origin4[2];
     for (int r=0; r<3; r++)
         for (int c=0; c<3; c++)
             direction3[r][c] = direction4[r][c];
     imageRegion3.SetSize(0, imageRegion4.GetSize()[0]);
     imageRegion3.SetSize(1, imageRegion4.GetSize()[1]);
     imageRegion3.SetSize(2, imageRegion4.GetSize()[2]);
 
     double minSpacing = spacing3[0];
     if (spacing3[1]<minSpacing)
         minSpacing = spacing3[1];
     if (spacing3[2]<minSpacing)
         minSpacing = spacing3[2];
 
     m_DirectionImageContainer = DirectionImageContainerType::New();
 
     typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
     for (int i=0; i<m_InputImages->Size(); i++)
     {
         InputImageType::Pointer img = m_InputImages->GetElement(i);
         int x = img->GetLargestPossibleRegion().GetSize(0);
         int y = img->GetLargestPossibleRegion().GetSize(1);
         int z = img->GetLargestPossibleRegion().GetSize(2);
 
         ItkDirectionImageType::Pointer directionImage = ItkDirectionImageType::New();
         directionImage->SetSpacing( spacing3 );
         directionImage->SetOrigin( origin3 );
         directionImage->SetDirection( direction3 );
         directionImage->SetRegions( imageRegion3 );
         directionImage->Allocate();
         Vector< PixelType, 3 > nullVec; nullVec.Fill(0.0);
         directionImage->FillBuffer(nullVec);
 
         for (int a=0; a<x; a++)
             for (int b=0; b<y; b++)
                 for (int c=0; c<z; c++)
                 {
                     // generate vector field
                     typename InputImageType::IndexType index;
                     index.SetElement(0,a);
                     index.SetElement(1,b);
                     index.SetElement(2,c);
                     vnl_vector<double> dirVec; dirVec.set_size(4);
                     for (int k=0; k<3; k++)
                     {
                         index.SetElement(3,k);
                         dirVec[k] = img->GetPixel(index);
                     }
                     dirVec[3] = 0;
 
                     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
                     itk::ContinuousIndex<double, 4> center;
                     center[0] = index[0];
                     center[1] = index[1];
                     center[2] = index[2];
                     center[3] = 0;
                     itk::Point<double, 4> worldCenter;
                     img->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
 
                     switch (m_NormalizationMethod)
                     {
                     case NO_NORM:
                         break;
                     case SINGLE_VEC_NORM:
                         dirVec.normalize();
                         break;
                     }
                     dirVec.normalize();
                     dirVec = img->GetDirection()*dirVec;
 
                     itk::Point<double> worldStart;
                     worldStart[0] = worldCenter[0]-dirVec[0]/2 * minSpacing;
                     worldStart[1] = worldCenter[1]-dirVec[1]/2 * minSpacing;
                     worldStart[2] = worldCenter[2]-dirVec[2]/2 * minSpacing;
                     vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
                     container->GetPointIds()->InsertNextId(id);
                     itk::Point<double> worldEnd;
                     worldEnd[0] = worldCenter[0]+dirVec[0]/2 * minSpacing;
                     worldEnd[1] = worldCenter[1]+dirVec[1]/2 * minSpacing;
                     worldEnd[2] = worldCenter[2]+dirVec[2]/2 * minSpacing;
                     id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
                     container->GetPointIds()->InsertNextId(id);
                     m_VtkCellArray->InsertNextCell(container);
 
                     // generate direction image
                     typename ItkDirectionImageType::IndexType index2;
                     index2[0] = index[0]; index2[1] = index[1]; index2[2] = index[2];
 
 
                     Vector< PixelType, 3 > pixel;
                     pixel.SetElement(0, dirVec[0]);
                     pixel.SetElement(1, dirVec[1]);
                     pixel.SetElement(2, dirVec[2]);
                     directionImage->SetPixel(index2, pixel);
                 }
 
         m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), directionImage);
     }
 
     vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
     directionsPolyData->SetPoints(m_VtkPoints);
     directionsPolyData->SetLines(m_VtkCellArray);
-    m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
+    m_OutputFiberBundle = mitk::FiberBundle::New(directionsPolyData);
 }
 
 }
 
 #endif // __itkFslPeakImageConverter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.h
index a118e35021..9639353f6d 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFslPeakImageConverter.h
@@ -1,89 +1,89 @@
 /*=========================================================================
 
   Program:   Insight Segmentation & Registration Toolkit
   Module:    $RCSfile: itkDiffusionTensor3DReconstructionImageFilter.h,v $
   Language:  C++
   Date:      $Date: 2006-03-27 17:01:06 $
   Version:   $Revision: 1.12 $
 
   Copyright (c) Insight Software Consortium. All rights reserved.
   See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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 __itkFslPeakImageConverter_h_
 #define __itkFslPeakImageConverter_h_
 
 #include <itkImageToImageFilter.h>
 #include <itkVectorContainer.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <itkOrientationDistributionFunction.h>
 
 namespace itk{
 /** \class FslPeakImageConverter
-  Converts a series of 4D images containing directional (3D vector) information into a vector field stored as mitkFiberBundleX.
+  Converts a series of 4D images containing directional (3D vector) information into a vector field stored as mitkFiberBundle.
   These 4D files are for example generated by the FSL qboot command.
 */
 
 template< class PixelType >
 class FslPeakImageConverter : public ProcessObject
 {
 
 public:
 
   enum NormalizationMethods {
     NO_NORM,            ///< don't normalize peaks
     SINGLE_VEC_NORM     ///< normalize peaks to length 1
   };
 
   typedef FslPeakImageConverter Self;
   typedef SmartPointer<Self>                      Pointer;
   typedef SmartPointer<const Self>                ConstPointer;
   typedef ProcessObject Superclass;
 
    /** Method for creation through the object factory. */
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   /** Runtime information support. */
   itkTypeMacro(FslPeakImageConverter, ImageToImageFilter)
 
   typedef vnl_vector_fixed< double, 3 >                                 DirectionType;
   typedef VectorContainer< int, DirectionType >                         DirectionContainerType;
   typedef VectorContainer< int, DirectionContainerType::Pointer >       ContainerType;
   typedef Image< float, 4 >                                             InputImageType;
   typedef VectorContainer< int, InputImageType::Pointer >               InputType;
   typedef Image< Vector< float, 3 >, 3>                                 ItkDirectionImageType;
   typedef VectorContainer< int, ItkDirectionImageType::Pointer >        DirectionImageContainerType;
 
   itkSetMacro( NormalizationMethod, NormalizationMethods)                       ///< normalization method of ODF peaks
   itkSetMacro( InputImages, InputType::Pointer)                                 ///< MRtrix peak image of type itk::Image< float, 4 >
-  itkGetMacro( OutputFiberBundle, mitk::FiberBundleX::Pointer)                  ///< vector field (peak sizes rescaled for visualization purposes)
+  itkGetMacro( OutputFiberBundle, mitk::FiberBundle::Pointer)                  ///< vector field (peak sizes rescaled for visualization purposes)
   itkGetMacro( DirectionImageContainer, DirectionImageContainerType::Pointer)   ///< container for output peaks
 
   void GenerateData();
 
 protected:
   FslPeakImageConverter();
   ~FslPeakImageConverter(){}
 
   NormalizationMethods                  m_NormalizationMethod;      ///< normalization method of ODF peaks
-  mitk::FiberBundleX::Pointer           m_OutputFiberBundle;        ///< vector field (peak sizes rescaled for visualization purposes)
+  mitk::FiberBundle::Pointer           m_OutputFiberBundle;        ///< vector field (peak sizes rescaled for visualization purposes)
   InputType::Pointer                    m_InputImages;              ///< MRtrix peak image of type itk::Image< float, 4 >
   DirectionImageContainerType::Pointer  m_DirectionImageContainer;  ///< container for output peaks
 
 private:
 
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkFslPeakImageConverter.cpp"
 #endif
 
 #endif //__itkFslPeakImageConverter_h_
 
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.cpp
index 49a5fc6b7e..9dc2978402 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.cpp
@@ -1,211 +1,211 @@
 /*===================================================================
 
 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 __itkMrtrixPeakImageConverter_cpp
 #define __itkMrtrixPeakImageConverter_cpp
 
 #include <time.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "itkMrtrixPeakImageConverter.h"
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionIterator.h>
 #include <itkContinuousIndex.h>
 
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 
 
 namespace itk {
 
 template< class PixelType >
 MrtrixPeakImageConverter< PixelType >::MrtrixPeakImageConverter():
     m_NormalizationMethod(NO_NORM)
 {
 
 }
 
 template< class PixelType >
 void MrtrixPeakImageConverter< PixelType >
 ::GenerateData()
 {
     // output vector field
     vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints>    m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
 
     Vector<float, 4> spacing4 = m_InputImage->GetSpacing();
     Point<float, 4> origin4 = m_InputImage->GetOrigin();
     Matrix<double, 4, 4> direction4 = m_InputImage->GetDirection();
     ImageRegion<4> imageRegion4 = m_InputImage->GetLargestPossibleRegion();
 
     Vector<double, 3> spacing3;
     Point<float, 3> origin3;
     Matrix<double, 3, 3> direction3;
     ImageRegion<3> imageRegion3;
 
     spacing3[0] = spacing4[0]; spacing3[1] = spacing4[1]; spacing3[2] = spacing4[2];
     origin3[0] = origin4[0]; origin3[1] = origin4[1]; origin3[2] = origin4[2];
     for (int r=0; r<3; r++)
         for (int c=0; c<3; c++)
             direction3[r][c] = direction4[r][c];
     imageRegion3.SetSize(0, imageRegion4.GetSize()[0]);
     imageRegion3.SetSize(1, imageRegion4.GetSize()[1]);
     imageRegion3.SetSize(2, imageRegion4.GetSize()[2]);
 
     double minSpacing = spacing3[0];
     if (spacing3[1]<minSpacing)
         minSpacing = spacing3[1];
     if (spacing3[2]<minSpacing)
         minSpacing = spacing3[2];
 
     m_DirectionImageContainer = DirectionImageContainerType::New();
 
     typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
 
     int x = m_InputImage->GetLargestPossibleRegion().GetSize(0);
     int y = m_InputImage->GetLargestPossibleRegion().GetSize(1);
     int z = m_InputImage->GetLargestPossibleRegion().GetSize(2);
     int numDirs = m_InputImage->GetLargestPossibleRegion().GetSize(3)/3;
 
     m_NumDirectionsImage = ItkUcharImgType::New();
     m_NumDirectionsImage->SetSpacing( spacing3 );
     m_NumDirectionsImage->SetOrigin( origin3 );
     m_NumDirectionsImage->SetDirection( direction3 );
     m_NumDirectionsImage->SetRegions( imageRegion3 );
     m_NumDirectionsImage->Allocate();
     m_NumDirectionsImage->FillBuffer(0);
 
     for (int i=0; i<numDirs; i++)
     {
         ItkDirectionImageType::Pointer directionImage = ItkDirectionImageType::New();
         directionImage->SetSpacing( spacing3 );
         directionImage->SetOrigin( origin3 );
         directionImage->SetDirection( direction3 );
         directionImage->SetRegions( imageRegion3 );
         directionImage->Allocate();
         Vector< PixelType, 3 > nullVec; nullVec.Fill(0.0);
         directionImage->FillBuffer(nullVec);
         m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), directionImage);
     }
 
     double minangle = 0;
     for (int i=0; i<numDirs; i++)
     {
         for (int a=0; a<x; a++)
             for (int b=0; b<y; b++)
                 for (int c=0; c<z; c++)
                 {
                     // generate vector field
                     typename InputImageType::IndexType index;
                     index.SetElement(0,a);
                     index.SetElement(1,b);
                     index.SetElement(2,c);
                     vnl_vector<double> dirVec; dirVec.set_size(4);
                     for (int k=0; k<3; k++)
                     {
                         index.SetElement(3,k+i*3);
                         dirVec[k] = m_InputImage->GetPixel(index);
                     }
                     dirVec[3] = 0;
 
                     if (dirVec.magnitude()<0.0001)
                         continue;
 
                     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
                     itk::ContinuousIndex<double, 4> center;
                     center[0] = index[0];
                     center[1] = index[1];
                     center[2] = index[2];
                     center[3] = 0;
                     itk::Point<double, 4> worldCenter;
                     m_InputImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
 
                     switch (m_NormalizationMethod)
                     {
                     case NO_NORM:
                         break;
                     case SINGLE_VEC_NORM:
                         dirVec.normalize();
                         break;
                     }
                     dirVec.normalize();
                     dirVec = m_InputImage->GetDirection()*dirVec;
 
                     itk::Point<double> worldStart;
                     worldStart[0] = worldCenter[0]-dirVec[0]/2 * minSpacing;
                     worldStart[1] = worldCenter[1]-dirVec[1]/2 * minSpacing;
                     worldStart[2] = worldCenter[2]-dirVec[2]/2 * minSpacing;
                     vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
                     container->GetPointIds()->InsertNextId(id);
                     itk::Point<double> worldEnd;
                     worldEnd[0] = worldCenter[0]+dirVec[0]/2 * minSpacing;
                     worldEnd[1] = worldCenter[1]+dirVec[1]/2 * minSpacing;
                     worldEnd[2] = worldCenter[2]+dirVec[2]/2 * minSpacing;
                     id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
                     container->GetPointIds()->InsertNextId(id);
                     m_VtkCellArray->InsertNextCell(container);
 
                     // generate direction image
                     typename ItkDirectionImageType::IndexType index2;
                     index2[0] = a; index2[1] = b; index2[2] = c;
 
                     // workaround *********************************************
                     dirVec = m_InputImage->GetDirection()*dirVec;
                     dirVec.normalize();
                     // workaround *********************************************
 
                     Vector< PixelType, 3 > pixel;
                     pixel.SetElement(0, dirVec[0]);
                     pixel.SetElement(1, dirVec[1]);
                     pixel.SetElement(2, dirVec[2]);
 
                     for (int j=0; j<numDirs; j++)
                     {
                         ItkDirectionImageType::Pointer directionImage = m_DirectionImageContainer->ElementAt(j);
                         Vector< PixelType, 3 > tempPix = directionImage->GetPixel(index2);
 
                         if (tempPix.GetNorm()<0.01)
                         {
                             directionImage->SetPixel(index2, pixel);
                             break;
                         }
                         else
                         {
                             if ( fabs(dot_product(tempPix.GetVnlVector(), pixel.GetVnlVector()))>minangle )
                             {
                                 minangle = fabs(dot_product(tempPix.GetVnlVector(), pixel.GetVnlVector()));
                                 MITK_INFO << "Minimum angle: " << acos(minangle)*180.0/M_PI;
                             }
                         }
                     }
 
                     m_NumDirectionsImage->SetPixel(index2, m_NumDirectionsImage->GetPixel(index2)+1);
                 }
     }
 
     vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
     directionsPolyData->SetPoints(m_VtkPoints);
     directionsPolyData->SetLines(m_VtkCellArray);
-    m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
+    m_OutputFiberBundle = mitk::FiberBundle::New(directionsPolyData);
 }
 
 }
 
 #endif // __itkMrtrixPeakImageConverter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.h
index ef134afc8f..34ad3f0e95 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkMrtrixPeakImageConverter.h
@@ -1,91 +1,91 @@
 /*=========================================================================
 
   Program:   Insight Segmentation & Registration Toolkit
   Module:    $RCSfile: itkDiffusionTensor3DReconstructionImageFilter.h,v $
   Language:  C++
   Date:      $Date: 2006-03-27 17:01:06 $
   Version:   $Revision: 1.12 $
 
   Copyright (c) Insight Software Consortium. All rights reserved.
   See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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 __itkMrtrixPeakImageConverter_h_
 #define __itkMrtrixPeakImageConverter_h_
 
 #include <itkImageToImageFilter.h>
 #include <itkVectorContainer.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <itkOrientationDistributionFunction.h>
 
 namespace itk{
 /** \class MrtrixPeakImageConverter
-  Converts a series of 4D images containing directional (3D vector) information into a vector field stored as mitkFiberBundleX.
+  Converts a series of 4D images containing directional (3D vector) information into a vector field stored as mitkFiberBundle.
   These 4D files are for example generated by the FSL qboot command.
 */
 
 template< class PixelType >
 class MrtrixPeakImageConverter : public ProcessObject
 {
 
 public:
 
   enum NormalizationMethods {
     NO_NORM,            ///< don't normalize peaks
     SINGLE_VEC_NORM     ///< normalize peaks to length 1
   };
 
   typedef MrtrixPeakImageConverter Self;
   typedef SmartPointer<Self>                      Pointer;
   typedef SmartPointer<const Self>                ConstPointer;
   typedef ProcessObject Superclass;
 
    /** Method for creation through the object factory. */
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   /** Runtime information support. */
   itkTypeMacro(MrtrixPeakImageConverter, ImageToImageFilter)
 
   typedef vnl_vector_fixed< double, 3 >                                 DirectionType;
   typedef VectorContainer< int, DirectionType >                         DirectionContainerType;
   typedef VectorContainer< int, DirectionContainerType::Pointer >       ContainerType;
   typedef Image< float, 4 >                                             InputImageType;
   typedef Image< Vector< float, 3 >, 3>                                 ItkDirectionImageType;
   typedef VectorContainer< int, ItkDirectionImageType::Pointer >        DirectionImageContainerType;
   typedef itk::Image<unsigned char, 3>                                  ItkUcharImgType;
 
   itkSetMacro( NormalizationMethod, NormalizationMethods)                       ///< normalization method of ODF peaks
   itkSetMacro( InputImage, InputImageType::Pointer)                             ///< MRtrix direction image of type itk::Image< float, 4 >
-  itkGetMacro( OutputFiberBundle, mitk::FiberBundleX::Pointer)                  ///< vector field (peak sizes rescaled for visualization purposes)
+  itkGetMacro( OutputFiberBundle, mitk::FiberBundle::Pointer)                  ///< vector field (peak sizes rescaled for visualization purposes)
   itkGetMacro( DirectionImageContainer, DirectionImageContainerType::Pointer)   ///< container for output peaks
   itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer)                    ///< number of peaks per voxel
 
   void GenerateData();
 
 protected:
   MrtrixPeakImageConverter();
   ~MrtrixPeakImageConverter(){}
 
   NormalizationMethods                  m_NormalizationMethod;          ///< normalization method of ODF peaks
-  mitk::FiberBundleX::Pointer           m_OutputFiberBundle;            ///< vector field (peak sizes rescaled for visualization purposes)
+  mitk::FiberBundle::Pointer           m_OutputFiberBundle;            ///< vector field (peak sizes rescaled for visualization purposes)
   InputImageType::Pointer               m_InputImage;                   ///< MRtrix direction image of type itk::Image< float, 4 >
   DirectionImageContainerType::Pointer  m_DirectionImageContainer;      ///< container for output peaks
   ItkUcharImgType::Pointer              m_NumDirectionsImage;           ///< number of peaks per voxel
 
 private:
 
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkMrtrixPeakImageConverter.cpp"
 #endif
 
 #endif //__itkMrtrixPeakImageConverter_h_
 
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.cpp
index 23a79eb8cf..c7acd3de0f 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.cpp
@@ -1,629 +1,629 @@
 /*===================================================================
 
 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 __itkOdfMaximaExtractionFilter_cpp
 #define __itkOdfMaximaExtractionFilter_cpp
 
 
 #include "itkOdfMaximaExtractionFilter.h"
 #include <itkImageRegionIterator.h>
 #include <itkContinuousIndex.h>
 
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 
 #include <boost/progress.hpp>
 #include <boost/math/special_functions.hpp>
 #include <vnl/vnl_det.h>
 #include <vnl/vnl_trace.h>
 
 using namespace boost::math;
 using namespace std;
 
 namespace itk {
 
 template< class TOdfPixelType >
 OdfMaximaExtractionFilter< TOdfPixelType >::OdfMaximaExtractionFilter():
     m_NormalizationMethod(MAX_VEC_NORM),
     m_PeakThreshold(0.2),
     m_MaxNumPeaks(10),
     m_ShCoeffImage(NULL),
     m_OutputFiberBundle(NULL),
     m_NumDirectionsImage(NULL),
     m_DirectionImageContainer(NULL)
 {
 
 }
 
 // solve ax? + bx? + cx + d = 0 using cardanos method
 template< class TOdfPixelType >
 bool OdfMaximaExtractionFilter<TOdfPixelType>::ReconstructQballImage()
 {
     if (m_ShCoeffImage.IsNotNull())
     {
         cout << "Using preset coefficient image\n";
         return true;
     }
 
     cout << "Starting qball reconstruction\n";
     try {
         QballReconstructionFilterType::Pointer filter = QballReconstructionFilterType::New();
         filter->SetGradientImage( m_DiffusionGradients, m_DiffusionImage );
         filter->SetBValue(m_Bvalue);
         filter->SetLambda(0.006);
         filter->SetNormalizationMethod(QballReconstructionFilterType::QBAR_SOLID_ANGLE);
         filter->Update();
         m_ShCoeffImage = filter->GetCoefficientImage();
         if (m_ShCoeffImage.IsNull())
             return false;
         return true;
     }
     catch (...)
     {
         return false;
     }
 }
 
 // solve ax³ + bx² + cx + d = 0 using cardanos method
 template< class TOdfPixelType >
 std::vector<double> OdfMaximaExtractionFilter< TOdfPixelType >
 ::SolveCubic(const double& a, const double& b, const double& c, const double& d)
 {
     double A, B, p, q, r, D, offset, ee, tmp, root;
     vector<double> roots;
     double inv3 = 1.0/3.0;
 
     if (a!=0) // solve ax³ + bx² + cx + d = 0
     {
         p = b/a; q = c/a; r = d/a; // x³ + px² + qx + r = 0
         A = q-p*p*inv3;
         B = (2.0*p*p*p-9.0*p*q+27.0*r)/27.0;
         A = A*inv3;
         B = B*0.5;
         D = B*B+A*A*A;
         offset = p*inv3;
 
         if (D>0.0) // one real root
         {
             ee = sqrt(D);
             tmp = -B+ee;  root  = cbrt(tmp);
             tmp = -B-ee;  root += cbrt(tmp);
             root -= offset; roots.push_back(root);
         }
         else if (D<0.0) // three real roots
         {
             ee = sqrt(-D);
             double tmp2 = -B;
             double angle =  2.0*inv3*atan(ee/(sqrt(tmp2*tmp2+ee*ee)+tmp2));
             double sqrt3 = sqrt(3.0);
             tmp = cos(angle);
             tmp2 = sin(angle);
             ee = sqrt(-A);
             root = 2*ee*tmp-offset;             roots.push_back(root);
             root = -ee*(tmp+sqrt3*tmp2)-offset; roots.push_back(root);
             root = -ee*(tmp-sqrt3*tmp2)-offset; roots.push_back(root);
         }
         else // one or two real roots
         {
             tmp=-B;
             tmp=cbrt(tmp);
             root=2*tmp-offset;      roots.push_back(root);
             if (A!=0 || B!=0)
                 root=-tmp-offset;   roots.push_back(root);
         }
     }
     else if (b!=0) // solve bx² + cx + d = 0
     {
         D = c*c-4*b*d;
         if (D>0)
         {
             tmp = sqrt(D);
             root = (-c+tmp)/(2.0*b); roots.push_back(root);
             root = (-c-tmp)/(2.0*b); roots.push_back(root);
         }
         else if (D==0)
             root = -c/(2.0*b); roots.push_back(root);
     }
     else if (c!=0) // solve cx + d = 0
         root = -d/c; roots.push_back(root);
 
     return roots;
 }
 
 template< class TOdfPixelType >
 double OdfMaximaExtractionFilter< TOdfPixelType >
 ::ODF_dtheta(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H)
 {
     double dtheta=(G-7*E)*sn*sn + (7*F-35*D-H)*sn*cs + (H+C-F-3*A-5*D)*sn + (0.5*E+B+0.5*G)*cs -0.5*G+3.5*E;
     return dtheta;
 }
 
 template< class TOdfPixelType >
 double OdfMaximaExtractionFilter< TOdfPixelType >
 ::ODF_dtheta2(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H)
 {
     double dtheta2=4*(G-7*E)*sn*cs + 2*(7*F-35*D-H)*(2*cs*cs-1) + 2*(H+C-F-3*A-5*D)*cs -(E+2*B+G)*sn;
     return dtheta2;
 }
 
 template< class TOdfPixelType >
 double OdfMaximaExtractionFilter< TOdfPixelType >
 ::ODF_dphi2(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H)
 {
     double dphi2=35*D*((1+cs)*(1+cs)/4)+(3*A-30*D)*(1+cs)/2.0+3*D-A + 0.5*(7*E*(1+cs)/2.0-3*E+B)*sn + (7*F*(1+cs)/2+C-F)*(1-cs)/2.0 + G*sn*(1-cs)/4.0 + H*((1-cs)*(1-cs)/4);
     return dphi2;
 }
 
 template< class TOdfPixelType >
 void OdfMaximaExtractionFilter< TOdfPixelType >
 ::FindCandidatePeaks(const CoefficientPixelType& SHcoeff)
 {
     const double thr = 0.03;             // threshold on the derivative of the ODF with respect to theta
     const double phi_step = 0.005;       // step size for 1D exhaustive search on phi
     bool highRes;                        // when close to maxima increase resolution
     double mag, Y, Yp, sn, cs;
     double phi, dPhi;
     double A, B, C, D, E, F, G, H, Bp, Cp, Ep, Fp, Gp, Hp, Bs, Cs, Es, Fs, Gs, Hs;
     CoefficientPixelType a, ap;
     a = SHcoeff; ap = SHcoeff;
 
     m_CandidatePeaks.clear();   // clear peaks of last voxel
 
     for (int adaptiveStepwidth=0; adaptiveStepwidth<=1; adaptiveStepwidth++)
     {
     phi=0;
     while (phi<(2*M_PI)) // phi exhaustive search 0..pi
     {
         // calculate 4th order SH representtaion of ODF and according derivative
         for (int l=0; l<=4; l=l+2)
         {
             for (int m=-l; m<=l; m++)
             {
                 int j=l*(l+1)/2+m;
                 if (m<0)
                 {
                     mag = sqrt(((2*l+1)/(2*M_PI))*factorial<double>(l+m)/factorial<double>(l-m));
                     Y = mag*cos(m*phi);
                     Yp = -m*mag*sin(m*phi);
                 }
                 else if (m==0)
                 {
                     Y = sqrt((2*l+1)/(4*M_PI));
                     Yp = 0;
                 }
                 else
                 {
                     mag = pow(-1.0,m)*sqrt(((2*l+1)/(2*M_PI))*factorial<double>(l-m)/factorial<double>(l+m));
                     Y = mag*sin(m*phi);
                     Yp = m*mag*cos(m*phi);
                 }
                 a[j] = SHcoeff[j]*Y;
                 ap[j] = SHcoeff[j]*Yp;
             }
         }
 
         // ODF
         A=0.5*a[3]; B=-3*(a[2]+a[4]); C=3*(a[1]+a[5]); D=0.125*a[10]; E=-2.5*(a[9]+a[11]);
         F=7.5*(a[8]+a[12]); G=-105*(a[7]+a[13]); H=105*(a[6]+a[14]);
 
         // phi derivative
         Bp=-3*(ap[2]+ap[4]); Cp=3*(ap[1]+ap[5]); Ep=-2.5*(ap[9]+ap[11]);
         Fp=7.5*(ap[8]+ap[12]); Gp=-105*(ap[7]+ap[13]); Hp=105*(ap[6]+ap[14]);
 
         // 2phi derivative
         Bs=-B;    Cs=-4*C;  Es=-E;
         Fs=-4*F;  Gs=-9*G;  Hs=-16*H;
 
         // solve cubic for tan(theta)
         std::vector<double> tanTheta = SolveCubic(Hp+Cp-Fp, Gp+Bp-3*Ep, 6*Fp+Cp, Bp+4*Ep);
 
         highRes = false;
         dPhi = phi_step;
 
         //for each real cubic solution for tan(theta)
         for (int n=0; n<tanTheta.size(); n++)
         {
             double tmp = atan(tanTheta[n]); // arcus tangens of root (theta -pi/2..pi/2)
             double theta = floor(tmp/M_PI); // project theta to 0..pi ...
             theta = tmp - theta*M_PI;       // ... as the modulo of the division atan(tth[n])/M_PI
 
             sn = sin(2*theta); cs = cos(2*theta);
             tmp = ODF_dtheta(sn, cs, A, B, C, D, E, F, G, H);
 
             if (fabs(tmp) < thr) // second condition for maximum is true (theta derivative < eps)
             {
                 //Compute the Hessian
                 vnl_matrix_fixed< double, 2, 2 > hessian;
                 hessian(0,0) = ODF_dtheta2(sn, cs, A, B, C, D, E, F, G, H);
                 hessian(0,1) = ODF_dtheta(sn, cs, 0, Bp, Cp, 0, Ep, Fp, Gp, Hp);
                 hessian(1,0) = hessian(0,1);
                 hessian(1,1) = ODF_dphi2(sn, cs, 0, Bs, Cs, 0, Es, Fs, Gs, Hs);
 
                 double det = vnl_det(hessian);  // determinant
                 double tr = vnl_trace(hessian); // trace
 
                 highRes = true; // we are close to a maximum, so turn on high resolution 1D exhaustive search
                 if (det>=0 && tr<=0) // check if we really have a local maximum
                 {
                     vnl_vector_fixed< double, 2 > peak;
                     peak[0] = theta;
                     peak[1] = phi;
                     m_CandidatePeaks.push_back(peak);
                 }
             }
 
             if (adaptiveStepwidth) // calculate adaptive step width
             {
                 double t2=tanTheta[n]*tanTheta[n];  double t3=t2*tanTheta[n]; double t4=t3*tanTheta[n];
                 double const_step=phi_step*(1+t2)/sqrt(t2+t4+pow((((Hs+Cs-Fs)*t3+(Gs+Bs-3*Es)*t2+(6*Fs+Cs)*tanTheta[n]+(Bs+4*Es))/(3*(Hp+Cp-Fp)*t2+2*(Gp+Bp-3*Ep)*tanTheta[n]+(6*Fp+Cp))),2.0));
                 if (const_step<dPhi)
                     dPhi=const_step;
             }
         }
 
         // update phi
         if (highRes)
             phi=phi+dPhi*0.5;
         else
             phi=phi+dPhi;
     }
     }
 }
 
 template< class TOdfPixelType >
 std::vector< vnl_vector_fixed< double, 3 > > OdfMaximaExtractionFilter< TOdfPixelType >
 ::ClusterPeaks(const CoefficientPixelType& shCoeff)
 {
     const double distThres = 0.4;
     int npeaks = 0, nMin = 0;
     double dMin, dPos, dNeg, d;
     Vector3D u;
     vector< Vector3D > v;
 
     // initialize container for vector clusters
     std::vector < std::vector< Vector3D > > clusters;
     clusters.resize(m_CandidatePeaks.size());
 
     for (int i=0; i<m_CandidatePeaks.size(); i++)
     {
         // calculate cartesian representation of peak
         u[0] = sin(m_CandidatePeaks[i](0))*cos(m_CandidatePeaks[i](1));
         u[1] = sin(m_CandidatePeaks[i](0))*sin(m_CandidatePeaks[i](1));
         u[2] = cos(m_CandidatePeaks[i](0));
 
         dMin = itk::NumericTraits<double>::max();
         for (int n=0; n<npeaks; n++) //for each other maximum v already visited
         {
             // euclidean distance from u/-u to other clusters
             dPos = vnl_vector_ssd(v[n],u);
             dNeg = vnl_vector_ssd(v[n],-u);
             d = std::min(dPos,dNeg);
 
             if ( d<dMin )
             {
                 dMin = d; // adjust minimum
                 nMin = n; // store its index
                 if ( dNeg<dPos ) // flip u if neccesary
                     u=-u;
             }
         }
         if ( dMin<distThres ) // if u is very close to any other maximum v
         {
             clusters[nMin].push_back(u);  //store it with all other vectors that are close to v vector (with index nMin)
         }
         else // otherwise store u as output peak
         {
             v.push_back(u);
             npeaks++;
         }
     }
 
     // calculate mean vector of each cluster
     for (int i=0; i<m_CandidatePeaks.size(); i++)
         if ( !clusters[i].empty() )
         {
             v[i].fill(0.0);
             for (int vc=0; vc<clusters[i].size(); vc++)
                 v[i]=v[i]+clusters[i][vc];
             v[i].normalize();
         }
 
 
     if (npeaks!=0)
     {
         // check the ODF amplitudes at each candidate peak
         vnl_matrix< double > shBasis, sphCoords;
 
         Cart2Sph(v, sphCoords);                 // convert candidate peaks to spherical angles
         shBasis = CalcShBasis(sphCoords, 4);  // evaluate spherical harmonics at each peak
         vnl_vector<double> odfVals(npeaks);
         odfVals.fill(0.0);
         double maxVal = itk::NumericTraits<double>::NonpositiveMin();
         int maxPos;
         for (int i=0; i<npeaks; i++) //compute the ODF value at each peak
         {
             for (int j=0; j<15; j++)
                 odfVals(i) += shCoeff[j]*shBasis(i,j);
 
             if ( odfVals(i)>maxVal )
             {
                 maxVal = odfVals(i);
                 maxPos = i;
             }
         }
         v.clear();
         vector< double > restVals;
         for (int i=0; i<npeaks; i++) // keep only peaks with high enough amplitude and convert back to cartesian coordinates
             if ( odfVals(i)>=m_PeakThreshold*maxVal )
             {
                 u[0] = odfVals(i)*cos(sphCoords(i,1))*sin(sphCoords(i,0));
                 u[1] = odfVals(i)*sin(sphCoords(i,1))*sin(sphCoords(i,0));
                 u[2] = odfVals(i)*cos(sphCoords(i,0));
                 restVals.push_back(odfVals(i));
                 v.push_back(u);
             }
         npeaks = v.size();
 
         if (npeaks>m_MaxNumPeaks) // if still too many peaks, keep only the m_MaxNumPeaks with maximum value
         {
             vector< Vector3D > v2;
             for (int i=0; i<m_MaxNumPeaks; i++)
             {
                 maxVal = itk::NumericTraits<double>::NonpositiveMin();  //Get the maximum ODF peak value and the corresponding peak index
                 for (int i=0; i<npeaks; i++)
                     if ( restVals[i]>maxVal )
                     {
                         maxVal = restVals[i];
                         maxPos = i;
                     }
 
                 v2.push_back(v[maxPos]);
                 restVals[maxPos] = 0;               //zero that entry in order to find the next maximum
             }
             return v2;
         }
     }
     return v;
 }
 
 // convert cartesian to spherical coordinates
 template< class TOdfPixelType >
 void OdfMaximaExtractionFilter< TOdfPixelType >
 ::Cart2Sph(const std::vector< Vector3D >& dir, vnl_matrix<double>& sphCoords)
 {
     sphCoords.set_size(dir.size(), 2);
 
     for (int i=0; i<dir.size(); i++)
     {
         double mag = dir[i].magnitude();
 
         if( mag<mitk::eps )
         {
             sphCoords(i,0) = M_PI/2; // theta
             sphCoords(i,1) = M_PI/2; // phi
         }
         else
         {
             sphCoords(i,0) = acos(dir[i](2)/mag); // theta
             sphCoords(i,1) = atan2(dir[i](1), dir[i](0)); // phi
         }
     }
 }
 
 // generate spherical harmonic values of the desired order for each input direction
 template< class TOdfPixelType >
 vnl_matrix<double> OdfMaximaExtractionFilter< TOdfPixelType >
 ::CalcShBasis(vnl_matrix<double>& sphCoords, const int& shOrder)
 {
     int R = (shOrder+1)*(shOrder+2)/2;
     int M = sphCoords.rows();
     int j, m; double mag, plm;
     vnl_matrix<double> shBasis;
     shBasis.set_size(M,R);
 
     for (int p=0; p<M; p++)
     {
         j=0;
         for (int l=0; l<=shOrder; l=l+2)
             for (m=-l; m<=l; m++)
             {
                 plm = legendre_p<double>(l,abs(m),cos(sphCoords(p,0)));
                 mag = sqrt((double)(2*l+1)/(4.0*M_PI)*factorial<double>(l-abs(m))/factorial<double>(l+abs(m)))*plm;
 
                 if (m<0)
                     shBasis(p,j) = sqrt(2.0)*mag*cos(fabs((double)m)*sphCoords(p,1));
                 else if (m==0)
                     shBasis(p,j) = mag;
                 else
                     shBasis(p,j) = pow(-1.0, m)*sqrt(2.0)*mag*sin(m*sphCoords(p,1));
                 j++;
             }
     }
     return shBasis;
 }
 
 template< class TOdfPixelType >
 void OdfMaximaExtractionFilter< TOdfPixelType >
 ::GenerateData()
 {
     if (!ReconstructQballImage())
         return;
 
     std::cout << "Starting maxima extraction\n";
 
     switch (m_NormalizationMethod)
     {
     case NO_NORM:
         std::cout << "NO_NORM\n";
         break;
     case SINGLE_VEC_NORM:
         std::cout << "SINGLE_VEC_NORM\n";
         break;
     case MAX_VEC_NORM:
         std::cout << "MAX_VEC_NORM\n";
         break;
     }
 
     typedef ImageRegionConstIterator< CoefficientImageType > InputIteratorType;
 
 
     InputIteratorType git(m_ShCoeffImage, m_ShCoeffImage->GetLargestPossibleRegion() );
 
     itk::Vector<double,3> spacing = m_ShCoeffImage->GetSpacing();
     double minSpacing = spacing[0];
     if (spacing[1]<minSpacing)
         minSpacing = spacing[1];
     if (spacing[2]<minSpacing)
         minSpacing = spacing[2];
 
     mitk::Point3D origin = m_ShCoeffImage->GetOrigin();
     itk::Matrix<double, 3, 3> direction = m_ShCoeffImage->GetDirection();
     ImageRegion<3> imageRegion = m_ShCoeffImage->GetLargestPossibleRegion();
 
     // initialize num directions image
     m_NumDirectionsImage = ItkUcharImgType::New();
     m_NumDirectionsImage->SetSpacing( spacing );
     m_NumDirectionsImage->SetOrigin( origin );
     m_NumDirectionsImage->SetDirection( direction );
     m_NumDirectionsImage->SetRegions( imageRegion );
     m_NumDirectionsImage->Allocate();
     m_NumDirectionsImage->FillBuffer(0);
 
     vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints>    m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
 
     m_DirectionImageContainer = ItkDirectionImageContainer::New();
     for (int i=0; i<m_MaxNumPeaks; i++)
     {
         itk::Vector< float, 3 > nullVec; nullVec.Fill(0.0);
         ItkDirectionImage::Pointer img = ItkDirectionImage::New();
         img->SetSpacing( spacing );
         img->SetOrigin( origin );
         img->SetDirection( direction );
         img->SetRegions( imageRegion );
         img->Allocate();
         img->FillBuffer(nullVec);
         m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), img);
     }
 
     if (m_MaskImage.IsNull())
     {
         m_MaskImage = ItkUcharImgType::New();
         m_MaskImage->SetSpacing( spacing );
         m_MaskImage->SetOrigin( origin );
         m_MaskImage->SetDirection( direction );
         m_MaskImage->SetRegions( imageRegion );
         m_MaskImage->Allocate();
         m_MaskImage->FillBuffer(1);
     }
 
     itk::ImageRegionIterator<ItkUcharImgType> dirIt(m_NumDirectionsImage, m_NumDirectionsImage->GetLargestPossibleRegion());
     itk::ImageRegionIterator<ItkUcharImgType> maskIt(m_MaskImage, m_MaskImage->GetLargestPossibleRegion());
 
     int maxProgress = m_MaskImage->GetLargestPossibleRegion().GetSize()[0]*m_MaskImage->GetLargestPossibleRegion().GetSize()[1]*m_MaskImage->GetLargestPossibleRegion().GetSize()[2];
 
     boost::progress_display disp(maxProgress);
 
     git.GoToBegin();
     while( !git.IsAtEnd() )
     {
         ++disp;
         if (maskIt.Value()<=0)
         {
             ++git;
             ++dirIt;
             ++maskIt;
             continue;
         }
 
         CoefficientPixelType c = git.Get();
         FindCandidatePeaks(c);
         std::vector< Vector3D > directions = ClusterPeaks(c);
 
         typename CoefficientImageType::IndexType index = git.GetIndex();
 
         float max = 0.0;
         for (int i=0; i<directions.size(); i++)
             if (directions.at(i).magnitude()>max)
                 max = directions.at(i).magnitude();
         if (max<0.0001)
             max = 1.0;
 
         for (int i=0; i<directions.size(); i++)
         {
             ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
             itk::Vector< float, 3 > pixel;
             vnl_vector<double> dir = directions.at(i);
 
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             itk::ContinuousIndex<double, 3> center;
             center[0] = index[0];
             center[1] = index[1];
             center[2] = index[2];
             itk::Point<double> worldCenter;
             m_ShCoeffImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
 
             switch (m_NormalizationMethod)
             {
             case NO_NORM:
                 break;
             case SINGLE_VEC_NORM:
                 dir.normalize();
                 break;
             case MAX_VEC_NORM:
                 dir /= max;
                 break;
             }
 
             dir = m_MaskImage->GetDirection()*dir;
             pixel.SetElement(0, dir[0]);
             pixel.SetElement(1, dir[1]);
             pixel.SetElement(2, dir[2]);
             img->SetPixel(index, pixel);
 
             itk::Point<double> worldStart;
             worldStart[0] = worldCenter[0]-dir[0]/2 * minSpacing;
             worldStart[1] = worldCenter[1]-dir[1]/2 * minSpacing;
             worldStart[2] = worldCenter[2]-dir[2]/2 * minSpacing;
             vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
             container->GetPointIds()->InsertNextId(id);
             itk::Point<double> worldEnd;
             worldEnd[0] = worldCenter[0]+dir[0]/2 * minSpacing;
             worldEnd[1] = worldCenter[1]+dir[1]/2 * minSpacing;
             worldEnd[2] = worldCenter[2]+dir[2]/2 * minSpacing;
             id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
             container->GetPointIds()->InsertNextId(id);
             m_VtkCellArray->InsertNextCell(container);
         }
 
         dirIt.Set(directions.size());
 
         ++git;
         ++dirIt;
         ++maskIt;
     }
 
     vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
     directionsPolyData->SetPoints(m_VtkPoints);
     directionsPolyData->SetLines(m_VtkCellArray);
-    m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
+    m_OutputFiberBundle = mitk::FiberBundle::New(directionsPolyData);
     std::cout << "Maxima extraction finished\n";
 }
 }
 
 #endif // __itkOdfMaximaExtractionFilter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.h
index 179fccb036..5ec120bca7 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.h
@@ -1,145 +1,145 @@
 /*=========================================================================
 
   Program:   Insight Segmentation & Registration Toolkit
   Module:    $RCSfile: itkDiffusionTensor3DReconstructionImageFilter.h,v $
   Language:  C++
   Date:      $Date: 2006-03-27 17:01:06 $
   Version:   $Revision: 1.12 $
 
   Copyright (c) Insight Software Consortium. All rights reserved.
   See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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 __itkOdfMaximaExtractionFilter_h_
 #define __itkOdfMaximaExtractionFilter_h_
 
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 
 #include <itkImageToImageFilter.h>
 #include <itkVectorContainer.h>
 #include <itkOrientationDistributionFunction.h>
 #include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
 
 namespace itk{
 /** \class OdfMaximaExtractionFilter
 Class that estimates the maxima of the 4th order SH representation of an ODF using analytic calculations (according to Aganj et al, MICCAI, 2010)
  */
 
 template< class TOdfPixelType >
 class OdfMaximaExtractionFilter : public ProcessObject
 {
 
 public:
 
   enum NormalizationMethods {
     NO_NORM,            ///< don't normalize peaks
     SINGLE_VEC_NORM,    ///< normalize peaks to length 1
     MAX_VEC_NORM        ///< largest peak is normalized to length 1, other peaks relative to it
   };
 
   typedef OdfMaximaExtractionFilter Self;
   typedef SmartPointer<Self>                      Pointer;
   typedef SmartPointer<const Self>                ConstPointer;
   typedef ProcessObject Superclass;
 
    /** Method for creation through the object factory. */
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   /** Runtime information support. */
   itkTypeMacro(OdfMaximaExtractionFilter, ImageToImageFilter)
 
   typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> QballReconstructionFilterType;
   typedef QballReconstructionFilterType::CoefficientImageType                                       CoefficientImageType;
   typedef CoefficientImageType::PixelType                                                           CoefficientPixelType;
   typedef itk::VectorImage< short, 3 >                                                              DiffusionImageType;
   typedef vnl_vector_fixed< double, 3 >                                                             Vector3D;
   typedef VectorContainer< unsigned int, Vector3D >                                                 DirectionContainerType;
   typedef VectorContainer< unsigned int, DirectionContainerType::Pointer >                          ContainerType;
   typedef itk::Image<unsigned char, 3>                                                              ItkUcharImgType;
   typedef itk::Image< itk::Vector< float, 3 >, 3>                                                   ItkDirectionImage;
   typedef itk::VectorContainer< unsigned int, ItkDirectionImage::Pointer >                          ItkDirectionImageContainer;
 
   // output
-  itkGetMacro( OutputFiberBundle, mitk::FiberBundleX::Pointer)                  ///< vector field (peak sizes rescaled for visualization purposes)
+  itkGetMacro( OutputFiberBundle, mitk::FiberBundle::Pointer)                  ///< vector field (peak sizes rescaled for visualization purposes)
   itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer)                    ///< number of peaks per voxel
   itkGetMacro( DirectionImageContainer, ItkDirectionImageContainer::Pointer)    ///< container for output peaks
 
   // input
   itkSetMacro( MaskImage, ItkUcharImgType::Pointer)                 ///< only voxels inside the binary mask are processed
   itkSetMacro( NormalizationMethod, NormalizationMethods)           ///< normalization method of ODF peaks
   itkSetMacro( DiffusionGradients, DirectionContainerType::Pointer) ///< input for qball reconstruction
   itkSetMacro( DiffusionImage, DiffusionImageType::Pointer)         ///< input for qball reconstruction
   itkSetMacro( Bvalue, float)                                       ///< input for qball reconstruction
   itkSetMacro( ShCoeffImage, CoefficientImageType::Pointer)         ///< conatins spherical harmonic coefficients
   itkSetMacro( MaxNumPeaks, unsigned int)                           ///< if more peaks are found, only the largest are kept
   itkSetMacro( PeakThreshold, double)                               ///< threshold on peak length relative to the largest peak in the current voxel
 
   void GenerateData();
 
 protected:
   OdfMaximaExtractionFilter();
   ~OdfMaximaExtractionFilter(){}
 
   /** CSA Qball reconstruction (SH order 4) **/
   bool ReconstructQballImage();
 
   /** calculate roots of cubic equation ax³ + bx² + cx + d = 0 using cardanos method **/
   std::vector<double> SolveCubic(const double& a, const double& b, const double& c, const double& d);
 
   /** derivatives of SH representation of the ODF **/
   double ODF_dtheta2(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H);
 
   /** derivatives of SH representation of the ODF **/
   double ODF_dphi2(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H);
 
   /** derivatives of SH representation of the ODF **/
   double ODF_dtheta(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H);
 
   /** calculate all directions fullfilling the maximum consitions **/
   void FindCandidatePeaks(const CoefficientPixelType& SHcoeff);
 
   /** cluster the peaks detected by FindCandidatePeaks and retain maximum m_MaxNumPeaks **/
   std::vector< Vector3D > ClusterPeaks(const CoefficientPixelType& shCoeff);
 
   void Cart2Sph(const std::vector< Vector3D >& dir,  vnl_matrix<double>& sphCoords);
   vnl_matrix<double> CalcShBasis(vnl_matrix<double>& sphCoords, const int& shOrder);
 
   // diffusion weighted image (mandatory input)
   DirectionContainerType::Pointer           m_DiffusionGradients;   ///< input for qball reconstruction
   DiffusionImageType::Pointer               m_DiffusionImage;       ///< input for qball reconstruction
   float                                     m_Bvalue;               ///< input for qball reconstruction
 
   // binary mask image (optional input)
   ItkUcharImgType::Pointer                  m_MaskImage;            ///< only voxels inside the binary mask are processed
 
   // input parameters
   NormalizationMethods                      m_NormalizationMethod;  ///< normalization for peaks
   double                                    m_PeakThreshold;        ///< threshold on peak length relative to the largest peak in the current voxel
   unsigned int                              m_MaxNumPeaks;          ///< if more peaks are found, only the largest are kept
 
   // intermediate results
   CoefficientImageType::Pointer                 m_ShCoeffImage;     ///< conatins spherical harmonic coefficients
   std::vector< vnl_vector_fixed< double, 2 > >  m_CandidatePeaks;   ///< container for candidate peaks (all extrema, also minima)
 
   // output data
-  mitk::FiberBundleX::Pointer               m_OutputFiberBundle;        ///< vector field (peak sizes rescaled for visualization purposes)
+  mitk::FiberBundle::Pointer               m_OutputFiberBundle;        ///< vector field (peak sizes rescaled for visualization purposes)
   ItkUcharImgType::Pointer                  m_NumDirectionsImage;       ///< number of peaks per voxel
   ItkDirectionImageContainer::Pointer       m_DirectionImageContainer;  ///< output peaks
 
 private:
 
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkOdfMaximaExtractionFilter.cpp"
 #endif
 
 #endif //__itkOdfMaximaExtractionFilter_h_
 
diff --git a/Modules/DiffusionImaging/DiffusionIO/files.cmake b/Modules/DiffusionImaging/DiffusionIO/files.cmake
index f3a9cf5840..01f7540f91 100644
--- a/Modules/DiffusionImaging/DiffusionIO/files.cmake
+++ b/Modules/DiffusionImaging/DiffusionIO/files.cmake
@@ -1,41 +1,43 @@
 set(CPP_FILES
   mitkDiffusionModuleActivator.cpp
   mitkNrrdTbssImageWriterFactory.cpp
-  #mitkFiberBundleXIOFactory.cpp
+  #mitkFiberBundleIOFactory.cpp
   mitkConnectomicsNetworkReader.cpp
   mitkConnectomicsNetworkWriter.cpp
   mitkConnectomicsNetworkSerializer.cpp
   mitkConnectomicsNetworkDefinitions.cpp
   mitkNrrdTbssRoiImageIOFactory.cpp
-  #mitkFiberBundleXWriterFactory.cpp
+  #mitkFiberBundleWriterFactory.cpp
   mitkNrrdTbssRoiImageWriterFactory.cpp
   mitkNrrdTensorImageReader.cpp
   mitkNrrdTensorImageWriter.cpp
   mitkTensorImageSerializer.cpp
   mitkTensorImageSource.cpp
   mitkFiberTrackingObjectFactory.cpp
   mitkConnectomicsObjectFactory.cpp
   mitkQuantificationObjectFactory.cpp
   mitkNrrdTbssImageIOFactory.cpp
   mitkDiffusionCoreObjectFactory.cpp
 
   mitkDiffusionIOMimeTypes.cpp
 
   mitkDiffusionImageNrrdReaderService.cpp
   mitkDiffusionImageNrrdWriterService.cpp
   mitkDiffusionImageNiftiReaderService.cpp
   mitkDiffusionImageNiftiWriterService.cpp
 
   mitkNrrdQBallImageReader.cpp
   mitkNrrdQBallImageWriter.cpp
   mitkQBallImageSerializer.cpp
 
-  mitkFiberBundleXReader.cpp
-  mitkFiberBundleXWriter.cpp
-  mitkFiberBundleXSerializer.cpp
-  mitkFiberBundleXMapper2D.cpp
-  mitkFiberBundleXMapper3D.cpp
+  mitkFiberBundleTrackVisReader.cpp
+  mitkFiberBundleTrackVisWriter.cpp
+  mitkFiberBundleVtkReader.cpp
+  mitkFiberBundleVtkWriter.cpp
+  mitkFiberBundleSerializer.cpp
+  mitkFiberBundleMapper2D.cpp
+  mitkFiberBundleMapper3D.cpp
   mitkCompositeMapper.cpp
 
 )
 
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
index fda24fc676..f3bb89a8e2 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
@@ -1,311 +1,327 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkDiffusionIOMimeTypes.h"
 #include "mitkIOMimeTypes.h"
 #include <itksys/SystemTools.hxx>
 #include <itkNrrdImageIO.h>
 #include <itkMetaDataDictionary.h>
 #include <itkMetaDataObject.h>
 #include <mitkLogMacros.h>
 
 namespace mitk
 {
 
 std::vector<CustomMimeType*> DiffusionIOMimeTypes::Get()
 {
   std::vector<CustomMimeType*> mimeTypes;
 
   // order matters here (descending rank for mime types)
 
   mimeTypes.push_back(DWI_NRRD_MIMETYPE().Clone());
   mimeTypes.push_back(DWI_NIFTI_MIMETYPE().Clone());
   mimeTypes.push_back(DTI_MIMETYPE().Clone());
   mimeTypes.push_back(QBI_MIMETYPE().Clone());
 
-  mimeTypes.push_back(FIBERBUNDLE_MIMETYPE().Clone());
+  mimeTypes.push_back(FIBERBUNDLE_VTK_MIMETYPE().Clone());
+  mimeTypes.push_back(FIBERBUNDLE_TRK_MIMETYPE().Clone());
 
   mimeTypes.push_back(CONNECTOMICS_MIMETYPE().Clone());
 
   return mimeTypes;
 }
 
 // Mime Types
 
-CustomMimeType DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE()
+CustomMimeType DiffusionIOMimeTypes::FIBERBUNDLE_VTK_MIMETYPE()
 {
-  CustomMimeType mimeType(FIBERBUNDLE_MIMETYPE_NAME());
-  std::string category = "Fiber Bundle File";
-  mimeType.SetComment("Fiber Bundles");
+  CustomMimeType mimeType(FIBERBUNDLE_VTK_MIMETYPE_NAME());
+  std::string category = "VTK Fibers";
+  mimeType.SetComment("VTK Fibers");
   mimeType.SetCategory(category);
   mimeType.AddExtension("fib");
+  mimeType.AddExtension("vtk");
+  return mimeType;
+}
+
+CustomMimeType DiffusionIOMimeTypes::FIBERBUNDLE_TRK_MIMETYPE()
+{
+  CustomMimeType mimeType(FIBERBUNDLE_TRK_MIMETYPE_NAME());
+  std::string category = "TrackVis Fibers";
+  mimeType.SetComment("TrackVis Fibers");
+  mimeType.SetCategory(category);
   mimeType.AddExtension("trk");
-  //mimeType.AddExtension("vtk");
   return mimeType;
 }
 
 DiffusionIOMimeTypes::DiffusionImageNrrdMimeType::DiffusionImageNrrdMimeType()
   : CustomMimeType(DWI_NRRD_MIMETYPE_NAME())
 {
   std::string category = "Diffusion Weighted Image";
   this->SetCategory(category);
   this->SetComment("Diffusion Weighted Images");
 
   this->AddExtension("dwi");
   this->AddExtension("hdwi");
   this->AddExtension("nrrd");
 }
 
 bool DiffusionIOMimeTypes::DiffusionImageNrrdMimeType::AppliesTo(const std::string &path) const
 {
   bool canRead( CustomMimeType::AppliesTo(path) );
 
   // fix for bug 18572
   // Currently this function is called for writing as well as reading, in that case
   // the image information can of course not be read
   // This is a bug, this function should only be called for reading.
   if( ! itksys::SystemTools::FileExists( path.c_str() ) )
   {
     return canRead;
   }
   //end fix for bug 18572
 
   std::string ext = this->GetExtension( path );
   ext = itksys::SystemTools::LowerCase( ext );
 
   // Simple NRRD files should only be considered for this mime type if they contain
   // corresponding tags
   if( ext == ".nrrd" )
   {
     itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
     io->SetFileName(path);
     try
     {
       io->ReadImageInformation();
 
       itk::MetaDataDictionary imgMetaDictionary = io->GetMetaDataDictionary();
       std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
       std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
       std::string metaString;
 
       for (; itKey != imgMetaKeys.end(); itKey ++)
       {
         itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
         if (itKey->find("modality") != std::string::npos)
         {
           if (metaString.find("DWMRI") != std::string::npos)
           {
             return canRead;
           }
         }
       }
 
     }
     catch( const itk::ExceptionObject &e )
     {
       MITK_ERROR << "ITK Exception: " << e.what();
     }
     canRead = false;
   }
 
   return canRead;
 }
 
 DiffusionIOMimeTypes::DiffusionImageNrrdMimeType* DiffusionIOMimeTypes::DiffusionImageNrrdMimeType::Clone() const
 {
   return new DiffusionImageNrrdMimeType(*this);
 }
 
 
 DiffusionIOMimeTypes::DiffusionImageNrrdMimeType DiffusionIOMimeTypes::DWI_NRRD_MIMETYPE()
 {
   return DiffusionImageNrrdMimeType();
 }
 
 DiffusionIOMimeTypes::DiffusionImageNiftiMimeType::DiffusionImageNiftiMimeType()
   : CustomMimeType(DWI_NIFTI_MIMETYPE_NAME())
 {
   std::string category = "Diffusion Weighted Image";
   this->SetCategory(category);
   this->SetComment("Diffusion Weighted Images");
   this->AddExtension("fsl");
   this->AddExtension("fslgz");
   this->AddExtension("nii");
   this->AddExtension("nii.gz");
 }
 
 bool DiffusionIOMimeTypes::DiffusionImageNiftiMimeType::AppliesTo(const std::string &path) const
 {
   bool canRead(CustomMimeType::AppliesTo(path));
 
   // fix for bug 18572
   // Currently this function is called for writing as well as reading, in that case
   // the image information can of course not be read
   // This is a bug, this function should only be called for reading.
   if (!itksys::SystemTools::FileExists(path.c_str()))
   {
     return canRead;
   }
   //end fix for bug 18572
 
   std::string ext = this->GetExtension(path);
   ext = itksys::SystemTools::LowerCase(ext);
 
   // Nifti files should only be considered for this mime type if they are
   // accompanied by bvecs and bvals files defining the diffusion information
   if (ext == ".nii" || ext == ".nii.gz")
   {
     std::string base = itksys::SystemTools::GetFilenamePath(path) + "/"
       + this->GetFilenameWithoutExtension(path);
 
     if (itksys::SystemTools::FileExists(std::string(base + ".bvec").c_str())
       && itksys::SystemTools::FileExists(std::string(base + ".bval").c_str())
       )
     {
       return canRead;
     }
 
     if (itksys::SystemTools::FileExists(std::string(base + ".bvecs").c_str())
       && itksys::SystemTools::FileExists(std::string(base + ".bvals").c_str())
       )
     {
       return canRead;
     }
 
     canRead = false;
   }
 
   return canRead;
 }
 
 DiffusionIOMimeTypes::DiffusionImageNiftiMimeType* DiffusionIOMimeTypes::DiffusionImageNiftiMimeType::Clone() const
 {
   return new DiffusionImageNiftiMimeType(*this);
 }
 
 
 DiffusionIOMimeTypes::DiffusionImageNiftiMimeType DiffusionIOMimeTypes::DWI_NIFTI_MIMETYPE()
 {
   return DiffusionImageNiftiMimeType();
 }
 
 CustomMimeType DiffusionIOMimeTypes::DTI_MIMETYPE()
 {
   CustomMimeType mimeType(DTI_MIMETYPE_NAME());
   std::string category = "Tensor Images";
   mimeType.SetComment("Diffusion Tensor Images");
   mimeType.SetCategory(category);
   mimeType.AddExtension("dti");
   mimeType.AddExtension("hdti");
   return mimeType;
 }
 
 CustomMimeType DiffusionIOMimeTypes::QBI_MIMETYPE()
 {
   CustomMimeType mimeType(QBI_MIMETYPE_NAME());
   std::string category = "Q-Ball Images";
   mimeType.SetComment("Diffusion Q-Ball Images");
   mimeType.SetCategory(category);
   mimeType.AddExtension("qbi");
   mimeType.AddExtension("hqbi");
   return mimeType;
 }
 
 CustomMimeType DiffusionIOMimeTypes::CONNECTOMICS_MIMETYPE()
 {
   CustomMimeType mimeType(CONNECTOMICS_MIMETYPE_NAME());
   std::string category = "Connectomics Networks";
   mimeType.SetComment("Connectomics Networks");
   mimeType.SetCategory(category);
   mimeType.AddExtension("cnf");
   return mimeType;
 }
 
 // Names
 std::string DiffusionIOMimeTypes::DWI_NRRD_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".dwi";
   return name;
 }
 
 std::string DiffusionIOMimeTypes::DWI_NIFTI_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".fsl";
   return name;
 }
 
 std::string DiffusionIOMimeTypes::DTI_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".dti";
   return name;
 }
 
 std::string DiffusionIOMimeTypes::QBI_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".qbi";
   return name;
 }
 
-std::string DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_NAME()
+std::string DiffusionIOMimeTypes::FIBERBUNDLE_VTK_MIMETYPE_NAME()
+{
+  static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".FiberBundle.vtk";
+  return name;
+}
+
+std::string DiffusionIOMimeTypes::FIBERBUNDLE_TRK_MIMETYPE_NAME()
 {
-  static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".fib";
+  static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".FiberBundle.trk";
   return name;
 }
 
 std::string DiffusionIOMimeTypes::CONNECTOMICS_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".cnf";
   return name;
 }
 
 // Descriptions
 std::string DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Fiberbundles";
   return description;
 }
 
 std::string DiffusionIOMimeTypes::DWI_NRRD_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Diffusion Weighted Images";
   return description;
 }
 
 std::string DiffusionIOMimeTypes::DWI_NIFTI_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Diffusion Weighted Images";
   return description;
 }
 
 std::string DiffusionIOMimeTypes::DTI_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Diffusion Tensor Images";
   return description;
 }
 
 std::string DiffusionIOMimeTypes::QBI_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Q-Ball Images";
   return description;
 }
 
 std::string DiffusionIOMimeTypes::CONNECTOMICS_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Connectomics Networks";
   return description;
 }
 
 }
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h
index a58c35bfb6..f458090fe6 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h
@@ -1,91 +1,96 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef MITKDIFFUSIONIOMIMETYPES_H
 #define MITKDIFFUSIONIOMIMETYPES_H
 
 #include "mitkCustomMimeType.h"
 #include <MitkDiffusionIOExports.h>
 
 #include <string>
 
 namespace mitk {
 
 class DiffusionIOMimeTypes
 {
 public:
 
   class MitkDiffusionIO_EXPORT DiffusionImageNrrdMimeType : public CustomMimeType
   {
   public:
     DiffusionImageNrrdMimeType();
     virtual bool AppliesTo(const std::string &path) const;
     virtual DiffusionImageNrrdMimeType* Clone() const;
   };
 
   class MitkDiffusionIO_EXPORT DiffusionImageNiftiMimeType : public CustomMimeType
   {
   public:
     DiffusionImageNiftiMimeType();
     virtual bool AppliesTo(const std::string &path) const;
     virtual DiffusionImageNiftiMimeType* Clone() const;
   };
   // Get all Diffusion Mime Types
   static std::vector<CustomMimeType*> Get();
 
   // ------------------------------ VTK formats ----------------------------------
 
-  static CustomMimeType FIBERBUNDLE_MIMETYPE(); // fib
-
-  static std::string FIBERBUNDLE_MIMETYPE_NAME();
+  static CustomMimeType FIBERBUNDLE_VTK_MIMETYPE();
+  static std::string FIBERBUNDLE_VTK_MIMETYPE_NAME();
 
   static std::string FIBERBUNDLE_MIMETYPE_DESCRIPTION();
 
+  // ------------------------------ TrackVis formats ----------------------------------
+
+  static CustomMimeType FIBERBUNDLE_TRK_MIMETYPE();
+  static std::string FIBERBUNDLE_TRK_MIMETYPE_NAME();
+
+
   // ------------------------- Image formats (ITK based) --------------------------
 
   static DiffusionImageNrrdMimeType DWI_NRRD_MIMETYPE();
   static DiffusionImageNiftiMimeType DWI_NIFTI_MIMETYPE();
   static CustomMimeType DTI_MIMETYPE(); // dti, hdti
   static CustomMimeType QBI_MIMETYPE(); // qbi, hqbi
 
   static std::string DWI_NRRD_MIMETYPE_NAME();
   static std::string DWI_NIFTI_MIMETYPE_NAME();
   static std::string DTI_MIMETYPE_NAME();
   static std::string QBI_MIMETYPE_NAME();
 
   static std::string DWI_NRRD_MIMETYPE_DESCRIPTION();
   static std::string DWI_NIFTI_MIMETYPE_DESCRIPTION();
   static std::string DTI_MIMETYPE_DESCRIPTION();
   static std::string QBI_MIMETYPE_DESCRIPTION();
 
   // ------------------------------ MITK formats ----------------------------------
 
   static CustomMimeType CONNECTOMICS_MIMETYPE(); // cnf
 
   static std::string CONNECTOMICS_MIMETYPE_NAME();
 
   static std::string CONNECTOMICS_MIMETYPE_DESCRIPTION();
 
 private:
 
   // purposely not implemented
   DiffusionIOMimeTypes();
   DiffusionIOMimeTypes(const DiffusionIOMimeTypes&);
 };
 
 }
 
 #endif // MITKDIFFUSIONIOMIMETYPES_H
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionModuleActivator.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionModuleActivator.cpp
index 813ead9e5e..1a4edcb659 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionModuleActivator.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionModuleActivator.cpp
@@ -1,114 +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.
 
 ===================================================================*/
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 
 #include <mitkDiffusionImageNrrdReaderService.h>
 #include <mitkDiffusionImageNiftiReaderService.h>
 #include <mitkNrrdTensorImageReader.h>
 #include <mitkNrrdQBallImageReader.h>
-#include <mitkFiberBundleXReader.h>
+#include <mitkFiberBundleVtkReader.h>
+#include <mitkFiberBundleTrackVisReader.h>
 #include <mitkConnectomicsNetworkReader.h>
 
 #include <mitkDiffusionImageNrrdWriterService.h>
 #include <mitkDiffusionImageNiftiWriterService.h>
 #include <mitkNrrdTensorImageWriter.h>
 #include <mitkNrrdQBallImageWriter.h>
-#include <mitkFiberBundleXWriter.h>
+#include <mitkFiberBundleVtkWriter.h>
+#include <mitkFiberBundleTrackVisWriter.h>
 #include <mitkConnectomicsNetworkWriter.h>
 
 #include "mitkDiffusionIOMimeTypes.h"
 
 namespace mitk
 {
   /**
   \brief Registers services for segmentation module.
   */
   class DiffusionModuleActivator : public us::ModuleActivator
   {
   public:
 
     void Load(us::ModuleContext* context)
     {
       us::ServiceProperties props;
       props[ us::ServiceConstants::SERVICE_RANKING() ] = 10;
 
       m_MimeTypes = mitk::DiffusionIOMimeTypes::Get();
       for (std::vector<mitk::CustomMimeType*>::const_iterator mimeTypeIter = m_MimeTypes.begin(),
         iterEnd = m_MimeTypes.end(); mimeTypeIter != iterEnd; ++mimeTypeIter)
       {
         context->RegisterService(*mimeTypeIter, props);
       }
 
       m_DiffusionImageNrrdReaderService = new DiffusionImageNrrdReaderService();
       m_DiffusionImageNiftiReaderService = new DiffusionImageNiftiReaderService();
       m_NrrdTensorImageReader = new NrrdTensorImageReader();
       m_NrrdQBallImageReader = new NrrdQBallImageReader();
-      m_FiberBundleXReader = new FiberBundleXReader();
+      m_FiberBundleVtkReader = new FiberBundleVtkReader();
+      m_FiberBundleTrackVisReader = new FiberBundleTrackVisReader();
       m_ConnectomicsNetworkReader = new ConnectomicsNetworkReader();
 
       m_DiffusionImageNrrdWriterService = new DiffusionImageNrrdWriterService();
       m_DiffusionImageNiftiWriterService = new DiffusionImageNiftiWriterService();
       m_NrrdTensorImageWriter = new NrrdTensorImageWriter();
       m_NrrdQBallImageWriter = new NrrdQBallImageWriter();
-      m_FiberBundleXWriter = new FiberBundleXWriter();
+      m_FiberBundleVtkWriter = new FiberBundleVtkWriter();
+      m_FiberBundleTrackVisWriter = new FiberBundleTrackVisWriter();
       m_ConnectomicsNetworkWriter = new ConnectomicsNetworkWriter();
     }
 
     void Unload(us::ModuleContext*)
     {
       for (unsigned int loop(0); loop < m_MimeTypes.size(); ++loop)
       {
         delete m_MimeTypes.at(loop);
       }
 
       delete m_DiffusionImageNrrdReaderService;
       delete m_DiffusionImageNiftiReaderService;
       delete m_NrrdTensorImageReader;
       delete m_NrrdQBallImageReader;
-      delete m_FiberBundleXReader;
+      delete m_FiberBundleVtkReader;
+      delete m_FiberBundleTrackVisReader;
       delete m_ConnectomicsNetworkReader;
 
       delete m_DiffusionImageNrrdWriterService;
       delete m_DiffusionImageNiftiWriterService;
       delete m_NrrdTensorImageWriter;
       delete m_NrrdQBallImageWriter;
-      delete m_FiberBundleXWriter;
+      delete m_FiberBundleVtkWriter;
+      delete m_FiberBundleTrackVisWriter;
       delete m_ConnectomicsNetworkWriter;
     }
 
   private:
 
     DiffusionImageNrrdReaderService * m_DiffusionImageNrrdReaderService;
     DiffusionImageNiftiReaderService * m_DiffusionImageNiftiReaderService;
     NrrdTensorImageReader * m_NrrdTensorImageReader;
     NrrdQBallImageReader * m_NrrdQBallImageReader;
-    FiberBundleXReader * m_FiberBundleXReader;
+    FiberBundleVtkReader * m_FiberBundleVtkReader;
+    FiberBundleTrackVisReader * m_FiberBundleTrackVisReader;
     ConnectomicsNetworkReader * m_ConnectomicsNetworkReader;
 
     DiffusionImageNrrdWriterService * m_DiffusionImageNrrdWriterService;
     DiffusionImageNiftiWriterService * m_DiffusionImageNiftiWriterService;
     NrrdTensorImageWriter * m_NrrdTensorImageWriter;
     NrrdQBallImageWriter * m_NrrdQBallImageWriter;
-    FiberBundleXWriter * m_FiberBundleXWriter;
+    FiberBundleVtkWriter * m_FiberBundleVtkWriter;
+    FiberBundleTrackVisWriter * m_FiberBundleTrackVisWriter;
     ConnectomicsNetworkWriter * m_ConnectomicsNetworkWriter;
 
     std::vector<mitk::CustomMimeType*> m_MimeTypes;
 
   };
 }
 
 US_EXPORT_MODULE_ACTIVATOR(mitk::DiffusionModuleActivator)
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper2D.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp
similarity index 87%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper2D.cpp
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp
index fc7de2ff13..e2fd8d57fd 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper2D.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp
@@ -1,199 +1,199 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
-#include "mitkFiberBundleXMapper2D.h"
+#include "mitkFiberBundleMapper2D.h"
 #include <mitkBaseRenderer.h>
 #include <vtkActor.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkPlane.h>
 #include <vtkPolyData.h>
 #include <vtkPointData.h>
 #include <vtkProperty.h>
 #include <vtkLookupTable.h>
 #include <vtkPoints.h>
 #include <vtkCamera.h>
 #include <vtkPolyLine.h>
 #include <vtkRenderer.h>
 #include <vtkCellArray.h>
 #include <vtkMatrix4x4.h>
 #include <vtkTubeFilter.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkSliceNavigationController.h>
 #include <mitkIShaderRepository.h>
 #include <mitkShaderProperty.h>
 #include <mitkCoreServices.h>
 
-mitk::FiberBundleXMapper2D::FiberBundleXMapper2D()
+mitk::FiberBundleMapper2D::FiberBundleMapper2D()
     : m_LineWidth(1)
 {
     m_lut = vtkLookupTable::New();
     m_lut->Build();
 
 }
 
-mitk::FiberBundleXMapper2D::~FiberBundleXMapper2D()
+mitk::FiberBundleMapper2D::~FiberBundleMapper2D()
 {
 }
 
 
-mitk::FiberBundleX* mitk::FiberBundleXMapper2D::GetInput()
+mitk::FiberBundle* mitk::FiberBundleMapper2D::GetInput()
 {
-    return dynamic_cast< mitk::FiberBundleX * > ( GetDataNode()->GetData() );
+    return dynamic_cast< mitk::FiberBundle * > ( GetDataNode()->GetData() );
 }
 
 
 
-void mitk::FiberBundleXMapper2D::Update(mitk::BaseRenderer * renderer)
+void mitk::FiberBundleMapper2D::Update(mitk::BaseRenderer * renderer)
 {
         bool visible = true;
         GetDataNode()->GetVisibility(visible, renderer, "visible");
         if ( !visible )
             return;
 
         // Calculate time step of the input data for the specified renderer (integer value)
         // this method is implemented in mitkMapper
         this->CalculateTimeStep( renderer );
 
         //check if updates occured in the node or on the display
         FBXLocalStorage *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
 
         //set renderer independent shader properties
         const DataNode::Pointer node = this->GetDataNode();
         float thickness = 2.0;
         if(!this->GetDataNode()->GetPropertyValue("Fiber2DSliceThickness",thickness))
             MITK_INFO << "FIBER2D SLICE THICKNESS PROPERTY ERROR";
 
         bool fiberfading = false;
         if(!this->GetDataNode()->GetPropertyValue("Fiber2DfadeEFX",fiberfading))
             MITK_INFO << "FIBER2D SLICE FADE EFX PROPERTY ERROR";
 
         float fiberOpacity;
         this->GetDataNode()->GetOpacity(fiberOpacity, NULL);
         node->SetFloatProperty("shader.mitkShaderFiberClipping.fiberThickness",thickness);
         node->SetIntProperty("shader.mitkShaderFiberClipping.fiberFadingON",fiberfading);
         node->SetFloatProperty("shader.mitkShaderFiberClipping.fiberOpacity",fiberOpacity);
 
-        mitk::FiberBundleX* fiberBundle = this->GetInput();
+        mitk::FiberBundle* fiberBundle = this->GetInput();
         if (fiberBundle==NULL)
             return;
 
         int lineWidth = 0;
         node->GetIntProperty("LineWidth", lineWidth);
         if (m_LineWidth!=lineWidth)
         {
             m_LineWidth = lineWidth;
             fiberBundle->RequestUpdate2D();
         }
 
         if ( localStorage->m_LastUpdateTime<renderer->GetDisplayGeometry()->GetMTime() || localStorage->m_LastUpdateTime<fiberBundle->GetUpdateTime2D() )
         {
             this->UpdateShaderParameter(renderer);
             this->GenerateDataForRenderer( renderer );
         }
 }
 
-void mitk::FiberBundleXMapper2D::UpdateShaderParameter(mitk::BaseRenderer * renderer)
+void mitk::FiberBundleMapper2D::UpdateShaderParameter(mitk::BaseRenderer * renderer)
 {
     //get information about current position of views
     mitk::SliceNavigationController::Pointer sliceContr = renderer->GetSliceNavigationController();
     mitk::PlaneGeometry::ConstPointer planeGeo = sliceContr->GetCurrentPlaneGeometry();
 
     //generate according cutting planes based on the view position
     float planeNormal[3];
     planeNormal[0] = planeGeo->GetNormal()[0];
     planeNormal[1] = planeGeo->GetNormal()[1];
     planeNormal[2] = planeGeo->GetNormal()[2];
 
     float tmp1 = planeGeo->GetOrigin()[0] * planeNormal[0];
     float tmp2 = planeGeo->GetOrigin()[1] * planeNormal[1];
     float tmp3 = planeGeo->GetOrigin()[2] * planeNormal[2];
     float thickness = tmp1 + tmp2 + tmp3; //attention, correct normalvector
 
     DataNode::Pointer node = this->GetDataNode();
     node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.w",thickness,renderer);
     node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.x",planeNormal[0],renderer);
     node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.y",planeNormal[1],renderer);
     node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.z",planeNormal[2],renderer);
 }
 
 // vtkActors and Mappers are feeded here
-void mitk::FiberBundleXMapper2D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
+void mitk::FiberBundleMapper2D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
 {
-    mitk::FiberBundleX* fiberBundle = this->GetInput();
+    mitk::FiberBundle* fiberBundle = this->GetInput();
 
     //the handler of local storage gets feeded in this method with requested data for related renderwindow
     FBXLocalStorage *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
 
     mitk::DataNode* node = this->GetDataNode();
     if ( node == NULL )
         return;
 
     vtkSmartPointer<vtkPolyData> fiberPolyData = fiberBundle->GetFiberPolyData();
     if (fiberPolyData == NULL)
         return;
 
     fiberPolyData->GetPointData()->AddArray(fiberBundle->GetFiberColors());
     localStorage->m_FiberMapper->ScalarVisibilityOn();
     localStorage->m_FiberMapper->SetScalarModeToUsePointFieldData();
     localStorage->m_FiberMapper->SetLookupTable(m_lut);  //apply the properties after the slice was set
     localStorage->m_PointActor->GetProperty()->SetOpacity(0.999);
     localStorage->m_FiberMapper->SelectColorArray("FIBER_COLORS");
 
     localStorage->m_FiberMapper->SetInputData(fiberPolyData);
     localStorage->m_PointActor->SetMapper(localStorage->m_FiberMapper);
     localStorage->m_PointActor->GetProperty()->ShadingOn();
     localStorage->m_PointActor->GetProperty()->SetLineWidth(m_LineWidth);
 
     // Applying shading properties
     this->ApplyShaderProperties(renderer);
 
     // We have been modified => save this for next Update()
     localStorage->m_LastUpdateTime.Modified();
 }
 
 
-vtkProp* mitk::FiberBundleXMapper2D::GetVtkProp(mitk::BaseRenderer *renderer)
+vtkProp* mitk::FiberBundleMapper2D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
     this->Update(renderer);
     return m_LocalStorageHandler.GetLocalStorage(renderer)->m_PointActor;
 }
 
 
-void mitk::FiberBundleXMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
+void mitk::FiberBundleMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
     Superclass::SetDefaultProperties(node, renderer, overwrite);
     node->SetProperty("shader",mitk::ShaderProperty::New("mitkShaderFiberClipping"));
 
     // Shaders
     IShaderRepository* shaderRepo = CoreServices::GetShaderRepository();
     if (shaderRepo)
     {
         shaderRepo->AddDefaultProperties(node, renderer, overwrite);
     }
 
     //add other parameters to propertylist
     node->AddProperty( "Fiber2DSliceThickness", mitk::FloatProperty::New(1.0f), renderer, overwrite );
     node->AddProperty( "Fiber2DfadeEFX", mitk::BoolProperty::New(true), renderer, overwrite );
     node->AddProperty( "color", mitk::ColorProperty::New(1.0,1.0,1.0), renderer, overwrite);
     node->AddProperty( "TubeRadius",mitk::FloatProperty::New( 0.0 ), renderer, overwrite);
 }
 
 
-mitk::FiberBundleXMapper2D::FBXLocalStorage::FBXLocalStorage()
+mitk::FiberBundleMapper2D::FBXLocalStorage::FBXLocalStorage()
 {
     m_PointActor = vtkSmartPointer<vtkActor>::New();
     m_FiberMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
 }
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper2D.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.h
similarity index 89%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper2D.h
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.h
index 85d61d0df8..ba1089e97f 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper2D.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.h
@@ -1,109 +1,109 @@
 /*===================================================================
 
 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 FIBERBUNDLEXMAPPER2D_H_HEADER_INCLUDED
-#define FIBERBUNDLEXMAPPER2D_H_HEADER_INCLUDED
+#ifndef FiberBundleMAPPER2D_H_HEADER_INCLUDED
+#define FiberBundleMAPPER2D_H_HEADER_INCLUDED
 
 //MITK Rendering
 #include <mitkCommon.h>
 #include <mitkBaseRenderer.h>
 //#include <MitkFiberTrackingExports.h>
 
 #include <mitkVtkMapper.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <vtkSmartPointer.h>
 
 
 class vtkActor;
 //class vtkPropAssembly; //lets see if we need it
 class mitkBaseRenderer;
 class vtkPolyDataMapper;
 class vtkCutter;
 class vtkPlane;
 class vtkPolyData;
 
 
 
 namespace mitk {
 
 struct IShaderRepository;
 
-class FiberBundleXMapper2D : public VtkMapper
+class FiberBundleMapper2D : public VtkMapper
 {
 
 public:
-    mitkClassMacro(FiberBundleXMapper2D, VtkMapper);
+    mitkClassMacro(FiberBundleMapper2D, VtkMapper);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
-    mitk::FiberBundleX* GetInput();
+    mitk::FiberBundle* GetInput();
 
 
     /** \brief Checks whether this mapper needs to update itself and generate data. */
     virtual void Update(mitk::BaseRenderer * renderer);
 
 
     static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false );
 
 
     //### methods of MITK-VTK rendering pipeline
     virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer);
     //### end of methods of MITK-VTK rendering pipeline
 
 
     class  FBXLocalStorage : public mitk::Mapper::BaseLocalStorage
     {
     public:
         /** \brief Point Actor of a 2D render window. */
         vtkSmartPointer<vtkActor> m_PointActor;
         /** \brief Point Mapper of a 2D render window. */
         vtkSmartPointer<vtkPolyDataMapper> m_FiberMapper;
         vtkSmartPointer<vtkPlane> m_SlicingPlane;  //needed later when optimized 2D mapper
         vtkSmartPointer<vtkPolyData> m_SlicedResult; //might be depricated in optimized 2D mapper
 
         /** \brief Timestamp of last update of stored data. */
         itk::TimeStamp m_LastUpdateTime;
         /** \brief Constructor of the local storage. Do as much actions as possible in here to avoid double executions. */
         FBXLocalStorage(); //if u copy&paste from this 2Dmapper, be aware that the implementation of this constructor is in the cpp file
 
         ~FBXLocalStorage()
         {
         }
     };
 
     /** \brief This member holds all three LocalStorages for the three 2D render windows. */
     mitk::LocalStorageHandler<FBXLocalStorage> m_LocalStorageHandler;
 
 
 
 protected:
-    FiberBundleXMapper2D();
-    virtual ~FiberBundleXMapper2D();
+    FiberBundleMapper2D();
+    virtual ~FiberBundleMapper2D();
 
     /** Does the actual resampling, without rendering. */
     virtual void GenerateDataForRenderer(mitk::BaseRenderer*);
 
     void UpdateShaderParameter(mitk::BaseRenderer*);
 
 private:
     vtkSmartPointer<vtkLookupTable> m_lut;
 
     int     m_LineWidth;
 };
 
 
 }//end namespace
 
 #endif
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper3D.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.cpp
similarity index 82%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper3D.cpp
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.cpp
index fd949cdbfa..b69590a4fe 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper3D.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.cpp
@@ -1,189 +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.
 
 ===================================================================*/
 
 
 
-#include "mitkFiberBundleXMapper3D.h"
+#include "mitkFiberBundleMapper3D.h"
 #include <mitkProperties.h>
 
 #include <vtkPropAssembly.h>
 #include <vtkPointData.h>
 #include <vtkProperty.h>
 #include <vtkCellArray.h>
 #include <vtkDepthSortPolyData.h>
 #include <vtkCamera.h>
 #include <vtkTubeFilter.h>
 
-mitk::FiberBundleXMapper3D::FiberBundleXMapper3D()
+mitk::FiberBundleMapper3D::FiberBundleMapper3D()
     : m_TubeRadius(0.0)
     , m_TubeSides(15)
     , m_LineWidth(1)
 {
     m_lut = vtkLookupTable::New();
     m_lut->Build();
 }
 
 
-mitk::FiberBundleXMapper3D::~FiberBundleXMapper3D()
+mitk::FiberBundleMapper3D::~FiberBundleMapper3D()
 {
 
 }
 
 
-const mitk::FiberBundleX* mitk::FiberBundleXMapper3D::GetInput()
+const mitk::FiberBundle* mitk::FiberBundleMapper3D::GetInput()
 {
-    return static_cast<const mitk::FiberBundleX * > ( GetDataNode()->GetData() );
+    return static_cast<const mitk::FiberBundle * > ( GetDataNode()->GetData() );
 }
 
 
 /*
  This method is called once the mapper gets new input,
  for UI rotation or changes in colorcoding this method is NOT called
  */
-void mitk::FiberBundleXMapper3D::InternalGenerateData(mitk::BaseRenderer *renderer)
+void mitk::FiberBundleMapper3D::InternalGenerateData(mitk::BaseRenderer *renderer)
 {
-    mitk::FiberBundleX* fiberBundle = dynamic_cast<mitk::FiberBundleX*> (GetDataNode()->GetData());
+    mitk::FiberBundle* fiberBundle = dynamic_cast<mitk::FiberBundle*> (GetDataNode()->GetData());
     if (fiberBundle == NULL)
         return;
 
     vtkSmartPointer<vtkPolyData> fiberPolyData = fiberBundle->GetFiberPolyData();
     if (fiberPolyData == NULL)
         return;
 
     fiberPolyData->GetPointData()->AddArray(fiberBundle->GetFiberColors());
     float tmpopa;
     this->GetDataNode()->GetOpacity(tmpopa, NULL);
     FBXLocalStorage3D *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
 
     if (m_TubeRadius>0.0)
     {
         vtkSmartPointer<vtkTubeFilter> tubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
         tubeFilter->SetInputData(fiberPolyData);
         tubeFilter->SetNumberOfSides(m_TubeSides);
         tubeFilter->SetRadius(m_TubeRadius);
         tubeFilter->Update();
         fiberPolyData = tubeFilter->GetOutput();
     }
 
     if (tmpopa<1)
     {
         vtkSmartPointer<vtkDepthSortPolyData> depthSort = vtkSmartPointer<vtkDepthSortPolyData>::New();
         depthSort->SetInputData( fiberPolyData );
         depthSort->SetCamera( renderer->GetVtkRenderer()->GetActiveCamera() );
         depthSort->SetDirectionToFrontToBack();
         depthSort->Update();
         localStorage->m_FiberMapper->SetInputConnection(depthSort->GetOutputPort());
     }
     else
     {
         localStorage->m_FiberMapper->SetInputData(fiberPolyData);
     }
 
     localStorage->m_FiberMapper->SelectColorArray("FIBER_COLORS");
     localStorage->m_FiberMapper->ScalarVisibilityOn();
     localStorage->m_FiberMapper->SetScalarModeToUsePointFieldData();
     localStorage->m_FiberActor->SetMapper(localStorage->m_FiberMapper);
     localStorage->m_FiberMapper->SetLookupTable(m_lut);
 
     // set Opacity
     localStorage->m_FiberActor->GetProperty()->SetOpacity((double) tmpopa);
     localStorage->m_FiberActor->GetProperty()->SetLineWidth(m_LineWidth);
 
     localStorage->m_FiberAssembly->AddPart(localStorage->m_FiberActor);
     localStorage->m_LastUpdateTime.Modified();
 }
 
 
 
-void mitk::FiberBundleXMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
+void mitk::FiberBundleMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
     bool visible = true;
     GetDataNode()->GetVisibility(visible, renderer, "visible");
     if ( !visible ) return;
 
     const DataNode* node = this->GetDataNode();
     FBXLocalStorage3D* localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
-    mitk::FiberBundleX* fiberBundle = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
+    mitk::FiberBundle* fiberBundle = dynamic_cast<mitk::FiberBundle*>(node->GetData());
 
     // did any rendering properties change?
     float tubeRadius = 0;
     node->GetFloatProperty("TubeRadius", tubeRadius);
     if (m_TubeRadius!=tubeRadius)
     {
         m_TubeRadius = tubeRadius;
         fiberBundle->RequestUpdate3D();
     }
 
     int tubeSides = 0;
     node->GetIntProperty("TubeSides", tubeSides);
     if (m_TubeSides!=tubeSides)
     {
         m_TubeSides = tubeSides;
         fiberBundle->RequestUpdate3D();
     }
 
     int lineWidth = 0;
     node->GetIntProperty("LineWidth", lineWidth);
     if (m_LineWidth!=lineWidth)
     {
         m_LineWidth = lineWidth;
         fiberBundle->RequestUpdate3D();
     }
 
     if (localStorage->m_LastUpdateTime>=fiberBundle->GetUpdateTime3D())
         return;
 
     // Calculate time step of the input data for the specified renderer (integer value)
     // this method is implemented in mitkMapper
     this->CalculateTimeStep( renderer );
     this->InternalGenerateData(renderer);
 }
 
 
-void mitk::FiberBundleXMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
+void mitk::FiberBundleMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
     Superclass::SetDefaultProperties(node, renderer, overwrite);
     node->AddProperty( "LineWidth", mitk::IntProperty::New( true ), renderer, overwrite );
     node->AddProperty( "opacity", mitk::FloatProperty::New( 1.0 ), renderer, overwrite);
     node->AddProperty( "color", mitk::ColorProperty::New(1.0,1.0,1.0), renderer, overwrite);
     node->AddProperty( "pickable", mitk::BoolProperty::New( true ), renderer, overwrite);
 
     node->AddProperty( "TubeRadius",mitk::FloatProperty::New( 0.0 ), renderer, overwrite);
     node->AddProperty( "TubeSides",mitk::IntProperty::New( 15 ), renderer, overwrite);
 }
 
-vtkProp* mitk::FiberBundleXMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
+vtkProp* mitk::FiberBundleMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
     return m_LocalStorageHandler.GetLocalStorage(renderer)->m_FiberAssembly;
 }
 
-void mitk::FiberBundleXMapper3D::UpdateVtkObjects()
+void mitk::FiberBundleMapper3D::UpdateVtkObjects()
 {
 
 }
 
-void mitk::FiberBundleXMapper3D::SetVtkMapperImmediateModeRendering(vtkMapper *)
+void mitk::FiberBundleMapper3D::SetVtkMapperImmediateModeRendering(vtkMapper *)
 {
 
 }
 
-mitk::FiberBundleXMapper3D::FBXLocalStorage3D::FBXLocalStorage3D()
+mitk::FiberBundleMapper3D::FBXLocalStorage3D::FBXLocalStorage3D()
 {
     m_FiberActor = vtkSmartPointer<vtkActor>::New();
     m_FiberMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     m_FiberAssembly = vtkSmartPointer<vtkPropAssembly>::New();
 }
 
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper3D.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.h
similarity index 86%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper3D.h
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.h
index b583b97a98..e1ffad5bb8 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXMapper3D.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.h
@@ -1,104 +1,104 @@
 /*===================================================================
 
 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 FiberBundleXMapper3D_H_HEADER_INCLUDED
-#define FiberBundleXMapper3D_H_HEADER_INCLUDED
+#ifndef FiberBundleMapper3D_H_HEADER_INCLUDED
+#define FiberBundleMapper3D_H_HEADER_INCLUDED
 
 //#include <mitkBaseData.h> //?? necessary
 #include <mitkVtkMapper.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 
 #include <vtkSmartPointer.h>
 #include <vtkOpenGLPolyDataMapper.h>
 #include <vtkOpenGLActor.h>
 #include <vtkLookupTable.h>
 
 
 
 class vtkPropAssembly;
 
 
 
 
 namespace mitk {
 
 //##Documentation
-//## @brief Mapper for FiberBundleX
+//## @brief Mapper for FiberBundle
 //## @ingroup Mapper
 
-class FiberBundleXMapper3D : public VtkMapper
+class FiberBundleMapper3D : public VtkMapper
 {
 public:
 
-    mitkClassMacro(FiberBundleXMapper3D, VtkMapper)
+    mitkClassMacro(FiberBundleMapper3D, VtkMapper)
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     //========== essential implementation for 3D mapper ========
-    const FiberBundleX* GetInput();
+    const FiberBundle* GetInput();
     virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer); //looks like depricated.. should be replaced bz GetViewProp()
     static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false );
     static void SetVtkMapperImmediateModeRendering(vtkMapper *mapper);
     virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
     //=========================================================
 
     class  FBXLocalStorage3D : public mitk::Mapper::BaseLocalStorage
     {
     public:
         /** \brief Point Actor of a 3D render window. */
         vtkSmartPointer<vtkActor> m_FiberActor;
         /** \brief Point Mapper of a 3D render window. */
         vtkSmartPointer<vtkPolyDataMapper> m_FiberMapper;
 
         vtkSmartPointer<vtkPropAssembly> m_FiberAssembly;
 
         /** \brief Timestamp of last update of stored data. */
         itk::TimeStamp m_LastUpdateTime;
         /** \brief Constructor of the local storage. Do as much actions as possible in here to avoid double executions. */
         FBXLocalStorage3D(); //if u copy&paste from this 2Dmapper, be aware that the implementation of this constructor is in the cpp file
 
         ~FBXLocalStorage3D()
         {
         }
     };
 
     /** \brief This member holds all three LocalStorages for the 3D render window(s). */
     mitk::LocalStorageHandler<FBXLocalStorage3D> m_LocalStorageHandler;
 
 
 protected:
 
-    FiberBundleXMapper3D();
-    virtual ~FiberBundleXMapper3D();
+    FiberBundleMapper3D();
+    virtual ~FiberBundleMapper3D();
     void InternalGenerateData(mitk::BaseRenderer *renderer);
 
     void UpdateVtkObjects(); //??
 
 private:
     vtkSmartPointer<vtkLookupTable> m_lut;
     float   m_TubeRadius;
     int     m_TubeSides;
     int     m_LineWidth;
 };
 
 } // end namespace mitk
 
 
 
 
-#endif /* FiberBundleXMapper3D_H_HEADER_INCLUDED */
+#endif /* FiberBundleMapper3D_H_HEADER_INCLUDED */
 
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXSerializer.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleSerializer.cpp
similarity index 68%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXSerializer.cpp
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleSerializer.cpp
index cd9b2a3725..28f7963fab 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXSerializer.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleSerializer.cpp
@@ -1,72 +1,72 @@
 /*===================================================================
 
 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 "mitkFiberBundleXSerializer.h"
-#include "mitkFiberBundleX.h"
-#include "mitkFiberBundleXWriter.h"
+#include "mitkFiberBundleSerializer.h"
+#include "mitkFiberBundle.h"
+#include "mitkFiberBundleVtkWriter.h"
 
 #include <itksys/SystemTools.hxx>
 #include <mitkIOUtil.h>
 
 
-MITK_REGISTER_SERIALIZER(FiberBundleXSerializer)
+MITK_REGISTER_SERIALIZER(FiberBundleSerializer)
 
 
-mitk::FiberBundleXSerializer::FiberBundleXSerializer()
+mitk::FiberBundleSerializer::FiberBundleSerializer()
 {
 }
 
 
-mitk::FiberBundleXSerializer::~FiberBundleXSerializer()
+mitk::FiberBundleSerializer::~FiberBundleSerializer()
 {
 }
 
 
-std::string mitk::FiberBundleXSerializer::Serialize()
+std::string mitk::FiberBundleSerializer::Serialize()
 {
-  const FiberBundleX* fb = dynamic_cast<const FiberBundleX*>( m_Data.GetPointer() );
+  const FiberBundle* fb = dynamic_cast<const FiberBundle*>( m_Data.GetPointer() );
   if (fb == NULL)
   {
     MITK_ERROR << " Object at " << (const void*) this->m_Data
-              << " is not an mitk::FiberBundleX. Cannot serialize as FiberBundleX.";
+              << " is not an mitk::FiberBundle. Cannot serialize as FiberBundle.";
     return "";
   }
 
   std::string filename( this->GetUniqueFilenameInWorkingDirectory() );
   filename += "_";
   filename += m_FilenameHint;
   filename += ".fib";
 
   std::string fullname(m_WorkingDirectory);
   fullname += "/";
   fullname += itksys::SystemTools::ConvertToOutputPath(filename.c_str());
 
   try
   {
-    mitk::IOUtil::Save(const_cast<FiberBundleX*>(fb),fullname);
+    mitk::IOUtil::Save(const_cast<FiberBundle*>(fb),fullname);
   }
   catch (std::exception& e)
   {
     MITK_ERROR << " Error serializing object at " << (const void*) this->m_Data
               << " to "
               << fullname
               << ": "
               << e.what();
     return "";
   }
   return filename;
 }
 
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXSerializer.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleSerializer.h
similarity index 72%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXSerializer.h
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleSerializer.h
index 02043bd112..df9640df27 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXSerializer.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleSerializer.h
@@ -1,39 +1,39 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
-#ifndef mitkFiberBundleXSerializer_h_included
-#define mitkFiberBundleXSerializer_h_included
+#ifndef mitkFiberBundleSerializer_h_included
+#define mitkFiberBundleSerializer_h_included
 
 #include "mitkBaseDataSerializer.h"
 
 namespace mitk
 {
 /**
   \brief Serializes mitk::Surface for mitk::SceneIO
 */
-class FiberBundleXSerializer : public BaseDataSerializer
+class FiberBundleSerializer : public BaseDataSerializer
 {
   public:
-    mitkClassMacro( FiberBundleXSerializer, BaseDataSerializer );
+    mitkClassMacro( FiberBundleSerializer, BaseDataSerializer );
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     virtual std::string Serialize();
   protected:
-    FiberBundleXSerializer();
-    virtual ~FiberBundleXSerializer();
+    FiberBundleSerializer();
+    virtual ~FiberBundleSerializer();
 };
 } // namespace
 #endif
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisReader.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisReader.cpp
new file mode 100644
index 0000000000..5e7a3712be
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisReader.cpp
@@ -0,0 +1,86 @@
+/*===================================================================
+
+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 "mitkFiberBundleTrackVisReader.h"
+#include <itkMetaDataObject.h>
+#include <vtkPolyData.h>
+#include <vtkDataReader.h>
+#include <vtkPolyDataReader.h>
+#include <vtkMatrix4x4.h>
+#include <vtkPolyLine.h>
+#include <vtkCellArray.h>
+#include <vtkDataArray.h>
+#include <vtkFloatArray.h>
+#include <vtkCellData.h>
+#include <vtkPointData.h>
+#include <itksys/SystemTools.hxx>
+#include <tinyxml.h>
+#include <vtkCleanPolyData.h>
+#include <mitkTrackvis.h>
+#include <mitkCustomMimeType.h>
+#include "mitkDiffusionIOMimeTypes.h"
+
+
+mitk::FiberBundleTrackVisReader::FiberBundleTrackVisReader()
+    : mitk::AbstractFileReader( mitk::DiffusionIOMimeTypes::FIBERBUNDLE_TRK_MIMETYPE_NAME(), "TrackVis Fiber Bundle Reader" )
+{
+    m_ServiceReg = this->RegisterService();
+}
+
+mitk::FiberBundleTrackVisReader::FiberBundleTrackVisReader(const FiberBundleTrackVisReader &other)
+    :mitk::AbstractFileReader(other)
+{
+}
+
+mitk::FiberBundleTrackVisReader * mitk::FiberBundleTrackVisReader::Clone() const
+{
+    return new FiberBundleTrackVisReader(*this);
+}
+
+std::vector<itk::SmartPointer<mitk::BaseData> > mitk::FiberBundleTrackVisReader::Read()
+{
+
+    std::vector<itk::SmartPointer<mitk::BaseData> > result;
+    try
+    {
+        const std::string& locale = "C";
+        const std::string& currLocale = setlocale( LC_ALL, NULL );
+        setlocale(LC_ALL, locale.c_str());
+
+        std::string filename = this->GetInputLocation();
+
+        std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
+        ext = itksys::SystemTools::LowerCase(ext);
+
+        if (ext==".trk")
+        {
+            FiberBundle::Pointer image = FiberBundle::New();
+            TrackVisFiberReader reader;
+            reader.open(this->GetInputLocation().c_str());
+            reader.read(image.GetPointer());
+            result.push_back(image.GetPointer());
+            return result;
+        }
+
+        setlocale(LC_ALL, currLocale.c_str());
+        MITK_INFO << "Fiber bundle read";
+    }
+    catch(...)
+    {
+        throw;
+    }
+    return result;
+}
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisReader.h
similarity index 67%
copy from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.h
copy to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisReader.h
index 386fdad556..035e96f44e 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisReader.h
@@ -1,52 +1,52 @@
 /*===================================================================
 
 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 __mitkFiberBundleXReader_h
-#define __mitkFiberBundleXReader_h
+#ifndef __mitkFiberBundleTrackVisReader_h
+#define __mitkFiberBundleTrackVisReader_h
 
 #include <mitkCommon.h>
 #include <mitkFileReader.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <vtkSmartPointer.h>
 
 #include <mitkAbstractFileReader.h>
 
 namespace mitk
 {
 
   /** \brief
   */
 
-  class FiberBundleXReader : public AbstractFileReader
+  class FiberBundleTrackVisReader : public AbstractFileReader
   {
   public:
 
-    FiberBundleXReader();
-    virtual ~FiberBundleXReader(){}
-    FiberBundleXReader(const FiberBundleXReader& other);
-    virtual FiberBundleXReader * Clone() const;
+    FiberBundleTrackVisReader();
+    virtual ~FiberBundleTrackVisReader(){}
+    FiberBundleTrackVisReader(const FiberBundleTrackVisReader& other);
+    virtual FiberBundleTrackVisReader * Clone() const;
 
     using mitk::AbstractFileReader::Read;
     virtual std::vector<itk::SmartPointer<BaseData> > Read();
 
   private:
 
     us::ServiceRegistration<mitk::IFileReader> m_ServiceReg;
   };
 
 } //namespace MITK
 
-#endif // __mitkFiberBundleXReader_h
+#endif // __mitkFiberBundleReader_h
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisWriter.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisWriter.cpp
new file mode 100644
index 0000000000..109ffc3480
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisWriter.cpp
@@ -0,0 +1,104 @@
+/*===================================================================
+
+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 "mitkFiberBundleTrackVisWriter.h"
+#include <vtkSmartPointer.h>
+#include <vtkCleanPolyData.h>
+#include <itksys/SystemTools.hxx>
+#include <mitkTrackvis.h>
+#include <itkSize.h>
+#include <vtkFloatArray.h>
+#include <vtkCellData.h>
+#include <vtkPointData.h>
+#include <mitkAbstractFileWriter.h>
+#include <mitkCustomMimeType.h>
+#include "mitkDiffusionIOMimeTypes.h"
+
+mitk::FiberBundleTrackVisWriter::FiberBundleTrackVisWriter()
+    : mitk::AbstractFileWriter(mitk::FiberBundle::GetStaticNameOfClass(), mitk::DiffusionIOMimeTypes::FIBERBUNDLE_TRK_MIMETYPE_NAME(), "TrackVis Fiber Bundle Reader")
+{
+    //    Options defaultOptions;
+    //    this->SetDefaultOptions(defaultOptions);
+    RegisterService();
+}
+
+mitk::FiberBundleTrackVisWriter::FiberBundleTrackVisWriter(const mitk::FiberBundleTrackVisWriter & other)
+    :mitk::AbstractFileWriter(other)
+{}
+
+mitk::FiberBundleTrackVisWriter::~FiberBundleTrackVisWriter()
+{}
+
+mitk::FiberBundleTrackVisWriter * mitk::FiberBundleTrackVisWriter::Clone() const
+{
+    return new mitk::FiberBundleTrackVisWriter(*this);
+}
+
+void mitk::FiberBundleTrackVisWriter::Write()
+{
+
+    std::ostream* out;
+    std::ofstream outStream;
+
+    if( this->GetOutputStream() )
+    {
+        out = this->GetOutputStream();
+    }else{
+        outStream.open( this->GetOutputLocation().c_str() );
+        out = &outStream;
+    }
+
+    if ( !out->good() )
+    {
+        mitkThrow() << "Stream not good.";
+    }
+
+    try
+    {
+        const std::string& locale = "C";
+        const std::string& currLocale = setlocale( LC_ALL, NULL );
+        setlocale(LC_ALL, locale.c_str());
+
+        std::locale previousLocale(out->getloc());
+        std::locale I("C");
+        out->imbue(I);
+
+        std::string filename = this->GetOutputLocation().c_str();
+
+        mitk::FiberBundle::ConstPointer input = dynamic_cast<const mitk::FiberBundle*>(this->GetInput());
+        std::string ext = itksys::SystemTools::GetFilenameLastExtension(this->GetOutputLocation().c_str());
+
+        // default extension is .fib
+        if(ext == "")
+        {
+            ext = ".trk";
+            this->SetOutputLocation(this->GetOutputLocation() + ext);
+        }
+
+        MITK_INFO << "Writing fiber bundle as TRK";
+        TrackVisFiberReader trk;
+        trk.create(filename, input.GetPointer());
+        trk.writeHdr();
+        trk.append(input.GetPointer());
+
+        setlocale(LC_ALL, currLocale.c_str());
+        MITK_INFO << "Fiber bundle written";
+    }
+    catch(...)
+    {
+        throw;
+    }
+}
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisWriter.h
similarity index 82%
copy from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.h
copy to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisWriter.h
index e7c7194e03..576a1b86b0 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTrackVisWriter.h
@@ -1,118 +1,118 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
-#ifndef __mitkFiberBundleXWriter_h
-#define __mitkFiberBundleXWriter_h
+#ifndef __mitkFiberBundleTrackVisWriter_h
+#define __mitkFiberBundleTrackVisWriter_h
 
 #include <mitkAbstractFileWriter.h>
 
-#include "mitkFiberBundleX.h"
+#include "mitkFiberBundle.h"
 #include <vtkPolyDataWriter.h>
 
 
 
 namespace mitk
 {
 
 /**
  * Writes fiber bundles to a file
  * @ingroup Process
  */
-class FiberBundleXWriter : public mitk::AbstractFileWriter
+class FiberBundleTrackVisWriter : public mitk::AbstractFileWriter
 {
 public:
 
 
-    FiberBundleXWriter();
-    FiberBundleXWriter(const FiberBundleXWriter & other);
-    virtual FiberBundleXWriter * Clone() const;
-    virtual ~FiberBundleXWriter();
+    FiberBundleTrackVisWriter();
+    FiberBundleTrackVisWriter(const FiberBundleTrackVisWriter & other);
+    virtual FiberBundleTrackVisWriter * Clone() const;
+    virtual ~FiberBundleTrackVisWriter();
 
     using mitk::AbstractFileWriter::Write;
     virtual void Write();
 
     static const char* XML_GEOMETRY;
 
     static const char* XML_MATRIX_XX;
 
     static const char* XML_MATRIX_XY;
 
     static const char* XML_MATRIX_XZ;
 
     static const char* XML_MATRIX_YX;
 
     static const char* XML_MATRIX_YY;
 
     static const char* XML_MATRIX_YZ;
 
     static const char* XML_MATRIX_ZX;
 
     static const char* XML_MATRIX_ZY;
 
     static const char* XML_MATRIX_ZZ;
 
     static const char* XML_ORIGIN_X;
 
     static const char* XML_ORIGIN_Y;
 
     static const char* XML_ORIGIN_Z;
 
     static const char* XML_SPACING_X;
 
     static const char* XML_SPACING_Y;
 
     static const char* XML_SPACING_Z;
 
     static const char* XML_SIZE_X;
 
     static const char* XML_SIZE_Y;
 
     static const char* XML_SIZE_Z;
 
     static const char* XML_FIBER_BUNDLE;
 
     static const char* XML_FIBER;
 
     static const char* XML_PARTICLE;
 
     static const char* XML_ID;
 
     static const char* XML_POS_X;
 
     static const char* XML_POS_Y;
 
     static const char* XML_POS_Z;
 
     static const char* VERSION_STRING;
 
     static const char* XML_FIBER_BUNDLE_FILE;
 
     static const char* XML_FILE_VERSION;
 
     static const char* XML_NUM_FIBERS;
 
     static const char* XML_NUM_PARTICLES;
 
     static const char* ASCII_FILE;
 
     static const char* FILE_NAME;
 
 };
 
 
 } // end of namespace mitk
 
-#endif //__mitkFiberBundleXWriter_h
+#endif //__mitkFiberBundleWriter_h
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkReader.cpp
similarity index 89%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.cpp
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkReader.cpp
index 025f2bbe20..cf874cb3ac 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkReader.cpp
@@ -1,229 +1,219 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
-#include "mitkFiberBundleXReader.h"
+#include "mitkFiberBundleVtkReader.h"
 #include <itkMetaDataObject.h>
 #include <vtkPolyData.h>
 #include <vtkDataReader.h>
 #include <vtkPolyDataReader.h>
 #include <vtkMatrix4x4.h>
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 #include <vtkDataArray.h>
 #include <vtkFloatArray.h>
 #include <vtkCellData.h>
 #include <vtkPointData.h>
 #include <itksys/SystemTools.hxx>
 #include <tinyxml.h>
 #include <vtkCleanPolyData.h>
 #include <mitkTrackvis.h>
 #include <mitkCustomMimeType.h>
 #include "mitkDiffusionIOMimeTypes.h"
 
 
-mitk::FiberBundleXReader::FiberBundleXReader()
-  : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE() ), mitk::DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_DESCRIPTION() )
+mitk::FiberBundleVtkReader::FiberBundleVtkReader()
+  : mitk::AbstractFileReader( mitk::DiffusionIOMimeTypes::FIBERBUNDLE_VTK_MIMETYPE_NAME(), "VTK Fiber Bundle Reader" )
 {
   m_ServiceReg = this->RegisterService();
 }
 
-mitk::FiberBundleXReader::FiberBundleXReader(const FiberBundleXReader &other)
+mitk::FiberBundleVtkReader::FiberBundleVtkReader(const FiberBundleVtkReader &other)
   :mitk::AbstractFileReader(other)
 {
 }
 
-mitk::FiberBundleXReader * mitk::FiberBundleXReader::Clone() const
+mitk::FiberBundleVtkReader * mitk::FiberBundleVtkReader::Clone() const
 {
-  return new FiberBundleXReader(*this);
+  return new FiberBundleVtkReader(*this);
 }
 
 
-std::vector<itk::SmartPointer<mitk::BaseData> > mitk::FiberBundleXReader::Read()
+std::vector<itk::SmartPointer<mitk::BaseData> > mitk::FiberBundleVtkReader::Read()
 {
 
   std::vector<itk::SmartPointer<mitk::BaseData> > result;
   try
   {
     const std::string& locale = "C";
     const std::string& currLocale = setlocale( LC_ALL, NULL );
     setlocale(LC_ALL, locale.c_str());
 
     std::string filename = this->GetInputLocation();
 
     std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
     ext = itksys::SystemTools::LowerCase(ext);
 
-    if (ext==".trk")
-    {
-      FiberBundleX::Pointer image = FiberBundleX::New();
-      TrackVisFiberReader reader;
-      reader.open(this->GetInputLocation().c_str());
-      reader.read(image.GetPointer());
-      result.push_back(image.GetPointer());
-      return result;
-    }
-
     vtkSmartPointer<vtkDataReader> chooser=vtkSmartPointer<vtkDataReader>::New();
     chooser->SetFileName( this->GetInputLocation().c_str() );
     if( chooser->IsFilePolyData())
     {
       vtkSmartPointer<vtkPolyDataReader> reader = vtkSmartPointer<vtkPolyDataReader>::New();
       reader->SetFileName( this->GetInputLocation().c_str() );
       reader->Update();
 
       if ( reader->GetOutput() != NULL )
       {
         vtkSmartPointer<vtkPolyData> fiberPolyData = reader->GetOutput();
-        FiberBundleX::Pointer fiberBundle = FiberBundleX::New(fiberPolyData);
+        FiberBundle::Pointer fiberBundle = FiberBundle::New(fiberPolyData);
 
         vtkSmartPointer<vtkFloatArray> weights = vtkFloatArray::SafeDownCast(fiberPolyData->GetCellData()->GetArray("FIBER_WEIGHTS"));
         if (weights!=NULL)
         {
 //            float weight=0;
 //            for (int i=0; i<weights->GetSize(); i++)
 //                if (!mitk::Equal(weights->GetValue(i),weight,0.00001))
 //                {
 //                    MITK_INFO << "Weight: " << weights->GetValue(i);
 //                    weight = weights->GetValue(i);
 //                }
             fiberBundle->SetFiberWeights(weights);
         }
 
         vtkSmartPointer<vtkUnsignedCharArray> fiberColors = vtkUnsignedCharArray::SafeDownCast(fiberPolyData->GetPointData()->GetArray("FIBER_COLORS"));
         if (fiberColors!=NULL)
             fiberBundle->SetFiberColors(fiberColors);
 
         result.push_back(fiberBundle.GetPointer());
         return result;
       }
     }
     else // try to read deprecated fiber bundle file format
     {
       MITK_INFO << "Reading xml fiber bundle";
       vtkSmartPointer<vtkPolyData> fiberPolyData = vtkSmartPointer<vtkPolyData>::New();
       vtkSmartPointer<vtkCellArray> cellArray = vtkSmartPointer<vtkCellArray>::New();
       vtkSmartPointer<vtkPoints>    points = vtkSmartPointer<vtkPoints>::New();
       TiXmlDocument doc( this->GetInputLocation().c_str() );
       if(doc.LoadFile())
       {
         TiXmlHandle hDoc(&doc);
         TiXmlElement* pElem;
         TiXmlHandle hRoot(0);
         pElem = hDoc.FirstChildElement().Element();
         // save this for later
         hRoot = TiXmlHandle(pElem);
         pElem = hRoot.FirstChildElement("geometry").Element();
         // read geometry
         mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
         // read origin
         mitk::Point3D origin;
         double temp = 0;
         pElem->Attribute("origin_x", &temp);
         origin[0] = temp;
         pElem->Attribute("origin_y", &temp);
         origin[1] = temp;
         pElem->Attribute("origin_z", &temp);
         origin[2] = temp;
         geometry->SetOrigin(origin);
         // read spacing
         ScalarType spacing[3];
         pElem->Attribute("spacing_x", &temp);
         spacing[0] = temp;
         pElem->Attribute("spacing_y", &temp);
         spacing[1] = temp;
         pElem->Attribute("spacing_z", &temp);
         spacing[2] = temp;
         geometry->SetSpacing(spacing);
         // read transform
         vtkMatrix4x4* m = vtkMatrix4x4::New();
         pElem->Attribute("xx", &temp);
         m->SetElement(0,0,temp);
         pElem->Attribute("xy", &temp);
         m->SetElement(1,0,temp);
         pElem->Attribute("xz", &temp);
         m->SetElement(2,0,temp);
         pElem->Attribute("yx", &temp);
         m->SetElement(0,1,temp);
         pElem->Attribute("yy", &temp);
         m->SetElement(1,1,temp);
         pElem->Attribute("yz", &temp);
         m->SetElement(2,1,temp);
         pElem->Attribute("zx", &temp);
         m->SetElement(0,2,temp);
         pElem->Attribute("zy", &temp);
         m->SetElement(1,2,temp);
         pElem->Attribute("zz", &temp);
         m->SetElement(2,2,temp);
         m->SetElement(0,3,origin[0]);
         m->SetElement(1,3,origin[1]);
         m->SetElement(2,3,origin[2]);
         m->SetElement(3,3,1);
         geometry->SetIndexToWorldTransformByVtkMatrix(m);
         // read bounds
         float bounds[] = {0, 0, 0, 0, 0, 0};
         pElem->Attribute("size_x", &temp);
         bounds[1] = temp;
         pElem->Attribute("size_y", &temp);
         bounds[3] = temp;
         pElem->Attribute("size_z", &temp);
         bounds[5] = temp;
         geometry->SetFloatBounds(bounds);
         geometry->SetImageGeometry(true);
         pElem = hRoot.FirstChildElement("fiber_bundle").FirstChild().Element();
         for( ; pElem ; pElem=pElem->NextSiblingElement())
         {
           TiXmlElement* pElem2 = pElem->FirstChildElement();
           vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
           for( ; pElem2; pElem2=pElem2->NextSiblingElement())
           {
             Point3D point;
             pElem2->Attribute("pos_x", &temp);
             point[0] = temp;
             pElem2->Attribute("pos_y", &temp);
             point[1] = temp;
             pElem2->Attribute("pos_z", &temp);
             point[2] = temp;
             geometry->IndexToWorld(point, point);
             vtkIdType id = points->InsertNextPoint(point.GetDataPointer());
             container->GetPointIds()->InsertNextId(id);
           }
           cellArray->InsertNextCell(container);
         }
         fiberPolyData->SetPoints(points);
         fiberPolyData->SetLines(cellArray);
         vtkSmartPointer<vtkCleanPolyData> cleaner = vtkSmartPointer<vtkCleanPolyData>::New();
         cleaner->SetInputData(fiberPolyData);
         cleaner->Update();
         fiberPolyData = cleaner->GetOutput();
-        FiberBundleX::Pointer image = FiberBundleX::New(fiberPolyData);
+        FiberBundle::Pointer image = FiberBundle::New(fiberPolyData);
         result.push_back(image.GetPointer());
         return result;
       }
       else
       {
         MITK_ERROR << "could not open xml file";
         throw "could not open xml file";
       }
     }
     setlocale(LC_ALL, currLocale.c_str());
     MITK_INFO << "Fiber bundle read";
   }
   catch(...)
   {
     throw;
   }
   return result;
 }
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkReader.h
similarity index 70%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.h
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkReader.h
index 386fdad556..3f5ec08a60 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkReader.h
@@ -1,52 +1,52 @@
 /*===================================================================
 
 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 __mitkFiberBundleXReader_h
-#define __mitkFiberBundleXReader_h
+#ifndef __mitkFiberBundleVtkReader_h
+#define __mitkFiberBundleVtkReader_h
 
 #include <mitkCommon.h>
 #include <mitkFileReader.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <vtkSmartPointer.h>
 
 #include <mitkAbstractFileReader.h>
 
 namespace mitk
 {
 
   /** \brief
   */
 
-  class FiberBundleXReader : public AbstractFileReader
+  class FiberBundleVtkReader : public AbstractFileReader
   {
   public:
 
-    FiberBundleXReader();
-    virtual ~FiberBundleXReader(){}
-    FiberBundleXReader(const FiberBundleXReader& other);
-    virtual FiberBundleXReader * Clone() const;
+    FiberBundleVtkReader();
+    virtual ~FiberBundleVtkReader(){}
+    FiberBundleVtkReader(const FiberBundleVtkReader& other);
+    virtual FiberBundleVtkReader * Clone() const;
 
     using mitk::AbstractFileReader::Read;
     virtual std::vector<itk::SmartPointer<BaseData> > Read();
 
   private:
 
     us::ServiceRegistration<mitk::IFileReader> m_ServiceReg;
   };
 
 } //namespace MITK
 
-#endif // __mitkFiberBundleXReader_h
+#endif // __mitkFiberBundleReader_h
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkWriter.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkWriter.cpp
new file mode 100644
index 0000000000..b8794229f9
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkWriter.cpp
@@ -0,0 +1,133 @@
+/*===================================================================
+
+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 "mitkFiberBundleVtkWriter.h"
+#include <vtkSmartPointer.h>
+#include <vtkCleanPolyData.h>
+#include <itksys/SystemTools.hxx>
+#include <mitkTrackvis.h>
+#include <itkSize.h>
+#include <vtkFloatArray.h>
+#include <vtkCellData.h>
+#include <vtkPointData.h>
+#include <mitkAbstractFileWriter.h>
+#include <mitkCustomMimeType.h>
+#include "mitkDiffusionIOMimeTypes.h"
+
+mitk::FiberBundleVtkWriter::FiberBundleVtkWriter()
+    : mitk::AbstractFileWriter(mitk::FiberBundle::GetStaticNameOfClass(), mitk::DiffusionIOMimeTypes::FIBERBUNDLE_VTK_MIMETYPE_NAME(), "VTK Fiber Bundle Reader")
+{
+    Options defaultOptions;
+    defaultOptions["Save as binary file"] = true;
+    defaultOptions["Save color information"] = true;
+    defaultOptions["Save fiber weights"] = true;
+    this->SetDefaultOptions(defaultOptions);
+    RegisterService();
+}
+
+mitk::FiberBundleVtkWriter::FiberBundleVtkWriter(const mitk::FiberBundleVtkWriter & other)
+    :mitk::AbstractFileWriter(other)
+{}
+
+mitk::FiberBundleVtkWriter::~FiberBundleVtkWriter()
+{}
+
+mitk::FiberBundleVtkWriter * mitk::FiberBundleVtkWriter::Clone() const
+{
+    return new mitk::FiberBundleVtkWriter(*this);
+}
+
+void mitk::FiberBundleVtkWriter::Write()
+{
+
+    std::ostream* out;
+    std::ofstream outStream;
+
+    if( this->GetOutputStream() )
+    {
+        out = this->GetOutputStream();
+    }else{
+        outStream.open( this->GetOutputLocation().c_str() );
+        out = &outStream;
+    }
+
+    if ( !out->good() )
+    {
+        mitkThrow() << "Stream not good.";
+    }
+
+    try
+    {
+        const std::string& locale = "C";
+        const std::string& currLocale = setlocale( LC_ALL, NULL );
+        setlocale(LC_ALL, locale.c_str());
+
+        std::locale previousLocale(out->getloc());
+        std::locale I("C");
+        out->imbue(I);
+
+        std::string filename = this->GetOutputLocation().c_str();
+
+        mitk::FiberBundle::ConstPointer input = dynamic_cast<const mitk::FiberBundle*>(this->GetInput());
+        std::string ext = itksys::SystemTools::GetFilenameLastExtension(this->GetOutputLocation().c_str());
+        Options options = this->GetOptions();
+
+        vtkSmartPointer<vtkPolyData> fibPoly = input->GetFiberPolyData();
+        if (us::any_cast<bool>(options["Save fiber weights"]))
+        {
+            MITK_INFO << "Adding fiber weight information";
+            fibPoly->GetCellData()->AddArray(input->GetFiberWeights());
+        }
+        else if (fibPoly->GetCellData()->HasArray("FIBER_WEIGHTS"))
+            fibPoly->GetCellData()->RemoveArray("FIBER_WEIGHTS");
+        if (us::any_cast<bool>(options["Save color information"]))
+        {
+            MITK_INFO << "Adding color information";
+            fibPoly->GetPointData()->AddArray(input->GetFiberColors());
+        }
+        else if (fibPoly->GetPointData()->HasArray("FIBER_COLORS"))
+            fibPoly->GetPointData()->RemoveArray("FIBER_COLORS");
+
+        // default extension is .fib
+        if(ext == "")
+        {
+            ext = ".fib";
+            this->SetOutputLocation(this->GetOutputLocation() + ext);
+        }
+
+        vtkSmartPointer<vtkPolyDataWriter> writer = vtkSmartPointer<vtkPolyDataWriter>::New();
+        writer->SetInputData(fibPoly);
+        writer->SetFileName(filename.c_str());
+        if (us::any_cast<bool>(options["Save as binary file"]))
+        {
+            MITK_INFO << "Writing fiber bundle as vtk binary file";
+            writer->SetFileTypeToBinary();
+        }
+        else
+        {
+            MITK_INFO << "Writing fiber bundle as vtk ascii file";
+            writer->SetFileTypeToASCII();
+        }
+        writer->Write();
+
+        setlocale(LC_ALL, currLocale.c_str());
+        MITK_INFO << "Fiber bundle written";
+    }
+    catch(...)
+    {
+        throw;
+    }
+}
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkWriter.h
similarity index 84%
rename from Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.h
rename to Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkWriter.h
index e7c7194e03..bd44ba9d36 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleVtkWriter.h
@@ -1,118 +1,118 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
-#ifndef __mitkFiberBundleXWriter_h
-#define __mitkFiberBundleXWriter_h
+#ifndef __mitkFiberBundleVtkWriter_h
+#define __mitkFiberBundleVtkWriter_h
 
 #include <mitkAbstractFileWriter.h>
 
-#include "mitkFiberBundleX.h"
+#include "mitkFiberBundle.h"
 #include <vtkPolyDataWriter.h>
 
 
 
 namespace mitk
 {
 
 /**
  * Writes fiber bundles to a file
  * @ingroup Process
  */
-class FiberBundleXWriter : public mitk::AbstractFileWriter
+class FiberBundleVtkWriter : public mitk::AbstractFileWriter
 {
 public:
 
 
-    FiberBundleXWriter();
-    FiberBundleXWriter(const FiberBundleXWriter & other);
-    virtual FiberBundleXWriter * Clone() const;
-    virtual ~FiberBundleXWriter();
+    FiberBundleVtkWriter();
+    FiberBundleVtkWriter(const FiberBundleVtkWriter & other);
+    virtual FiberBundleVtkWriter * Clone() const;
+    virtual ~FiberBundleVtkWriter();
 
     using mitk::AbstractFileWriter::Write;
     virtual void Write();
 
     static const char* XML_GEOMETRY;
 
     static const char* XML_MATRIX_XX;
 
     static const char* XML_MATRIX_XY;
 
     static const char* XML_MATRIX_XZ;
 
     static const char* XML_MATRIX_YX;
 
     static const char* XML_MATRIX_YY;
 
     static const char* XML_MATRIX_YZ;
 
     static const char* XML_MATRIX_ZX;
 
     static const char* XML_MATRIX_ZY;
 
     static const char* XML_MATRIX_ZZ;
 
     static const char* XML_ORIGIN_X;
 
     static const char* XML_ORIGIN_Y;
 
     static const char* XML_ORIGIN_Z;
 
     static const char* XML_SPACING_X;
 
     static const char* XML_SPACING_Y;
 
     static const char* XML_SPACING_Z;
 
     static const char* XML_SIZE_X;
 
     static const char* XML_SIZE_Y;
 
     static const char* XML_SIZE_Z;
 
     static const char* XML_FIBER_BUNDLE;
 
     static const char* XML_FIBER;
 
     static const char* XML_PARTICLE;
 
     static const char* XML_ID;
 
     static const char* XML_POS_X;
 
     static const char* XML_POS_Y;
 
     static const char* XML_POS_Z;
 
     static const char* VERSION_STRING;
 
     static const char* XML_FIBER_BUNDLE_FILE;
 
     static const char* XML_FILE_VERSION;
 
     static const char* XML_NUM_FIBERS;
 
     static const char* XML_NUM_PARTICLES;
 
     static const char* ASCII_FILE;
 
     static const char* FILE_NAME;
 
 };
 
 
 } // end of namespace mitk
 
-#endif //__mitkFiberBundleXWriter_h
+#endif //__mitkFiberBundleWriter_h
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.cpp
deleted file mode 100644
index 987d8f75fc..0000000000
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.cpp
+++ /dev/null
@@ -1,139 +0,0 @@
-/*===================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center,
-Division of Medical and Biological Informatics.
-All rights reserved.
-
-This software is distributed WITHOUT ANY WARRANTY; without
-even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.
-
-See LICENSE.txt or http://www.mitk.org for details.
-
-===================================================================*/
-
-#include "mitkFiberBundleXWriter.h"
-#include <vtkSmartPointer.h>
-#include <vtkCleanPolyData.h>
-#include <itksys/SystemTools.hxx>
-#include <mitkTrackvis.h>
-#include <itkSize.h>
-#include <vtkFloatArray.h>
-#include <vtkCellData.h>
-#include <vtkPointData.h>
-#include <mitkAbstractFileWriter.h>
-#include <mitkCustomMimeType.h>
-#include "mitkDiffusionIOMimeTypes.h"
-
-mitk::FiberBundleXWriter::FiberBundleXWriter()
-  : mitk::AbstractFileWriter(mitk::FiberBundleX::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE() ), mitk::DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_DESCRIPTION())
-{
-  RegisterService();
-}
-
-mitk::FiberBundleXWriter::FiberBundleXWriter(const mitk::FiberBundleXWriter & other)
-  :mitk::AbstractFileWriter(other)
-{}
-
-mitk::FiberBundleXWriter::~FiberBundleXWriter()
-{}
-
-mitk::FiberBundleXWriter * mitk::FiberBundleXWriter::Clone() const
-{
-  return new mitk::FiberBundleXWriter(*this);
-}
-
-void mitk::FiberBundleXWriter::Write()
-{
-
-  std::ostream* out;
-  std::ofstream outStream;
-
-  if( this->GetOutputStream() )
-  {
-    out = this->GetOutputStream();
-  }else{
-    outStream.open( this->GetOutputLocation().c_str() );
-    out = &outStream;
-  }
-
-  if ( !out->good() )
-  {
-    mitkThrow() << "Stream not good.";
-  }
-
-  try
-  {
-    const std::string& locale = "C";
-    const std::string& currLocale = setlocale( LC_ALL, NULL );
-    setlocale(LC_ALL, locale.c_str());
-
-
-    std::locale previousLocale(out->getloc());
-    std::locale I("C");
-    out->imbue(I);
-
-    std::string filename = this->GetOutputLocation().c_str();
-
-    mitk::FiberBundleX::ConstPointer input = dynamic_cast<const mitk::FiberBundleX*>(this->GetInput());
-    std::string ext = itksys::SystemTools::GetFilenameLastExtension(this->GetOutputLocation().c_str());
-
-    vtkSmartPointer<vtkPolyData> fibPoly = input->GetFiberPolyData();
-    fibPoly->GetCellData()->AddArray(input->GetFiberWeights());
-    fibPoly->GetPointData()->AddArray(input->GetFiberColors());
-
-    // default extension is .fib
-    if(ext == "")
-    {
-      ext = ".fib";
-      this->SetOutputLocation(this->GetOutputLocation() + ext);
-    }
-
-    if (ext==".fib" || ext==".vtk")
-    {
-        MITK_INFO << "Writing fiber bundle as binary VTK";
-        vtkSmartPointer<vtkPolyDataWriter> writer = vtkSmartPointer<vtkPolyDataWriter>::New();
-        writer->SetInputData(fibPoly);
-        writer->SetFileName(filename.c_str());
-        writer->SetFileTypeToBinary();
-        writer->Write();
-    }
-    else if (ext==".afib")
-    {
-        itksys::SystemTools::ReplaceString(filename,".afib",".fib");
-        MITK_INFO << "Writing fiber bundle as ascii VTK";
-        vtkSmartPointer<vtkPolyDataWriter> writer = vtkSmartPointer<vtkPolyDataWriter>::New();
-        writer->SetInputData(fibPoly);
-        writer->SetFileName(filename.c_str());
-        writer->SetFileTypeToASCII();
-        writer->Write();
-    }
-    else if (ext==".avtk")
-    {
-        itksys::SystemTools::ReplaceString(filename,".avtk",".vtk");
-        MITK_INFO << "Writing fiber bundle as ascii VTK";
-        vtkSmartPointer<vtkPolyDataWriter> writer = vtkSmartPointer<vtkPolyDataWriter>::New();
-        writer->SetInputData(fibPoly);
-        writer->SetFileName(filename.c_str());
-        writer->SetFileTypeToASCII();
-        writer->Write();
-    }
-    else if (ext==".trk")
-    {
-        MITK_INFO << "Writing fiber bundle as TRK";
-        TrackVisFiberReader trk;
-        trk.create(filename, input.GetPointer());
-        trk.writeHdr();
-        trk.append(input.GetPointer());
-    }
-
-    setlocale(LC_ALL, currLocale.c_str());
-    MITK_INFO << "Fiber bundle written";
-  }
-  catch(...)
-  {
-    throw;
-  }
-}
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.cpp
index cb78e2f291..a3ccbf6e60 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.cpp
@@ -1,114 +1,114 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkFiberTrackingObjectFactory.h"
 
 
 mitk::FiberTrackingObjectFactory::FiberTrackingObjectFactory()
   : CoreObjectFactoryBase()
 {
 }
 
 mitk::FiberTrackingObjectFactory::~FiberTrackingObjectFactory()
 {
 }
 
 mitk::Mapper::Pointer mitk::FiberTrackingObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper=NULL;
 
   if ( id == mitk::BaseRenderer::Standard2D )
   {
-    std::string classname("FiberBundleX");
+    std::string classname("FiberBundle");
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
-      newMapper = mitk::FiberBundleXMapper2D::New();
+      newMapper = mitk::FiberBundleMapper2D::New();
       newMapper->SetDataNode(node);
     }
 
   }
   else if ( id == mitk::BaseRenderer::Standard3D )
   {
-    std::string classname("FiberBundleX");
+    std::string classname("FiberBundle");
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
-      newMapper = mitk::FiberBundleXMapper3D::New();
+      newMapper = mitk::FiberBundleMapper3D::New();
       newMapper->SetDataNode(node);
     }
   }
 
   return newMapper;
 }
 
 void mitk::FiberTrackingObjectFactory::SetDefaultProperties(mitk::DataNode* node)
 {
-  std::string classname("FiberBundleX");
+  std::string classname("FiberBundle");
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
-    mitk::FiberBundleXMapper3D::SetDefaultProperties(node);
-    mitk::FiberBundleXMapper2D::SetDefaultProperties(node);
+    mitk::FiberBundleMapper3D::SetDefaultProperties(node);
+    mitk::FiberBundleMapper2D::SetDefaultProperties(node);
   }
 }
 
 const char* mitk::FiberTrackingObjectFactory::GetFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_FileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::FiberTrackingObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 const char* mitk::FiberTrackingObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::FiberTrackingObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 void mitk::FiberTrackingObjectFactory::CreateFileExtensionsMap()
 {
 
 }
 
 void mitk::FiberTrackingObjectFactory::RegisterIOFactories()
 {
 }
 
 struct RegisterFiberTrackingObjectFactory{
   RegisterFiberTrackingObjectFactory()
     : m_Factory( mitk::FiberTrackingObjectFactory::New() )
   {
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory( m_Factory );
   }
 
   ~RegisterFiberTrackingObjectFactory()
   {
     mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory( m_Factory );
   }
 
   mitk::FiberTrackingObjectFactory::Pointer m_Factory;
 };
 
 static RegisterFiberTrackingObjectFactory registerFiberTrackingObjectFactory;
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.h
index b26f470e1b..0c0806e8c2 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.h
@@ -1,70 +1,70 @@
 /*===================================================================
 
 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 MITKFIBERTRACKINGOBJECTFACTORY_H
 #define MITKFIBERTRACKINGOBJECTFACTORY_H
 
 #include "mitkCoreObjectFactory.h"
 
 //modernized fiberbundle datastrucutre
-#include "mitkFiberBundleX.h"
-#include "mitkFiberBundleXMapper3D.h"
-#include "mitkFiberBundleXMapper2D.h"
+#include "mitkFiberBundle.h"
+#include "mitkFiberBundleMapper3D.h"
+#include "mitkFiberBundleMapper2D.h"
 
-//#include "mitkFiberBundleXThreadMonitorMapper3D.h"
-//#include "mitkFiberBundleXThreadMonitor.h"
+//#include "mitkFiberBundleThreadMonitorMapper3D.h"
+//#include "mitkFiberBundleThreadMonitor.h"
 
 namespace mitk {
 
 class FiberTrackingObjectFactory : public CoreObjectFactoryBase
 {
   public:
     mitkClassMacro(FiberTrackingObjectFactory,CoreObjectFactoryBase)
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     ~FiberTrackingObjectFactory();
 
     virtual Mapper::Pointer CreateMapper(mitk::DataNode* node, MapperSlotId slotId);
 
     virtual void SetDefaultProperties(mitk::DataNode* node);
 
     virtual const char* GetFileExtensions();
 
     virtual mitk::CoreObjectFactoryBase::MultimapType GetFileExtensionsMap();
 
     virtual const char* GetSaveFileExtensions();
 
     virtual mitk::CoreObjectFactoryBase::MultimapType GetSaveFileExtensionsMap();
 
     void RegisterIOFactories();
 
 protected:
     FiberTrackingObjectFactory();
   private:
     void CreateFileExtensionsMap();
     std::string m_ExternalFileExtensions;
     std::string m_InternalFileExtensions;
     std::string m_SaveFileExtensions;
     MultimapType m_FileExtensionsMap;
     MultimapType m_SaveFileExtensionsMap;
 
 };
 
 }
 
 
 #endif // MITKFIBERTRACKINGOBJECTFACTORY_H
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateTractogramDirectionsFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateTractogramDirectionsFilter.h
index a54a2cb1b9..47f590315a 100755
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateTractogramDirectionsFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateTractogramDirectionsFilter.h
@@ -1,108 +1,108 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 /*===================================================================
 
 This file is based heavily on a corresponding ITK filter.
 
 ===================================================================*/
 #ifndef __itkEvaluateTractogramDirectionsFilter_h_
 #define __itkEvaluateTractogramDirectionsFilter_h_
 
 #include <itkProcessObject.h>
 #include <itkVectorContainer.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <itkImageSource.h>
 
 namespace itk{
 /** \brief Calculates the voxel-wise angular error of the input tractogram to a set of voxel-wise directions.
  */
 
 template< class PixelType >
 class EvaluateTractogramDirectionsFilter : public ImageSource< Image< PixelType, 3 > >
 {
 
 public:
 
     typedef EvaluateTractogramDirectionsFilter Self;
     typedef SmartPointer<Self>                          Pointer;
     typedef SmartPointer<const Self>                    ConstPointer;
     typedef ImageSource< Image< PixelType, 3 > >        Superclass;
     typedef typename Superclass::OutputImageRegionType  OutputImageRegionType;
     typedef typename Superclass::OutputImageType        OutputImageType;
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     /** Runtime information support. */
     itkTypeMacro(EvaluateTractogramDirectionsFilter, ImageToImageFilter)
 
-    typedef mitk::FiberBundleX                                  FiberBundleType;
+    typedef mitk::FiberBundle                                  FiberBundleType;
     typedef Vector< float, 3 >                                  DirectionType;
     typedef Image< DirectionType, 3 >                           DirectionImageType;
     typedef VectorContainer< int, DirectionImageType::Pointer > DirectionImageContainerType;
     typedef Image< float, 3 >                                   FloatImageType;
     typedef Image< bool, 3 >                                    BoolImageType;
     typedef Image< unsigned char, 3 >                           UCharImageType;
     typedef Image< double, 3 >                                  DoubleImageType;
 
     itkSetMacro( Tractogram, FiberBundleType::Pointer)                      ///< Input tractogram
     itkSetMacro( ReferenceImageSet , DirectionImageContainerType::Pointer)  ///< Input images containing one reference direction per voxel.
     itkSetMacro( MaskImage , UCharImageType::Pointer)                       ///< Calculation is only performed inside of the mask image.
     itkSetMacro( IgnoreMissingDirections , bool)                            ///< If in one voxel, the number of directions differs between the input tractogram and the reference, the excess directions are ignored. Otherwise, the error to the next closest direction is calculated.
     itkSetMacro( UseInterpolation , bool)                                   ///< Use trilinear interpolation.
 
     /** Output statistics. */
     itkGetMacro( MeanAngularError, float)
     itkGetMacro( MinAngularError, float)
     itkGetMacro( MaxAngularError, float)
     itkGetMacro( VarAngularError, float)
     itkGetMacro( MedianAngularError, float)
 
 protected:
     EvaluateTractogramDirectionsFilter();
     ~EvaluateTractogramDirectionsFilter() {}
 
     void GenerateData();
 
     itk::Point<PixelType, 3> GetItkPoint(double point[3]);
     itk::Vector<PixelType, 3> GetItkVector(double point[3]);
     vnl_vector_fixed<PixelType, 3> GetVnlVector(double point[3]);
     vnl_vector_fixed<PixelType, 3> GetVnlVector(Vector< PixelType, 3 >& vector);
 
     UCharImageType::Pointer                 m_MaskImage;
     DirectionImageContainerType::Pointer    m_ReferenceImageSet;
     bool                                    m_IgnoreMissingDirections;
     double                                  m_MeanAngularError;
     double                                  m_MedianAngularError;
     double                                  m_MaxAngularError;
     double                                  m_MinAngularError;
     double                                  m_VarAngularError;
     std::vector< double >                   m_AngularErrorVector;
     double                                  m_Eps;
     FiberBundleType::Pointer                m_Tractogram;
     bool                                    m_UseInterpolation;
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkEvaluateTractogramDirectionsFilter.cpp"
 #endif
 
 #endif //__itkEvaluateTractogramDirectionsFilter_h_
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberCurvatureFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberCurvatureFilter.cpp
index 883473377c..81ebca3171 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberCurvatureFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberCurvatureFilter.cpp
@@ -1,147 +1,147 @@
 /*===================================================================
 
 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 "itkFiberCurvatureFilter.h"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 #include <vtkDoubleArray.h>
 #include <vtkPointData.h>
 #include <boost/progress.hpp>
 
 namespace itk{
 
 FiberCurvatureFilter::FiberCurvatureFilter()
     : m_AngularDeviation(20)
     , m_Distance(1.0)
     , m_RemoveFibers(false)
 {
 
 }
 
 FiberCurvatureFilter::~FiberCurvatureFilter()
 {
 
 }
 
 void FiberCurvatureFilter::GenerateData()
 {
     vtkSmartPointer<vtkPolyData> inputPoly = m_InputFiberBundle->GetFiberPolyData();
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     MITK_INFO << "Applying curvature threshold";
     boost::progress_display disp(inputPoly->GetNumberOfCells());
     for (int i=0; i<inputPoly->GetNumberOfCells(); i++)
     {
         ++disp;
         vtkCell* cell = inputPoly->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         // calculate curvatures
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double dist = 0;
             int c = j;
             std::vector< vnl_vector_fixed< float, 3 > > vectors;
             vnl_vector_fixed< float, 3 > meanV;
             while(dist<m_Distance/2 && c>1)
             {
                 double p1[3];
                 points->GetPoint(c-1, p1);
                 double p2[3];
                 points->GetPoint(c, p2);
 
                 vnl_vector_fixed< float, 3 > v;
                 v[0] = p2[0]-p1[0];
                 v[1] = p2[1]-p1[1];
                 v[2] = p2[2]-p1[2];
                 dist += v.magnitude();
                 v.normalize();
                 vectors.push_back(v);
                 meanV += v;
                 c--;
             }
             c = j;
             dist = 0;
             while(dist<m_Distance/2 && c<numPoints-1)
             {
                 double p1[3];
                 points->GetPoint(c, p1);
                 double p2[3];
                 points->GetPoint(c+1, p2);
 
                 vnl_vector_fixed< float, 3 > v;
                 v[0] = p2[0]-p1[0];
                 v[1] = p2[1]-p1[1];
                 v[2] = p2[2]-p1[2];
                 dist += v.magnitude();
                 v.normalize();
                 vectors.push_back(v);
                 meanV += v;
                 c++;
             }
             meanV.normalize();
 
             double dev = 0;
             for (int c=0; c<vectors.size(); c++)
             {
                 double angle = dot_product(meanV, vectors.at(c));
                 if (angle>1.0)
                     angle = 1.0;
                 if (angle<0.0)
                     angle = 0.0;
                 dev += acos(angle)*180/M_PI;
             }
             if (vectors.size()>0)
                 dev /= vectors.size();
 
             if (dev<m_AngularDeviation)
             {
                 double p[3];
                 points->GetPoint(j, p);
                 vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                 container->GetPointIds()->InsertNextId(id);
             }
             else
             {
                 if (m_RemoveFibers)
                 {
                     container = vtkSmartPointer<vtkPolyLine>::New();
                     break;
                 }
 
                 if (container->GetNumberOfPoints()>0)
                     vtkNewCells->InsertNextCell(container);
                 container = vtkSmartPointer<vtkPolyLine>::New();
             }
         }
         if (container->GetNumberOfPoints()>0)
             vtkNewCells->InsertNextCell(container);
     }
 
     vtkSmartPointer<vtkPolyData> outputPoly = vtkSmartPointer<vtkPolyData>::New();
     outputPoly->SetPoints(vtkNewPoints);
     outputPoly->SetLines(vtkNewCells);
-    m_OutputFiberBundle = FiberBundleX::New(outputPoly);
+    m_OutputFiberBundle = FiberBundle::New(outputPoly);
 }
 
 }
 
 
 
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberCurvatureFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberCurvatureFilter.h
index 3230a2675b..eeeb588d60 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberCurvatureFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberCurvatureFilter.h
@@ -1,83 +1,83 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #ifndef itkFiberCurvatureFilter_h
 #define itkFiberCurvatureFilter_h
 
 // MITK
 #include <mitkPlanarEllipse.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <mitkFiberfoxParameters.h>
 
 // ITK
 #include <itkProcessObject.h>
 
 // VTK
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 
 using namespace std;
 
 namespace itk{
 
 /**
 * \brief Generates artificial fibers distributed in and interpolated between the input planar figures.   */
 
 class FiberCurvatureFilter : public ProcessObject
 {
 public:
 
     typedef FiberCurvatureFilter Self;
     typedef ProcessObject                                       Superclass;
     typedef SmartPointer< Self >                                Pointer;
     typedef SmartPointer< const Self >                          ConstPointer;
 
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     itkTypeMacro( FiberCurvatureFilter, ProcessObject )
 
     virtual void Update(){
         this->GenerateData();
     }
 
     itkSetMacro( Distance, double )
     itkSetMacro( AngularDeviation, double )
     itkSetMacro( RemoveFibers, bool )
-    itkSetMacro( InputFiberBundle, FiberBundleX::Pointer )
-    itkGetMacro( OutputFiberBundle, FiberBundleX::Pointer )
+    itkSetMacro( InputFiberBundle, FiberBundle::Pointer )
+    itkGetMacro( OutputFiberBundle, FiberBundle::Pointer )
 
 protected:
 
     void GenerateData();
 
     FiberCurvatureFilter();
     virtual ~FiberCurvatureFilter();
 
-    FiberBundleX::Pointer m_InputFiberBundle;
-    FiberBundleX::Pointer m_OutputFiberBundle;
+    FiberBundle::Pointer m_InputFiberBundle;
+    FiberBundle::Pointer m_OutputFiberBundle;
     double  m_AngularDeviation;
     double  m_Distance;
     bool    m_RemoveFibers;
 };
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkFiberCurvatureFilter.cpp"
 #endif
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFibersFromPlanarFiguresFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFibersFromPlanarFiguresFilter.cpp
index 41eaac38e2..6d2506664a 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFibersFromPlanarFiguresFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFibersFromPlanarFiguresFilter.cpp
@@ -1,241 +1,241 @@
 /*===================================================================
 
 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 "itkFibersFromPlanarFiguresFilter.h"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 // MITK
 #include <itkOrientationDistributionFunction.h>
 #include <itkDiffusionQballGeneralizedFaImageFilter.h>
 #include <mitkStandardFileLocations.h>
 #include <mitkFiberBuilder.h>
 #include <mitkMetropolisHastingsSampler.h>
 #include <itkTensorImageToQBallImageFilter.h>
 #include <mitkGibbsEnergyComputer.h>
 #include <mitkRotationOperation.h>
 #include <mitkInteractionConst.h>
 
 // ITK
 #include <itkImageDuplicator.h>
 #include <itkResampleImageFilter.h>
 #include <itkTimeProbe.h>
 #include <itkMersenneTwisterRandomVariateGenerator.h>
 
 // MISC
 #include <math.h>
 
 namespace itk{
 
 FibersFromPlanarFiguresFilter::FibersFromPlanarFiguresFilter()
 {
 
 }
 
 FibersFromPlanarFiguresFilter::~FibersFromPlanarFiguresFilter()
 {
 
 }
 
 
 void FibersFromPlanarFiguresFilter::GeneratePoints()
 {
     Statistics::MersenneTwisterRandomVariateGenerator::Pointer randGen = Statistics::MersenneTwisterRandomVariateGenerator::New();
     randGen->SetSeed((unsigned int)0);
     m_2DPoints.clear();
     int count = 0;
 
     while (count < m_Parameters.m_Density)
     {
         mitk::Vector2D p;
         switch (m_Parameters.m_Distribution) {
             case FiberGenerationParameters::DISTRIBUTE_GAUSSIAN:
                 p[0] = randGen->GetNormalVariate(0, m_Parameters.m_Variance);
                 p[1] = randGen->GetNormalVariate(0, m_Parameters.m_Variance);
                 break;
             default:
                 p[0] = randGen->GetUniformVariate(-1, 1);
                 p[1] = randGen->GetUniformVariate(-1, 1);
         }
 
         if (sqrt(p[0]*p[0]+p[1]*p[1]) <= 1)
         {
             m_2DPoints.push_back(p);
             count++;
         }
     }
 }
 
 void FibersFromPlanarFiguresFilter::GenerateData()
 {
     // check if enough fiducials are available
     for (unsigned int i=0; i<m_Parameters.m_Fiducials.size(); i++)
         if (m_Parameters.m_Fiducials.at(i).size()<2)
             itkExceptionMacro("At least 2 fiducials needed per fiber bundle!");
 
     for (unsigned int i=0; i<m_Parameters.m_Fiducials.size(); i++)
     {
         vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
         vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
 
         vector< mitk::PlanarEllipse::Pointer > bundle = m_Parameters.m_Fiducials.at(i);
 
         vector< unsigned int > fliplist;
         if (i<m_Parameters.m_FlipList.size())
             fliplist = m_Parameters.m_FlipList.at(i);
         else
             fliplist.resize(bundle.size(), 0);
         if (fliplist.size()<bundle.size())
             fliplist.resize(bundle.size(), 0);
 
         GeneratePoints();
         for (int j=0; j<m_Parameters.m_Density; j++)
         {
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
 
             mitk::PlanarEllipse::Pointer figure = bundle.at(0);
             mitk::Point2D p0 = figure->GetControlPoint(0);
             mitk::Point2D p1 = figure->GetControlPoint(1);
             mitk::Point2D p2 = figure->GetControlPoint(2);
             mitk::Point2D p3 = figure->GetControlPoint(3);
             double r1 = p0.EuclideanDistanceTo(p1);
             double r2 = p0.EuclideanDistanceTo(p2);
             mitk::Vector2D eDir = p1-p0; eDir.Normalize();
             mitk::Vector2D tDir = p3-p0; tDir.Normalize();
 
             // apply twist
             vnl_matrix_fixed<double, 2, 2> tRot;
             tRot[0][0] = tDir[0];
             tRot[1][1] = tRot[0][0];
             tRot[1][0] = sin(acos(tRot[0][0]));
             tRot[0][1] = -tRot[1][0];
             if (tDir[1]<0)
                 tRot.inplace_transpose();
             m_2DPoints[j].SetVnlVector(tRot*m_2DPoints[j].GetVnlVector());
 
             // apply new ellipse shape
             vnl_vector_fixed< double, 2 > newP;
             newP[0] = m_2DPoints.at(j)[0];
             newP[1] = m_2DPoints.at(j)[1];
             double alpha = acos(eDir[0]);
             if (eDir[1]>0)
                 alpha = 2*M_PI-alpha;
             vnl_matrix_fixed<double, 2, 2> eRot;
             eRot[0][0] = cos(alpha);
             eRot[1][1] = eRot[0][0];
             eRot[1][0] = sin(alpha);
             eRot[0][1] = -eRot[1][0];
             newP = eRot*newP;
             newP[0] *= r1;
             newP[1] *= r2;
             newP = eRot.transpose()*newP;
 
             p0[0] += newP[0];
             p0[1] += newP[1];
 
             const mitk::PlaneGeometry* planeGeo = figure->GetPlaneGeometry();
 
             mitk::Point3D w, wc;
             planeGeo->Map(p0, w);
 
             wc = figure->GetWorldControlPoint(0);
 
             vtkIdType id = m_VtkPoints->InsertNextPoint(w.GetDataPointer());
             container->GetPointIds()->InsertNextId(id);
 
             vnl_vector_fixed< double, 3 > n = planeGeo->GetNormalVnl();
 
             for (unsigned int k=1; k<bundle.size(); k++)
             {
                 figure = bundle.at(k);
                 p0 = figure->GetControlPoint(0);
                 p1 = figure->GetControlPoint(1);
                 p2 = figure->GetControlPoint(2);
                 p3 = figure->GetControlPoint(3);
                 r1 = p0.EuclideanDistanceTo(p1);
                 r2 = p0.EuclideanDistanceTo(p2);
 
                 eDir = p1-p0; eDir.Normalize();
                 mitk::Vector2D tDir2 = p3-p0; tDir2.Normalize();
                 mitk::Vector2D temp; temp.SetVnlVector(tRot.transpose() * tDir2.GetVnlVector());
 
                 // apply twist
                 tRot[0][0] = tDir[0]*tDir2[0] + tDir[1]*tDir2[1];
                 tRot[1][1] = tRot[0][0];
                 tRot[1][0] = sin(acos(tRot[0][0]));
                 tRot[0][1] = -tRot[1][0];
                 if (temp[1]<0)
                     tRot.inplace_transpose();
                 m_2DPoints[j].SetVnlVector(tRot*m_2DPoints[j].GetVnlVector());
                 tDir = tDir2;
 
                 // apply new ellipse shape
                 newP[0] = m_2DPoints.at(j)[0];
                 newP[1] = m_2DPoints.at(j)[1];
 
                 // calculate normal
                 mitk::PlaneGeometry* planeGeo = const_cast<mitk::PlaneGeometry*>(figure->GetPlaneGeometry());
                 mitk::Vector3D perp = wc-planeGeo->ProjectPointOntoPlane(wc); perp.Normalize();
                 vnl_vector_fixed< double, 3 > n2 = planeGeo->GetNormalVnl();
                 wc = figure->GetWorldControlPoint(0);
 
                 // is flip needed?
                 if (dot_product(perp.GetVnlVector(),n2)>0 && dot_product(n,n2)<=0.00001)
                     newP[0] *= -1;
                 if (fliplist.at(k)>0)
                     newP[0] *= -1;
                 n = n2;
 
                 alpha = acos(eDir[0]);
                 if (eDir[1]>0)
                     alpha = 2*M_PI-alpha;
                 eRot[0][0] = cos(alpha);
                 eRot[1][1] = eRot[0][0];
                 eRot[1][0] = sin(alpha);
                 eRot[0][1] = -eRot[1][0];
                 newP = eRot*newP;
                 newP[0] *= r1;
                 newP[1] *= r2;
                 newP = eRot.transpose()*newP;
 
                 p0[0] += newP[0];
                 p0[1] += newP[1];
 
                 mitk::Point3D w;
                 planeGeo->Map(p0, w);
 
 
                 vtkIdType id = m_VtkPoints->InsertNextPoint(w.GetDataPointer());
                 container->GetPointIds()->InsertNextId(id);
             }
 
             m_VtkCellArray->InsertNextCell(container);
         }
 
         vtkSmartPointer<vtkPolyData> fiberPolyData = vtkSmartPointer<vtkPolyData>::New();
         fiberPolyData->SetPoints(m_VtkPoints);
         fiberPolyData->SetLines(m_VtkCellArray);
-        mitk::FiberBundleX::Pointer mitkFiberBundle = mitk::FiberBundleX::New(fiberPolyData);
+        mitk::FiberBundle::Pointer mitkFiberBundle = mitk::FiberBundle::New(fiberPolyData);
         mitkFiberBundle->ResampleSpline(m_Parameters.m_Sampling, m_Parameters.m_Tension, m_Parameters.m_Continuity, m_Parameters.m_Bias);
         m_FiberBundles.push_back(mitkFiberBundle);
     }
 }
 
 }
 
 
 
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFibersFromPlanarFiguresFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFibersFromPlanarFiguresFilter.h
index f7e9451f76..3e6c0c0809 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFibersFromPlanarFiguresFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFibersFromPlanarFiguresFilter.h
@@ -1,87 +1,87 @@
 /*===================================================================
 
 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 itkFibersFromPlanarFiguresFilter_h
 #define itkFibersFromPlanarFiguresFilter_h
 
 // MITK
 #include <mitkPlanarEllipse.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <mitkFiberfoxParameters.h>
 
 // ITK
 #include <itkProcessObject.h>
 
 // VTK
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 
 using namespace std;
 
 namespace itk{
 
 /**
 * \brief Generates artificial fibers distributed in and interpolated between the input planar figures.   */
 
 class FibersFromPlanarFiguresFilter : public ProcessObject
 {
 public:
 
     typedef FibersFromPlanarFiguresFilter Self;
     typedef ProcessObject                                       Superclass;
     typedef SmartPointer< Self >                                Pointer;
     typedef SmartPointer< const Self >                          ConstPointer;
-    typedef mitk::FiberBundleX::Pointer                         FiberType;
-    typedef vector< mitk::FiberBundleX::Pointer >               FiberContainerType;
+    typedef mitk::FiberBundle::Pointer                         FiberType;
+    typedef vector< mitk::FiberBundle::Pointer >               FiberContainerType;
 
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     itkTypeMacro( FibersFromPlanarFiguresFilter, ProcessObject )
 
     virtual void Update(){
         this->GenerateData();
     }
 
     // input
     void SetParameters( FiberGenerationParameters param )  ///< Simulation parameters.
     {
         m_Parameters = param;
     }
 
     // output
     FiberContainerType GetFiberBundles(){ return m_FiberBundles; }
 
 protected:
 
     void GenerateData();
 
     FibersFromPlanarFiguresFilter();
     virtual ~FibersFromPlanarFiguresFilter();
     void GeneratePoints();
 
     FiberContainerType              m_FiberBundles;    ///< container for the output fiber bundles
     vector< mitk::Vector2D >        m_2DPoints;        ///< container for the 2D fiber waypoints
     FiberGenerationParameters       m_Parameters;
 };
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkFibersFromPlanarFiguresFilter.cpp"
 #endif
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.h
index b0e3724eed..fc9c23714e 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.h
@@ -1,87 +1,87 @@
 /*===================================================================
 
 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 __itkTractDensityImageFilter_h__
 #define __itkTractDensityImageFilter_h__
 
 #include <itkImageSource.h>
 #include <itkImage.h>
 #include <itkVectorContainer.h>
 #include <itkRGBAPixel.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 
 namespace itk{
 
 /**
 * \brief Generates tract density images from input fiberbundles (Calamante 2010).   */
 
 template< class OutputImageType >
 class TractDensityImageFilter : public ImageSource< OutputImageType >
 {
 
 public:
   typedef TractDensityImageFilter Self;
   typedef ProcessObject Superclass;
   typedef SmartPointer< Self > Pointer;
   typedef SmartPointer< const Self > ConstPointer;
 
   typedef typename OutputImageType::PixelType OutPixelType;
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
   itkTypeMacro( TractDensityImageFilter, ImageSource )
 
   itkSetMacro( UpsamplingFactor, float)                         ///< use higher resolution for ouput image
   itkGetMacro( UpsamplingFactor, float)                         ///< use higher resolution for ouput image
   itkSetMacro( InvertImage, bool)                               ///< voxelvalue = 1-voxelvalue
   itkGetMacro( InvertImage, bool)                               ///< voxelvalue = 1-voxelvalue
   itkSetMacro( BinaryOutput, bool)                              ///< generate binary fiber envelope
   itkGetMacro( BinaryOutput, bool)                              ///< generate binary fiber envelope
   itkSetMacro( OutputAbsoluteValues, bool)                      ///< output absolute values of the number of fibers per voxel
   itkGetMacro( OutputAbsoluteValues, bool)                      ///< output absolute values of the number of fibers per voxel
   itkSetMacro( UseImageGeometry, bool)                          ///< use input image geometry to initialize output image
   itkGetMacro( UseImageGeometry, bool)                          ///< use input image geometry to initialize output image
-  itkSetMacro( FiberBundle, mitk::FiberBundleX::Pointer)        ///< input fiber bundle
+  itkSetMacro( FiberBundle, mitk::FiberBundle::Pointer)        ///< input fiber bundle
   itkSetMacro( InputImage, typename OutputImageType::Pointer)   ///< use input image geometry to initialize output image
   itkSetMacro( UseTrilinearInterpolation, bool )
   itkSetMacro( DoFiberResampling, bool )
 
   void GenerateData();
 
 protected:
 
   itk::Point<float, 3> GetItkPoint(double point[3]);
 
   TractDensityImageFilter();
   virtual ~TractDensityImageFilter();
 
   typename OutputImageType::Pointer m_InputImage;           ///< use input image geometry to initialize output image
-  mitk::FiberBundleX::Pointer       m_FiberBundle;          ///< input fiber bundle
+  mitk::FiberBundle::Pointer       m_FiberBundle;          ///< input fiber bundle
   float                             m_UpsamplingFactor;     ///< use higher resolution for ouput image
   bool                              m_InvertImage;          ///< voxelvalue = 1-voxelvalue
   bool                              m_BinaryOutput;         ///< generate binary fiber envelope
   bool                              m_UseImageGeometry;     ///< use input image geometry to initialize output image
   bool                              m_OutputAbsoluteValues; ///< do not normalize image values to 0-1
   bool                              m_UseTrilinearInterpolation;
   bool                              m_DoFiberResampling;
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkTractDensityImageFilter.cpp"
 #endif
 
 #endif // __itkTractDensityImageFilter_h__
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
index c284489d44..ee42dfddc7 100755
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
@@ -1,131 +1,131 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #ifndef __itkTractsToDWIImageFilter_h__
 #define __itkTractsToDWIImageFilter_h__
 
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <itkVnlForwardFFTImageFilter.h>
 #include <itkVectorImage.h>
 #include <cmath>
 #include <mitkFiberfoxParameters.h>
 #include <itkTimeProbe.h>
 #include <mitkRawShModel.h>
 #include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
 
 namespace itk
 {
 
 /**
 * \brief Generates artificial diffusion weighted image volume from the input fiberbundle using a generic multicompartment model.
 * See "Fiberfox: Facilitating the creation of realistic white matter software phantoms" (DOI: 10.1002/mrm.25045) for details.
 */
 
 template< class PixelType >
 class TractsToDWIImageFilter : public ImageSource< itk::VectorImage< PixelType, 3 > >
 {
 
 public:
 
     typedef TractsToDWIImageFilter                          Self;
     typedef ImageSource< itk::VectorImage< PixelType, 3 > > Superclass;
     typedef SmartPointer< Self >                            Pointer;
     typedef SmartPointer< const Self >                      ConstPointer;
 
     typedef typename Superclass::OutputImageType                        OutputImageType;
     typedef itk::Image<double, 3>                                       ItkDoubleImgType;
     typedef itk::Image<unsigned char, 3>                                ItkUcharImgType;
-    typedef mitk::FiberBundleX::Pointer                                 FiberBundleType;
+    typedef mitk::FiberBundle::Pointer                                 FiberBundleType;
     typedef itk::VectorImage< double, 3 >                               DoubleDwiType;
     typedef itk::Matrix<double, 3, 3>                                   MatrixType;
     typedef itk::Image< double, 2 >                                     SliceType;
     typedef itk::VnlForwardFFTImageFilter<SliceType>::OutputImageType   ComplexSliceType;
     typedef itk::Vector< double,3>                                      DoubleVectorType;
 
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     itkTypeMacro( TractsToDWIImageFilter, ImageSource )
 
     /** Input */
     itkSetMacro( FiberBundle, FiberBundleType )             ///< Input fiber bundle
     itkSetMacro( UseConstantRandSeed, bool )                ///< Seed for random generator.
     void SetParameters( FiberfoxParameters<double> param )  ///< Simulation parameters.
     { m_Parameters = param; }
 
     /** Output */
     FiberfoxParameters<double> GetParameters(){ return m_Parameters; }
     std::vector< ItkDoubleImgType::Pointer > GetVolumeFractions() ///< one double image for each compartment containing the corresponding volume fraction per voxel
     { return m_VolumeFractions; }
     mitk::LevelWindow GetLevelWindow(){ return m_LevelWindow; }
     itkGetMacro( StatusText, std::string )
 
     void GenerateData();
 
 protected:
 
     TractsToDWIImageFilter();
     virtual ~TractsToDWIImageFilter();
     itk::Point<float, 3> GetItkPoint(double point[3]);
     itk::Vector<double, 3> GetItkVector(double point[3]);
     vnl_vector_fixed<double, 3> GetVnlVector(double point[3]);
     vnl_vector_fixed<double, 3> GetVnlVector(Vector< float, 3 >& vector);
     double RoundToNearest(double num);
     std::string GetTime();
 
     /** Transform generated image compartment by compartment, channel by channel and slice by slice using DFT and add k-space artifacts. */
     DoubleDwiType::Pointer DoKspaceStuff(std::vector< DoubleDwiType::Pointer >& images);
 
     /** Generate signal of non-fiber compartments. */
     void SimulateNonFiberSignal(ItkUcharImgType::IndexType index, double intraAxonalVolume, int g=-1);
 
     /** Move fibers to simulate headmotion */
     void SimulateMotion(int g=-1);
 
     // input
     mitk::FiberfoxParameters<double>            m_Parameters;
     FiberBundleType                             m_FiberBundle;
 
     // output
     mitk::LevelWindow                           m_LevelWindow;
     std::vector< ItkDoubleImgType::Pointer >    m_VolumeFractions;
     std::string                                 m_StatusText;
 
     // MISC
     itk::TimeProbe                              m_TimeProbe;
     bool                                        m_UseConstantRandSeed;
     bool                                        m_MaskImageSet;
     ofstream                                    m_Logfile;
 
     // signal generation
     FiberBundleType                             m_FiberBundleWorkingCopy;   ///< we work on an upsampled version of the input bundle
     FiberBundleType                             m_FiberBundleTransformed;   ///< transformed bundle simulating headmotion
     itk::Vector<double,3>                       m_UpsampledSpacing;
     itk::Point<double,3>                        m_UpsampledOrigin;
     ImageRegion<3>                              m_UpsampledImageRegion;
     double                                      m_VoxelVolume;
     std::vector< DoubleDwiType::Pointer >       m_CompartmentImages;
     ItkUcharImgType::Pointer                    m_MaskImage;                ///< copy of mask image (changes for each motion step)
     ItkUcharImgType::Pointer                    m_UpsampledMaskImage;       ///< helper image for motion simulation
     DoubleVectorType                            m_Rotation;
     DoubleVectorType                            m_Translation;
     itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer m_RandGen;
 };
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkTractsToDWIImageFilter.cpp"
 #endif
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToFiberEndingsImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToFiberEndingsImageFilter.h
index 74cf06930d..4687fb80fa 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToFiberEndingsImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToFiberEndingsImageFilter.h
@@ -1,86 +1,86 @@
 /*===================================================================
 
 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 __itkTractsToFiberEndingsImageFilter_h__
 #define __itkTractsToFiberEndingsImageFilter_h__
 
 #include <itkImageSource.h>
 #include <itkImage.h>
 #include <itkVectorContainer.h>
 #include <itkRGBAPixel.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 
 namespace itk{
 
 /**
 * \brief Generates image where the pixel values are set according to the number of fibers ending in the voxel.   */
 
 template< class OutputImageType >
 class TractsToFiberEndingsImageFilter : public ImageSource< OutputImageType >
 {
 
 public:
   typedef TractsToFiberEndingsImageFilter Self;
   typedef ProcessObject Superclass;
   typedef SmartPointer< Self > Pointer;
   typedef SmartPointer< const Self > ConstPointer;
 
   typedef typename OutputImageType::PixelType OutPixelType;
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
   itkTypeMacro( TractsToFiberEndingsImageFilter, ImageSource )
 
   /** Upsampling factor **/
   itkSetMacro( UpsamplingFactor, float)
   itkGetMacro( UpsamplingFactor, float)
 
   /** Invert Image **/
   itkSetMacro( InvertImage, bool)
   itkGetMacro( InvertImage, bool)
 
-  itkSetMacro( FiberBundle, mitk::FiberBundleX::Pointer)
+  itkSetMacro( FiberBundle, mitk::FiberBundle::Pointer)
   itkSetMacro( InputImage, typename OutputImageType::Pointer)
 
   /** Use input image geometry to initialize output image **/
   itkSetMacro( UseImageGeometry, bool)
   itkGetMacro( UseImageGeometry, bool)
 
   itkSetMacro( BinaryOutput, bool)
 
   void GenerateData();
 
 protected:
 
   itk::Point<float, 3> GetItkPoint(double point[3]);
 
   TractsToFiberEndingsImageFilter();
   virtual ~TractsToFiberEndingsImageFilter();
 
-  mitk::FiberBundleX::Pointer       m_FiberBundle;          ///< input fiber bundle
+  mitk::FiberBundle::Pointer       m_FiberBundle;          ///< input fiber bundle
   float                             m_UpsamplingFactor;     ///< use higher resolution for ouput image
   bool                              m_InvertImage;          ///< voxelvalue = 1-voxelvalue
   bool                              m_UseImageGeometry;     ///< output image is given other geometry than fiberbundle (input image geometry)
   bool                              m_BinaryOutput;
   typename OutputImageType::Pointer m_InputImage;
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkTractsToFiberEndingsImageFilter.cpp"
 #endif
 
 #endif // __itkTractsToFiberEndingsImageFilter_h__
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToRgbaImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToRgbaImageFilter.h
index 9571a150e1..29a3aa3393 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToRgbaImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToRgbaImageFilter.h
@@ -1,80 +1,80 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #ifndef __itkTractsToRgbaImageFilter_h__
 #define __itkTractsToRgbaImageFilter_h__
 
 #include <itkImageSource.h>
 #include <itkImage.h>
 #include <itkVectorContainer.h>
 #include <itkRGBAPixel.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 
 namespace itk{
 
 /**
 * \brief Generates RGBA image from the input fibers where color values are set according to the local fiber directions.   */
 
 template< class OutputImageType >
 class TractsToRgbaImageFilter : public ImageSource< OutputImageType >
 {
 
 public:
   typedef TractsToRgbaImageFilter Self;
   typedef ProcessObject Superclass;
   typedef SmartPointer< Self > Pointer;
   typedef SmartPointer< const Self > ConstPointer;
 
   typedef typename OutputImageType::PixelType OutPixelType;
   typedef itk::Image<unsigned char, 3> InputImageType;
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
   itkTypeMacro( TractsToRgbaImageFilter, ImageSource )
 
   /** Upsampling factor **/
   itkSetMacro( UpsamplingFactor, float)
   itkGetMacro( UpsamplingFactor, float)
 
-  itkSetMacro( FiberBundle, mitk::FiberBundleX::Pointer)
+  itkSetMacro( FiberBundle, mitk::FiberBundle::Pointer)
   itkSetMacro( InputImage, typename InputImageType::Pointer)
 
   /** Use input image geometry to initialize output image **/
   itkSetMacro( UseImageGeometry, bool)
   itkGetMacro( UseImageGeometry, bool)
 
 
   void GenerateData();
 
 protected:
 
   itk::Point<float, 3> GetItkPoint(double point[3]);
 
   TractsToRgbaImageFilter();
   virtual ~TractsToRgbaImageFilter();
 
-  mitk::FiberBundleX::Pointer       m_FiberBundle;      ///< input fiber bundle
+  mitk::FiberBundle::Pointer       m_FiberBundle;      ///< input fiber bundle
   float                             m_UpsamplingFactor; ///< use higher resolution for ouput image
   bool                              m_UseImageGeometry; ///< output image is given other geometry than fiberbundle (input image geometry)
   typename InputImageType::Pointer  m_InputImage;
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkTractsToRgbaImageFilter.cpp"
 #endif
 
 #endif // __itkTractsToRgbaImageFilter_h__
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp
index ad60351fb8..4d434011cb 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp
@@ -1,565 +1,565 @@
 #include "itkTractsToVectorImageFilter.h"
 
 // VTK
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 #include <vtkCellData.h>
 
 // ITK
 #include <itkTimeProbe.h>
 #include <itkImageRegionIterator.h>
 
 // misc
 #define _USE_MATH_DEFINES
 #include <math.h>
 #include <boost/progress.hpp>
 
 
 namespace itk{
 
 static bool CompareVectorLengths(const vnl_vector_fixed< double, 3 >& v1, const vnl_vector_fixed< double, 3 >& v2)
 {
     return (v1.magnitude()>v2.magnitude());
 }
 
 template< class PixelType >
 TractsToVectorImageFilter< PixelType >::TractsToVectorImageFilter():
     m_AngularThreshold(0.7),
     m_Epsilon(0.999),
     m_MaskImage(NULL),
     m_NormalizeVectors(false),
     m_UseWorkingCopy(true),
     m_MaxNumDirections(3),
     m_SizeThreshold(0.3),
     m_NumDirectionsImage(NULL),
     m_CreateDirectionImages(true)
 {
     this->SetNumberOfRequiredOutputs(1);
 }
 
 
 template< class PixelType >
 TractsToVectorImageFilter< PixelType >::~TractsToVectorImageFilter()
 {
 }
 
 
 template< class PixelType >
 vnl_vector_fixed<double, 3> TractsToVectorImageFilter< PixelType >::GetVnlVector(double point[])
 {
     vnl_vector_fixed<double, 3> vnlVector;
     vnlVector[0] = point[0];
     vnlVector[1] = point[1];
     vnlVector[2] = point[2];
     return vnlVector;
 }
 
 
 template< class PixelType >
 itk::Point<double, 3> TractsToVectorImageFilter< PixelType >::GetItkPoint(double point[])
 {
     itk::Point<double, 3> itkPoint;
     itkPoint[0] = point[0];
     itkPoint[1] = point[1];
     itkPoint[2] = point[2];
     return itkPoint;
 }
 
 template< class PixelType >
 void TractsToVectorImageFilter< PixelType >::GenerateData()
 {
     mitk::BaseGeometry::Pointer geometry = m_FiberBundle->GetGeometry();
 
     // calculate new image parameters
     itk::Vector<double> spacing;
     itk::Point<double> origin;
     itk::Matrix<double, 3, 3> direction;
     ImageRegion<3> imageRegion;
     if (!m_MaskImage.IsNull())
     {
         spacing = m_MaskImage->GetSpacing();
         imageRegion = m_MaskImage->GetLargestPossibleRegion();
         origin = m_MaskImage->GetOrigin();
         direction = m_MaskImage->GetDirection();
     }
     else
     {
         spacing = geometry->GetSpacing();
         origin = geometry->GetOrigin();
         mitk::BaseGeometry::BoundsArrayType bounds = geometry->GetBounds();
         origin[0] += bounds.GetElement(0);
         origin[1] += bounds.GetElement(2);
         origin[2] += bounds.GetElement(4);
 
         for (int i=0; i<3; i++)
             for (int j=0; j<3; j++)
                 direction[j][i] = geometry->GetMatrixColumn(i)[j];
         imageRegion.SetSize(0, geometry->GetExtent(0));
         imageRegion.SetSize(1, geometry->GetExtent(1));
         imageRegion.SetSize(2, geometry->GetExtent(2));
 
 
         m_MaskImage = ItkUcharImgType::New();
         m_MaskImage->SetSpacing( spacing );
         m_MaskImage->SetOrigin( origin );
         m_MaskImage->SetDirection( direction );
         m_MaskImage->SetRegions( imageRegion );
         m_MaskImage->Allocate();
         m_MaskImage->FillBuffer(1);
     }
     OutputImageType::RegionType::SizeType outImageSize = imageRegion.GetSize();
     m_OutImageSpacing = m_MaskImage->GetSpacing();
     m_ClusteredDirectionsContainer = ContainerType::New();
 
     // initialize num directions image
     m_NumDirectionsImage = ItkUcharImgType::New();
     m_NumDirectionsImage->SetSpacing( spacing );
     m_NumDirectionsImage->SetOrigin( origin );
     m_NumDirectionsImage->SetDirection( direction );
     m_NumDirectionsImage->SetRegions( imageRegion );
     m_NumDirectionsImage->Allocate();
     m_NumDirectionsImage->FillBuffer(0);
 
     // initialize direction images
     m_DirectionImageContainer = DirectionImageContainerType::New();
 
     // resample fiber bundle
     double minSpacing = 1;
     if(m_OutImageSpacing[0]<m_OutImageSpacing[1] && m_OutImageSpacing[0]<m_OutImageSpacing[2])
         minSpacing = m_OutImageSpacing[0];
     else if (m_OutImageSpacing[1] < m_OutImageSpacing[2])
         minSpacing = m_OutImageSpacing[1];
     else
         minSpacing = m_OutImageSpacing[2];
 
     if (m_UseWorkingCopy)
         m_FiberBundle = m_FiberBundle->GetDeepCopy();
 
     // resample fiber bundle for sufficient voxel coverage
     m_FiberBundle->ResampleSpline(minSpacing/10);
 
     // iterate over all fibers
     vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
     int numFibers = m_FiberBundle->GetNumFibers();
     m_DirectionsContainer = ContainerType::New();
 
     MITK_INFO << "Generating directions from tractogram";
     boost::progress_display disp(numFibers);
     for( int i=0; i<numFibers; i++ )
     {
         ++disp;
         vtkCell* cell = fiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
         if (numPoints<2)
             continue;
 
         vnl_vector_fixed<double, 3> dir;
         itk::Point<double, 3> worldPos;
         vnl_vector<double> v;
 
         for( int j=0; j<numPoints-1; j++)
         {
             // get current position along fiber in world coordinates
             double* temp = points->GetPoint(j);
             worldPos = GetItkPoint(temp);
             itk::Index<3> index;
             m_MaskImage->TransformPhysicalPointToIndex(worldPos, index);
             if (!m_MaskImage->GetLargestPossibleRegion().IsInside(index) || m_MaskImage->GetPixel(index)==0)
                 continue;
 
             // get fiber tangent direction at this position
             v = GetVnlVector(temp);
             dir = GetVnlVector(points->GetPoint(j+1))-v;
             if (dir.is_zero())
                 continue;
             dir.normalize();
 
             // add direction to container
             unsigned int idx = index[0] + outImageSize[0]*(index[1] + outImageSize[1]*index[2]);
             DirectionContainerType::Pointer dirCont;
             if (m_DirectionsContainer->IndexExists(idx))
             {
                 dirCont = m_DirectionsContainer->GetElement(idx);
                 if (dirCont.IsNull())
                 {
                     dirCont = DirectionContainerType::New();
                     dirCont->push_back(dir);
                     m_DirectionsContainer->InsertElement(idx, dirCont);
                 }
                 else
                     dirCont->push_back(dir);
             }
             else
             {
                 dirCont = DirectionContainerType::New();
                 dirCont->push_back(dir);
                 m_DirectionsContainer->InsertElement(idx, dirCont);
             }
         }
     }
 
     vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints>    m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
 
     itk::ImageRegionIterator<ItkUcharImgType> dirIt(m_NumDirectionsImage, m_NumDirectionsImage->GetLargestPossibleRegion());
 
     MITK_INFO << "Clustering directions";
     boost::progress_display disp2(outImageSize[0]*outImageSize[1]*outImageSize[2]);
     while(!dirIt.IsAtEnd())
     {
         ++disp2;
         OutputImageType::IndexType index = dirIt.GetIndex();
         int idx = index[0]+(index[1]+index[2]*outImageSize[1])*outImageSize[0];
 
         if (!m_DirectionsContainer->IndexExists(idx))
         {
             ++dirIt;
             continue;
         }
         DirectionContainerType::Pointer dirCont = m_DirectionsContainer->GetElement(idx);
         if (dirCont.IsNull() || dirCont->empty())
         {
             ++dirIt;
             continue;
         }
 
         std::vector< double > lengths; lengths.resize(dirCont->size(), 1);  // all peaks have size 1
         DirectionContainerType::Pointer directions;
         if (m_MaxNumDirections>0)
         {
             directions = FastClustering(dirCont, lengths);
             std::sort( directions->begin(), directions->end(), CompareVectorLengths );
         }
         else
             directions = dirCont;
 
         unsigned int numDir = directions->size();
         if (m_MaxNumDirections>0 && numDir>m_MaxNumDirections)
             numDir = m_MaxNumDirections;
 
         int count = 0;
         for (unsigned int i=0; i<numDir; i++)
         {
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             itk::ContinuousIndex<double, 3> center;
             center[0] = index[0];
             center[1] = index[1];
             center[2] = index[2];
             itk::Point<double> worldCenter;
             m_MaskImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
             DirectionType dir = directions->at(i);
 
             if (dir.magnitude()<m_SizeThreshold)
                 continue;
             if (m_NormalizeVectors)
                 dir.normalize();
             count++;
 
             if (m_CreateDirectionImages && i<10)
             {
                 if (i==m_DirectionImageContainer->size())
                 {
                     ItkDirectionImageType::Pointer directionImage = ItkDirectionImageType::New();
                     directionImage->SetSpacing( spacing );
                     directionImage->SetOrigin( origin );
                     directionImage->SetDirection( direction );
                     directionImage->SetRegions( imageRegion );
                     directionImage->Allocate();
                     Vector< float, 3 > nullVec; nullVec.Fill(0.0);
                     directionImage->FillBuffer(nullVec);
                     m_DirectionImageContainer->InsertElement(i, directionImage);
                 }
 
                 // set direction image pixel
                 ItkDirectionImageType::Pointer directionImage = m_DirectionImageContainer->GetElement(i);
                 Vector< float, 3 > pixel;
                 pixel.SetElement(0, dir[0]);
                 pixel.SetElement(1, dir[1]);
                 pixel.SetElement(2, dir[2]);
                 directionImage->SetPixel(index, pixel);
             }
 
             // add direction to vector field (with spacing compensation)
             itk::Point<double> worldStart;
             worldStart[0] = worldCenter[0]-dir[0]/2*minSpacing;
             worldStart[1] = worldCenter[1]-dir[1]/2*minSpacing;
             worldStart[2] = worldCenter[2]-dir[2]/2*minSpacing;
             vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
             container->GetPointIds()->InsertNextId(id);
             itk::Point<double> worldEnd;
             worldEnd[0] = worldCenter[0]+dir[0]/2*minSpacing;
             worldEnd[1] = worldCenter[1]+dir[1]/2*minSpacing;
             worldEnd[2] = worldCenter[2]+dir[2]/2*minSpacing;
             id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
             container->GetPointIds()->InsertNextId(id);
             m_VtkCellArray->InsertNextCell(container);
         }
         dirIt.Set(count);
         ++dirIt;
     }
 
     vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
     directionsPolyData->SetPoints(m_VtkPoints);
     directionsPolyData->SetLines(m_VtkCellArray);
-    m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
+    m_OutputFiberBundle = mitk::FiberBundle::New(directionsPolyData);
 }
 
 
 template< class PixelType >
 TractsToVectorImageFilter< PixelType >::DirectionContainerType::Pointer TractsToVectorImageFilter< PixelType >::FastClustering(DirectionContainerType::Pointer inDirs, std::vector< double > lengths)
 {
     DirectionContainerType::Pointer outDirs = DirectionContainerType::New();
     if (inDirs->size()<2)
         return inDirs;
 
     DirectionType oldMean, currentMean;
     std::vector< int > touched;
 
     // initialize
     touched.resize(inDirs->size(), 0);
     bool free = true;
     currentMean = inDirs->at(0);  // initialize first seed
     currentMean.normalize();
     double length = lengths.at(0);
     touched[0] = 1;
     std::vector< double > newLengths;
     bool meanChanged = false;
 
     double max = 0;
     while (free)
     {
         oldMean.fill(0.0);
 
         // start mean-shift clustering
         double angle = 0;
 
         while (fabs(dot_product(currentMean, oldMean))<0.99)
         {
             oldMean = currentMean;
             currentMean.fill(0.0);
             for (unsigned int i=0; i<inDirs->size(); i++)
             {
                 angle = dot_product(oldMean, inDirs->at(i));
                 if (angle>=m_AngularThreshold)
                 {
                     currentMean += inDirs->at(i);
                     if (meanChanged)
                         length += lengths.at(i);
                     touched[i] = 1;
                     meanChanged = true;
                 }
                 else if (-angle>=m_AngularThreshold)
                 {
                     currentMean -= inDirs->at(i);
                     if (meanChanged)
                         length += lengths.at(i);
                     touched[i] = 1;
                     meanChanged = true;
                 }
             }
             if(!meanChanged)
                 currentMean = oldMean;
             else
                 currentMean.normalize();
         }
 
         // found stable mean
         outDirs->push_back(currentMean);
         newLengths.push_back(length);
         if (length>max)
             max = length;
 
         // find next unused seed
         free = false;
         for (unsigned int i=0; i<touched.size(); i++)
             if (touched[i]==0)
             {
                 currentMean = inDirs->at(i);
                 free = true;
                 meanChanged = false;
                 length = lengths.at(i);
                 touched[i] = 1;
                 break;
             }
     }
 
     if (inDirs->size()==outDirs->size())
     {
         if (max>0)
             for (unsigned int i=0; i<outDirs->size(); i++)
                 outDirs->SetElement(i, outDirs->at(i)*newLengths.at(i)/max);
         return outDirs;
     }
     else
         return FastClustering(outDirs, newLengths);
 }
 
 
 //template< class PixelType >
 //std::vector< DirectionType > TractsToVectorImageFilter< PixelType >::Clustering(std::vector< DirectionType >& inDirs)
 //{
 //    std::vector< DirectionType > outDirs;
 //    if (inDirs.empty())
 //        return outDirs;
 //    DirectionType oldMean, currentMean, workingMean;
 
 //    std::vector< DirectionType > normalizedDirs;
 //    std::vector< int > touched;
 //    for (std::size_t i=0; i<inDirs.size(); i++)
 //    {
 //        normalizedDirs.push_back(inDirs[i]);
 //        normalizedDirs.back().normalize();
 //    }
 
 //    // initialize
 //    double max = 0.0;
 //    touched.resize(inDirs.size(), 0);
 //    for (std::size_t j=0; j<inDirs.size(); j++)
 //    {
 //        currentMean = inDirs[j];
 //        oldMean.fill(0.0);
 
 //        // start mean-shift clustering
 //        double angle = 0.0;
 //        int counter = 0;
 //        while ((currentMean-oldMean).magnitude()>0.0001)
 //        {
 //            counter = 0;
 //            oldMean = currentMean;
 //            workingMean = oldMean;
 //            workingMean.normalize();
 //            currentMean.fill(0.0);
 //            for (std::size_t i=0; i<normalizedDirs.size(); i++)
 //            {
 //                angle = dot_product(workingMean, normalizedDirs[i]);
 //                if (angle>=m_AngularThreshold)
 //                {
 //                    currentMean += inDirs[i];
 //                    counter++;
 //                }
 //                else if (-angle>=m_AngularThreshold)
 //                {
 //                    currentMean -= inDirs[i];
 //                    counter++;
 //                }
 //            }
 //        }
 
 //        // found stable mean
 //        if (counter>0)
 //        {
 //            bool add = true;
 //            DirectionType normMean = currentMean;
 //            normMean.normalize();
 //            for (std::size_t i=0; i<outDirs.size(); i++)
 //            {
 //                DirectionType dir = outDirs[i];
 //                dir.normalize();
 //                if ((normMean-dir).magnitude()<=0.0001)
 //                {
 //                    add = false;
 //                    break;
 //                }
 //            }
 
 //            currentMean /= counter;
 //            if (add)
 //            {
 //                double mag = currentMean.magnitude();
 //                if (mag>0)
 //                {
 //                    if (mag>max)
 //                        max = mag;
 
 //                    outDirs.push_back(currentMean);
 //                }
 //            }
 //        }
 //    }
 
 //    if (m_NormalizeVectors)
 //        for (std::size_t i=0; i<outDirs.size(); i++)
 //            outDirs[i].normalize();
 //    else if (max>0)
 //        for (std::size_t i=0; i<outDirs.size(); i++)
 //            outDirs[i] /= max;
 
 //    if (inDirs.size()==outDirs.size())
 //        return outDirs;
 //    else
 //        return FastClustering(outDirs);
 //}
 
 
 //template< class PixelType >
 //TractsToVectorImageFilter< PixelType >::DirectionContainerType::Pointer TractsToVectorImageFilter< PixelType >::MeanShiftClustering(DirectionContainerType::Pointer dirCont)
 //{
 //    DirectionContainerType::Pointer container = DirectionContainerType::New();
 
 //    double max = 0;
 //    for (DirectionContainerType::ConstIterator it = dirCont->Begin(); it!=dirCont->End(); ++it)
 //    {
 //        vnl_vector_fixed<double, 3> mean = ClusterStep(dirCont, it.Value());
 
 //        if (mean.is_zero())
 //            continue;
 //        bool addMean = true;
 
 //        for (DirectionContainerType::ConstIterator it2 = container->Begin(); it2!=container->End(); ++it2)
 //        {
 //            vnl_vector_fixed<double, 3> dir = it2.Value();
 //            double angle = fabs(dot_product(mean, dir)/(mean.magnitude()*dir.magnitude()));
 //            if (angle>=m_Epsilon)
 //            {
 //                addMean = false;
 //                break;
 //            }
 //        }
 
 //        if (addMean)
 //        {
 //            if (m_NormalizeVectors)
 //                mean.normalize();
 //            else if (mean.magnitude()>max)
 //                max = mean.magnitude();
 //            container->InsertElement(container->Size(), mean);
 //        }
 //    }
 
 //    // max normalize voxel directions
 //    if (max>0 && !m_NormalizeVectors)
 //        for (std::size_t i=0; i<container->Size(); i++)
 //            container->ElementAt(i) /= max;
 
 //    if (container->Size()<dirCont->Size())
 //        return MeanShiftClustering(container);
 //    else
 //        return container;
 //}
 
 
 //template< class PixelType >
 //vnl_vector_fixed<double, 3> TractsToVectorImageFilter< PixelType >::ClusterStep(DirectionContainerType::Pointer dirCont, vnl_vector_fixed<double, 3> currentMean)
 //{
 //    vnl_vector_fixed<double, 3> newMean; newMean.fill(0);
 
 //    for (DirectionContainerType::ConstIterator it = dirCont->Begin(); it!=dirCont->End(); ++it)
 //    {
 //        vnl_vector_fixed<double, 3> dir = it.Value();
 //        double angle = dot_product(currentMean, dir)/(currentMean.magnitude()*dir.magnitude());
 //        if (angle>=m_AngularThreshold)
 //            newMean += dir;
 //        else if (-angle>=m_AngularThreshold)
 //            newMean -= dir;
 //    }
 
 //    if (fabs(dot_product(currentMean, newMean)/(currentMean.magnitude()*newMean.magnitude()))>=m_Epsilon || newMean.is_zero())
 //        return newMean;
 //    else
 //        return ClusterStep(dirCont, newMean);
 //}
 }
 
 
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.h
index 3a3eab15be..67a324ac46 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.h
@@ -1,110 +1,110 @@
 #ifndef __itkTractsToVectorImageFilter_h__
 #define __itkTractsToVectorImageFilter_h__
 
 // MITK
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 
 // ITK
 #include <itkImageSource.h>
 #include <itkVectorImage.h>
 
 // VTK
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 
 using namespace mitk;
 
 namespace itk{
 
 /**
 * \brief Extracts the voxel-wise main directions of the input fiber bundle.   */
 
 template< class PixelType >
 class TractsToVectorImageFilter : public ImageSource< VectorImage< float, 3 > >
 {
 
 public:
     typedef TractsToVectorImageFilter Self;
     typedef ProcessObject Superclass;
     typedef SmartPointer< Self > Pointer;
     typedef SmartPointer< const Self > ConstPointer;
 
     typedef itk::Vector<float,3>                    OutputVectorType;
     typedef itk::Image<OutputVectorType, 3>         OutputImageType;
     typedef std::vector< OutputImageType::Pointer > OutputImageContainerType;
 
     typedef vnl_vector_fixed< double, 3 >                                       DirectionType;
     typedef VectorContainer< unsigned int, DirectionType >                      DirectionContainerType;
     typedef VectorContainer< unsigned int, DirectionContainerType::Pointer >    ContainerType;
     typedef Image< Vector< float, 3 >, 3>                                       ItkDirectionImageType;
     typedef VectorContainer< unsigned int, ItkDirectionImageType::Pointer >     DirectionImageContainerType;
     typedef itk::Image<unsigned char, 3>                                        ItkUcharImgType;
     typedef itk::Image<double, 3>                                               ItkDoubleImgType;
 
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     itkTypeMacro( TractsToVectorImageFilter, ImageSource )
 
     itkSetMacro( SizeThreshold, float)
     itkGetMacro( SizeThreshold, float)
     itkSetMacro( AngularThreshold, float)                               ///< cluster directions that are closer together than the specified threshold
     itkGetMacro( AngularThreshold, float)                               ///< cluster directions that are closer together than the specified threshold
     itkSetMacro( NormalizeVectors, bool)                                ///< Normalize vectors to length 1
     itkGetMacro( NormalizeVectors, bool)                                ///< Normalize vectors to length 1
     itkSetMacro( UseWorkingCopy, bool)                                  ///< Do not modify input fiber bundle. Use a copy.
     itkGetMacro( UseWorkingCopy, bool)                                  ///< Do not modify input fiber bundle. Use a copy.
     itkSetMacro( MaxNumDirections, unsigned long)                       ///< If more directions are extracted, only the largest are kept.
     itkGetMacro( MaxNumDirections, unsigned long)                       ///< If more directions are extracted, only the largest are kept.
     itkSetMacro( MaskImage, ItkUcharImgType::Pointer)                   ///< only process voxels inside mask
-    itkSetMacro( FiberBundle, FiberBundleX::Pointer)                    ///< input fiber bundle
+    itkSetMacro( FiberBundle, FiberBundle::Pointer)                    ///< input fiber bundle
     itkGetMacro( ClusteredDirectionsContainer, ContainerType::Pointer)  ///< output directions
     itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer)          ///< number of directions per voxel
-    itkGetMacro( OutputFiberBundle, FiberBundleX::Pointer)              ///< vector field for visualization purposes
+    itkGetMacro( OutputFiberBundle, FiberBundle::Pointer)              ///< vector field for visualization purposes
     itkGetMacro( DirectionImageContainer, DirectionImageContainerType::Pointer) ///< output directions
     itkSetMacro( CreateDirectionImages, bool)
 
     void GenerateData();
 
 protected:
 
     DirectionContainerType::Pointer FastClustering(DirectionContainerType::Pointer inDirs, std::vector< double > lengths);  ///< cluster fiber directions
 //    std::vector< DirectionType > Clustering(std::vector< DirectionType >& inDirs);
 //    DirectionContainerType::Pointer MeanShiftClustering(DirectionContainerType::Pointer dirCont);
 //    vnl_vector_fixed<double, 3> ClusterStep(DirectionContainerType::Pointer dirCont, vnl_vector_fixed<double, 3> currentMean);
 
     vnl_vector_fixed<double, 3> GetVnlVector(double point[3]);
     itk::Point<double, 3> GetItkPoint(double point[3]);
 
 
     TractsToVectorImageFilter();
     virtual ~TractsToVectorImageFilter();
 
-    FiberBundleX::Pointer               m_FiberBundle;                      ///< input fiber bundle
+    FiberBundle::Pointer               m_FiberBundle;                      ///< input fiber bundle
     float                               m_AngularThreshold;                 ///< cluster directions that are closer together than the specified threshold
     float                               m_Epsilon;                          ///< epsilon for vector equality check
     ItkUcharImgType::Pointer            m_MaskImage;                        ///< only voxels inside the binary mask are processed
     bool                                m_NormalizeVectors;                 ///< normalize vectors to length 1
     itk::Vector<float>                  m_OutImageSpacing;                  ///< spacing of output image
     ContainerType::Pointer              m_DirectionsContainer;              ///< container for fiber directions
     bool                                m_UseWorkingCopy;                   ///< do not modify input fiber bundle but work on copy
     unsigned long                       m_MaxNumDirections;                 ///< if more directions per voxel are extracted, only the largest are kept
     float                               m_SizeThreshold;
     bool                                m_CreateDirectionImages;
 
     // output datastructures
     ContainerType::Pointer                  m_ClusteredDirectionsContainer; ///< contains direction vectors for each voxel
     ItkUcharImgType::Pointer                m_NumDirectionsImage;           ///< shows number of fibers per voxel
     DirectionImageContainerType::Pointer    m_DirectionImageContainer;      ///< contains images that contain the output directions
-    FiberBundleX::Pointer                   m_OutputFiberBundle;            ///< vector field for visualization purposes
+    FiberBundle::Pointer                   m_OutputFiberBundle;            ///< vector field for visualization purposes
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkTractsToVectorImageFilter.cpp"
 #endif
 
 #endif // __itkTractsToVectorImageFilter_h__
diff --git a/Modules/DiffusionImaging/FiberTracking/CMakeLists.txt b/Modules/DiffusionImaging/FiberTracking/CMakeLists.txt
index 56f846586b..1445f55941 100644
--- a/Modules/DiffusionImaging/FiberTracking/CMakeLists.txt
+++ b/Modules/DiffusionImaging/FiberTracking/CMakeLists.txt
@@ -1,65 +1,65 @@
 
 set(_module_deps MitkDiffusionCore MitkGraphAlgorithms)
 
 mitk_check_module_dependencies(
   MODULES ${_module_deps}
   MISSING_DEPENDENCIES_VAR _missing_deps
 )
 
 # Enable OpenMP support
 find_package(OpenMP)
 if(NOT OPENMP_FOUND)
    message("OpenMP is not available.")
 endif()
 if(OPENMP_FOUND)
   message(STATUS "Found OpenMP.")
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
 endif()
 
 if(NOT _missing_deps)
 
   set(lut_url http://mitk.org/download/data/FibertrackingLUT.tar.gz)
   set(lut_tarball ${CMAKE_CURRENT_BINARY_DIR}/FibertrackingLUT.tar.gz)
   message("Downloading FiberTracking LUT ${lut_url}...")
   file(DOWNLOAD ${lut_url} ${lut_tarball}
        EXPECTED_MD5 38ecb6d4a826c9ebb0f4965eb9aeee44
        TIMEOUT 60
        STATUS status
        SHOW_PROGRESS
       )
 
   list(GET status 0 status_code)
   list(GET status 1 status_msg)
 
   if(NOT status_code EQUAL 0)
     message(SEND_ERROR "${status_msg} (error code ${status_code})")
   else()
     message("done.")
   endif()
 
   file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Resources)
   message("Unpacking FiberTracking LUT tarball...")
   execute_process(COMMAND ${CMAKE_COMMAND} -E  tar xzf ../FibertrackingLUT.tar.gz
                   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Resources
                   RESULT_VARIABLE result
                   ERROR_VARIABLE err_msg)
   if(result)
     message(SEND_ERROR "Unpacking FibertrackingLUT.tar.gz failed: ${err_msg}")
   else()
     message("done.")
   endif()
 
 endif()
 
 MITK_CREATE_MODULE(
   SUBPROJECTS MITK-DTI
-  INCLUDE_DIRS Algorithms Algorithms/GibbsTracking Algorithms/StochasticTracking IODataStructures IODataStructures/FiberBundleX IODataStructures/PlanarFigureComposite Interactions SignalModels Rendering ${CMAKE_CURRENT_BINARY_DIR}
+  INCLUDE_DIRS Algorithms Algorithms/GibbsTracking Algorithms/StochasticTracking IODataStructures IODataStructures/FiberBundle IODataStructures/PlanarFigureComposite Interactions SignalModels Rendering ${CMAKE_CURRENT_BINARY_DIR}
   DEPENDS ${_module_deps}
   PACKAGE_DEPENDS ITK|ITKFFT ITK|ITKDiffusionTensorImage
   #WARNINGS_AS_ERRORS
 )
 
 if(MODULE_IS_ENABLED)
   add_subdirectory(Testing)
 endif()
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.cpp
similarity index 93%
rename from Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
rename to Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.cpp
index 7d5e97f8ac..14db052d96 100755
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.cpp
@@ -1,1849 +1,1849 @@
 /*===================================================================
 
 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 _USE_MATH_DEFINES
-#include "mitkFiberBundleX.h"
+#include "mitkFiberBundle.h"
 
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarFigureComposite.h>
 #include "mitkImagePixelReadAccessor.h"
 #include <mitkPixelTypeMultiplex.h>
 
 #include <vtkPointData.h>
 #include <vtkDataArray.h>
 #include <vtkUnsignedCharArray.h>
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 #include <vtkCellData.h>
 #include <vtkIdFilter.h>
 #include <vtkClipPolyData.h>
 #include <vtkPlane.h>
 #include <vtkDoubleArray.h>
 #include <vtkKochanekSpline.h>
 #include <vtkParametricFunctionSource.h>
 #include <vtkParametricSpline.h>
 #include <vtkPolygon.h>
 #include <vtkCleanPolyData.h>
 #include <cmath>
 #include <boost/progress.hpp>
 #include <vtkTransformPolyDataFilter.h>
 #include <mitkTransferFunction.h>
 #include <vtkLookupTable.h>
 #include <mitkLookupTable.h>
 
-const char* mitk::FiberBundleX::FIBER_ID_ARRAY = "Fiber_IDs";
+const char* mitk::FiberBundle::FIBER_ID_ARRAY = "Fiber_IDs";
 
 using namespace std;
 
-mitk::FiberBundleX::FiberBundleX( vtkPolyData* fiberPolyData )
+mitk::FiberBundle::FiberBundle( vtkPolyData* fiberPolyData )
     : m_NumFibers(0)
     , m_FiberSampling(0)
 {
     m_FiberWeights = vtkSmartPointer<vtkFloatArray>::New();
     m_FiberWeights->SetName("FIBER_WEIGHTS");
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     if (fiberPolyData != NULL)
     {
         m_FiberPolyData = fiberPolyData;
         this->DoColorCodingOrientationBased();
     }
 
     this->UpdateFiberGeometry();
     this->GenerateFiberIds();
 }
 
-mitk::FiberBundleX::~FiberBundleX()
+mitk::FiberBundle::~FiberBundle()
 {
 
 }
 
-mitk::FiberBundleX::Pointer mitk::FiberBundleX::GetDeepCopy()
+mitk::FiberBundle::Pointer mitk::FiberBundle::GetDeepCopy()
 {
-    mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(m_FiberPolyData);
+    mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(m_FiberPolyData);
     newFib->SetFiberColors(this->m_FiberColors);
     newFib->SetFiberWeights(this->m_FiberWeights);
     return newFib;
 }
 
-vtkSmartPointer<vtkPolyData> mitk::FiberBundleX::GeneratePolyDataByIds(std::vector<long> fiberIds)
+vtkSmartPointer<vtkPolyData> mitk::FiberBundle::GeneratePolyDataByIds(std::vector<long> fiberIds)
 {
     vtkSmartPointer<vtkPolyData> newFiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> newLineSet = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> newPointSet = vtkSmartPointer<vtkPoints>::New();
 
     std::vector<long>::iterator finIt = fiberIds.begin();
     while ( finIt != fiberIds.end() )
     {
         if (*finIt < 0 || *finIt>GetNumFibers()){
             MITK_INFO << "FiberID can not be negative or >NumFibers!!! check id Extraction!" << *finIt;
             break;
         }
 
         vtkSmartPointer<vtkCell> fiber = m_FiberIdDataSet->GetCell(*finIt);//->DeepCopy(fiber);
         vtkSmartPointer<vtkPoints> fibPoints = fiber->GetPoints();
         vtkSmartPointer<vtkPolyLine> newFiber = vtkSmartPointer<vtkPolyLine>::New();
         newFiber->GetPointIds()->SetNumberOfIds( fibPoints->GetNumberOfPoints() );
 
         for(int i=0; i<fibPoints->GetNumberOfPoints(); i++)
         {
             newFiber->GetPointIds()->SetId(i, newPointSet->GetNumberOfPoints());
             newPointSet->InsertNextPoint(fibPoints->GetPoint(i)[0], fibPoints->GetPoint(i)[1], fibPoints->GetPoint(i)[2]);
         }
 
         newLineSet->InsertNextCell(newFiber);
         ++finIt;
     }
 
     newFiberPolyData->SetPoints(newPointSet);
     newFiberPolyData->SetLines(newLineSet);
     return newFiberPolyData;
 }
 
 // merge two fiber bundles
-mitk::FiberBundleX::Pointer mitk::FiberBundleX::AddBundle(mitk::FiberBundleX* fib)
+mitk::FiberBundle::Pointer mitk::FiberBundle::AddBundle(mitk::FiberBundle* fib)
 {
     if (fib==NULL)
     {
         MITK_WARN << "trying to call AddBundle with NULL argument";
         return NULL;
     }
     MITK_INFO << "Adding fibers";
 
     vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
     // add current fiber bundle
     vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
     weights->SetNumberOfValues(this->GetNumFibers()+fib->GetNumFibers());
 
     unsigned int counter = 0;
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double p[3];
             points->GetPoint(j, p);
 
             vtkIdType id = vNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
         weights->InsertValue(counter, this->GetFiberWeight(i));
         vNewLines->InsertNextCell(container);
         counter++;
     }
 
     // add new fiber bundle
     for (int i=0; i<fib->GetFiberPolyData()->GetNumberOfCells(); i++)
     {
         vtkCell* cell = fib->GetFiberPolyData()->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double p[3];
             points->GetPoint(j, p);
 
             vtkIdType id = vNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
         weights->InsertValue(counter, fib->GetFiberWeight(i));
         vNewLines->InsertNextCell(container);
         counter++;
     }
 
     // initialize polydata
     vNewPolyData->SetPoints(vNewPoints);
     vNewPolyData->SetLines(vNewLines);
 
     // initialize fiber bundle
-    mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(vNewPolyData);
+    mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(vNewPolyData);
     newFib->SetFiberWeights(weights);
     return newFib;
 }
 
 // subtract two fiber bundles
-mitk::FiberBundleX::Pointer mitk::FiberBundleX::SubtractBundle(mitk::FiberBundleX* fib)
+mitk::FiberBundle::Pointer mitk::FiberBundle::SubtractBundle(mitk::FiberBundle* fib)
 {
     MITK_INFO << "Subtracting fibers";
 
     vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
     // iterate over current fibers
     boost::progress_display disp(m_NumFibers);
     for( int i=0; i<m_NumFibers; i++ )
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         if (points==NULL || numPoints<=0)
             continue;
 
         int numFibers2 = fib->GetNumFibers();
         bool contained = false;
         for( int i2=0; i2<numFibers2; i2++ )
         {
             vtkCell* cell2 = fib->GetFiberPolyData()->GetCell(i2);
             int numPoints2 = cell2->GetNumberOfPoints();
             vtkPoints* points2 = cell2->GetPoints();
 
             if (points2==NULL)// || numPoints2<=0)
                 continue;
 
             // check endpoints
             if (numPoints2==numPoints)
             {
                 itk::Point<float, 3> point_start = GetItkPoint(points->GetPoint(0));
                 itk::Point<float, 3> point_end = GetItkPoint(points->GetPoint(numPoints-1));
                 itk::Point<float, 3> point2_start = GetItkPoint(points2->GetPoint(0));
                 itk::Point<float, 3> point2_end = GetItkPoint(points2->GetPoint(numPoints2-1));
 
                 if ((point_start.SquaredEuclideanDistanceTo(point2_start)<=mitk::eps && point_end.SquaredEuclideanDistanceTo(point2_end)<=mitk::eps) ||
                         (point_start.SquaredEuclideanDistanceTo(point2_end)<=mitk::eps && point_end.SquaredEuclideanDistanceTo(point2_start)<=mitk::eps))
                 {
                     // further checking ???
                     contained = true;
                     break;
                 }
             }
         }
 
         // add to result because fiber is not subtracted
         if (!contained)
         {
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for( int j=0; j<numPoints; j++)
             {
                 vtkIdType id = vNewPoints->InsertNextPoint(points->GetPoint(j));
                 container->GetPointIds()->InsertNextId(id);
             }
             vNewLines->InsertNextCell(container);
         }
     }
     if(vNewLines->GetNumberOfCells()==0)
         return NULL;
     // initialize polydata
     vNewPolyData->SetPoints(vNewPoints);
     vNewPolyData->SetLines(vNewLines);
 
     // initialize fiber bundle
-    return mitk::FiberBundleX::New(vNewPolyData);
+    return mitk::FiberBundle::New(vNewPolyData);
 }
 
-itk::Point<float, 3> mitk::FiberBundleX::GetItkPoint(double point[3])
+itk::Point<float, 3> mitk::FiberBundle::GetItkPoint(double point[3])
 {
     itk::Point<float, 3> itkPoint;
     itkPoint[0] = point[0];
     itkPoint[1] = point[1];
     itkPoint[2] = point[2];
     return itkPoint;
 }
 
 /*
  * set polydata (additional flag to recompute fiber geometry, default = true)
  */
-void mitk::FiberBundleX::SetFiberPolyData(vtkSmartPointer<vtkPolyData> fiberPD, bool updateGeometry)
+void mitk::FiberBundle::SetFiberPolyData(vtkSmartPointer<vtkPolyData> fiberPD, bool updateGeometry)
 {
     if (fiberPD == NULL)
         this->m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     else
     {
         m_FiberPolyData->DeepCopy(fiberPD);
         DoColorCodingOrientationBased();
     }
 
     m_NumFibers = m_FiberPolyData->GetNumberOfLines();
 
     if (updateGeometry)
         UpdateFiberGeometry();
     GenerateFiberIds();
 }
 
 /*
  * return vtkPolyData
  */
-vtkSmartPointer<vtkPolyData> mitk::FiberBundleX::GetFiberPolyData() const
+vtkSmartPointer<vtkPolyData> mitk::FiberBundle::GetFiberPolyData() const
 {
     return m_FiberPolyData;
 }
 
-void mitk::FiberBundleX::DoColorCodingOrientationBased()
+void mitk::FiberBundle::DoColorCodingOrientationBased()
 {
     //===== FOR WRITING A TEST ========================
     //  colorT size == tupelComponents * tupelElements
     //  compare color results
     //  to cover this code 100% also polydata needed, where colorarray already exists
     //  + one fiber with exactly 1 point
     //  + one fiber with 0 points
     //=================================================
 
     vtkPoints* extrPoints = NULL;
     extrPoints = m_FiberPolyData->GetPoints();
     int numOfPoints = 0;
     if (extrPoints!=NULL)
         numOfPoints = extrPoints->GetNumberOfPoints();
 
     //colors and alpha value for each single point, RGBA = 4 components
     unsigned char rgba[4] = {0,0,0,0};
     int componentSize = 4;
     m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
     m_FiberColors->Allocate(numOfPoints * componentSize);
     m_FiberColors->SetNumberOfComponents(componentSize);
     m_FiberColors->SetName("FIBER_COLORS");
 
     int numOfFibers = m_FiberPolyData->GetNumberOfLines();
     if (numOfFibers < 1)
         return;
 
     /* extract single fibers of fiberBundle */
     vtkCellArray* fiberList = m_FiberPolyData->GetLines();
     fiberList->InitTraversal();
     for (int fi=0; fi<numOfFibers; ++fi) {
 
         vtkIdType* idList; // contains the point id's of the line
         vtkIdType pointsPerFiber; // number of points for current line
         fiberList->GetNextCell(pointsPerFiber, idList);
 
         /* single fiber checkpoints: is number of points valid */
         if (pointsPerFiber > 1)
         {
             /* operate on points of single fiber */
             for (int i=0; i <pointsPerFiber; ++i)
             {
                 /* process all points except starting and endpoint for calculating color value take current point, previous point and next point */
                 if (i<pointsPerFiber-1 && i > 0)
                 {
                     /* The color value of the current point is influenced by the previous point and next point. */
                     vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
                     vnl_vector_fixed< double, 3 > nextPntvtk(extrPoints->GetPoint(idList[i+1])[0], extrPoints->GetPoint(idList[i+1])[1], extrPoints->GetPoint(idList[i+1])[2]);
                     vnl_vector_fixed< double, 3 > prevPntvtk(extrPoints->GetPoint(idList[i-1])[0], extrPoints->GetPoint(idList[i-1])[1], extrPoints->GetPoint(idList[i-1])[2]);
 
                     vnl_vector_fixed< double, 3 > diff1;
                     diff1 = currentPntvtk - nextPntvtk;
 
                     vnl_vector_fixed< double, 3 > diff2;
                     diff2 = currentPntvtk - prevPntvtk;
 
                     vnl_vector_fixed< double, 3 > diff;
                     diff = (diff1 - diff2) / 2.0;
                     diff.normalize();
 
                     rgba[0] = (unsigned char) (255.0 * std::fabs(diff[0]));
                     rgba[1] = (unsigned char) (255.0 * std::fabs(diff[1]));
                     rgba[2] = (unsigned char) (255.0 * std::fabs(diff[2]));
                     rgba[3] = (unsigned char) (255.0);
                 }
                 else if (i==0)
                 {
                     /* First point has no previous point, therefore only diff1 is taken */
 
                     vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
                     vnl_vector_fixed< double, 3 > nextPntvtk(extrPoints->GetPoint(idList[i+1])[0], extrPoints->GetPoint(idList[i+1])[1], extrPoints->GetPoint(idList[i+1])[2]);
 
                     vnl_vector_fixed< double, 3 > diff1;
                     diff1 = currentPntvtk - nextPntvtk;
                     diff1.normalize();
 
                     rgba[0] = (unsigned char) (255.0 * std::fabs(diff1[0]));
                     rgba[1] = (unsigned char) (255.0 * std::fabs(diff1[1]));
                     rgba[2] = (unsigned char) (255.0 * std::fabs(diff1[2]));
                     rgba[3] = (unsigned char) (255.0);
                 }
                 else if (i==pointsPerFiber-1)
                 {
                     /* Last point has no next point, therefore only diff2 is taken */
                     vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
                     vnl_vector_fixed< double, 3 > prevPntvtk(extrPoints->GetPoint(idList[i-1])[0], extrPoints->GetPoint(idList[i-1])[1], extrPoints->GetPoint(idList[i-1])[2]);
 
                     vnl_vector_fixed< double, 3 > diff2;
                     diff2 = currentPntvtk - prevPntvtk;
                     diff2.normalize();
 
                     rgba[0] = (unsigned char) (255.0 * std::fabs(diff2[0]));
                     rgba[1] = (unsigned char) (255.0 * std::fabs(diff2[1]));
                     rgba[2] = (unsigned char) (255.0 * std::fabs(diff2[2]));
                     rgba[3] = (unsigned char) (255.0);
                 }
                 m_FiberColors->InsertTupleValue(idList[i], rgba);
             }
         }
         else if (pointsPerFiber == 1)
         {
             /* a single point does not define a fiber (use vertex mechanisms instead */
             continue;
         }
         else
         {
             MITK_DEBUG << "Fiber with 0 points detected... please check your tractography algorithm!" ;
             continue;
         }
     }
     m_UpdateTime3D.Modified();
     m_UpdateTime2D.Modified();
 }
 
-void mitk::FiberBundleX::SetFiberOpacity(vtkDoubleArray* FAValArray)
+void mitk::FiberBundle::SetFiberOpacity(vtkDoubleArray* FAValArray)
 {
     for(long i=0; i<m_FiberColors->GetNumberOfTuples(); i++)
     {
         double faValue = FAValArray->GetValue(i);
         faValue = faValue * 255.0;
         m_FiberColors->SetComponent(i,3, (unsigned char) faValue );
     }
     m_UpdateTime3D.Modified();
     m_UpdateTime2D.Modified();
 }
 
-void mitk::FiberBundleX::ResetFiberOpacity()
+void mitk::FiberBundle::ResetFiberOpacity()
 {
     for(long i=0; i<m_FiberColors->GetNumberOfTuples(); i++)
         m_FiberColors->SetComponent(i,3, 255.0 );
     m_UpdateTime3D.Modified();
     m_UpdateTime2D.Modified();
 }
 
-void mitk::FiberBundleX::ColorFibersByScalarMap(mitk::Image::Pointer FAimage, bool opacity)
+void mitk::FiberBundle::ColorFibersByScalarMap(mitk::Image::Pointer FAimage, bool opacity)
 {
     mitkPixelTypeMultiplex2( ColorFibersByScalarMap, FAimage->GetPixelType(), FAimage, opacity );
     m_UpdateTime3D.Modified();
     m_UpdateTime2D.Modified();
 }
 
 template <typename TPixel>
-void mitk::FiberBundleX::ColorFibersByScalarMap(const mitk::PixelType, mitk::Image::Pointer image, bool opacity)
+void mitk::FiberBundle::ColorFibersByScalarMap(const mitk::PixelType, mitk::Image::Pointer image, bool opacity)
 {
     m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
     m_FiberColors->Allocate(m_FiberPolyData->GetNumberOfPoints() * 4);
     m_FiberColors->SetNumberOfComponents(4);
     m_FiberColors->SetName("FIBER_COLORS");
 
     mitk::ImagePixelReadAccessor<TPixel,3> readimage(image, image->GetVolumeData(0));
 
     unsigned char rgba[4] = {0,0,0,0};
     vtkPoints* pointSet = m_FiberPolyData->GetPoints();
 
     mitk::LookupTable::Pointer mitkLookup = mitk::LookupTable::New();
     vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
     lookupTable->SetTableRange(0.0, 0.8);
     lookupTable->Build();
     mitkLookup->SetVtkLookupTable(lookupTable);
     mitkLookup->SetType(mitk::LookupTable::JET);
 
     for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
     {
         Point3D px;
         px[0] = pointSet->GetPoint(i)[0];
         px[1] = pointSet->GetPoint(i)[1];
         px[2] = pointSet->GetPoint(i)[2];
         double pixelValue = readimage.GetPixelByWorldCoordinates(px);
 
         double color[3];
         lookupTable->GetColor(pixelValue, color);
 
         rgba[0] = (unsigned char) (255.0 * color[0]);
         rgba[1] = (unsigned char) (255.0 * color[1]);
         rgba[2] = (unsigned char) (255.0 * color[2]);
         if (opacity)
             rgba[3] = (unsigned char) (255.0 * pixelValue);
         else
             rgba[3] = (unsigned char) (255.0);
         m_FiberColors->InsertTupleValue(i, rgba);
     }
     m_UpdateTime3D.Modified();
     m_UpdateTime2D.Modified();
 }
 
-void mitk::FiberBundleX::SetFiberColors(float r, float g, float b, float alpha)
+void mitk::FiberBundle::SetFiberColors(float r, float g, float b, float alpha)
 {
     m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
     m_FiberColors->Allocate(m_FiberPolyData->GetNumberOfPoints() * 4);
     m_FiberColors->SetNumberOfComponents(4);
     m_FiberColors->SetName("FIBER_COLORS");
 
     unsigned char rgba[4] = {0,0,0,0};
     for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
     {
         rgba[0] = (unsigned char) r;
         rgba[1] = (unsigned char) g;
         rgba[2] = (unsigned char) b;
         rgba[3] = (unsigned char) alpha;
         m_FiberColors->InsertTupleValue(i, rgba);
     }
     m_UpdateTime3D.Modified();
     m_UpdateTime2D.Modified();
 }
 
-void mitk::FiberBundleX::GenerateFiberIds()
+void mitk::FiberBundle::GenerateFiberIds()
 {
     if (m_FiberPolyData == NULL)
         return;
 
     vtkSmartPointer<vtkIdFilter> idFiberFilter = vtkSmartPointer<vtkIdFilter>::New();
     idFiberFilter->SetInputData(m_FiberPolyData);
     idFiberFilter->CellIdsOn();
     //  idFiberFilter->PointIdsOn(); // point id's are not needed
     idFiberFilter->SetIdsArrayName(FIBER_ID_ARRAY);
     idFiberFilter->FieldDataOn();
     idFiberFilter->Update();
 
     m_FiberIdDataSet = idFiberFilter->GetOutput();
 
 }
 
-mitk::FiberBundleX::Pointer mitk::FiberBundleX::ExtractFiberSubset(ItkUcharImgType* mask, bool anyPoint, bool invert)
+mitk::FiberBundle::Pointer mitk::FiberBundle::ExtractFiberSubset(ItkUcharImgType* mask, bool anyPoint, bool invert)
 {
     vtkSmartPointer<vtkPolyData> polyData = m_FiberPolyData;
     if (anyPoint)
     {
         float minSpacing = 1;
         if(mask->GetSpacing()[0]<mask->GetSpacing()[1] && mask->GetSpacing()[0]<mask->GetSpacing()[2])
             minSpacing = mask->GetSpacing()[0];
         else if (mask->GetSpacing()[1] < mask->GetSpacing()[2])
             minSpacing = mask->GetSpacing()[1];
         else
             minSpacing = mask->GetSpacing()[2];
 
-        mitk::FiberBundleX::Pointer fibCopy = this->GetDeepCopy();
+        mitk::FiberBundle::Pointer fibCopy = this->GetDeepCopy();
         fibCopy->ResampleSpline(minSpacing/5);
         polyData = fibCopy->GetFiberPolyData();
     }
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     MITK_INFO << "Extracting fibers";
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
 
         vtkCell* cell = polyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkCell* cellOriginal = m_FiberPolyData->GetCell(i);
         int numPointsOriginal = cellOriginal->GetNumberOfPoints();
         vtkPoints* pointsOriginal = cellOriginal->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
 
         if (numPoints>1 && numPointsOriginal)
         {
             if (anyPoint)
             {
                 if (!invert)
                 {
                     for (int j=0; j<numPoints; j++)
                     {
                         double* p = points->GetPoint(j);
 
                         itk::Point<float, 3> itkP;
                         itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
                         itk::Index<3> idx;
                         mask->TransformPhysicalPointToIndex(itkP, idx);
 
                         if ( mask->GetPixel(idx)>0 && mask->GetLargestPossibleRegion().IsInside(idx) )
                         {
                             for (int k=0; k<numPointsOriginal; k++)
                             {
                                 double* p = pointsOriginal->GetPoint(k);
                                 vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                                 container->GetPointIds()->InsertNextId(id);
                             }
                             break;
                         }
                     }
                 }
                 else
                 {
                     bool includeFiber = true;
                     for (int j=0; j<numPoints; j++)
                     {
                         double* p = points->GetPoint(j);
 
                         itk::Point<float, 3> itkP;
                         itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
                         itk::Index<3> idx;
                         mask->TransformPhysicalPointToIndex(itkP, idx);
 
                         if ( mask->GetPixel(idx)>0 && mask->GetLargestPossibleRegion().IsInside(idx) )
                         {
                             includeFiber = false;
                             break;
                         }
                     }
                     if (includeFiber)
                     {
 
                         for (int k=0; k<numPointsOriginal; k++)
                         {
                             double* p = pointsOriginal->GetPoint(k);
                             vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                             container->GetPointIds()->InsertNextId(id);
                         }
                     }
                 }
             }
             else
             {
                 double* start = pointsOriginal->GetPoint(0);
                 itk::Point<float, 3> itkStart;
                 itkStart[0] = start[0]; itkStart[1] = start[1]; itkStart[2] = start[2];
                 itk::Index<3> idxStart;
                 mask->TransformPhysicalPointToIndex(itkStart, idxStart);
 
                 double* end = pointsOriginal->GetPoint(numPointsOriginal-1);
                 itk::Point<float, 3> itkEnd;
                 itkEnd[0] = end[0]; itkEnd[1] = end[1]; itkEnd[2] = end[2];
                 itk::Index<3> idxEnd;
                 mask->TransformPhysicalPointToIndex(itkEnd, idxEnd);
 
                 if ( mask->GetPixel(idxStart)>0 && mask->GetPixel(idxEnd)>0 && mask->GetLargestPossibleRegion().IsInside(idxStart) && mask->GetLargestPossibleRegion().IsInside(idxEnd) )
                 {
                     for (int j=0; j<numPointsOriginal; j++)
                     {
                         double* p = pointsOriginal->GetPoint(j);
                         vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                         container->GetPointIds()->InsertNextId(id);
                     }
                 }
             }
         }
 
         vtkNewCells->InsertNextCell(container);
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return NULL;
 
     vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
     newPolyData->SetPoints(vtkNewPoints);
     newPolyData->SetLines(vtkNewCells);
-    return mitk::FiberBundleX::New(newPolyData);
+    return mitk::FiberBundle::New(newPolyData);
 }
 
-mitk::FiberBundleX::Pointer mitk::FiberBundleX::RemoveFibersOutside(ItkUcharImgType* mask, bool invert)
+mitk::FiberBundle::Pointer mitk::FiberBundle::RemoveFibersOutside(ItkUcharImgType* mask, bool invert)
 {
     float minSpacing = 1;
     if(mask->GetSpacing()[0]<mask->GetSpacing()[1] && mask->GetSpacing()[0]<mask->GetSpacing()[2])
         minSpacing = mask->GetSpacing()[0];
     else if (mask->GetSpacing()[1] < mask->GetSpacing()[2])
         minSpacing = mask->GetSpacing()[1];
     else
         minSpacing = mask->GetSpacing()[2];
 
-    mitk::FiberBundleX::Pointer fibCopy = this->GetDeepCopy();
+    mitk::FiberBundle::Pointer fibCopy = this->GetDeepCopy();
     fibCopy->ResampleSpline(minSpacing/10);
     vtkSmartPointer<vtkPolyData> polyData =fibCopy->GetFiberPolyData();
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     MITK_INFO << "Cutting fibers";
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
 
         vtkCell* cell = polyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         if (numPoints>1)
         {
             int newNumPoints = 0;
             for (int j=0; j<numPoints; j++)
             {
                 double* p = points->GetPoint(j);
 
                 itk::Point<float, 3> itkP;
                 itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
                 itk::Index<3> idx;
                 mask->TransformPhysicalPointToIndex(itkP, idx);
 
                 if ( mask->GetPixel(idx)>0 && mask->GetLargestPossibleRegion().IsInside(idx) && !invert )
                 {
                     vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                     container->GetPointIds()->InsertNextId(id);
                     newNumPoints++;
                 }
                 else if ( (mask->GetPixel(idx)<=0 || !mask->GetLargestPossibleRegion().IsInside(idx)) && invert )
                 {
                     vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                     container->GetPointIds()->InsertNextId(id);
                     newNumPoints++;
                 }
                 else if (newNumPoints>0)
                 {
                     vtkNewCells->InsertNextCell(container);
 
                     newNumPoints = 0;
                     container = vtkSmartPointer<vtkPolyLine>::New();
                 }
             }
 
             if (newNumPoints>0)
                 vtkNewCells->InsertNextCell(container);
         }
 
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return NULL;
 
     vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
     newPolyData->SetPoints(vtkNewPoints);
     newPolyData->SetLines(vtkNewCells);
-    mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(newPolyData);
+    mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(newPolyData);
     newFib->ResampleSpline(minSpacing/2);
     return newFib;
 }
 
-mitk::FiberBundleX::Pointer mitk::FiberBundleX::ExtractFiberSubset(BaseData* roi)
+mitk::FiberBundle::Pointer mitk::FiberBundle::ExtractFiberSubset(BaseData* roi)
 {
     if (roi==NULL || !(dynamic_cast<PlanarFigure*>(roi) || dynamic_cast<PlanarFigureComposite*>(roi)) )
         return NULL;
 
     std::vector<long> tmp = ExtractFiberIdSubset(roi);
 
     if (tmp.size()<=0)
-        return mitk::FiberBundleX::New();
+        return mitk::FiberBundle::New();
     vtkSmartPointer<vtkPolyData> pTmp = GeneratePolyDataByIds(tmp);
-    return mitk::FiberBundleX::New(pTmp);
+    return mitk::FiberBundle::New(pTmp);
 }
 
-std::vector<long> mitk::FiberBundleX::ExtractFiberIdSubset(BaseData* roi)
+std::vector<long> mitk::FiberBundle::ExtractFiberIdSubset(BaseData* roi)
 {
     std::vector<long> result;
     if (roi==NULL)
         return result;
 
     mitk::PlanarFigureComposite::Pointer pfc = dynamic_cast<mitk::PlanarFigureComposite*>(roi);
     if (!pfc.IsNull()) // handle composite
     {
         switch (pfc->getOperationType())
         {
         case 0: // AND
         {
             result = this->ExtractFiberIdSubset(pfc->getChildAt(0));
             std::vector<long>::iterator it;
             for (int i=1; i<pfc->getNumberOfChildren(); ++i)
             {
                 std::vector<long> inRoi = this->ExtractFiberIdSubset(pfc->getChildAt(i));
 
                 std::vector<long> rest(std::min(result.size(),inRoi.size()));
                 it = std::set_intersection(result.begin(), result.end(), inRoi.begin(), inRoi.end(), rest.begin() );
                 rest.resize( it - rest.begin() );
                 result = rest;
             }
             break;
         }
         case 1: // OR
         {
             result = ExtractFiberIdSubset(pfc->getChildAt(0));
             std::vector<long>::iterator it;
             for (int i=1; i<pfc->getNumberOfChildren(); ++i)
             {
                 it = result.end();
                 std::vector<long> inRoi = ExtractFiberIdSubset(pfc->getChildAt(i));
                 result.insert(it, inRoi.begin(), inRoi.end());
             }
 
             // remove duplicates
             sort(result.begin(), result.end());
             it = unique(result.begin(), result.end());
             result.resize( it - result.begin() );
             break;
         }
         case 2: // NOT
         {
             for(long i=0; i<this->GetNumFibers(); i++)
                 result.push_back(i);
 
             std::vector<long>::iterator it;
             for (long i=0; i<pfc->getNumberOfChildren(); ++i)
             {
                 std::vector<long> inRoi = ExtractFiberIdSubset(pfc->getChildAt(i));
 
                 std::vector<long> rest(result.size()-inRoi.size());
                 it = std::set_difference(result.begin(), result.end(), inRoi.begin(), inRoi.end(), rest.begin() );
                 rest.resize( it - rest.begin() );
                 result = rest;
             }
             break;
         }
         }
     }
     else if ( dynamic_cast<mitk::PlanarFigure*>(roi) )  // actual extraction
     {
         if ( dynamic_cast<mitk::PlanarPolygon*>(roi) )
         {
             mitk::PlanarFigure::Pointer planarPoly = dynamic_cast<mitk::PlanarFigure*>(roi);
 
             //create vtkPolygon using controlpoints from planarFigure polygon
             vtkSmartPointer<vtkPolygon> polygonVtk = vtkSmartPointer<vtkPolygon>::New();
             for (unsigned int i=0; i<planarPoly->GetNumberOfControlPoints(); ++i)
             {
                 itk::Point<double,3> p = planarPoly->GetWorldControlPoint(i);
                 vtkIdType id = polygonVtk->GetPoints()->InsertNextPoint(p[0], p[1], p[2] );
                 polygonVtk->GetPointIds()->InsertNextId(id);
             }
 
             MITK_INFO << "Extracting with polygon";
             boost::progress_display disp(m_NumFibers);
             for (int i=0; i<m_NumFibers; i++)
             {
                 ++disp ;
                 vtkCell* cell = m_FiberPolyData->GetCell(i);
                 int numPoints = cell->GetNumberOfPoints();
                 vtkPoints* points = cell->GetPoints();
 
                 for (int j=0; j<numPoints-1; j++)
                 {
                     // Inputs
                     double p1[3] = {0,0,0};
                     points->GetPoint(j, p1);
                     double p2[3] = {0,0,0};
                     points->GetPoint(j+1, p2);
                     double tolerance = 0.001;
 
                     // Outputs
                     double t = 0; // Parametric coordinate of intersection (0 (corresponding to p1) to 1 (corresponding to p2))
                     double x[3] = {0,0,0}; // The coordinate of the intersection
                     double pcoords[3] = {0,0,0};
                     int subId = 0;
 
                     int iD = polygonVtk->IntersectWithLine(p1, p2, tolerance, t, x, pcoords, subId);
                     if (iD!=0)
                     {
                         result.push_back(i);
                         break;
                     }
                 }
             }
         }
         else if ( dynamic_cast<mitk::PlanarCircle*>(roi) )
         {
             mitk::PlanarFigure::Pointer planarFigure = dynamic_cast<mitk::PlanarFigure*>(roi);
             Vector3D planeNormal = planarFigure->GetPlaneGeometry()->GetNormal();
             planeNormal.Normalize();
 
             //calculate circle radius
             mitk::Point3D V1w = planarFigure->GetWorldControlPoint(0); //centerPoint
             mitk::Point3D V2w  = planarFigure->GetWorldControlPoint(1); //radiusPoint
 
             double radius = V1w.EuclideanDistanceTo(V2w);
             radius *= radius;
 
             MITK_INFO << "Extracting with circle";
             boost::progress_display disp(m_NumFibers);
             for (int i=0; i<m_NumFibers; i++)
             {
                 ++disp ;
                 vtkCell* cell = m_FiberPolyData->GetCell(i);
                 int numPoints = cell->GetNumberOfPoints();
                 vtkPoints* points = cell->GetPoints();
 
                 for (int j=0; j<numPoints-1; j++)
                 {
                     // Inputs
                     double p1[3] = {0,0,0};
                     points->GetPoint(j, p1);
                     double p2[3] = {0,0,0};
                     points->GetPoint(j+1, p2);
 
                     // Outputs
                     double t = 0; // Parametric coordinate of intersection (0 (corresponding to p1) to 1 (corresponding to p2))
                     double x[3] = {0,0,0}; // The coordinate of the intersection
 
                     int iD = vtkPlane::IntersectWithLine(p1,p2,planeNormal.GetDataPointer(),V1w.GetDataPointer(),t,x);
 
                     if (iD!=0)
                     {
                         double dist = (x[0]-V1w[0])*(x[0]-V1w[0])+(x[1]-V1w[1])*(x[1]-V1w[1])+(x[2]-V1w[2])*(x[2]-V1w[2]);
                         if( dist <= radius)
                         {
                             result.push_back(i);
                             break;
                         }
                     }
                 }
             }
         }
         return result;
     }
 
     return result;
 }
 
-void mitk::FiberBundleX::UpdateFiberGeometry()
+void mitk::FiberBundle::UpdateFiberGeometry()
 {
     vtkSmartPointer<vtkCleanPolyData> cleaner = vtkSmartPointer<vtkCleanPolyData>::New();
     cleaner->SetInputData(m_FiberPolyData);
     cleaner->PointMergingOff();
     cleaner->Update();
     m_FiberPolyData = cleaner->GetOutput();
 
     m_FiberLengths.clear();
     m_MeanFiberLength = 0;
     m_MedianFiberLength = 0;
     m_LengthStDev = 0;
     m_NumFibers = m_FiberPolyData->GetNumberOfCells();
 
     if (m_FiberColors==NULL || m_FiberColors->GetNumberOfTuples()!=m_FiberPolyData->GetNumberOfPoints())
         this->DoColorCodingOrientationBased();
 
     if (m_FiberWeights->GetSize()!=m_NumFibers)
     {
         m_FiberWeights = vtkSmartPointer<vtkFloatArray>::New();
         m_FiberWeights->SetName("FIBER_WEIGHTS");
         m_FiberWeights->SetNumberOfValues(m_NumFibers);
         this->SetFiberWeights(1);
     }
 
     if (m_NumFibers<=0) // no fibers present; apply default geometry
     {
         m_MinFiberLength = 0;
         m_MaxFiberLength = 0;
         mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
         geometry->SetImageGeometry(false);
         float b[] = {0, 1, 0, 1, 0, 1};
         geometry->SetFloatBounds(b);
         SetGeometry(geometry);
         return;
     }
     double b[6];
     m_FiberPolyData->GetBounds(b);
 
     // calculate statistics
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int p = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
         float length = 0;
         for (int j=0; j<p-1; j++)
         {
             double p1[3];
             points->GetPoint(j, p1);
             double p2[3];
             points->GetPoint(j+1, p2);
 
             float dist = std::sqrt((p1[0]-p2[0])*(p1[0]-p2[0])+(p1[1]-p2[1])*(p1[1]-p2[1])+(p1[2]-p2[2])*(p1[2]-p2[2]));
             length += dist;
         }
         m_FiberLengths.push_back(length);
         m_MeanFiberLength += length;
         if (i==0)
         {
             m_MinFiberLength = length;
             m_MaxFiberLength = length;
         }
         else
         {
             if (length<m_MinFiberLength)
                 m_MinFiberLength = length;
             if (length>m_MaxFiberLength)
                 m_MaxFiberLength = length;
         }
     }
     m_MeanFiberLength /= m_NumFibers;
 
     std::vector< float > sortedLengths = m_FiberLengths;
     std::sort(sortedLengths.begin(), sortedLengths.end());
     for (int i=0; i<m_NumFibers; i++)
         m_LengthStDev += (m_MeanFiberLength-sortedLengths.at(i))*(m_MeanFiberLength-sortedLengths.at(i));
     if (m_NumFibers>1)
         m_LengthStDev /= (m_NumFibers-1);
     else
         m_LengthStDev = 0;
     m_LengthStDev = std::sqrt(m_LengthStDev);
     m_MedianFiberLength = sortedLengths.at(m_NumFibers/2);
 
     mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
     geometry->SetFloatBounds(b);
     this->SetGeometry(geometry);
 
     m_UpdateTime3D.Modified();
     m_UpdateTime2D.Modified();
 }
 
-float mitk::FiberBundleX::GetFiberWeight(unsigned int fiber)
+float mitk::FiberBundle::GetFiberWeight(unsigned int fiber)
 {
     return m_FiberWeights->GetValue(fiber);
 }
 
-void mitk::FiberBundleX::SetFiberWeights(float newWeight)
+void mitk::FiberBundle::SetFiberWeights(float newWeight)
 {
     for (int i=0; i<m_FiberWeights->GetSize(); i++)
         m_FiberWeights->SetValue(i, newWeight);
 }
 
-void mitk::FiberBundleX::SetFiberWeights(vtkSmartPointer<vtkFloatArray> weights)
+void mitk::FiberBundle::SetFiberWeights(vtkSmartPointer<vtkFloatArray> weights)
 {
     if (m_NumFibers!=weights->GetSize())
         return;
 
     for (int i=0; i<weights->GetSize(); i++)
         m_FiberWeights->SetValue(i, weights->GetValue(i));
 
     m_FiberWeights->SetName("FIBER_WEIGHTS");
 }
 
-void mitk::FiberBundleX::SetFiberWeight(unsigned int fiber, float weight)
+void mitk::FiberBundle::SetFiberWeight(unsigned int fiber, float weight)
 {
     m_FiberWeights->SetValue(fiber, weight);
 }
 
-void mitk::FiberBundleX::SetFiberColors(vtkSmartPointer<vtkUnsignedCharArray> fiberColors)
+void mitk::FiberBundle::SetFiberColors(vtkSmartPointer<vtkUnsignedCharArray> fiberColors)
 {
     for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
     {
         unsigned char source[4] = {0,0,0,0};
         fiberColors->GetTupleValue(i, source);
 
         unsigned char target[4] = {0,0,0,0};
         target[0] = source[0];
         target[1] = source[1];
         target[2] = source[2];
         target[3] = source[3];
         m_FiberColors->InsertTupleValue(i, target);
     }
     m_UpdateTime3D.Modified();
     m_UpdateTime2D.Modified();
 }
 
-itk::Matrix< double, 3, 3 > mitk::FiberBundleX::TransformMatrix(itk::Matrix< double, 3, 3 > m, double rx, double ry, double rz)
+itk::Matrix< double, 3, 3 > mitk::FiberBundle::TransformMatrix(itk::Matrix< double, 3, 3 > m, double rx, double ry, double rz)
 {
     rx = rx*M_PI/180;
     ry = ry*M_PI/180;
     rz = rz*M_PI/180;
 
     itk::Matrix< double, 3, 3 > rotX; rotX.SetIdentity();
     rotX[1][1] = cos(rx);
     rotX[2][2] = rotX[1][1];
     rotX[1][2] = -sin(rx);
     rotX[2][1] = -rotX[1][2];
 
     itk::Matrix< double, 3, 3 > rotY; rotY.SetIdentity();
     rotY[0][0] = cos(ry);
     rotY[2][2] = rotY[0][0];
     rotY[0][2] = sin(ry);
     rotY[2][0] = -rotY[0][2];
 
     itk::Matrix< double, 3, 3 > rotZ; rotZ.SetIdentity();
     rotZ[0][0] = cos(rz);
     rotZ[1][1] = rotZ[0][0];
     rotZ[0][1] = -sin(rz);
     rotZ[1][0] = -rotZ[0][1];
 
     itk::Matrix< double, 3, 3 > rot = rotZ*rotY*rotX;
 
     m = rot*m;
 
     return m;
 }
 
-itk::Point<float, 3> mitk::FiberBundleX::TransformPoint(vnl_vector_fixed< double, 3 > point, double rx, double ry, double rz, double tx, double ty, double tz)
+itk::Point<float, 3> mitk::FiberBundle::TransformPoint(vnl_vector_fixed< double, 3 > point, double rx, double ry, double rz, double tx, double ty, double tz)
 {
     rx = rx*M_PI/180;
     ry = ry*M_PI/180;
     rz = rz*M_PI/180;
 
     vnl_matrix_fixed< double, 3, 3 > rotX; rotX.set_identity();
     rotX[1][1] = cos(rx);
     rotX[2][2] = rotX[1][1];
     rotX[1][2] = -sin(rx);
     rotX[2][1] = -rotX[1][2];
 
     vnl_matrix_fixed< double, 3, 3 > rotY; rotY.set_identity();
     rotY[0][0] = cos(ry);
     rotY[2][2] = rotY[0][0];
     rotY[0][2] = sin(ry);
     rotY[2][0] = -rotY[0][2];
 
     vnl_matrix_fixed< double, 3, 3 > rotZ; rotZ.set_identity();
     rotZ[0][0] = cos(rz);
     rotZ[1][1] = rotZ[0][0];
     rotZ[0][1] = -sin(rz);
     rotZ[1][0] = -rotZ[0][1];
 
     vnl_matrix_fixed< double, 3, 3 > rot = rotZ*rotY*rotX;
 
     mitk::BaseGeometry::Pointer geom = this->GetGeometry();
     mitk::Point3D center = geom->GetCenter();
 
     point[0] -= center[0];
     point[1] -= center[1];
     point[2] -= center[2];
     point = rot*point;
     point[0] += center[0]+tx;
     point[1] += center[1]+ty;
     point[2] += center[2]+tz;
     itk::Point<float, 3> out; out[0] = point[0]; out[1] = point[1]; out[2] = point[2];
     return out;
 }
 
-void mitk::FiberBundleX::TransformFibers(double rx, double ry, double rz, double tx, double ty, double tz)
+void mitk::FiberBundle::TransformFibers(double rx, double ry, double rz, double tx, double ty, double tz)
 {
     rx = rx*M_PI/180;
     ry = ry*M_PI/180;
     rz = rz*M_PI/180;
 
     vnl_matrix_fixed< double, 3, 3 > rotX; rotX.set_identity();
     rotX[1][1] = cos(rx);
     rotX[2][2] = rotX[1][1];
     rotX[1][2] = -sin(rx);
     rotX[2][1] = -rotX[1][2];
 
     vnl_matrix_fixed< double, 3, 3 > rotY; rotY.set_identity();
     rotY[0][0] = cos(ry);
     rotY[2][2] = rotY[0][0];
     rotY[0][2] = sin(ry);
     rotY[2][0] = -rotY[0][2];
 
     vnl_matrix_fixed< double, 3, 3 > rotZ; rotZ.set_identity();
     rotZ[0][0] = cos(rz);
     rotZ[1][1] = rotZ[0][0];
     rotZ[0][1] = -sin(rz);
     rotZ[1][0] = -rotZ[0][1];
 
     vnl_matrix_fixed< double, 3, 3 > rot = rotZ*rotY*rotX;
 
     mitk::BaseGeometry::Pointer geom = this->GetGeometry();
     mitk::Point3D center = geom->GetCenter();
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     for (int i=0; i<m_NumFibers; i++)
     {
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double* p = points->GetPoint(j);
             vnl_vector_fixed< double, 3 > dir;
             dir[0] = p[0]-center[0];
             dir[1] = p[1]-center[1];
             dir[2] = p[2]-center[2];
             dir = rot*dir;
             dir[0] += center[0]+tx;
             dir[1] += center[1]+ty;
             dir[2] += center[2]+tz;
             vtkIdType id = vtkNewPoints->InsertNextPoint(dir.data_block());
             container->GetPointIds()->InsertNextId(id);
         }
         vtkNewCells->InsertNextCell(container);
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
-void mitk::FiberBundleX::RotateAroundAxis(double x, double y, double z)
+void mitk::FiberBundle::RotateAroundAxis(double x, double y, double z)
 {
     x = x*M_PI/180;
     y = y*M_PI/180;
     z = z*M_PI/180;
 
     vnl_matrix_fixed< double, 3, 3 > rotX; rotX.set_identity();
     rotX[1][1] = cos(x);
     rotX[2][2] = rotX[1][1];
     rotX[1][2] = -sin(x);
     rotX[2][1] = -rotX[1][2];
 
     vnl_matrix_fixed< double, 3, 3 > rotY; rotY.set_identity();
     rotY[0][0] = cos(y);
     rotY[2][2] = rotY[0][0];
     rotY[0][2] = sin(y);
     rotY[2][0] = -rotY[0][2];
 
     vnl_matrix_fixed< double, 3, 3 > rotZ; rotZ.set_identity();
     rotZ[0][0] = cos(z);
     rotZ[1][1] = rotZ[0][0];
     rotZ[0][1] = -sin(z);
     rotZ[1][0] = -rotZ[0][1];
 
     mitk::BaseGeometry::Pointer geom = this->GetGeometry();
     mitk::Point3D center = geom->GetCenter();
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     for (int i=0; i<m_NumFibers; i++)
     {
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double* p = points->GetPoint(j);
             vnl_vector_fixed< double, 3 > dir;
             dir[0] = p[0]-center[0];
             dir[1] = p[1]-center[1];
             dir[2] = p[2]-center[2];
             dir = rotZ*rotY*rotX*dir;
             dir[0] += center[0];
             dir[1] += center[1];
             dir[2] += center[2];
             vtkIdType id = vtkNewPoints->InsertNextPoint(dir.data_block());
             container->GetPointIds()->InsertNextId(id);
         }
         vtkNewCells->InsertNextCell(container);
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
-void mitk::FiberBundleX::ScaleFibers(double x, double y, double z, bool subtractCenter)
+void mitk::FiberBundle::ScaleFibers(double x, double y, double z, bool subtractCenter)
 {
     MITK_INFO << "Scaling fibers";
     boost::progress_display disp(m_NumFibers);
 
     mitk::BaseGeometry* geom = this->GetGeometry();
     mitk::Point3D c = geom->GetCenter();
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp ;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double* p = points->GetPoint(j);
             if (subtractCenter)
             {
                 p[0] -= c[0]; p[1] -= c[1]; p[2] -= c[2];
             }
             p[0] *= x;
             p[1] *= y;
             p[2] *= z;
             if (subtractCenter)
             {
                 p[0] += c[0]; p[1] += c[1]; p[2] += c[2];
             }
             vtkIdType id = vtkNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
         vtkNewCells->InsertNextCell(container);
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
-void mitk::FiberBundleX::TranslateFibers(double x, double y, double z)
+void mitk::FiberBundle::TranslateFibers(double x, double y, double z)
 {
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     for (int i=0; i<m_NumFibers; i++)
     {
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double* p = points->GetPoint(j);
             p[0] += x;
             p[1] += y;
             p[2] += z;
             vtkIdType id = vtkNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
         vtkNewCells->InsertNextCell(container);
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
-void mitk::FiberBundleX::MirrorFibers(unsigned int axis)
+void mitk::FiberBundle::MirrorFibers(unsigned int axis)
 {
     if (axis>2)
         return;
 
     MITK_INFO << "Mirroring fibers";
     boost::progress_display disp(m_NumFibers);
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double* p = points->GetPoint(j);
             p[axis] = -p[axis];
             vtkIdType id = vtkNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
         vtkNewCells->InsertNextCell(container);
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
-void mitk::FiberBundleX::RemoveDir(vnl_vector_fixed<double,3> dir, double threshold)
+void mitk::FiberBundle::RemoveDir(vnl_vector_fixed<double,3> dir, double threshold)
 {
     dir.normalize();
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     boost::progress_display disp(m_FiberPolyData->GetNumberOfCells());
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
         ++disp ;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         // calculate curvatures
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         bool discard = false;
         for (int j=0; j<numPoints-1; j++)
         {
             double p1[3];
             points->GetPoint(j, p1);
             double p2[3];
             points->GetPoint(j+1, p2);
 
             vnl_vector_fixed< double, 3 > v1;
             v1[0] = p2[0]-p1[0];
             v1[1] = p2[1]-p1[1];
             v1[2] = p2[2]-p1[2];
             if (v1.magnitude()>0.001)
             {
                 v1.normalize();
 
                 if (fabs(dot_product(v1,dir))>threshold)
                 {
                     discard = true;
                     break;
                 }
             }
         }
         if (!discard)
         {
             for (int j=0; j<numPoints; j++)
             {
                 double p1[3];
                 points->GetPoint(j, p1);
 
                 vtkIdType id = vtkNewPoints->InsertNextPoint(p1);
                 container->GetPointIds()->InsertNextId(id);
             }
             vtkNewCells->InsertNextCell(container);
         }
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
 
     this->SetFiberPolyData(m_FiberPolyData, true);
 
     //    UpdateColorCoding();
     //    UpdateFiberGeometry();
 }
 
-bool mitk::FiberBundleX::ApplyCurvatureThreshold(float minRadius, bool deleteFibers)
+bool mitk::FiberBundle::ApplyCurvatureThreshold(float minRadius, bool deleteFibers)
 {
     if (minRadius<0)
         return true;
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     MITK_INFO << "Applying curvature threshold";
     boost::progress_display disp(m_FiberPolyData->GetNumberOfCells());
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
         ++disp ;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         // calculate curvatures
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints-2; j++)
         {
             double p1[3];
             points->GetPoint(j, p1);
             double p2[3];
             points->GetPoint(j+1, p2);
             double p3[3];
             points->GetPoint(j+2, p3);
 
             vnl_vector_fixed< float, 3 > v1, v2, v3;
 
             v1[0] = p2[0]-p1[0];
             v1[1] = p2[1]-p1[1];
             v1[2] = p2[2]-p1[2];
 
             v2[0] = p3[0]-p2[0];
             v2[1] = p3[1]-p2[1];
             v2[2] = p3[2]-p2[2];
 
             v3[0] = p1[0]-p3[0];
             v3[1] = p1[1]-p3[1];
             v3[2] = p1[2]-p3[2];
 
             float a = v1.magnitude();
             float b = v2.magnitude();
             float c = v3.magnitude();
             float r = a*b*c/std::sqrt((a+b+c)*(a+b-c)*(b+c-a)*(a-b+c)); // radius of triangle via Heron's formula (area of triangle)
 
             vtkIdType id = vtkNewPoints->InsertNextPoint(p1);
             container->GetPointIds()->InsertNextId(id);
 
             if (deleteFibers && r<minRadius)
                 break;
 
             if (r<minRadius)
             {
                 j += 2;
                 vtkNewCells->InsertNextCell(container);
                 container = vtkSmartPointer<vtkPolyLine>::New();
             }
             else if (j==numPoints-3)
             {
                 id = vtkNewPoints->InsertNextPoint(p2);
                 container->GetPointIds()->InsertNextId(id);
                 id = vtkNewPoints->InsertNextPoint(p3);
                 container->GetPointIds()->InsertNextId(id);
                 vtkNewCells->InsertNextCell(container);
             }
         }
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return false;
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
     return true;
 }
 
-bool mitk::FiberBundleX::RemoveShortFibers(float lengthInMM)
+bool mitk::FiberBundle::RemoveShortFibers(float lengthInMM)
 {
     MITK_INFO << "Removing short fibers";
     if (lengthInMM<=0 || lengthInMM<m_MinFiberLength)
     {
         MITK_INFO << "No fibers shorter than " << lengthInMM << " mm found!";
         return true;
     }
 
     if (lengthInMM>m_MaxFiberLength)    // can't remove all fibers
     {
         MITK_WARN << "Process aborted. No fibers would be left!";
         return false;
     }
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
     float min = m_MaxFiberLength;
 
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         if (m_FiberLengths.at(i)>=lengthInMM)
         {
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (int j=0; j<numPoints; j++)
             {
                 double* p = points->GetPoint(j);
                 vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                 container->GetPointIds()->InsertNextId(id);
             }
             vtkNewCells->InsertNextCell(container);
             if (m_FiberLengths.at(i)<min)
                 min = m_FiberLengths.at(i);
         }
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return false;
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
     return true;
 }
 
-bool mitk::FiberBundleX::RemoveLongFibers(float lengthInMM)
+bool mitk::FiberBundle::RemoveLongFibers(float lengthInMM)
 {
     if (lengthInMM<=0 || lengthInMM>m_MaxFiberLength)
         return true;
 
     if (lengthInMM<m_MinFiberLength)    // can't remove all fibers
         return false;
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     MITK_INFO << "Removing long fibers";
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         if (m_FiberLengths.at(i)<=lengthInMM)
         {
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (int j=0; j<numPoints; j++)
             {
                 double* p = points->GetPoint(j);
                 vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                 container->GetPointIds()->InsertNextId(id);
             }
             vtkNewCells->InsertNextCell(container);
         }
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return false;
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
     return true;
 }
 
-void mitk::FiberBundleX::ResampleSpline(float pointDistance, double tension, double continuity, double bias )
+void mitk::FiberBundle::ResampleSpline(float pointDistance, double tension, double continuity, double bias )
 {
     if (pointDistance<=0)
         return;
 
     vtkSmartPointer<vtkPoints> vtkSmoothPoints = vtkSmartPointer<vtkPoints>::New(); //in smoothpoints the interpolated points representing a fiber are stored.
 
     //in vtkcells all polylines are stored, actually all id's of them are stored
     vtkSmartPointer<vtkCellArray> vtkSmoothCells = vtkSmartPointer<vtkCellArray>::New(); //cellcontainer for smoothed lines
     vtkIdType pointHelperCnt = 0;
 
     MITK_INFO << "Smoothing fibers";
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPoints> newPoints = vtkSmartPointer<vtkPoints>::New();
         for (int j=0; j<numPoints; j++)
             newPoints->InsertNextPoint(points->GetPoint(j));
 
         float length = m_FiberLengths.at(i);
         int sampling = std::ceil(length/pointDistance);
 
         vtkSmartPointer<vtkKochanekSpline> xSpline = vtkSmartPointer<vtkKochanekSpline>::New();
         vtkSmartPointer<vtkKochanekSpline> ySpline = vtkSmartPointer<vtkKochanekSpline>::New();
         vtkSmartPointer<vtkKochanekSpline> zSpline = vtkSmartPointer<vtkKochanekSpline>::New();
         xSpline->SetDefaultBias(bias); xSpline->SetDefaultTension(tension); xSpline->SetDefaultContinuity(continuity);
         ySpline->SetDefaultBias(bias); ySpline->SetDefaultTension(tension); ySpline->SetDefaultContinuity(continuity);
         zSpline->SetDefaultBias(bias); zSpline->SetDefaultTension(tension); zSpline->SetDefaultContinuity(continuity);
 
         vtkSmartPointer<vtkParametricSpline> spline = vtkSmartPointer<vtkParametricSpline>::New();
         spline->SetXSpline(xSpline);
         spline->SetYSpline(ySpline);
         spline->SetZSpline(zSpline);
         spline->SetPoints(newPoints);
 
         vtkSmartPointer<vtkParametricFunctionSource> functionSource = vtkSmartPointer<vtkParametricFunctionSource>::New();
         functionSource->SetParametricFunction(spline);
         functionSource->SetUResolution(sampling);
         functionSource->SetVResolution(sampling);
         functionSource->SetWResolution(sampling);
         functionSource->Update();
 
         vtkPolyData* outputFunction = functionSource->GetOutput();
         vtkPoints* tmpSmoothPnts = outputFunction->GetPoints(); //smoothPoints of current fiber
 
         vtkSmartPointer<vtkPolyLine> smoothLine = vtkSmartPointer<vtkPolyLine>::New();
         smoothLine->GetPointIds()->SetNumberOfIds(tmpSmoothPnts->GetNumberOfPoints());
 
         for (int j=0; j<smoothLine->GetNumberOfPoints(); j++)
         {
             smoothLine->GetPointIds()->SetId(j, j+pointHelperCnt);
             vtkSmoothPoints->InsertNextPoint(tmpSmoothPnts->GetPoint(j));
         }
         vtkSmoothCells->InsertNextCell(smoothLine);
         pointHelperCnt += tmpSmoothPnts->GetNumberOfPoints();
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkSmoothPoints);
     m_FiberPolyData->SetLines(vtkSmoothCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
     m_FiberSampling = 10/pointDistance;
 }
 
-void mitk::FiberBundleX::ResampleSpline(float pointDistance)
+void mitk::FiberBundle::ResampleSpline(float pointDistance)
 {
     ResampleSpline(pointDistance, 0, 0, 0 );
 }
 
-unsigned long mitk::FiberBundleX::GetNumberOfPoints()
+unsigned long mitk::FiberBundle::GetNumberOfPoints()
 {
     unsigned long points = 0;
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         points += cell->GetNumberOfPoints();
     }
     return points;
 }
 
-void mitk::FiberBundleX::Compress(float error)
+void mitk::FiberBundle::Compress(float error)
 {
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     MITK_INFO << "Compressing fibers";
     unsigned long numRemovedPoints = 0;
     boost::progress_display disp(m_FiberPolyData->GetNumberOfCells());
 
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         // calculate curvatures
         std::vector< int > removedPoints; removedPoints.resize(numPoints, 0);
         removedPoints[0]=-1; removedPoints[numPoints-1]=-1;
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
 
         bool pointFound = true;
         while (pointFound)
         {
             pointFound = false;
             double minError = error;
             int removeIndex = -1;
 
             for (int j=0; j<numPoints; j++)
             {
                 if (removedPoints[j]==0)
                 {
                     double cand[3];
                     points->GetPoint(j, cand);
                     vnl_vector_fixed< double, 3 > candV;
                     candV[0]=cand[0]; candV[1]=cand[1]; candV[2]=cand[2];
 
                     int validP = -1;
                     vnl_vector_fixed< double, 3 > pred;
                     for (int k=j-1; k>=0; k--)
                         if (removedPoints[k]<=0)
                         {
                             double ref[3];
                             points->GetPoint(k, ref);
                             pred[0]=ref[0]; pred[1]=ref[1]; pred[2]=ref[2];
                             validP = k;
                             break;
                         }
                     int validS = -1;
                     vnl_vector_fixed< double, 3 > succ;
                     for (int k=j+1; k<numPoints; k++)
                         if (removedPoints[k]<=0)
                         {
                             double ref[3];
                             points->GetPoint(k, ref);
                             succ[0]=ref[0]; succ[1]=ref[1]; succ[2]=ref[2];
                             validS = k;
                             break;
                         }
 
                     if (validP>=0 && validS>=0)
                     {
                         double a = (candV-pred).magnitude();
                         double b = (candV-succ).magnitude();
                         double c = (pred-succ).magnitude();
                         double s=0.5*(a+b+c);
                         double hc=(2.0/c)*sqrt(fabs(s*(s-a)*(s-b)*(s-c)));
 
                         if (hc<minError)
                         {
                             removeIndex = j;
                             minError = hc;
                             pointFound = true;
                         }
                     }
                 }
             }
 
             if (pointFound)
             {
                 removedPoints[removeIndex] = 1;
                 numRemovedPoints++;
             }
         }
 
         for (int j=0; j<numPoints; j++)
         {
             if (removedPoints[j]<=0)
             {
                 double cand[3];
                 points->GetPoint(j, cand);
                 vtkIdType id = vtkNewPoints->InsertNextPoint(cand);
                 container->GetPointIds()->InsertNextId(id);
             }
         }
 
         vtkNewCells->InsertNextCell(container);
     }
 
     if (vtkNewCells->GetNumberOfCells()>0)
     {
         MITK_INFO << "Removed points: " << numRemovedPoints;
         m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
         m_FiberPolyData->SetPoints(vtkNewPoints);
         m_FiberPolyData->SetLines(vtkNewCells);
         this->SetFiberPolyData(m_FiberPolyData, true);
     }
 }
 
 // reapply selected colorcoding in case polydata structure has changed
-bool mitk::FiberBundleX::Equals(mitk::FiberBundleX* fib, double eps)
+bool mitk::FiberBundle::Equals(mitk::FiberBundle* fib, double eps)
 {
     if (fib==NULL)
     {
         MITK_INFO << "Reference bundle is NULL!";
         return false;
     }
 
     if (m_NumFibers!=fib->GetNumFibers())
     {
         MITK_INFO << "Unequal number of fibers!";
         MITK_INFO << m_NumFibers << " vs. " << fib->GetNumFibers();
         return false;
     }
 
     for (int i=0; i<m_NumFibers; i++)
     {
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkCell* cell2 = fib->GetFiberPolyData()->GetCell(i);
         int numPoints2 = cell2->GetNumberOfPoints();
         vtkPoints* points2 = cell2->GetPoints();
 
         if (numPoints2!=numPoints)
         {
             MITK_INFO << "Unequal number of points in fiber " << i << "!";
             MITK_INFO << numPoints2 << " vs. " << numPoints;
             return false;
         }
 
         for (int j=0; j<numPoints; j++)
         {
             double* p1 = points->GetPoint(j);
             double* p2 = points2->GetPoint(j);
             if (fabs(p1[0]-p2[0])>eps || fabs(p1[1]-p2[1])>eps || fabs(p1[2]-p2[2])>eps)
             {
                 MITK_INFO << "Unequal points in fiber " << i << " at position " << j << "!";
                 MITK_INFO << "p1: " << p1[0] << ", " << p1[1] << ", " << p1[2];
                 MITK_INFO << "p2: " << p2[0] << ", " << p2[1] << ", " << p2[2];
                 return false;
             }
         }
     }
 
     return true;
 }
 
 /* ESSENTIAL IMPLEMENTATION OF SUPERCLASS METHODS */
-void mitk::FiberBundleX::UpdateOutputInformation()
+void mitk::FiberBundle::UpdateOutputInformation()
 {
 
 }
-void mitk::FiberBundleX::SetRequestedRegionToLargestPossibleRegion()
+void mitk::FiberBundle::SetRequestedRegionToLargestPossibleRegion()
 {
 
 }
-bool mitk::FiberBundleX::RequestedRegionIsOutsideOfTheBufferedRegion()
+bool mitk::FiberBundle::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
     return false;
 }
-bool mitk::FiberBundleX::VerifyRequestedRegion()
+bool mitk::FiberBundle::VerifyRequestedRegion()
 {
     return true;
 }
-void mitk::FiberBundleX::SetRequestedRegion(const itk::DataObject* )
+void mitk::FiberBundle::SetRequestedRegion(const itk::DataObject* )
 {
 
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.h
similarity index 87%
rename from Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h
rename to Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.h
index 37d44ad5f2..59ca9cf869 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.h
@@ -1,178 +1,178 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
-#ifndef _MITK_FiberBundleX_H
-#define _MITK_FiberBundleX_H
+#ifndef _MITK_FiberBundle_H
+#define _MITK_FiberBundle_H
 
 //includes for MITK datastructure
 #include <mitkBaseData.h>
 #include <MitkFiberTrackingExports.h>
 #include <mitkImage.h>
 
 
 //includes storing fiberdata
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkPoints.h>
 #include <vtkDataSet.h>
 #include <vtkTransform.h>
 #include <vtkFloatArray.h>
 
 //#include <QStringList>
 
 #include <mitkPlanarFigure.h>
 #include <mitkPixelTypeTraits.h>
 #include <mitkPlanarFigureComposite.h>
 
 
 namespace mitk {
 
 /**
    * \brief Base Class for Fiber Bundles;   */
-class MitkFiberTracking_EXPORT FiberBundleX : public BaseData
+class MitkFiberTracking_EXPORT FiberBundle : public BaseData
 {
 public:
 
     typedef itk::Image<unsigned char, 3> ItkUcharImgType;
 
     // fiber colorcodings
     static const char* FIBER_ID_ARRAY;
 
     virtual void UpdateOutputInformation();
     virtual void SetRequestedRegionToLargestPossibleRegion();
     virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
     virtual bool VerifyRequestedRegion();
     virtual void SetRequestedRegion(const itk::DataObject*);
 
-    mitkClassMacro( FiberBundleX, BaseData )
+    mitkClassMacro( FiberBundle, BaseData )
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     mitkNewMacro1Param(Self, vtkSmartPointer<vtkPolyData>) // custom constructor
 
     // colorcoding related methods
     void ColorFibersByScalarMap(mitk::Image::Pointer, bool opacity);
     template <typename TPixel>
     void ColorFibersByScalarMap(const mitk::PixelType pixelType, mitk::Image::Pointer, bool opacity);
     void DoColorCodingOrientationBased();
     void SetFiberOpacity(vtkDoubleArray *FAValArray);
     void ResetFiberOpacity();
     void SetFiberColors(vtkSmartPointer<vtkUnsignedCharArray> fiberColors);
     void SetFiberColors(float r, float g, float b, float alpha=255);
     vtkSmartPointer<vtkUnsignedCharArray> GetFiberColors() const { return m_FiberColors; }
 
     // fiber compression
     void Compress(float error = 0.0);
 
     // fiber resampling
     void ResampleSpline(float pointDistance=1);
     void ResampleSpline(float pointDistance, double tension, double continuity, double bias );
 
     bool RemoveShortFibers(float lengthInMM);
     bool RemoveLongFibers(float lengthInMM);
     bool ApplyCurvatureThreshold(float minRadius, bool deleteFibers);
     void MirrorFibers(unsigned int axis);
     void RotateAroundAxis(double x, double y, double z);
     void TranslateFibers(double x, double y, double z);
     void ScaleFibers(double x, double y, double z, bool subtractCenter=true);
     void TransformFibers(double rx, double ry, double rz, double tx, double ty, double tz);
     void RemoveDir(vnl_vector_fixed<double,3> dir, double threshold);
     itk::Point<float, 3> TransformPoint(vnl_vector_fixed< double, 3 > point, double rx, double ry, double rz, double tx, double ty, double tz);
     itk::Matrix< double, 3, 3 > TransformMatrix(itk::Matrix< double, 3, 3 > m, double rx, double ry, double rz);
 
     // add/subtract fibers
-    FiberBundleX::Pointer AddBundle(FiberBundleX* fib);
-    FiberBundleX::Pointer SubtractBundle(FiberBundleX* fib);
+    FiberBundle::Pointer AddBundle(FiberBundle* fib);
+    FiberBundle::Pointer SubtractBundle(FiberBundle* fib);
 
     // fiber subset extraction
-    FiberBundleX::Pointer           ExtractFiberSubset(BaseData* roi);
+    FiberBundle::Pointer           ExtractFiberSubset(BaseData* roi);
     std::vector<long>               ExtractFiberIdSubset(BaseData* roi);
-    FiberBundleX::Pointer           ExtractFiberSubset(ItkUcharImgType* mask, bool anyPoint, bool invert=false);
-    FiberBundleX::Pointer           RemoveFibersOutside(ItkUcharImgType* mask, bool invert=false);
+    FiberBundle::Pointer           ExtractFiberSubset(ItkUcharImgType* mask, bool anyPoint, bool invert=false);
+    FiberBundle::Pointer           RemoveFibersOutside(ItkUcharImgType* mask, bool invert=false);
 
     vtkSmartPointer<vtkPolyData>    GeneratePolyDataByIds( std::vector<long> ); // TODO: make protected
     void                            GenerateFiberIds(); // TODO: make protected
 
     // get/set data
     vtkSmartPointer<vtkFloatArray> GetFiberWeights() const { return m_FiberWeights; }
     float GetFiberWeight(unsigned int fiber);
     void SetFiberWeights(float newWeight);
     void SetFiberWeight(unsigned int fiber, float weight);
     void SetFiberWeights(vtkSmartPointer<vtkFloatArray> weights);
     void SetFiberPolyData(vtkSmartPointer<vtkPolyData>, bool updateGeometry = true);
     vtkSmartPointer<vtkPolyData> GetFiberPolyData() const;
     itkGetMacro( NumFibers, int)
     //itkGetMacro( FiberSampling, int)
     int GetNumFibers() const {return m_NumFibers;}
     itkGetMacro( MinFiberLength, float )
     itkGetMacro( MaxFiberLength, float )
     itkGetMacro( MeanFiberLength, float )
     itkGetMacro( MedianFiberLength, float )
     itkGetMacro( LengthStDev, float )
     itkGetMacro( UpdateTime2D, itk::TimeStamp )
     itkGetMacro( UpdateTime3D, itk::TimeStamp )
     void RequestUpdate2D(){ m_UpdateTime2D.Modified(); }
     void RequestUpdate3D(){ m_UpdateTime3D.Modified(); }
     void RequestUpdate(){ m_UpdateTime2D.Modified(); m_UpdateTime3D.Modified(); }
 
     unsigned long GetNumberOfPoints();
 
     // copy fiber bundle
-    mitk::FiberBundleX::Pointer GetDeepCopy();
+    mitk::FiberBundle::Pointer GetDeepCopy();
 
     // compare fiber bundles
-    bool Equals(FiberBundleX* fib, double eps=0.0001);
+    bool Equals(FiberBundle* fib, double eps=0.0001);
 
     itkSetMacro( ReferenceGeometry, mitk::BaseGeometry::Pointer )
     itkGetConstMacro( ReferenceGeometry, mitk::BaseGeometry::Pointer )
 
 protected:
 
-    FiberBundleX( vtkPolyData* fiberPolyData = NULL );
-    virtual ~FiberBundleX();
+    FiberBundle( vtkPolyData* fiberPolyData = NULL );
+    virtual ~FiberBundle();
 
     itk::Point<float, 3> GetItkPoint(double point[3]);
 
     // calculate geometry from fiber extent
     void UpdateFiberGeometry();
 
 private:
 
     // actual fiber container
     vtkSmartPointer<vtkPolyData>  m_FiberPolyData;
 
     // contains fiber ids
     vtkSmartPointer<vtkDataSet>   m_FiberIdDataSet;
 
     int   m_NumFibers;
 
     vtkSmartPointer<vtkUnsignedCharArray> m_FiberColors;
     vtkSmartPointer<vtkFloatArray> m_FiberWeights;
     std::vector< float > m_FiberLengths;
     float   m_MinFiberLength;
     float   m_MaxFiberLength;
     float   m_MeanFiberLength;
     float   m_MedianFiberLength;
     float   m_LengthStDev;
     int     m_FiberSampling;
     itk::TimeStamp m_UpdateTime2D;
     itk::TimeStamp m_UpdateTime3D;
     mitk::BaseGeometry::Pointer m_ReferenceGeometry;
 };
 
 } // namespace mitk
 
-#endif /*  _MITK_FiberBundleX_H */
+#endif /*  _MITK_FiberBundle_H */
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXSource.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleSource.cpp
similarity index 100%
rename from Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXSource.cpp
rename to Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleSource.cpp
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXSource.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleSource.h
similarity index 100%
rename from Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXSource.h
rename to Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleSource.h
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleThreadMonitor.cpp
similarity index 55%
rename from Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp
rename to Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleThreadMonitor.cpp
index caf0d042cd..3aa3cbf85f 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleThreadMonitor.cpp
@@ -1,254 +1,254 @@
 /*===================================================================
 
 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 "mitkFiberBundleXThreadMonitor.h"
+#include "mitkFiberBundleThreadMonitor.h"
 
 
 
-mitk::FiberBundleXThreadMonitor::FiberBundleXThreadMonitor()
+mitk::FiberBundleThreadMonitor::FiberBundleThreadMonitor()
 : m_monitorBracketOpen("[")
 , m_monitorBracketClose("]")
 , m_monitorHeading("Monitoring Fiberprocessing Threads")
 , m_monitorMask("Thread Status:\nStarted:         Finished:         Terminated:")
 , m_monitorStatus("_initialized")
 , m_monitorStarted(0)
 , m_monitorFinished(0)
 , m_monitorTerminated(0)
 {
   m_monitorBracketOpenPosition[0] = 0;
   m_monitorBracketOpenPosition[1] = 0;
   m_monitorBracketClosePosition[0] = 0;
   m_monitorBracketClosePosition[1] = 0;
   m_monitorHeadingPosition[0] =  0;
   m_monitorHeadingPosition[1] =  0;
   m_monitorMaskPosition[0] = 0;
   m_monitorMaskPosition[1] = 0;
   m_monitorStatusPosition[0] = 0;
   m_monitorStatusPosition[1] = 0;
   m_monitorStartedPosition[0] = 0;
   m_monitorStartedPosition[1] = 0;
   m_monitorFinishedPosition[0] = 0;
   m_monitorFinishedPosition[1] = 0;
   m_monitorTerminatedPosition[0] = 0;
   m_monitorTerminatedPosition[1] = 0;
 
 
   m_monitorHeadingOpacity = 0;
   m_monitorMaskOpacity = 0;
   m_monitorTerminatedOpacity = 0;
   m_monitorFinishedOpacity = 0;
   m_monitorStartedOpacity = 0;
   m_monitorStatusOpacity = 0;
 }
 
-mitk::FiberBundleXThreadMonitor::~FiberBundleXThreadMonitor()
+mitk::FiberBundleThreadMonitor::~FiberBundleThreadMonitor()
 {
 
 }
 
 
-QString mitk::FiberBundleXThreadMonitor::getBracketOpen(){
+QString mitk::FiberBundleThreadMonitor::getBracketOpen(){
   return m_monitorBracketOpen;
 }
-mitk::Point2D mitk::FiberBundleXThreadMonitor::getBracketOpenPosition(){
+mitk::Point2D mitk::FiberBundleThreadMonitor::getBracketOpenPosition(){
   return m_monitorBracketOpenPosition;
 }
-void mitk::FiberBundleXThreadMonitor::setBracketOpenPosition(mitk::Point2D pnt){
+void mitk::FiberBundleThreadMonitor::setBracketOpenPosition(mitk::Point2D pnt){
   m_monitorBracketOpenPosition[0] = pnt[0];
   m_monitorBracketOpenPosition[1] = pnt[1];
 }
 
 
 
 
-QString mitk::FiberBundleXThreadMonitor::getBracketClose(){
+QString mitk::FiberBundleThreadMonitor::getBracketClose(){
   return m_monitorBracketClose;
 }
-mitk::Point2D mitk::FiberBundleXThreadMonitor::getBracketClosePosition(){
+mitk::Point2D mitk::FiberBundleThreadMonitor::getBracketClosePosition(){
   return m_monitorBracketClosePosition;
 }
-void mitk::FiberBundleXThreadMonitor::setBracketClosePosition(mitk::Point2D pnt){
+void mitk::FiberBundleThreadMonitor::setBracketClosePosition(mitk::Point2D pnt){
   m_monitorBracketClosePosition[0] = pnt[0];
   m_monitorBracketClosePosition[1] = pnt[1];
 }
 
 
 
-QString mitk::FiberBundleXThreadMonitor::getHeading(){
+QString mitk::FiberBundleThreadMonitor::getHeading(){
   return m_monitorHeading;
 }
-mitk::Point2D mitk::FiberBundleXThreadMonitor::getHeadingPosition(){
+mitk::Point2D mitk::FiberBundleThreadMonitor::getHeadingPosition(){
   return m_monitorHeadingPosition;
 }
-void mitk::FiberBundleXThreadMonitor::setHeadingPosition(mitk::Point2D pnt){
+void mitk::FiberBundleThreadMonitor::setHeadingPosition(mitk::Point2D pnt){
   m_monitorHeadingPosition[0] = pnt[0];
   m_monitorHeadingPosition[1] = pnt[1];
 }
-int mitk::FiberBundleXThreadMonitor::getHeadingOpacity(){
+int mitk::FiberBundleThreadMonitor::getHeadingOpacity(){
   return m_monitorHeadingOpacity;
 }
-void mitk::FiberBundleXThreadMonitor::setHeadingOpacity(int opacity){
+void mitk::FiberBundleThreadMonitor::setHeadingOpacity(int opacity){
   m_monitorHeadingOpacity = opacity;
 }
 
 
 
 
-QString mitk::FiberBundleXThreadMonitor::getMask(){
+QString mitk::FiberBundleThreadMonitor::getMask(){
   return m_monitorMask;
 }
-mitk::Point2D mitk::FiberBundleXThreadMonitor::getMaskPosition(){
+mitk::Point2D mitk::FiberBundleThreadMonitor::getMaskPosition(){
   return m_monitorMaskPosition;
 }
-void mitk::FiberBundleXThreadMonitor::setMaskPosition(mitk::Point2D pnt){
+void mitk::FiberBundleThreadMonitor::setMaskPosition(mitk::Point2D pnt){
   m_monitorMaskPosition[0] = pnt[0];
   m_monitorMaskPosition[1] = pnt[1];
 }
-int mitk::FiberBundleXThreadMonitor::getMaskOpacity(){
+int mitk::FiberBundleThreadMonitor::getMaskOpacity(){
   return m_monitorMaskOpacity;
 }
-void mitk::FiberBundleXThreadMonitor::setMaskOpacity(int opacity){
+void mitk::FiberBundleThreadMonitor::setMaskOpacity(int opacity){
   m_monitorMaskOpacity = opacity;
 }
 
 
 
 
 
-QString mitk::FiberBundleXThreadMonitor::getStatus(){
+QString mitk::FiberBundleThreadMonitor::getStatus(){
   return m_monitorStatus;
 }
-void mitk::FiberBundleXThreadMonitor::setStatus(QString status){
+void mitk::FiberBundleThreadMonitor::setStatus(QString status){
   m_statusMutex.lock();
   m_monitorStatus = status;
   m_statusMutex.unlock();
 }
-mitk::Point2D mitk::FiberBundleXThreadMonitor::getStatusPosition(){
+mitk::Point2D mitk::FiberBundleThreadMonitor::getStatusPosition(){
   return m_monitorStatusPosition;
 }
-void mitk::FiberBundleXThreadMonitor::setStatusPosition(mitk::Point2D pnt){
+void mitk::FiberBundleThreadMonitor::setStatusPosition(mitk::Point2D pnt){
   m_monitorStatusPosition[0] = pnt[0];
   m_monitorStatusPosition[1] = pnt[1];
 }
-int mitk::FiberBundleXThreadMonitor::getStatusOpacity(){
+int mitk::FiberBundleThreadMonitor::getStatusOpacity(){
   return m_monitorStatusOpacity;
 }
-void mitk::FiberBundleXThreadMonitor::setStatusOpacity(int opacity){
+void mitk::FiberBundleThreadMonitor::setStatusOpacity(int opacity){
   m_monitorStatusOpacity = opacity;
 }
 
 
-int mitk::FiberBundleXThreadMonitor::getStarted(){
+int mitk::FiberBundleThreadMonitor::getStarted(){
   return m_monitorStarted;
 }
 /* is thread safe :) */
-void mitk::FiberBundleXThreadMonitor::setStarted(int val)
+void mitk::FiberBundleThreadMonitor::setStarted(int val)
 {
   m_startedMutex.lock();
   m_monitorStarted = val;
   m_startedMutex.unlock();
 }
-mitk::Point2D mitk::FiberBundleXThreadMonitor::getStartedPosition(){
+mitk::Point2D mitk::FiberBundleThreadMonitor::getStartedPosition(){
   return m_monitorStartedPosition;
 }
-void mitk::FiberBundleXThreadMonitor::setStartedPosition(mitk::Point2D pnt){
+void mitk::FiberBundleThreadMonitor::setStartedPosition(mitk::Point2D pnt){
   m_monitorStartedPosition[0] = pnt[0];
   m_monitorStartedPosition[1] = pnt[1];
 }
-int mitk::FiberBundleXThreadMonitor::getStartedOpacity(){
+int mitk::FiberBundleThreadMonitor::getStartedOpacity(){
   return m_monitorStartedOpacity;
 }
-void mitk::FiberBundleXThreadMonitor::setStartedOpacity(int opacity){
+void mitk::FiberBundleThreadMonitor::setStartedOpacity(int opacity){
   m_monitorStartedOpacity = opacity;
 }
 
 
 
 
-int mitk::FiberBundleXThreadMonitor::getFinished(){
+int mitk::FiberBundleThreadMonitor::getFinished(){
   return m_monitorFinished;
 }
-void mitk::FiberBundleXThreadMonitor::setFinished(int val)
+void mitk::FiberBundleThreadMonitor::setFinished(int val)
 {
   m_finishedMutex.lock();
   m_monitorFinished = val;
   m_finishedMutex.unlock();
 }
-mitk::Point2D mitk::FiberBundleXThreadMonitor::getFinishedPosition(){
+mitk::Point2D mitk::FiberBundleThreadMonitor::getFinishedPosition(){
   return m_monitorFinishedPosition;
 }
-void mitk::FiberBundleXThreadMonitor::setFinishedPosition(mitk::Point2D pnt){
+void mitk::FiberBundleThreadMonitor::setFinishedPosition(mitk::Point2D pnt){
   m_monitorFinishedPosition[0] = pnt[0];
   m_monitorFinishedPosition[1] = pnt[1];
 }
-int mitk::FiberBundleXThreadMonitor::getFinishedOpacity(){
+int mitk::FiberBundleThreadMonitor::getFinishedOpacity(){
   return m_monitorFinishedOpacity;
 }
-void mitk::FiberBundleXThreadMonitor::setFinishedOpacity(int opacity){
+void mitk::FiberBundleThreadMonitor::setFinishedOpacity(int opacity){
   m_monitorFinishedOpacity = opacity;
 }
 
 
 
 
-int mitk::FiberBundleXThreadMonitor::getTerminated(){
+int mitk::FiberBundleThreadMonitor::getTerminated(){
   return m_monitorTerminated;
 }
-void mitk::FiberBundleXThreadMonitor::setTerminated(int val)
+void mitk::FiberBundleThreadMonitor::setTerminated(int val)
 {
   m_terminatedMutex.lock();
   m_monitorTerminated = val;
   m_terminatedMutex.unlock();
 }
-mitk::Point2D mitk::FiberBundleXThreadMonitor::getTerminatedPosition(){
+mitk::Point2D mitk::FiberBundleThreadMonitor::getTerminatedPosition(){
   return m_monitorTerminatedPosition;
 }
-void mitk::FiberBundleXThreadMonitor::setTerminatedPosition(mitk::Point2D pnt){
+void mitk::FiberBundleThreadMonitor::setTerminatedPosition(mitk::Point2D pnt){
   m_monitorTerminatedPosition[0] = pnt[0];
   m_monitorTerminatedPosition[1] = pnt[1];
 }
-int mitk::FiberBundleXThreadMonitor::getTerminatedOpacity(){
+int mitk::FiberBundleThreadMonitor::getTerminatedOpacity(){
   return m_monitorTerminatedOpacity;
 }
-void mitk::FiberBundleXThreadMonitor::setTerminatedOpacity(int opacity){
+void mitk::FiberBundleThreadMonitor::setTerminatedOpacity(int opacity){
   m_monitorTerminatedOpacity = opacity;
 }
 
 
 
 /* ESSENTIAL IMPLEMENTATION OF SUPERCLASS METHODS */
-void mitk::FiberBundleXThreadMonitor::UpdateOutputInformation()
+void mitk::FiberBundleThreadMonitor::UpdateOutputInformation()
 {
 
 }
-void mitk::FiberBundleXThreadMonitor::SetRequestedRegionToLargestPossibleRegion()
+void mitk::FiberBundleThreadMonitor::SetRequestedRegionToLargestPossibleRegion()
 {
 
 }
-bool mitk::FiberBundleXThreadMonitor::RequestedRegionIsOutsideOfTheBufferedRegion()
+bool mitk::FiberBundleThreadMonitor::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   return false;
 }
-bool mitk::FiberBundleXThreadMonitor::VerifyRequestedRegion()
+bool mitk::FiberBundleThreadMonitor::VerifyRequestedRegion()
 {
   return true;
 }
-void mitk::FiberBundleXThreadMonitor::SetRequestedRegion(const itk::DataObject *data )
+void mitk::FiberBundleThreadMonitor::SetRequestedRegion(const itk::DataObject *data )
 {
 
 }
 
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleThreadMonitor.h
similarity index 92%
rename from Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h
rename to Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleThreadMonitor.h
index 406e587d79..24f57d17a2 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundleThreadMonitor.h
@@ -1,154 +1,154 @@
 
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
-#ifndef _MITK_FiberBundleXThreadMonitor_H
-#define _MITK_FiberBundleXThreadMonitor_H
+#ifndef _MITK_FiberBundleThreadMonitor_H
+#define _MITK_FiberBundleThreadMonitor_H
 
 //includes for MITK datastructure
 #include "mitkBaseData.h"
 #include <MitkFiberTrackingExports.h>
 #include <QString>
 
 #include <QMutex>
 
 
 namespace mitk {
 
   /**
    * \brief Base Class for Fiber Bundles;   */
-  class Mitk FiberTracking_EXPORT FiberBundleXThreadMonitor : public BaseData
+  class Mitk FiberTracking_EXPORT FiberBundleThreadMonitor : public BaseData
   {
 
   public:
 
     // ======virtual methods must have======
     virtual void UpdateOutputInformation();
     virtual void SetRequestedRegionToLargestPossibleRegion();
     virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
     virtual bool VerifyRequestedRegion();
     virtual void SetRequestedRegion(const itk::DataObject *data );
     //=======================================
 
-    mitkClassMacro( FiberBundleXThreadMonitor, BaseData );
+    mitkClassMacro( FiberBundleThreadMonitor, BaseData );
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
 
     void setTextL1(QString);
     QString getTextL1();
 
     QString         getBracketOpen();
     mitk::Point2D   getBracketOpenPosition();
     void            setBracketOpenPosition(mitk::Point2D);
     int             getBracketOpenOpacity(); // range 0 - 10,  multiplicationfactor 0.1 (in mapper)
 
     QString         getBracketClose();
     mitk::Point2D   getBracketClosePosition();
     void            setBracketClosePosition(mitk::Point2D);
     int             getBracketCloseOpacity(); // range 0 - 10,  multiplicationfactor 0.1 (in mapper)
 
     QString         getHeading();
     mitk::Point2D   getHeadingPosition();
     void            setHeadingPosition(mitk::Point2D);
     int             getHeadingOpacity(); // range 0 - 10,  multiplicationfactor 0.1 (in mapper)
     void            setHeadingOpacity(int);
 
     QString         getMask();
     mitk::Point2D   getMaskPosition();
     void            setMaskPosition(mitk::Point2D);
     int             getMaskOpacity(); // multiplicationfactor 0.1 (in mapper)
     void            setMaskOpacity(int);
 
     QString         getStatus();
     void            setStatus(QString);
     mitk::Point2D   getStatusPosition();
     void            setStatusPosition(mitk::Point2D);
     int             getStatusOpacity(); // multiplicationfactor 0.1 (in mapper)
     void            setStatusOpacity(int);
 
     int             getStarted();
     void            setStarted(int);
     mitk::Point2D   getStartedPosition();
     void            setStartedPosition(mitk::Point2D);
     int             getStartedOpacity(); // multiplicationfactor 0.1 (in mapper)
     void            setStartedOpacity(int);
 
     int             getFinished();
     void            setFinished(int);
     mitk::Point2D   getFinishedPosition();
     void            setFinishedPosition(mitk::Point2D);
     int             getFinishedOpacity(); // multiplicationfactor 0.1 (in mapper)
     void            setFinishedOpacity(int);
 
     int             getTerminated();
     void            setTerminated(int);
     mitk::Point2D   getTerminatedPosition();
     void            setTerminatedPosition(mitk::Point2D);
     int             getTerminatedOpacity(); // multiplicationfactor 0.1 (in mapper)
     void            setTerminatedOpacity(int);
 
 
   protected:
-    FiberBundleXThreadMonitor();
-    virtual ~FiberBundleXThreadMonitor();
+    FiberBundleThreadMonitor();
+    virtual ~FiberBundleThreadMonitor();
 
 
   private:
     QString m_monitorBracketOpen;
     mitk::Point2D m_monitorBracketOpenPosition;
 
     QString m_monitorBracketClose;
     mitk::Point2D m_monitorBracketClosePosition;
 
     QString m_monitorHeading;
     mitk::Point2D m_monitorHeadingPosition;
     int m_monitorHeadingOpacity;
 
     QString m_monitorMask;
     mitk::Point2D m_monitorMaskPosition;
     int m_monitorMaskOpacity;
 
     QString m_monitorStatus;
     mitk::Point2D m_monitorStatusPosition;
     int m_monitorStatusOpacity;
 
     int m_monitorStarted;
     mitk::Point2D m_monitorStartedPosition;
     int m_monitorStartedOpacity;
 
     int m_monitorFinished;
     mitk::Point2D m_monitorFinishedPosition;
     int m_monitorFinishedOpacity;
 
     int m_monitorTerminated;
     mitk::Point2D m_monitorTerminatedPosition;
     int m_monitorTerminatedOpacity;
 
     QMutex m_startedMutex;
     QMutex m_finishedMutex;
     QMutex m_terminatedMutex;
     QMutex m_statusMutex;
 
 
 
 
 
   };
 
 } // namespace mitk
 
-#endif /*  _MITK_FiberBundleX_H */
+#endif /*  _MITK_FiberBundle_H */
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkTrackvis.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkTrackvis.cpp
similarity index 98%
rename from Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkTrackvis.cpp
rename to Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkTrackvis.cpp
index e63fdb8603..93bd176a51 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkTrackvis.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkTrackvis.cpp
@@ -1,237 +1,237 @@
 #include <mitkTrackvis.h>
 #include <vtkTransformPolyDataFilter.h>
 
 TrackVisFiberReader::TrackVisFiberReader()  { m_Filename = ""; m_FilePointer = NULL; }
 
 TrackVisFiberReader::~TrackVisFiberReader() { if (m_FilePointer) fclose( m_FilePointer ); }
 
 
 // Create a TrackVis file and store standard metadata. The file is ready to append fibers.
 // ---------------------------------------------------------------------------------------
-short TrackVisFiberReader::create(string filename , const mitk::FiberBundleX *fib)
+short TrackVisFiberReader::create(string filename , const mitk::FiberBundle *fib)
 {
     // prepare the header
     for(int i=0; i<3 ;i++)
     {
         if (fib->GetReferenceGeometry().IsNotNull())
         {
             m_Header.dim[i]            = fib->GetReferenceGeometry()->GetExtent(i);
             m_Header.voxel_size[i]     = fib->GetReferenceGeometry()->GetSpacing()[i];
             m_Header.origin[i]         = fib->GetReferenceGeometry()->GetOrigin()[i];
         }
         else
         {
             m_Header.dim[i]            = fib->GetGeometry()->GetExtent(i);
             m_Header.voxel_size[i]     = fib->GetGeometry()->GetSpacing()[i];
             m_Header.origin[i]         = fib->GetGeometry()->GetOrigin()[i];
         }
     }
     m_Header.n_scalars = 0;
     m_Header.n_properties = 0;
     sprintf(m_Header.voxel_order,"LPS");
     m_Header.image_orientation_patient[0] = 1.0;
     m_Header.image_orientation_patient[1] = 0.0;
     m_Header.image_orientation_patient[2] = 0.0;
     m_Header.image_orientation_patient[3] = 0.0;
     m_Header.image_orientation_patient[4] = 1.0;
     m_Header.image_orientation_patient[5] = 0.0;
     m_Header.pad1[0] = 0;
     m_Header.pad1[1] = 0;
     m_Header.pad2[0] = 0;
     m_Header.pad2[1] = 0;
     m_Header.invert_x = 0;
     m_Header.invert_y = 0;
     m_Header.invert_z = 0;
     m_Header.swap_xy = 0;
     m_Header.swap_yz = 0;
     m_Header.swap_zx = 0;
     m_Header.n_count = 0;
     m_Header.version = 1;
     m_Header.hdr_size = 1000;
 
     // write the header to the file
     m_FilePointer = fopen(filename.c_str(),"w+b");
     if (m_FilePointer == NULL)
     {
         printf("[ERROR] Unable to create file '%s'\n",filename.c_str());
         return 0;
     }
     sprintf(m_Header.id_string,"TRACK");
     if (fwrite((char*)&m_Header, 1, 1000, m_FilePointer) != 1000)
         MITK_ERROR << "TrackVis::create : Error occurding during writing fiber.";
 
     this->m_Filename = filename;
 
     return 1;
 }
 
 
 // Open an existing TrackVis file and read metadata information.
 // The file pointer is positiond at the beginning of fibers data
 // -------------------------------------------------------------
 short TrackVisFiberReader::open( string filename )
 {
     m_FilePointer = fopen(filename.c_str(),"r+b");
     if (m_FilePointer == NULL)
     {
         printf("[ERROR] Unable to open file '%s'\n",filename.c_str());
         return 0;
     }
     this->m_Filename = filename;
 
     return fread((char*)(&m_Header), 1, 1000, m_FilePointer);
 }
 
 
 
 // Append a fiber to the file
 // --------------------------
-short TrackVisFiberReader::append(const mitk::FiberBundleX *fib)
+short TrackVisFiberReader::append(const mitk::FiberBundle *fib)
 {
     vtkPolyData* poly = fib->GetFiberPolyData();
     for (int i=0; i<fib->GetNumFibers(); i++)
     {
         vtkCell* cell = poly->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         unsigned int     numSaved, pos = 0;
         //float* tmp = new float[3*maxSteps];
         std::vector< float > tmp;
         tmp.reserve(3*numPoints);
 
         numSaved = numPoints;
         for(unsigned int i=0; i<numSaved ;i++)
         {
             double* p = points->GetPoint(i);
 
             tmp[pos++] = p[0];
             tmp[pos++] = p[1];
             tmp[pos++] = p[2];
         }
 
         // write the coordinates to the file
         if ( fwrite((char*)&numSaved, 1, 4, m_FilePointer) != 4 )
         {
             printf( "[ERROR] Problems saving the fiber!\n" );
             return 1;
         }
         if ( fwrite((char*)&(tmp.front()), 1, 4*pos, m_FilePointer) != 4*pos )
         {
             printf( "[ERROR] Problems saving the fiber!\n" );
             return 1;
         }
     }
 
     return 0;
 }
 
 //// Read one fiber from the file
 //// ----------------------------
-short TrackVisFiberReader::read( mitk::FiberBundleX* fib )
+short TrackVisFiberReader::read( mitk::FiberBundle* fib )
 {
     int numPoints;
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     while (fread((char*)&numPoints, 1, 4, m_FilePointer)==4)
     {
         if ( numPoints <= 0 )
         {
             printf( "[ERROR] Trying to read a fiber with %d points!\n", numPoints );
             return -1;
         }
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
 
         float tmp[3];
         for(int i=0; i<numPoints; i++)
         {
             if (fread((char*)tmp, 1, 12, m_FilePointer) == 0)
                 MITK_ERROR << "TrackVis::read: Error during read.";
 
             vtkIdType id = vtkNewPoints->InsertNextPoint(tmp);
             container->GetPointIds()->InsertNextId(id);
         }
         vtkNewCells->InsertNextCell(container);
     }
 
     vtkSmartPointer<vtkPolyData> fiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     fiberPolyData->SetPoints(vtkNewPoints);
     fiberPolyData->SetLines(vtkNewCells);
 
     MITK_INFO << "Coordinate convention: " << m_Header.voxel_order;
 
     mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
     vtkSmartPointer< vtkMatrix4x4 > matrix = vtkSmartPointer< vtkMatrix4x4 >::New();
     matrix->Identity();
 
     if (m_Header.voxel_order[0]=='R')
         matrix->SetElement(0,0,-matrix->GetElement(0,0));
     if (m_Header.voxel_order[1]=='A')
         matrix->SetElement(1,1,-matrix->GetElement(1,1));
     if (m_Header.voxel_order[2]=='I')
         matrix->SetElement(2,2,-matrix->GetElement(2,2));
 
     geometry->SetIndexToWorldTransformByVtkMatrix(matrix);
 
     vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
     transformFilter->SetInputData(fiberPolyData);
     transformFilter->SetTransform(geometry->GetVtkTransform());
     transformFilter->Update();
     fib->SetFiberPolyData(transformFilter->GetOutput());
 
     mitk::Point3D origin;
     origin[0]=m_Header.origin[0];
     origin[1]=m_Header.origin[1];
     origin[2]=m_Header.origin[2];
     geometry->SetOrigin(origin);
 
     mitk::Vector3D spacing;
     spacing[0]=m_Header.voxel_size[0];
     spacing[1]=m_Header.voxel_size[1];
     spacing[2]=m_Header.voxel_size[2];
     geometry->SetSpacing(spacing);
 
     geometry->SetExtentInMM(0, m_Header.voxel_size[0]*m_Header.dim[0]);
     geometry->SetExtentInMM(1, m_Header.voxel_size[1]*m_Header.dim[1]);
     geometry->SetExtentInMM(2, m_Header.voxel_size[2]*m_Header.dim[2]);
 
     fib->SetReferenceGeometry(dynamic_cast<mitk::BaseGeometry*>(geometry.GetPointer()));
 
     return numPoints;
 }
 
 
 
 // Update the field in the header to the new FIBER TOTAL.
 // ------------------------------------------------------
 void TrackVisFiberReader::updateTotal( int totFibers )
 {
     fseek(m_FilePointer, 1000-12, SEEK_SET);
     if (fwrite((char*)&totFibers, 1, 4, m_FilePointer) != 4)
         MITK_ERROR << "[ERROR] Problems saving the fiber!";
 }
 
 
 void TrackVisFiberReader::writeHdr()
 {
     fseek(m_FilePointer, 0, SEEK_SET);
     if (fwrite((char*)&m_Header, 1, 1000, m_FilePointer) != 1000)
         MITK_ERROR << "[ERROR] Problems saving the fiber!";
 }
 
 
 // Close the TrackVis file, but keep the metadata in the header.
 // -------------------------------------------------------------
 void TrackVisFiberReader::close()
 {
     fclose(m_FilePointer);
     m_FilePointer = NULL;
 }
 
 bool TrackVisFiberReader::IsTransformValid()
 {
     if (fabs(m_Header.image_orientation_patient[0])<=0.001 || fabs(m_Header.image_orientation_patient[3])<=0.001 || fabs(m_Header.image_orientation_patient[5])<=0.001)
         return false;
     return true;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkTrackvis.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkTrackvis.h
similarity index 91%
rename from Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkTrackvis.h
rename to Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkTrackvis.h
index ab48c25597..69d90c0a97 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkTrackvis.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkTrackvis.h
@@ -1,82 +1,82 @@
 /*===================================================================
 
 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 _TRACKVIS
 #define _TRACKVIS
 
 #include <mitkCommon.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 #include <itkSize.h>
 
 using namespace std;
 
 // Structure to hold metadata of a TrackVis file
 // ---------------------------------------------
 struct TrackVis_header
 {
     char                id_string[6];
     short int           dim[3];
     float               voxel_size[3];
     float               origin[3];
     short int           n_scalars;
     char                scalar_name[10][20];
     short int           n_properties;
     char                property_name[10][20];
     char                reserved[508];
     char                voxel_order[4];
     char                pad2[4];
     float               image_orientation_patient[6];
     char                pad1[2];
     unsigned char       invert_x;
     unsigned char       invert_y;
     unsigned char       invert_z;
     unsigned char       swap_xy;
     unsigned char       swap_yz;
     unsigned char       swap_zx;
     int                 n_count;
     int                 version;
     int                 hdr_size;
 };
 
 // Class to handle TrackVis files.
 // -------------------------------
 class MitkFiberTracking_EXPORT TrackVisFiberReader
 {
 private:
     string              m_Filename;
     FILE*               m_FilePointer;
 
 public:
     TrackVis_header     m_Header;
 
-    short   create(string m_Filename, const mitk::FiberBundleX* fib);
+    short   create(string m_Filename, const mitk::FiberBundle* fib);
     short   open( string m_Filename );
-    short   read( mitk::FiberBundleX* fib );
-    short   append(const mitk::FiberBundleX* fib );
+    short   read( mitk::FiberBundle* fib );
+    short   append(const mitk::FiberBundle* fib );
     void    writeHdr();
     void    updateTotal( int totFibers );
     void    close();
     bool    IsTransformValid();
 
     TrackVisFiberReader();
     ~TrackVisFiberReader();
 };
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Interactions/mitkFiberBundleInteractor.cpp b/Modules/DiffusionImaging/FiberTracking/Interactions/mitkFiberBundleInteractor.cpp
index 29096f44b0..ba35536836 100644
--- a/Modules/DiffusionImaging/FiberTracking/Interactions/mitkFiberBundleInteractor.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Interactions/mitkFiberBundleInteractor.cpp
@@ -1,240 +1,240 @@
 /*===================================================================
 
 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 "mitkFiberBundleInteractor.h"
 #include <mitkPointOperation.h>
 #include <mitkPositionEvent.h>
 #include <mitkOperationEvent.h>
 #include <mitkDataNode.h>
 #include <mitkPointSet.h>
 #include <mitkInteractionConst.h>
 #include <mitkAction.h>
 #include <mitkProperties.h>
 #include <mitkUndoController.h>
 #include <mitkStateEvent.h>
 #include <mitkState.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include "mitkBaseRenderer.h"
 
 #include <vtkLinearTransform.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
 #include <vtkCamera.h>
 #include <vtkInteractorObserver.h>
 
 // #include <qapplication.h>
 
 mitk::FiberBundleInteractor::FiberBundleInteractor(const char * type, DataNode* dataNode)
   : Interactor(type, dataNode), m_LastPosition(0)
 {
   m_LastPoint.Fill(0);
 }
 
 mitk::FiberBundleInteractor::~FiberBundleInteractor()
 {}
 
 void mitk::FiberBundleInteractor::SelectFiber(int position)
 {
   MITK_INFO << "mitk::FiberBundleInteractor::SelectFiber " << position;
 
   mitk::PointSet* pointSet = dynamic_cast<mitk::PointSet*>(m_DataNode->GetData());
   if (pointSet == NULL)
     return;
   if (pointSet->GetSize()<=0)//if List is empty, then no select of a point can be done!
     return;
 
   mitk::Point3D noPoint;//dummyPoint... not needed anyway
   noPoint.Fill(0);
   mitk::PointOperation* doOp = new mitk::PointOperation(OpSELECTPOINT, noPoint, position);
   if (m_UndoEnabled)
   {
     mitk::PointOperation* undoOp = new mitk::PointOperation(OpDESELECTPOINT, noPoint, position);
     OperationEvent *operationEvent = new OperationEvent(pointSet, doOp, undoOp);
     m_UndoController->SetOperationEvent(operationEvent);
   }
   pointSet->ExecuteOperation(doOp);
 }
 
 void mitk::FiberBundleInteractor::DeselectAllFibers()
 {
   MITK_INFO << "mitk::FiberBundleInteractor::DeselectAllFibers ";
 
   mitk::PointSet* pointSet = dynamic_cast<mitk::PointSet*>(m_DataNode->GetData());
   if (pointSet == NULL)
     return;
 
   mitk::PointSet::DataType *itkPointSet = pointSet->GetPointSet();
   mitk::PointSet::PointsContainer::Iterator it, end;
   end = itkPointSet->GetPoints()->End();
 
   for (it = itkPointSet->GetPoints()->Begin(); it != end; it++)
   {
     int position = it->Index();
     PointSet::PointDataType pointData = {0, false, PTUNDEFINED};
     itkPointSet->GetPointData(position, &pointData);
     if ( pointData.selected )//then declare an operation which unselects this point; UndoOperation as well!
     {
       mitk::Point3D noPoint;
       noPoint.Fill(0);
 
       mitk::PointOperation* doOp = new mitk::PointOperation(OpDESELECTPOINT, noPoint, position);
       if (m_UndoEnabled)
       {
         mitk::PointOperation* undoOp = new mitk::PointOperation(OpSELECTPOINT, noPoint, position);
         OperationEvent *operationEvent = new OperationEvent(pointSet, doOp, undoOp);
         m_UndoController->SetOperationEvent(operationEvent);
       }
       pointSet->ExecuteOperation(doOp);
     }
   }
 }
 
 float mitk::FiberBundleInteractor::CanHandleEvent(StateEvent const* stateEvent) const
     //go through all points and check, if the given Point lies near a line
 {
 
   mitk::PositionEvent const  *posEvent = dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
   //checking if a keyevent can be handled:
   if (posEvent == NULL)
   {
     //check, if the current state has a transition waiting for that key event.
     if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL)
     {
       return 0.5;
     }
     else
     {
       return 0;
     }
   }
 
   //Mouse event handling:
   //on MouseMove do nothing! reimplement if needed differently
   if (stateEvent->GetEvent()->GetType() == mitk::Type_MouseMove)
   {
     return 0;
   }
 
   //check on the right data-type
-  mitk::FiberBundleX* bundle = dynamic_cast<mitk::FiberBundleX*>(m_DataNode->GetData());
+  mitk::FiberBundle* bundle = dynamic_cast<mitk::FiberBundle*>(m_DataNode->GetData());
   if (bundle == NULL)
     return 0;
 
   return 0.5;
 
 }
 
 
 bool mitk::FiberBundleInteractor::ExecuteAction( Action* action, mitk::StateEvent const* stateEvent )
 {
   bool ok = false;//for return type bool
 
   //checking corresponding Data; has to be a PointSet or a subclass
-  mitk::FiberBundleX* bundle = dynamic_cast<mitk::FiberBundleX*>(m_DataNode->GetData());
+  mitk::FiberBundle* bundle = dynamic_cast<mitk::FiberBundle*>(m_DataNode->GetData());
   if (bundle == NULL)
     return false;
 
   // Get Event and extract renderer
   vtkRenderWindowInteractor *renderWindowInteractor = NULL;
 
   /*Each case must watch the type of the event!*/
   switch (action->GetActionId())
   {
   case AcCHECKHOVERING:
     {
 
 //      QApplication::restoreOverrideCursor();
 
       // Re-enable VTK interactor (may have been disabled previously)
       if ( renderWindowInteractor != NULL )
       {
         renderWindowInteractor->Enable();
       }
 
       const DisplayPositionEvent *dpe =
           dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
 
       // Check if we have a DisplayPositionEvent
       if ( dpe != NULL )
       {
 
         // Check if an object is present at the current mouse position
         DataNode *pickedNode = dpe->GetPickedObjectNode();
         if ( pickedNode != m_DataNode )
         {
 //          if(pickedNode == 0)
 //            MITK_INFO << "picked node is NULL, no hovering";
 //          else
 //            MITK_INFO << "wrong node: " << pickedNode;
 
           this->HandleEvent( new StateEvent( EIDNOFIGUREHOVER ) );
 
           ok = true;
           break;
         }
 
         m_CurrentPickedPoint = dpe->GetWorldPosition();
         m_CurrentPickedDisplayPoint = dpe->GetDisplayPosition();
 
 //        QApplication::setOverrideCursor(Qt::UpArrowCursor);
         this->HandleEvent( new StateEvent( EIDFIGUREHOVER ) );
 
       }
 
       ok = true;
       break;
     }
     break;
     //  case AcSELECTPICKEDOBJECT:
     //    MITK_INFO << "FiberBundleInteractor AcSELECTPICKEDOBJECT";
 
     //    break;
     //  case AcDESELECTALL:
     //    MITK_INFO << "FiberBundleInteractor AcDESELECTALL";
     //    break;
   case AcREMOVE:
     {
       MITK_INFO << "picking fiber at " << m_CurrentPickedPoint;
 
 //      QmitkStdMultiWidgetEditor::Pointer multiWidgetEditor;
 //      multiWidgetEditor->GetStdMultiWidget()->GetRenderWindow1()->GetRenderer()->GetSliceNavigationController()->SelectSliceByPoint(
 //          m_CurrentPickedPoint);
 
       BaseRenderer* renderer = mitk::BaseRenderer::GetByName("stdmulti.widget1");
       renderer->GetSliceNavigationController()->SelectSliceByPoint(
           m_CurrentPickedPoint);
 
       renderer = mitk::BaseRenderer::GetByName("stdmulti.widget2");
       renderer->GetSliceNavigationController()->SelectSliceByPoint(
           m_CurrentPickedPoint);
 
       renderer = mitk::BaseRenderer::GetByName("stdmulti.widget3");
       renderer->GetSliceNavigationController()->SelectSliceByPoint(
           m_CurrentPickedPoint);
 //      mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
     break;
   default:
     return Superclass::ExecuteAction( action, stateEvent );
   }
 
   return ok;
 
 }
 
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp b/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleThreadMonitorMapper3D.cpp
similarity index 82%
rename from Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp
rename to Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleThreadMonitorMapper3D.cpp
index cff4f67bb3..4402c2d72a 100644
--- a/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleThreadMonitorMapper3D.cpp
@@ -1,206 +1,206 @@
 /*===================================================================
 
 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 "mitkFiberBundleXThreadMonitorMapper3D.h"
+#include "mitkFiberBundleThreadMonitorMapper3D.h"
 #include <mitkProperties.h>
 #include <vtkPropAssembly.h>
 //#include <vtkTextActor.h>
 #include <vtkTextProperty.h>
 
 
 
 
-mitk::FiberBundleXThreadMonitorMapper3D::FiberBundleXThreadMonitorMapper3D()
+mitk::FiberBundleThreadMonitorMapper3D::FiberBundleThreadMonitorMapper3D()
 : m_FiberMonitorMapper(vtkSmartPointer<vtkPolyDataMapper>::New())
 , m_TextActorClose(vtkSmartPointer<vtkTextActor>::New())
 , m_TextActorOpen(vtkSmartPointer<vtkTextActor>::New())
 , m_TextActorHeading(vtkSmartPointer<vtkTextActor>::New())
 , m_TextActorMask(vtkSmartPointer<vtkTextActor>::New())
 , m_TextActorStatus(vtkSmartPointer<vtkTextActor>::New())
 , m_TextActorStarted(vtkSmartPointer<vtkTextActor>::New())
 , m_TextActorFinished(vtkSmartPointer<vtkTextActor>::New())
 , m_TextActorTerminated(vtkSmartPointer<vtkTextActor>::New())
 , m_FiberAssembly(vtkPropAssembly::New())
 , m_lastModifiedMonitorNodeTime(-1)
 {
   m_FiberAssembly->AddPart(m_TextActorClose);
   m_FiberAssembly->AddPart(m_TextActorOpen);
   m_FiberAssembly->AddPart(m_TextActorHeading);
   m_FiberAssembly->AddPart(m_TextActorMask);
   m_FiberAssembly->AddPart(m_TextActorStatus);
   m_FiberAssembly->AddPart(m_TextActorStarted);
   m_FiberAssembly->AddPart(m_TextActorFinished);
   m_FiberAssembly->AddPart(m_TextActorTerminated);
 
 }
 
 
-mitk::FiberBundleXThreadMonitorMapper3D::~FiberBundleXThreadMonitorMapper3D()
+mitk::FiberBundleThreadMonitorMapper3D::~FiberBundleThreadMonitorMapper3D()
 {
   m_FiberAssembly->Delete();
 }
 
 
-const mitk::FiberBundleXThreadMonitor* mitk::FiberBundleXThreadMonitorMapper3D::GetInput()
+const mitk::FiberBundleThreadMonitor* mitk::FiberBundleThreadMonitorMapper3D::GetInput()
 {
-  return static_cast<const mitk::FiberBundleXThreadMonitor * > ( GetDataNode()->GetData() );
+  return static_cast<const mitk::FiberBundleThreadMonitor * > ( GetDataNode()->GetData() );
 }
 
 
 /*
  This method is called once the mapper gets new input,
  for UI rotation or changes in colorcoding this method is NOT called
  */
-void mitk::FiberBundleXThreadMonitorMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
+void mitk::FiberBundleThreadMonitorMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if ( !visible ) return;
 
   const DataNode *node = this->GetDataNode();
 
   if (m_lastModifiedMonitorNodeTime >= node->GetMTime())
     return;
 
   m_lastModifiedMonitorNodeTime = node->GetMTime();
 
   //  MITK_INFO << m_LastUpdateTime;
-  FiberBundleXThreadMonitor* monitor = dynamic_cast<FiberBundleXThreadMonitor * > ( GetDataNode()->GetData() );
+  FiberBundleThreadMonitor* monitor = dynamic_cast<FiberBundleThreadMonitor * > ( GetDataNode()->GetData() );
 
 //  m_TextActor->SetInput( monitor->getTextL1().toStdString().c_str() );
   m_TextActorClose->SetInput( monitor->getBracketClose().toStdString().c_str() );
   vtkTextProperty* tpropClose = m_TextActorClose->GetTextProperty();
   //tprop->SetFontFamilyToArial ();
   //tprop->SetLineSpacing(1.0);
   tpropClose->SetFontSize(16);
   tpropClose->SetColor(0.85,0.8,0.8);
   m_TextActorClose->SetDisplayPosition( monitor->getBracketClosePosition()[0], monitor->getBracketClosePosition()[1] );
   //m_TextActorClose->Modified();
 
 
   m_TextActorOpen->SetInput( monitor->getBracketOpen().toStdString().c_str() );
   vtkTextProperty* tpropOpen = m_TextActorOpen->GetTextProperty();
   //tprop->SetFontFamilyToArial ();
   //tprop->SetLineSpacing(1.0);
   tpropOpen->SetFontSize(16);
   tpropOpen->SetColor(0.85,0.8,0.8);
   m_TextActorOpen->SetDisplayPosition( monitor->getBracketOpenPosition()[0], monitor->getBracketOpenPosition()[1] );
   //m_TextActorOpen->Modified();
 
 
   m_TextActorHeading->SetInput(  monitor->getHeading().toStdString().c_str() );
   vtkTextProperty* tpropHeading = m_TextActorHeading->GetTextProperty();
   tpropHeading->SetFontSize(12);
   tpropHeading->SetOpacity( monitor->getHeadingOpacity() * 0.1 );
   tpropHeading->SetColor(0.85,0.8,0.8);
   m_TextActorHeading->SetDisplayPosition( monitor->getHeadingPosition()[0], monitor->getHeadingPosition()[1] );
   //m_TextActorHeading->Modified();
 
 
   m_TextActorMask->SetInput(  monitor->getMask().toStdString().c_str() );
   vtkTextProperty* tpropMask = m_TextActorMask->GetTextProperty();
   tpropMask->SetFontSize(12);
   tpropMask->SetOpacity( monitor->getMaskOpacity() * 0.1 );
   tpropMask->SetColor(1.0,1.0,1.0);
   m_TextActorMask->SetDisplayPosition( monitor->getMaskPosition()[0], monitor->getMaskPosition()[1] );
   //m_TextActorHeading->Modified();
 
 
   m_TextActorStatus->SetInput(monitor->getStatus().toStdString().c_str());
   vtkTextProperty* tpropStatus = m_TextActorStatus->GetTextProperty();
   tpropStatus->SetFontSize(10);
   tpropStatus->SetOpacity( monitor->getStatusOpacity() * 0.1 );
   tpropStatus->SetColor(0.85,0.8,0.8);
   m_TextActorStatus->SetDisplayPosition( monitor->getStatusPosition()[0], monitor->getStatusPosition()[1] );
   //m_TextActorStatus->Modified();
 
   m_TextActorStarted->SetInput(QString::number(monitor->getStarted()).toStdString().c_str());
   vtkTextProperty* tpropStarted = m_TextActorStarted->GetTextProperty();
   tpropStarted->SetFontSize(12);
   tpropStarted->SetOpacity( monitor->getStartedOpacity() * 0.1 );
   tpropStarted->SetColor(0.0,1.0,0.0);
   m_TextActorStarted->SetDisplayPosition( monitor->getStartedPosition()[0], monitor->getStartedPosition()[1] );
   //m_TextActorStarted->Modified();
 
   m_TextActorFinished->SetInput(QString::number(monitor->getFinished()).toStdString().c_str());
   vtkTextProperty* tpropFinished = m_TextActorFinished->GetTextProperty();
   tpropFinished->SetFontSize(12);
   tpropFinished->SetOpacity( monitor->getFinishedOpacity() * 0.1 );
   tpropFinished->SetColor(1.0,1.0,1.0);
   m_TextActorFinished->SetDisplayPosition( monitor->getFinishedPosition()[0], monitor->getFinishedPosition()[1] );
   //m_TextActorFinished->Modified();
 
   m_TextActorTerminated->SetInput(QString::number(monitor->getTerminated()).toStdString().c_str());
   vtkTextProperty* tpropTerminated = m_TextActorTerminated->GetTextProperty();
   tpropTerminated->SetFontSize(12);
   tpropTerminated->SetOpacity( monitor->getTerminatedOpacity() * 0.1 );
   tpropTerminated->SetColor(1.0,1.0,1.0);
   m_TextActorTerminated->SetDisplayPosition( monitor->getTerminatedPosition()[0], monitor->getTerminatedPosition()[1] );
   //m_TextActorTerminated->Modified();
 
 
   // Calculate time step of the input data for the specified renderer (integer value)
   // this method is implemented in mitkMapper
 //  this->CalculateTimeStep( renderer );
 
 
 }
 
 
-void mitk::FiberBundleXThreadMonitorMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
+void mitk::FiberBundleThreadMonitorMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
 
-//  MITK_INFO << "FiberBundleXxXXMapper3D()SetDefaultProperties";
+//  MITK_INFO << "FiberBundlexXXMapper3D()SetDefaultProperties";
 
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 
 
 
 }
 
-vtkProp* mitk::FiberBundleXThreadMonitorMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
+vtkProp* mitk::FiberBundleThreadMonitorMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
-  //MITK_INFO << "FiberBundleXxXXMapper3D()GetVTKProp";
+  //MITK_INFO << "FiberBundlexXXMapper3D()GetVTKProp";
   //this->GenerateData();
   return m_FiberAssembly;
 
 }
 
-void mitk::FiberBundleXThreadMonitorMapper3D::ApplyProperties(mitk::BaseRenderer* renderer)
+void mitk::FiberBundleThreadMonitorMapper3D::ApplyProperties(mitk::BaseRenderer* renderer)
 {
-//  MITK_INFO << "FiberBundleXXXXMapper3D ApplyProperties(renderer)";
+//  MITK_INFO << "FiberBundleXXXMapper3D ApplyProperties(renderer)";
 }
 
-void mitk::FiberBundleXThreadMonitorMapper3D::UpdateVtkObjects()
+void mitk::FiberBundleThreadMonitorMapper3D::UpdateVtkObjects()
 {
-//  MITK_INFO << "FiberBundleXxxXMapper3D UpdateVtkObjects()";
+//  MITK_INFO << "FiberBundlexxXMapper3D UpdateVtkObjects()";
 
 
 }
 
-void mitk::FiberBundleXThreadMonitorMapper3D::SetVtkMapperImmediateModeRendering(vtkMapper *)
+void mitk::FiberBundleThreadMonitorMapper3D::SetVtkMapperImmediateModeRendering(vtkMapper *)
 {
 
 
 
 }
 
 
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXThreadMonitorMapper3D.h b/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleThreadMonitorMapper3D.h
similarity index 79%
rename from Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXThreadMonitorMapper3D.h
rename to Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleThreadMonitorMapper3D.h
index 270137adc9..653a9a0f21 100644
--- a/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleXThreadMonitorMapper3D.h
+++ b/Modules/DiffusionImaging/FiberTracking/Rendering/mitkFiberBundleThreadMonitorMapper3D.h
@@ -1,90 +1,90 @@
 /*===================================================================
 
 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 FiberBundleXThreadMonitorMapper3D_H_HEADER_INCLUDED
-#define FiberBundleXThreadMonitorMapper3D_H_HEADER_INCLUDED
+#ifndef FiberBundleThreadMonitorMapper3D_H_HEADER_INCLUDED
+#define FiberBundleThreadMonitorMapper3D_H_HEADER_INCLUDED
 
 //#include <mitkBaseData.h> //?? necessary
 #include <MitkFiberTrackingExports.h>
 #include <mitkVtkMapper.h>
-#include <mitkFiberBundleXThreadMonitor.h>
+#include <mitkFiberBundleThreadMonitor.h>
 
 #include <vtkSmartPointer.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkTextActor.h>
 
 
 
 class vtkPropAssembly;
 
 
 
 
 namespace mitk {
 
   //##Documentation
-  //## @brief Mapper for FiberBundleX
+  //## @brief Mapper for FiberBundle
   //## @ingroup Mapper
 
-  class MitkFiberTracking_EXPORT FiberBundleXThreadMonitorMapper3D : public VtkMapper
+  class MitkFiberTracking_EXPORT FiberBundleThreadMonitorMapper3D : public VtkMapper
   {
   public:
 
-    mitkClassMacro(FiberBundleXThreadMonitorMapper3D, VtkMapper);
+    mitkClassMacro(FiberBundleThreadMonitorMapper3D, VtkMapper);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     //========== essential implementation for 3D mapper ========
-    const FiberBundleXThreadMonitor* GetInput();
+    const FiberBundleThreadMonitor* GetInput();
     virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer); //looks like depricated.. should be replaced bz GetViewProp()
     static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false );
     virtual void ApplyProperties(mitk::BaseRenderer* renderer);
     static void SetVtkMapperImmediateModeRendering(vtkMapper *mapper);
     virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
     //=========================================================
 
   protected:
 
-    FiberBundleXThreadMonitorMapper3D();
-    virtual ~FiberBundleXThreadMonitorMapper3D();
+    FiberBundleThreadMonitorMapper3D();
+    virtual ~FiberBundleThreadMonitorMapper3D();
 
     void UpdateVtkObjects(); //??
 
 
     vtkSmartPointer<vtkPolyDataMapper> m_FiberMonitorMapper;
     vtkSmartPointer<vtkTextActor> m_TextActorClose;
     vtkSmartPointer<vtkTextActor> m_TextActorOpen;
     vtkSmartPointer<vtkTextActor> m_TextActorHeading;
     vtkSmartPointer<vtkTextActor> m_TextActorMask;
     vtkSmartPointer<vtkTextActor> m_TextActorStatus;
     vtkSmartPointer<vtkTextActor> m_TextActorStarted;
     vtkSmartPointer<vtkTextActor> m_TextActorFinished;
     vtkSmartPointer<vtkTextActor> m_TextActorTerminated;
     vtkPropAssembly* m_FiberAssembly;
 
   private:
     double m_lastModifiedMonitorNodeTime;
 
   };
 
 } // end namespace mitk
 
 
 
 
-#endif /* FiberBundleXMapper3D_H_HEADER_INCLUDED */
+#endif /* FiberBundleMapper3D_H_HEADER_INCLUDED */
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/CMakeLists.txt b/Modules/DiffusionImaging/FiberTracking/Testing/CMakeLists.txt
index 3b03f3f67d..712d4ecde0 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/CMakeLists.txt
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/CMakeLists.txt
@@ -1,14 +1,14 @@
 MITK_CREATE_MODULE_TESTS()
 
 if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
-mitkAddCustomModuleTest(mitkFiberBundleXReaderWriterTest mitkFiberBundleXReaderWriterTest)
+mitkAddCustomModuleTest(mitkFiberBundleReaderWriterTest mitkFiberBundleReaderWriterTest)
 mitkAddCustomModuleTest(mitkGibbsTrackingTest mitkGibbsTrackingTest ${MITK_DATA_DIR}/DiffusionImaging/qBallImage.qbi ${MITK_DATA_DIR}/DiffusionImaging/diffusionImageMask.nrrd ${MITK_DATA_DIR}/DiffusionImaging/gibbsTrackingParameters.gtp ${MITK_DATA_DIR}/DiffusionImaging/gibbsTractogram.fib)
 mitkAddCustomModuleTest(mitkStreamlineTrackingTest mitkStreamlineTrackingTest ${MITK_DATA_DIR}/DiffusionImaging/tensorImage.dti ${MITK_DATA_DIR}/DiffusionImaging/diffusionImageMask.nrrd ${MITK_DATA_DIR}/DiffusionImaging/streamlineTractogramInterpolated.fib)
 #mitkAddCustomModuleTest(mitkPeakExtractionTest mitkPeakExtractionTest ${MITK_DATA_DIR}/DiffusionImaging/qBallImage_SHCoeffs.nrrd ${MITK_DATA_DIR}/DiffusionImaging/diffusionImageMask.nrrd ${MITK_DATA_DIR}/DiffusionImaging/qBallImage_VectorField.fib)
 mitkAddCustomModuleTest(mitkLocalFiberPlausibilityTest mitkLocalFiberPlausibilityTest ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX.fib ${MITK_DATA_DIR}/DiffusionImaging/LDFP_GT_DIRECTION_0.nrrd ${MITK_DATA_DIR}/DiffusionImaging/LDFP_GT_DIRECTION_1.nrrd ${MITK_DATA_DIR}/DiffusionImaging/LDFP_ERROR_IMAGE.nrrd ${MITK_DATA_DIR}/DiffusionImaging/LDFP_NUM_DIRECTIONS.nrrd ${MITK_DATA_DIR}/DiffusionImaging/LDFP_VECTOR_FIELD.fib ${MITK_DATA_DIR}/DiffusionImaging/LDFP_ERROR_IMAGE_IGNORE.nrrd)
 mitkAddCustomModuleTest(mitkFiberTransformationTest mitkFiberTransformationTest ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_transformed.fib)
 mitkAddCustomModuleTest(mitkFiberExtractionTest mitkFiberExtractionTest ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_extracted.fib ${MITK_DATA_DIR}/DiffusionImaging/ROI1.pf ${MITK_DATA_DIR}/DiffusionImaging/ROI2.pf ${MITK_DATA_DIR}/DiffusionImaging/ROI3.pf ${MITK_DATA_DIR}/DiffusionImaging/ROIIMAGE.nrrd ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_inside.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_outside.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_passing-mask.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_ending-in-mask.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_subtracted.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_added.fib)
 mitkAddCustomModuleTest(mitkFiberGenerationTest mitkFiberGenerationTest ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/Fiducial_0.pf ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/Fiducial_1.pf ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/Fiducial_2.pf ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/uniform.fib ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/gaussian.fib)
 mitkAddCustomModuleTest(mitkFiberfoxSignalGenerationTest mitkFiberfoxSignalGenerationTest ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/gaussian.fib ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickBall_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickAstrosticks_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickDot_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/TensorBall_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickTensorBall_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickTensorBallAstrosticks_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/gibbsringing.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/ghost.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/aliasing.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/eddy.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/linearmotion.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/randommotion.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/spikes.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/riciannoise.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/chisquarenoise.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/distortions.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/Fieldmap.nrrd)
 mitkAddCustomModuleTest(mitkFiberfoxAddArtifactsToDwiTest mitkFiberfoxAddArtifactsToDwiTest)
 ENDIF()
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/files.cmake b/Modules/DiffusionImaging/FiberTracking/Testing/files.cmake
index 5ac537c171..a71e6776fa 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/files.cmake
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/files.cmake
@@ -1,14 +1,14 @@
 SET(MODULE_CUSTOM_TESTS
-  mitkFiberBundleXReaderWriterTest.cpp
+  mitkFiberBundleReaderWriterTest.cpp
   mitkGibbsTrackingTest.cpp
   mitkStreamlineTrackingTest.cpp
   mitkPeakExtractionTest.cpp
   mitkLocalFiberPlausibilityTest.cpp
   mitkFiberTransformationTest.cpp
   mitkFiberExtractionTest.cpp
   mitkFiberGenerationTest.cpp
   mitkFiberfoxSignalGenerationTest.cpp
   mitkFiberfoxAddArtifactsToDwiTest.cpp
 )
 
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberBundleXReaderWriterTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberBundleReaderWriterTest.cpp
similarity index 79%
rename from Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberBundleXReaderWriterTest.cpp
rename to Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberBundleReaderWriterTest.cpp
index 6e048ee7fe..1105138c17 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberBundleXReaderWriterTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberBundleReaderWriterTest.cpp
@@ -1,71 +1,71 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkTestingMacros.h"
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <mitkBaseData.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkTestingConfig.h>
 #include <mitkIOUtil.h>
 
 #include "mitkTestFixture.h"
 
-class mitkFiberBundleXReaderWriterTestSuite : public mitk::TestFixture
+class mitkFiberBundleReaderWriterTestSuite : public mitk::TestFixture
 {
 
-  CPPUNIT_TEST_SUITE(mitkFiberBundleXReaderWriterTestSuite);
+  CPPUNIT_TEST_SUITE(mitkFiberBundleReaderWriterTestSuite);
   MITK_TEST(Equal_SaveLoad_ReturnsTrue);
   CPPUNIT_TEST_SUITE_END();
 
 private:
 
   /** Members used inside the different (sub-)tests. All members are initialized via setUp().*/
-  mitk::FiberBundleX::Pointer fib1;
-  mitk::FiberBundleX::Pointer fib2;
+  mitk::FiberBundle::Pointer fib1;
+  mitk::FiberBundle::Pointer fib2;
 
 public:
 
   void setUp()
   {
     fib1 = NULL;
     fib2 = NULL;
 
     std::string filename = GetTestDataFilePath("DiffusionImaging/fiberBundleX.fib");
 
     std::vector<mitk::BaseData::Pointer> fibInfile = mitk::IOUtil::Load( filename);
     mitk::BaseData::Pointer baseData = fibInfile.at(0);
 
-    fib1 = dynamic_cast<mitk::FiberBundleX*>(baseData.GetPointer());
+    fib1 = dynamic_cast<mitk::FiberBundle*>(baseData.GetPointer());
   }
 
   void tearDown()
   {
     fib1 = NULL;
     fib2 = NULL;
   }
 
   void Equal_SaveLoad_ReturnsTrue()
   {
     mitk::IOUtil::Save(fib1.GetPointer(), std::string(MITK_TEST_OUTPUT_DIR)+"/writerTest.fib");
     std::vector<mitk::BaseData::Pointer> baseData = mitk::IOUtil::Load(std::string(MITK_TEST_OUTPUT_DIR)+"/writerTest.fib");
-    fib2 = dynamic_cast<mitk::FiberBundleX*>(baseData[0].GetPointer());
+    fib2 = dynamic_cast<mitk::FiberBundle*>(baseData[0].GetPointer());
     CPPUNIT_ASSERT_MESSAGE("Should be equal", fib1->Equals(fib2));
     //MITK_ASSERT_EQUAL(fib1, fib2, "A saved and re-loaded file should be equal");
   }
 
 };
 
-MITK_TEST_SUITE_REGISTRATION(mitkFiberBundleXReaderWriter)
+MITK_TEST_SUITE_REGISTRATION(mitkFiberBundleReaderWriter)
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberExtractionTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberExtractionTest.cpp
index 847be12cb8..dc6fe5cc97 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberExtractionTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberExtractionTest.cpp
@@ -1,109 +1,109 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkTestingMacros.h>
 #include <mitkIOUtil.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <mitkPlanarFigure.h>
 #include <mitkPlanarFigureComposite.h>
 #include <mitkImageCast.h>
 
 #include <vtkDebugLeaks.h>
 
 /**Documentation
  *  Test if fiber transfortaiom methods work correctly
  */
 int mitkFiberExtractionTest(int argc, char* argv[])
 {
     MITK_TEST_BEGIN("mitkFiberExtractionTest");
 
     /// \todo Fix VTK memory leaks. Bug 18097.
     vtkDebugLeaks::SetExitError(0);
 
     MITK_INFO << "argc: " << argc;
     MITK_TEST_CONDITION_REQUIRED(argc==13,"check for input data")
 
             try{
-        mitk::FiberBundleX::Pointer groundTruthFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[1])->GetData());
-        mitk::FiberBundleX::Pointer testFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
+        mitk::FiberBundle::Pointer groundTruthFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[1])->GetData());
+        mitk::FiberBundle::Pointer testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
 
         // test planar figure based extraction
         mitk::PlanarFigure::Pointer pf1 = dynamic_cast<mitk::PlanarFigure*>(mitk::IOUtil::LoadDataNode(argv[3])->GetData());
         mitk::PlanarFigure::Pointer pf2 = dynamic_cast<mitk::PlanarFigure*>(mitk::IOUtil::LoadDataNode(argv[4])->GetData());
         mitk::PlanarFigure::Pointer pf3 = dynamic_cast<mitk::PlanarFigure*>(mitk::IOUtil::LoadDataNode(argv[5])->GetData());
 
         MITK_INFO << "TEST1";
 
         mitk::PlanarFigureComposite::Pointer pfc1 = mitk::PlanarFigureComposite::New();
         pfc1->setOperationType(mitk::PFCOMPOSITION_AND_OPERATION);
         pfc1->addPlanarFigure(dynamic_cast<mitk::BaseData*>(pf2.GetPointer()));
         pfc1->addPlanarFigure(dynamic_cast<mitk::BaseData*>(pf3.GetPointer()));
         MITK_INFO << "TEST2";
         mitk::PlanarFigureComposite::Pointer pfc2 = mitk::PlanarFigureComposite::New();
         pfc2->setOperationType(mitk::PFCOMPOSITION_OR_OPERATION);
         pfc2->addPlanarFigure(dynamic_cast<mitk::BaseData*>(pf1.GetPointer()));
         pfc2->addPlanarFigure(pfc1.GetPointer());
         MITK_INFO << "TEST3";
-        mitk::FiberBundleX::Pointer extractedFibs = groundTruthFibs->ExtractFiberSubset(pfc2);
+        mitk::FiberBundle::Pointer extractedFibs = groundTruthFibs->ExtractFiberSubset(pfc2);
         MITK_INFO << "TEST4";
         MITK_TEST_CONDITION_REQUIRED(extractedFibs->Equals(testFibs),"check planar figure extraction")
 
                 MITK_INFO << "TEST5";
         // test subtraction and addition
-        mitk::FiberBundleX::Pointer notExtractedFibs = groundTruthFibs->SubtractBundle(extractedFibs);
+        mitk::FiberBundle::Pointer notExtractedFibs = groundTruthFibs->SubtractBundle(extractedFibs);
 
         MITK_INFO << argv[11];
-        testFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[11])->GetData());
+        testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[11])->GetData());
         MITK_TEST_CONDITION_REQUIRED(notExtractedFibs->Equals(testFibs),"check bundle subtraction")
 
-        mitk::FiberBundleX::Pointer joinded = extractedFibs->AddBundle(notExtractedFibs);
-        testFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[12])->GetData());
+        mitk::FiberBundle::Pointer joinded = extractedFibs->AddBundle(notExtractedFibs);
+        testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[12])->GetData());
         MITK_TEST_CONDITION_REQUIRED(joinded->Equals(testFibs),"check bundle addition")
 
         // test binary image based extraction
         mitk::Image::Pointer mitkRoiImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[6])->GetData());
         typedef itk::Image< unsigned char, 3 >    itkUCharImageType;
         itkUCharImageType::Pointer itkRoiImage = itkUCharImageType::New();
         mitk::CastToItkImage(mitkRoiImage, itkRoiImage);
 
-        mitk::FiberBundleX::Pointer inside = groundTruthFibs->RemoveFibersOutside(itkRoiImage, false);
+        mitk::FiberBundle::Pointer inside = groundTruthFibs->RemoveFibersOutside(itkRoiImage, false);
         mitk::IOUtil::SaveBaseData(inside, mitk::IOUtil::GetTempPath()+"inside.fib");
-        mitk::FiberBundleX::Pointer outside = groundTruthFibs->RemoveFibersOutside(itkRoiImage, true);
+        mitk::FiberBundle::Pointer outside = groundTruthFibs->RemoveFibersOutside(itkRoiImage, true);
         mitk::IOUtil::SaveBaseData(outside, mitk::IOUtil::GetTempPath()+"outside.fib");
-        mitk::FiberBundleX::Pointer passing = groundTruthFibs->ExtractFiberSubset(itkRoiImage, true);
+        mitk::FiberBundle::Pointer passing = groundTruthFibs->ExtractFiberSubset(itkRoiImage, true);
         mitk::IOUtil::SaveBaseData(passing, mitk::IOUtil::GetTempPath()+"passing.fib");
-        mitk::FiberBundleX::Pointer ending = groundTruthFibs->ExtractFiberSubset(itkRoiImage, false);
+        mitk::FiberBundle::Pointer ending = groundTruthFibs->ExtractFiberSubset(itkRoiImage, false);
         mitk::IOUtil::SaveBaseData(ending, mitk::IOUtil::GetTempPath()+"ending.fib");
 
-        testFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[7])->GetData());
+        testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[7])->GetData());
         MITK_TEST_CONDITION_REQUIRED(inside->Equals(testFibs),"check inside mask extraction")
 
-        testFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[8])->GetData());
+        testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[8])->GetData());
         MITK_TEST_CONDITION_REQUIRED(outside->Equals(testFibs),"check outside mask extraction")
 
-        testFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[9])->GetData());
+        testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[9])->GetData());
         MITK_TEST_CONDITION_REQUIRED(passing->Equals(testFibs),"check passing mask extraction")
 
-        testFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[10])->GetData());
+        testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[10])->GetData());
         MITK_TEST_CONDITION_REQUIRED(ending->Equals(testFibs),"check ending in mask extraction")
     }
     catch(...) {
         return EXIT_FAILURE;
     }
 
     // always end with this!
     MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberGenerationTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberGenerationTest.cpp
index 2e06ab9d38..c4f2d01f28 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberGenerationTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberGenerationTest.cpp
@@ -1,78 +1,78 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkTestingMacros.h>
 #include <mitkIOUtil.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <mitkPlanarEllipse.h>
 #include <itkFibersFromPlanarFiguresFilter.h>
 
 /**Documentation
  *  Test if fiber transfortaiom methods work correctly
  */
 int mitkFiberGenerationTest(int argc, char* argv[])
 {
     MITK_TEST_BEGIN("mitkFiberGenerationTest");
 
     MITK_TEST_CONDITION_REQUIRED(argc==6,"check for input data")
 
             try{
 
         mitk::PlanarEllipse::Pointer pf1 = dynamic_cast<mitk::PlanarEllipse*>(mitk::IOUtil::LoadDataNode(argv[1])->GetData());
         mitk::PlanarEllipse::Pointer pf2 = dynamic_cast<mitk::PlanarEllipse*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
         mitk::PlanarEllipse::Pointer pf3 = dynamic_cast<mitk::PlanarEllipse*>(mitk::IOUtil::LoadDataNode(argv[3])->GetData());
-        mitk::FiberBundleX::Pointer uniform = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[4])->GetData());
-        mitk::FiberBundleX::Pointer gaussian = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[5])->GetData());
+        mitk::FiberBundle::Pointer uniform = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[4])->GetData());
+        mitk::FiberBundle::Pointer gaussian = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[5])->GetData());
 
         FiberGenerationParameters parameters;
         vector< mitk::PlanarEllipse::Pointer > fid; fid.push_back(pf1); fid.push_back(pf2); fid.push_back(pf3);
         vector< unsigned int > flip; flip.push_back(0); flip.push_back(0); flip.push_back(0);
         parameters.m_Fiducials.push_back(fid); parameters.m_FlipList.push_back(flip);
         parameters.m_Density = 50;
         parameters.m_Tension = 0;
         parameters.m_Continuity = 0;
         parameters.m_Bias = 0;
         parameters.m_Sampling = 1;
         parameters.m_Variance = 0.1;
 
         // check uniform fiber distribution
         {
             itk::FibersFromPlanarFiguresFilter::Pointer filter = itk::FibersFromPlanarFiguresFilter::New();
             parameters.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
             filter->SetParameters(parameters);
             filter->Update();
-            vector< mitk::FiberBundleX::Pointer > fiberBundles = filter->GetFiberBundles();
+            vector< mitk::FiberBundle::Pointer > fiberBundles = filter->GetFiberBundles();
             MITK_TEST_CONDITION_REQUIRED(uniform->Equals(fiberBundles.at(0)),"check uniform bundle")
         }
 
         // check gaussian fiber distribution
         {
             itk::FibersFromPlanarFiguresFilter::Pointer filter = itk::FibersFromPlanarFiguresFilter::New();
             parameters.m_Distribution = FiberGenerationParameters::DISTRIBUTE_GAUSSIAN;
             filter->SetParameters(parameters);
             filter->SetParameters(parameters);
             filter->Update();
-            vector< mitk::FiberBundleX::Pointer > fiberBundles = filter->GetFiberBundles();
+            vector< mitk::FiberBundle::Pointer > fiberBundles = filter->GetFiberBundles();
             MITK_TEST_CONDITION_REQUIRED(gaussian->Equals(fiberBundles.at(0)),"check gaussian bundle")
         }
     }
     catch(...) {
         return EXIT_FAILURE;
     }
 
     // always end with this!
     MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberTransformationTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberTransformationTest.cpp
index 764fcf9fe1..9e48b3c7f1 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberTransformationTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberTransformationTest.cpp
@@ -1,53 +1,53 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkTestingMacros.h>
 #include <mitkIOUtil.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 
 /**Documentation
  *  Test if fiber transfortaiom methods work correctly
  */
 int mitkFiberTransformationTest(int argc, char* argv[])
 {
     MITK_TEST_BEGIN("mitkFiberTransformationTest");
 
     MITK_TEST_CONDITION_REQUIRED(argc==3,"check for input data")
 
             try{
-        mitk::FiberBundleX::Pointer groundTruthFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[1])->GetData());
-        mitk::FiberBundleX::Pointer transformedFibs = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
+        mitk::FiberBundle::Pointer groundTruthFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[1])->GetData());
+        mitk::FiberBundle::Pointer transformedFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
 
         groundTruthFibs->RotateAroundAxis(90, 45, 10);
         groundTruthFibs->TranslateFibers(2, 3, 5);
         groundTruthFibs->ScaleFibers(1, 0.1, 1.3);
         groundTruthFibs->RemoveLongFibers(150);
         groundTruthFibs->RemoveShortFibers(20);
         groundTruthFibs->ResampleSpline(1.0);
         groundTruthFibs->ApplyCurvatureThreshold(3.0, true);
         groundTruthFibs->MirrorFibers(0);
         groundTruthFibs->MirrorFibers(1);
         groundTruthFibs->MirrorFibers(2);
 
         MITK_TEST_CONDITION_REQUIRED(groundTruthFibs->Equals(transformedFibs),"check transformation")
     }
     catch(...) {
         return EXIT_FAILURE;
     }
 
     // always end with this!
     MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp
index 53622ec71b..92284a7db5 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp
@@ -1,199 +1,199 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkTestingMacros.h>
 #include <mitkIOUtil.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <itkAddArtifactsToDwiImageFilter.h>
 #include <mitkFiberfoxParameters.h>
 #include <mitkStickModel.h>
 #include <mitkTensorModel.h>
 #include <mitkBallModel.h>
 #include <mitkDotModel.h>
 #include <mitkAstroStickModel.h>
 #include <mitkImage.h>
 #include <itkTestingComparisonImageFilter.h>
 #include <itkImageRegionConstIterator.h>
 #include <mitkRicianNoiseModel.h>
 #include <mitkChiSquareNoiseModel.h>
 #include <mitkTestFixture.h>
 #include <mitkITKImageImport.h>
 #include <mitkProperties.h>
 #include <mitkImageCast.h>
 
 typedef itk::VectorImage<short, 3> ITKDiffusionImageType;
 
 /**Documentation
  * Test the Fiberfox simulation functions (diffusion weighted image -> diffusion weighted image)
  */
 class mitkFiberfoxAddArtifactsToDwiTestSuite : public mitk::TestFixture
 {
 
     CPPUNIT_TEST_SUITE(mitkFiberfoxAddArtifactsToDwiTestSuite);
     MITK_TEST(Spikes);
     MITK_TEST(GibbsRinging);
     MITK_TEST(Ghost);
     MITK_TEST(Aliasing);
     MITK_TEST(Eddy);
     MITK_TEST(RicianNoise);
     MITK_TEST(ChiSquareNoise);
     MITK_TEST(Distortions);
     CPPUNIT_TEST_SUITE_END();
 
 private:
 
     mitk::Image::Pointer m_InputDwi;
     FiberfoxParameters<short> m_Parameters;
 
 public:
 
     void setUp()
     {
         // reference files
         m_InputDwi = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(GetTestDataFilePath("DiffusionImaging/Fiberfox/StickBall_RELAX.dwi"))->GetData());
 
         // parameter setup
 
         ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
         mitk::CastToItkImage(m_InputDwi, itkVectorImagePointer);
 
         m_Parameters = FiberfoxParameters<short>();
         m_Parameters.m_SignalGen.m_ImageRegion = itkVectorImagePointer->GetLargestPossibleRegion();
         m_Parameters.m_SignalGen.m_ImageSpacing = itkVectorImagePointer->GetSpacing();
         m_Parameters.m_SignalGen.m_ImageOrigin = itkVectorImagePointer->GetOrigin();
         m_Parameters.m_SignalGen.m_ImageDirection = itkVectorImagePointer->GetDirection();
         m_Parameters.m_SignalGen.m_Bvalue = static_cast<mitk::FloatProperty*>(m_InputDwi->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue();
         m_Parameters.m_SignalGen.SetGradienDirections( static_cast<mitk::GradientDirectionsProperty*>( m_InputDwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
     }
 
     bool CompareDwi(itk::VectorImage< short, 3 >* dwi1, itk::VectorImage< short, 3 >* dwi2)
     {
         typedef itk::VectorImage< short, 3 > DwiImageType;
         try{
             itk::ImageRegionIterator< DwiImageType > it1(dwi1, dwi1->GetLargestPossibleRegion());
             itk::ImageRegionIterator< DwiImageType > it2(dwi2, dwi2->GetLargestPossibleRegion());
             while(!it1.IsAtEnd())
             {
                 if (it1.Get()!=it2.Get())
                     return false;
                 ++it1;
                 ++it2;
             }
         }
         catch(...)
         {
             return false;
         }
         return true;
     }
 
     void StartSimulation(string testFileName)
     {
         mitk::Image::Pointer refImage = NULL;
         if (!testFileName.empty())
             CPPUNIT_ASSERT(refImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(testFileName)->GetData()));
 
         ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
         mitk::CastToItkImage(m_InputDwi, itkVectorImagePointer);
 
         itk::AddArtifactsToDwiImageFilter< short >::Pointer artifactsToDwiFilter = itk::AddArtifactsToDwiImageFilter< short >::New();
         artifactsToDwiFilter->SetUseConstantRandSeed(true);
         artifactsToDwiFilter->SetInput(itkVectorImagePointer);
         artifactsToDwiFilter->SetParameters(m_Parameters);
         CPPUNIT_ASSERT_NO_THROW(artifactsToDwiFilter->Update());
 
         mitk::Image::Pointer testImage = mitk::GrabItkImageMemory( artifactsToDwiFilter->GetOutput() );
         testImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( m_Parameters.m_SignalGen.GetGradientDirections() ) );
         testImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( m_Parameters.m_SignalGen.m_Bvalue ) );
         mitk::DiffusionPropertyHelper propertyHelper( testImage );
         propertyHelper.InitializeImage();
 
         if (refImage.IsNotNull())
         {
           ITKDiffusionImageType::Pointer itkTestVectorImagePointer = ITKDiffusionImageType::New();
           mitk::CastToItkImage(testImage, itkTestVectorImagePointer);
           ITKDiffusionImageType::Pointer itkRefVectorImagePointer = ITKDiffusionImageType::New();
           mitk::CastToItkImage(refImage, itkRefVectorImagePointer);
           if (!CompareDwi( itkTestVectorImagePointer, itkRefVectorImagePointer))
               mitk::IOUtil::SaveBaseData(testImage, mitk::IOUtil::GetTempPath()+"testImage.dwi");
 
           CPPUNIT_ASSERT_MESSAGE(testFileName, CompareDwi( itkTestVectorImagePointer, itkRefVectorImagePointer));
         }
     }
 
     void Spikes()
     {
         m_Parameters.m_SignalGen.m_Spikes = 5;
         m_Parameters.m_SignalGen.m_SpikeAmplitude = 1;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/spikes2.dwi") );
     }
 
     void GibbsRinging()
     {
         m_Parameters.m_SignalGen.m_DoAddGibbsRinging = true;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/gibbsringing2.dwi") );
     }
 
     void Ghost()
     {
         m_Parameters.m_SignalGen.m_KspaceLineOffset = 0.25;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/ghost2.dwi") );
     }
 
     void Aliasing()
     {
         m_Parameters.m_SignalGen.m_CroppingFactor = 0.4;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/aliasing2.dwi") );
     }
 
     void Eddy()
     {
         m_Parameters.m_SignalGen.m_EddyStrength = 0.05;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/eddy2.dwi") );
     }
 
     void RicianNoise()
     {
         mitk::RicianNoiseModel<short>* ricianNoiseModel = new mitk::RicianNoiseModel<short>();
         ricianNoiseModel->SetNoiseVariance(1000000);
         ricianNoiseModel->SetSeed(0);
         m_Parameters.m_NoiseModel = ricianNoiseModel;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/riciannoise2.dwi") );
         delete  m_Parameters.m_NoiseModel;
     }
 
     void ChiSquareNoise()
     {
         mitk::ChiSquareNoiseModel<short>* chiSquareNoiseModel = new mitk::ChiSquareNoiseModel<short>();
         chiSquareNoiseModel->SetNoiseVariance(1000000);
         chiSquareNoiseModel->SetSeed(0);
         m_Parameters.m_NoiseModel = chiSquareNoiseModel;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/chisquarenoise2.dwi") );
         delete  m_Parameters.m_NoiseModel;
     }
 
     void Distortions()
     {
         mitk::Image::Pointer mitkFMap = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode( GetTestDataFilePath("DiffusionImaging/Fiberfox/Fieldmap.nrrd") )->GetData());
         typedef itk::Image<double, 3> ItkDoubleImgType;
         ItkDoubleImgType::Pointer fMap = ItkDoubleImgType::New();
         mitk::CastToItkImage(mitkFMap, fMap);
         m_Parameters.m_SignalGen.m_FrequencyMap = fMap;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/distortions2.dwi") );
     }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkFiberfoxAddArtifactsToDwi)
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp
index 1e73c01dce..7265da47be 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp
@@ -1,293 +1,293 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkTestingMacros.h>
 #include <mitkIOUtil.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <itkTractsToDWIImageFilter.h>
 #include <mitkFiberfoxParameters.h>
 #include <mitkStickModel.h>
 #include <mitkTensorModel.h>
 #include <mitkBallModel.h>
 #include <mitkDotModel.h>
 #include <mitkAstroStickModel.h>
 #include <mitkImage.h>
 #include <itkTestingComparisonImageFilter.h>
 #include <itkImageRegionConstIterator.h>
 #include <mitkRicianNoiseModel.h>
 #include <mitkChiSquareNoiseModel.h>
 #include <mitkIOUtil.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkProperties.h>
 #include <mitkITKImageImport.h>
 #include <mitkImageCast.h>
 
 #include <itkVectorImage.h>
 
 typedef itk::VectorImage< short, 3>   ItkDwiType;
 
 /**Documentation
  * Test the Fiberfox simulation functions (fiberBundle -> diffusion weighted image)
  */
 bool CompareDwi(itk::VectorImage< short, 3 >* dwi1, itk::VectorImage< short, 3 >* dwi2)
 {
     typedef itk::VectorImage< short, 3 > DwiImageType;
     try{
         itk::ImageRegionIterator< DwiImageType > it1(dwi1, dwi1->GetLargestPossibleRegion());
         itk::ImageRegionIterator< DwiImageType > it2(dwi2, dwi2->GetLargestPossibleRegion());
         while(!it1.IsAtEnd())
         {
             if (it1.Get()!=it2.Get())
                 return false;
             ++it1;
             ++it2;
         }
     }
     catch(...)
     {
         return false;
     }
     return true;
 }
 
-void StartSimulation(FiberfoxParameters<double> parameters, FiberBundleX::Pointer fiberBundle, mitk::Image::Pointer refImage, string message)
+void StartSimulation(FiberfoxParameters<double> parameters, FiberBundle::Pointer fiberBundle, mitk::Image::Pointer refImage, string message)
 {
     itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
     tractsToDwiFilter->SetUseConstantRandSeed(true);
     tractsToDwiFilter->SetParameters(parameters);
     tractsToDwiFilter->SetFiberBundle(fiberBundle);
     tractsToDwiFilter->Update();
 
     mitk::Image::Pointer testImage = mitk::GrabItkImageMemory( tractsToDwiFilter->GetOutput() );
     testImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( parameters.m_SignalGen.GetGradientDirections() ) );
     testImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( parameters.m_SignalGen.m_Bvalue ) );
 
     mitk::DiffusionPropertyHelper propertyHelper( testImage );
     propertyHelper.InitializeImage();
 
     if (refImage.IsNotNull())
     {
       if( static_cast<mitk::GradientDirectionsProperty*>( refImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer().IsNotNull() )
       {
         ItkDwiType::Pointer itkTestImagePointer = ItkDwiType::New();
         mitk::CastToItkImage(testImage, itkTestImagePointer);
         ItkDwiType::Pointer itkRefImagePointer = ItkDwiType::New();
         mitk::CastToItkImage(refImage, itkRefImagePointer);
 
         bool cond = CompareDwi(itkTestImagePointer, itkRefImagePointer);
         if (!cond)
         {
           MITK_INFO << "Saving test and rference image to " << mitk::IOUtil::GetTempPath();
           mitk::IOUtil::SaveBaseData(testImage, mitk::IOUtil::GetTempPath()+"testImage.nrrd");
           mitk::IOUtil::SaveBaseData(refImage, mitk::IOUtil::GetTempPath()+"refImage.nrrd");
         }
         MITK_TEST_CONDITION_REQUIRED(cond, message);
       }
     }
 }
 
 int mitkFiberfoxSignalGenerationTest(int argc, char* argv[])
 {
     MITK_TEST_BEGIN("mitkFiberfoxSignalGenerationTest");
 
     MITK_TEST_CONDITION_REQUIRED(argc>=19,"check for input data");
 
     // input fiber bundle
-    FiberBundleX::Pointer fiberBundle = dynamic_cast<FiberBundleX*>(mitk::IOUtil::Load(argv[1])[0].GetPointer());
+    FiberBundle::Pointer fiberBundle = dynamic_cast<FiberBundle*>(mitk::IOUtil::Load(argv[1])[0].GetPointer());
 
     // reference diffusion weighted images
     mitk::Image::Pointer stickBall = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
     mitk::Image::Pointer stickAstrosticks = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[3])->GetData());
     mitk::Image::Pointer stickDot = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[4])->GetData());
     mitk::Image::Pointer tensorBall = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[5])->GetData());
     mitk::Image::Pointer stickTensorBall = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[6])->GetData());
     mitk::Image::Pointer stickTensorBallAstrosticks = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[7])->GetData());
     mitk::Image::Pointer gibbsringing = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[8])->GetData());
     mitk::Image::Pointer ghost = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[9])->GetData());
     mitk::Image::Pointer aliasing = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[10])->GetData());
     mitk::Image::Pointer eddy = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[11])->GetData());
     mitk::Image::Pointer linearmotion = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[12])->GetData());
     mitk::Image::Pointer randommotion = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[13])->GetData());
     mitk::Image::Pointer spikes = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[14])->GetData());
     mitk::Image::Pointer riciannoise = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[15])->GetData());
     mitk::Image::Pointer chisquarenoise = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[16])->GetData());
     mitk::Image::Pointer distortions = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[17])->GetData());
     mitk::Image::Pointer mitkFMap = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[18])->GetData());
     typedef itk::Image<double, 3> ItkDoubleImgType;
     ItkDoubleImgType::Pointer fMap = ItkDoubleImgType::New();
     mitk::CastToItkImage(mitkFMap, fMap);
 
     ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
   mitk::CastToItkImage(stickBall, itkVectorImagePointer);
 
     FiberfoxParameters<double> parameters;
     parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
     parameters.m_SignalGen.m_SignalScale = 10000;
     parameters.m_SignalGen.m_ImageRegion = itkVectorImagePointer->GetLargestPossibleRegion();
     parameters.m_SignalGen.m_ImageSpacing = itkVectorImagePointer->GetSpacing();
     parameters.m_SignalGen.m_ImageOrigin = itkVectorImagePointer->GetOrigin();
     parameters.m_SignalGen.m_ImageDirection = itkVectorImagePointer->GetDirection();
     parameters.m_SignalGen.m_Bvalue = static_cast<mitk::FloatProperty*>(stickBall->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue();
     parameters.m_SignalGen.SetGradienDirections( static_cast<mitk::GradientDirectionsProperty*>( stickBall->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
 
     // intra and inter axonal compartments
     mitk::StickModel<double> stickModel;
     stickModel.SetBvalue(parameters.m_SignalGen.m_Bvalue);
     stickModel.SetT2(110);
     stickModel.SetDiffusivity(0.001);
     stickModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
 
     mitk::TensorModel<double> tensorModel;
     tensorModel.SetT2(110);
     stickModel.SetBvalue(parameters.m_SignalGen.m_Bvalue);
     tensorModel.SetDiffusivity1(0.001);
     tensorModel.SetDiffusivity2(0.00025);
     tensorModel.SetDiffusivity3(0.00025);
     tensorModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
 
     // extra axonal compartment models
     mitk::BallModel<double> ballModel;
     ballModel.SetT2(80);
     ballModel.SetBvalue(parameters.m_SignalGen.m_Bvalue);
     ballModel.SetDiffusivity(0.001);
     ballModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
 
     mitk::AstroStickModel<double> astrosticksModel;
     astrosticksModel.SetT2(80);
     astrosticksModel.SetBvalue(parameters.m_SignalGen.m_Bvalue);
     astrosticksModel.SetDiffusivity(0.001);
     astrosticksModel.SetRandomizeSticks(true);
     astrosticksModel.SetSeed(0);
     astrosticksModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
 
     mitk::DotModel<double> dotModel;
     dotModel.SetT2(80);
     dotModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
 
     // noise models
     mitk::RicianNoiseModel<double>* ricianNoiseModel = new mitk::RicianNoiseModel<double>();
     ricianNoiseModel->SetNoiseVariance(1000000);
     ricianNoiseModel->SetSeed(0);
 
     // Rician noise
     mitk::ChiSquareNoiseModel<double>* chiSquareNoiseModel = new mitk::ChiSquareNoiseModel<double>();
     chiSquareNoiseModel->SetNoiseVariance(1000000);
     chiSquareNoiseModel->SetSeed(0);
 
     try{
         // Stick-Ball
         parameters.m_FiberModelList.push_back(&stickModel);
         parameters.m_NonFiberModelList.push_back(&ballModel);
         StartSimulation(parameters, fiberBundle, stickBall, argv[2]);
 
         // Srick-Astrosticks
         parameters.m_NonFiberModelList.clear();
         parameters.m_NonFiberModelList.push_back(&astrosticksModel);
         StartSimulation(parameters, fiberBundle, stickAstrosticks, argv[3]);
 
         // Stick-Dot
         parameters.m_NonFiberModelList.clear();
         parameters.m_NonFiberModelList.push_back(&dotModel);
         StartSimulation(parameters, fiberBundle, stickDot, argv[4]);
 
         // Tensor-Ball
         parameters.m_FiberModelList.clear();
         parameters.m_FiberModelList.push_back(&tensorModel);
         parameters.m_NonFiberModelList.clear();
         parameters.m_NonFiberModelList.push_back(&ballModel);
         StartSimulation(parameters, fiberBundle, tensorBall, argv[5]);
 
         // Stick-Tensor-Ball
         parameters.m_FiberModelList.clear();
         parameters.m_FiberModelList.push_back(&stickModel);
         parameters.m_FiberModelList.push_back(&tensorModel);
         parameters.m_NonFiberModelList.clear();
         parameters.m_NonFiberModelList.push_back(&ballModel);
         StartSimulation(parameters, fiberBundle, stickTensorBall, argv[6]);
 
         // Stick-Tensor-Ball-Astrosticks
         parameters.m_NonFiberModelList.push_back(&astrosticksModel);
         StartSimulation(parameters, fiberBundle, stickTensorBallAstrosticks, argv[7]);
 
         // Gibbs ringing
         parameters.m_FiberModelList.clear();
         parameters.m_FiberModelList.push_back(&stickModel);
         parameters.m_NonFiberModelList.clear();
         parameters.m_NonFiberModelList.push_back(&ballModel);
         parameters.m_SignalGen.m_DoAddGibbsRinging = true;
         StartSimulation(parameters, fiberBundle, gibbsringing, argv[8]);
 
         // Ghost
         parameters.m_SignalGen.m_DoAddGibbsRinging = false;
         parameters.m_SignalGen.m_KspaceLineOffset = 0.25;
         StartSimulation(parameters, fiberBundle, ghost, argv[9]);
 
         // Aliasing
         parameters.m_SignalGen.m_KspaceLineOffset = 0;
         parameters.m_SignalGen.m_CroppingFactor = 0.4;
         parameters.m_SignalGen.m_SignalScale = 1000;
         StartSimulation(parameters, fiberBundle, aliasing, argv[10]);
 
         // Eddy currents
         parameters.m_SignalGen.m_CroppingFactor = 1;
         parameters.m_SignalGen.m_SignalScale = 10000;
         parameters.m_SignalGen.m_EddyStrength = 0.05;
         StartSimulation(parameters, fiberBundle, eddy, argv[11]);
 
         // Motion (linear)
         parameters.m_SignalGen.m_EddyStrength = 0.0;
         parameters.m_SignalGen.m_DoAddMotion = true;
         parameters.m_SignalGen.m_DoRandomizeMotion = false;
         parameters.m_SignalGen.m_Translation[1] = 10;
         parameters.m_SignalGen.m_Rotation[2] = 90;
         StartSimulation(parameters, fiberBundle, linearmotion, argv[12]);
 
         // Motion (random)
         parameters.m_SignalGen.m_DoRandomizeMotion = true;
         parameters.m_SignalGen.m_Translation[1] = 5;
         parameters.m_SignalGen.m_Rotation[2] = 45;
         StartSimulation(parameters, fiberBundle, randommotion, argv[13]);
 
         // Spikes
         parameters.m_SignalGen.m_DoAddMotion = false;
         parameters.m_SignalGen.m_Spikes = 5;
         parameters.m_SignalGen.m_SpikeAmplitude = 1;
         StartSimulation(parameters, fiberBundle, spikes, argv[14]);
 
         // Rician noise
         parameters.m_SignalGen.m_Spikes = 0;
         parameters.m_NoiseModel = ricianNoiseModel;
         StartSimulation(parameters, fiberBundle, riciannoise, argv[15]);
         delete parameters.m_NoiseModel;
 
         // Chi-square noise
         parameters.m_NoiseModel = chiSquareNoiseModel;
         StartSimulation(parameters, fiberBundle, chisquarenoise, argv[16]);
         delete parameters.m_NoiseModel;
 
         // Distortions
         parameters.m_NoiseModel = NULL;
         parameters.m_SignalGen.m_FrequencyMap = fMap;
         StartSimulation(parameters, fiberBundle, distortions, argv[17]);
     }
     catch (std::exception &e)
     {
         MITK_TEST_CONDITION_REQUIRED(false, e.what());
     }
 
     // always end with this!
     MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkGibbsTrackingTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkGibbsTrackingTest.cpp
index cbfe9626ed..635d5d0a28 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkGibbsTrackingTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkGibbsTrackingTest.cpp
@@ -1,92 +1,92 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkTestingMacros.h>
 #include <mitkImageCast.h>
 #include <mitkQBallImage.h>
 #include <itkGibbsTrackingFilter.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <mitkIOUtil.h>
 
 using namespace mitk;
 
 /**Documentation
  *  Test for gibbs tracking filter
  */
 int mitkGibbsTrackingTest(int argc, char* argv[])
 {
   MITK_TEST_BEGIN("mitkGibbsTrackingTest");
 
   MITK_TEST_CONDITION_REQUIRED(argc>4,"check for input data")
 
   QBallImage::Pointer mitkQballImage;
   Image::Pointer mitkMaskImage;
-  mitk::FiberBundleX::Pointer fib1;
+  mitk::FiberBundle::Pointer fib1;
 
   try{
 
     MITK_INFO << "Q-Ball image: " << argv[1];
     MITK_INFO << "Mask image: " << argv[2];
     MITK_INFO << "Parameter file: " << argv[3];
     MITK_INFO << "Reference bundle: " << argv[4];
 
     std::vector<mitk::BaseData::Pointer> infile = mitk::IOUtil::Load( argv[1]);
     mitkQballImage = dynamic_cast<mitk::QBallImage*>(infile.at(0).GetPointer());
     MITK_TEST_CONDITION_REQUIRED(mitkQballImage.IsNotNull(),"check qball image")
 
     infile = mitk::IOUtil::Load( argv[2] );
     mitkMaskImage = dynamic_cast<mitk::Image*>(infile.at(0).GetPointer());
     MITK_TEST_CONDITION_REQUIRED(mitkMaskImage.IsNotNull(),"check mask image")
 
     infile = mitk::IOUtil::Load( argv[4]);
-    fib1 = dynamic_cast<mitk::FiberBundleX*>(infile.at(0).GetPointer());
+    fib1 = dynamic_cast<mitk::FiberBundle*>(infile.at(0).GetPointer());
     MITK_TEST_CONDITION_REQUIRED(fib1.IsNotNull(),"check fiber bundle")
 
     typedef itk::Vector<float, QBALL_ODFSIZE> OdfVectorType;
     typedef itk::Image<OdfVectorType,3> OdfVectorImgType;
     typedef itk::Image<float,3> MaskImgType;
     typedef itk::GibbsTrackingFilter<OdfVectorImgType> GibbsTrackingFilterType;
 
     OdfVectorImgType::Pointer itk_qbi = OdfVectorImgType::New();
     mitk::CastToItkImage(mitkQballImage, itk_qbi);
 
     MaskImgType::Pointer itk_mask = MaskImgType::New();
     mitk::CastToItkImage(mitkMaskImage, itk_mask);
 
     GibbsTrackingFilterType::Pointer gibbsTracker = GibbsTrackingFilterType::New();
     gibbsTracker->SetQBallImage(itk_qbi.GetPointer());
     gibbsTracker->SetMaskImage(itk_mask);
     gibbsTracker->SetDuplicateImage(false);
     gibbsTracker->SetRandomSeed(1);
     gibbsTracker->SetLoadParameterFile(argv[3]);
     gibbsTracker->Update();
 
-    mitk::FiberBundleX::Pointer fib2 = mitk::FiberBundleX::New(gibbsTracker->GetFiberBundle());
+    mitk::FiberBundle::Pointer fib2 = mitk::FiberBundle::New(gibbsTracker->GetFiberBundle());
     MITK_TEST_CONDITION_REQUIRED(fib1->Equals(fib2), "check if gibbs tracking has changed");
 
     gibbsTracker->SetRandomSeed(0);
     gibbsTracker->Update();
-    fib2 = mitk::FiberBundleX::New(gibbsTracker->GetFiberBundle());
+    fib2 = mitk::FiberBundle::New(gibbsTracker->GetFiberBundle());
     MITK_TEST_CONDITION_REQUIRED(!fib1->Equals(fib2), "check if gibbs tracking has changed after wrong seed");
   }
   catch(...)
   {
     return EXIT_FAILURE;
   }
 
   // always end with this!
   MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkLocalFiberPlausibilityTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkLocalFiberPlausibilityTest.cpp
index 99828d891b..556c6d695c 100755
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkLocalFiberPlausibilityTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkLocalFiberPlausibilityTest.cpp
@@ -1,166 +1,166 @@
 /*===================================================================
 
 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 <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <itkEvaluateDirectionImagesFilter.h>
 #include <itkTractsToVectorImageFilter.h>
 #include <usAny.h>
 #include <itkImageFileWriter.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <iostream>
 #include <fstream>
 #include <itksys/SystemTools.hxx>
 #include <mitkTestingMacros.h>
 #include <mitkCompareImageDataFilter.h>
 #include <mitkCoreObjectFactory.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 using namespace std;
 
 int mitkLocalFiberPlausibilityTest(int argc, char* argv[])
 {
     MITK_TEST_BEGIN("mitkLocalFiberPlausibilityTest");
     MITK_TEST_CONDITION_REQUIRED(argc==8,"check for input data")
 
             string fibFile = argv[1];
     vector< string > referenceImages;
     referenceImages.push_back(argv[2]);
     referenceImages.push_back(argv[3]);
     string LDFP_ERROR_IMAGE = argv[4];
     string LDFP_NUM_DIRECTIONS = argv[5];
     string LDFP_VECTOR_FIELD = argv[6];
     string LDFP_ERROR_IMAGE_IGNORE = argv[7];
 
     float angularThreshold = 30;
 
     try
     {
         typedef itk::Image<unsigned char, 3>                                    ItkUcharImgType;
         typedef itk::Image< itk::Vector< float, 3>, 3 >                         ItkDirectionImage3DType;
         typedef itk::VectorContainer< unsigned int, ItkDirectionImage3DType::Pointer >   ItkDirectionImageContainerType;
         typedef itk::EvaluateDirectionImagesFilter< float >                     EvaluationFilterType;
 
         // load fiber bundle
-        mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
+        mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
 
         // load reference directions
         ItkDirectionImageContainerType::Pointer referenceImageContainer = ItkDirectionImageContainerType::New();
         for (unsigned int i=0; i<referenceImages.size(); i++)
         {
             try
             {
                 mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(referenceImages.at(i))->GetData());
                 typedef mitk::ImageToItk< ItkDirectionImage3DType > CasterType;
                 CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(img);
                 caster->Update();
                 ItkDirectionImage3DType::Pointer itkImg = caster->GetOutput();
                 referenceImageContainer->InsertElement(referenceImageContainer->Size(),itkImg);
             }
             catch(...){ MITK_INFO << "could not load: " << referenceImages.at(i); }
         }
 
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         ItkDirectionImage3DType::Pointer dirImg = referenceImageContainer->GetElement(0);
         itkMaskImage->SetSpacing( dirImg->GetSpacing() );
         itkMaskImage->SetOrigin( dirImg->GetOrigin() );
         itkMaskImage->SetDirection( dirImg->GetDirection() );
         itkMaskImage->SetLargestPossibleRegion( dirImg->GetLargestPossibleRegion() );
         itkMaskImage->SetBufferedRegion( dirImg->GetLargestPossibleRegion() );
         itkMaskImage->SetRequestedRegion( dirImg->GetLargestPossibleRegion() );
         itkMaskImage->Allocate();
         itkMaskImage->FillBuffer(1);
 
         // extract directions from fiber bundle
         itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
         fOdfFilter->SetFiberBundle(inputTractogram);
         fOdfFilter->SetMaskImage(itkMaskImage);
         fOdfFilter->SetAngularThreshold(cos(angularThreshold*M_PI/180));
         fOdfFilter->SetNormalizeVectors(true);
         fOdfFilter->SetMaxNumDirections(3);
         fOdfFilter->SetSizeThreshold(0.3);
 
         fOdfFilter->SetUseWorkingCopy(false);
         fOdfFilter->SetNumberOfThreads(1);
         fOdfFilter->Update();
         ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
 
         // Get directions and num directions image
         ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
         mitk::Image::Pointer mitkNumDirImage = mitk::Image::New();
         mitkNumDirImage->InitializeByItk( numDirImage.GetPointer() );
         mitkNumDirImage->SetVolume( numDirImage->GetBufferPointer() );
-        mitk::FiberBundleX::Pointer testDirections = fOdfFilter->GetOutputFiberBundle();
+        mitk::FiberBundle::Pointer testDirections = fOdfFilter->GetOutputFiberBundle();
 
         //mitk::IOUtil::SaveImage(mitkNumDirImage, "/local/mitk/release-binary/MITK-superbuild/CMakeExternals/Source/MITK-Data/DiffusionImaging/LDFP_NUM_DIRECTIONS.nrrd");
         //mitk::IOUtil::SaveBaseData(testDirections, "/local/mitk/release-binary/MITK-superbuild/CMakeExternals/Source/MITK-Data/DiffusionImaging/LDFP_VECTOR_FIELD.fib");
 
         // evaluate directions with missing directions
         EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
         evaluationFilter->SetImageSet(directionImageContainer);
         evaluationFilter->SetReferenceImageSet(referenceImageContainer);
         evaluationFilter->SetMaskImage(itkMaskImage);
         evaluationFilter->SetIgnoreMissingDirections(false);
         evaluationFilter->Update();
 
         EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
         mitk::Image::Pointer mitkAngularErrorImage = mitk::Image::New();
         mitkAngularErrorImage->InitializeByItk( angularErrorImage.GetPointer() );
         mitkAngularErrorImage->SetVolume( angularErrorImage->GetBufferPointer() );
         //mitk::IOUtil::SaveImage(mitkAngularErrorImage, "/local/mitk/release-binary/MITK-superbuild/CMakeExternals/Source/MITK-Data/DiffusionImaging/LDFP_ERROR_IMAGE.nrrd");
 
         // evaluate directions without missing directions
         evaluationFilter->SetIgnoreMissingDirections(true);
         evaluationFilter->Update();
 
         EvaluationFilterType::OutputImageType::Pointer angularErrorImageIgnore = evaluationFilter->GetOutput(0);
         mitk::Image::Pointer mitkAngularErrorImageIgnore = mitk::Image::New();
         mitkAngularErrorImageIgnore->InitializeByItk( angularErrorImageIgnore.GetPointer() );
         mitkAngularErrorImageIgnore->SetVolume( angularErrorImageIgnore->GetBufferPointer() );
         //mitk::IOUtil::SaveImage(mitkAngularErrorImageIgnore, "/local/mitk/release-binary/MITK-superbuild/CMakeExternals/Source/MITK-Data/DiffusionImaging/LDFP_ERROR_IMAGE_IGNORE.nrrd");
 
         mitk::Image::Pointer gtAngularErrorImageIgnore = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(LDFP_ERROR_IMAGE_IGNORE)->GetData());
         mitk::Image::Pointer gtAngularErrorImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(LDFP_ERROR_IMAGE)->GetData());
         mitk::Image::Pointer gtNumTestDirImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(LDFP_NUM_DIRECTIONS)->GetData());
-        mitk::FiberBundleX::Pointer gtTestDirections = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(LDFP_VECTOR_FIELD)->GetData());
+        mitk::FiberBundle::Pointer gtTestDirections = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(LDFP_VECTOR_FIELD)->GetData());
 
         MITK_TEST_CONDITION_REQUIRED(mitk::Equal(gtAngularErrorImageIgnore, mitkAngularErrorImageIgnore, 0.01, true), "Check if error images are equal (ignored missing directions).");
         MITK_TEST_CONDITION_REQUIRED(mitk::Equal(gtAngularErrorImage, mitkAngularErrorImage, 0.01, true), "Check if error images are equal.");
         MITK_TEST_CONDITION_REQUIRED(testDirections->Equals(gtTestDirections), "Check if vector fields are equal.");
         MITK_TEST_CONDITION_REQUIRED(mitk::Equal(gtNumTestDirImage, mitkNumDirImage, 0.1, true), "Check if num direction images are equal.");
     }
     catch (itk::ExceptionObject e)
     {
         MITK_INFO << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         MITK_INFO << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         MITK_INFO << "ERROR!?!";
         return EXIT_FAILURE;
     }
     MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp
index 6e1f252e20..fd106794d7 100755
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp
@@ -1,106 +1,106 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <itkImageFileWriter.h>
 #include <itkResampleImageFilter.h>
 #include <itkFiniteDiffOdfMaximaExtractionFilter.h>
 
 #include <mitkQBallImage.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkTensorImage.h>
 
 #include <mitkCoreObjectFactory.h>
 #include <itkShCoefficientImageImporter.h>
 #include <itkFlipImageFilter.h>
 #include <boost/lexical_cast.hpp>
 #include <boost/algorithm/string.hpp>
 #include <mitkTestingMacros.h>
 #include <mitkIOUtil.h>
 
 using namespace std;
 
 int mitkPeakExtractionTest(int argc, char* argv[])
 {
     MITK_TEST_BEGIN("mitkStreamlineTrackingTest");
 
     MITK_TEST_CONDITION_REQUIRED(argc>3,"check for input data")
 
     string shCoeffFileName = argv[1];
     string maskFileName = argv[2];
     string referenceFileName = argv[3];
 
     MITK_INFO << "SH-coefficient file: " << shCoeffFileName;
     MITK_INFO << "Mask file: " << maskFileName;
     MITK_INFO << "Reference fiber file: " << referenceFileName;
 
     try
     {
         mitk::CoreObjectFactory::GetInstance();
 
         mitk::Image::Pointer image = mitk::IOUtil::LoadImage(shCoeffFileName);
         mitk::Image::Pointer mitkMaskImage = mitk::IOUtil::LoadImage(maskFileName);
 
         typedef itk::Image<unsigned char, 3>  ItkUcharImgType;
         typedef itk::FiniteDiffOdfMaximaExtractionFilter< float, 4, 20242 > MaximaExtractionFilterType;
         MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
 
         MITK_INFO << "Casting mask image ...";
         ItkUcharImgType::Pointer itkMask = ItkUcharImgType::New();
         mitk::CastToItkImage(mitkMaskImage, itkMask);
         filter->SetMaskImage(itkMask);
 
         MITK_INFO << "Casting SH image ...";
         typedef mitk::ImageToItk< MaximaExtractionFilterType::CoefficientImageType > CasterType;
         CasterType::Pointer caster = CasterType::New();
         caster->SetInput(image);
         caster->Update();
         filter->SetInput(caster->GetOutput());
         filter->SetMaxNumPeaks(2);
         filter->SetPeakThreshold(0.4);
         filter->SetAbsolutePeakThreshold(0.01);
         filter->SetAngularThreshold(25);
         filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
         filter->SetNumberOfThreads(1);
         MITK_INFO << "Starting extraction ...";
         filter->Update();
-        mitk::FiberBundleX::Pointer fib1 = filter->GetOutputFiberBundle();
+        mitk::FiberBundle::Pointer fib1 = filter->GetOutputFiberBundle();
 
         MITK_INFO << "Loading reference ...";
         std::vector<mitk::BaseData::Pointer> infile = mitk::IOUtil::Load( referenceFileName );
-        mitk::FiberBundleX::Pointer fib2 = dynamic_cast<mitk::FiberBundleX*>(infile.at(0).GetPointer());
+        mitk::FiberBundle::Pointer fib2 = dynamic_cast<mitk::FiberBundle*>(infile.at(0).GetPointer());
 
         // TODO: reduce epsilon. strange issues with differing values between windows and linux.
         MITK_TEST_CONDITION_REQUIRED(fib1->Equals(fib2), "Check if tractograms are equal.");
     }
     catch (itk::ExceptionObject e)
     {
         MITK_INFO << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         MITK_INFO << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         MITK_INFO << "ERROR!?!";
         return EXIT_FAILURE;
     }
 
     MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkStreamlineTrackingTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkStreamlineTrackingTest.cpp
index a075bbf718..144c64b1a4 100755
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkStreamlineTrackingTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkStreamlineTrackingTest.cpp
@@ -1,127 +1,127 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkImageCast.h>
 #include <mitkTensorImage.h>
 #include <mitkIOUtil.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <itkStreamlineTrackingFilter.h>
 #include <itkDiffusionTensor3D.h>
 #include <mitkTestingMacros.h>
 
 using namespace std;
 
 int mitkStreamlineTrackingTest(int argc, char* argv[])
 {
     MITK_TEST_BEGIN("mitkStreamlineTrackingTest");
 
     MITK_TEST_CONDITION_REQUIRED(argc>3,"check for input data")
 
     string dtiFileName = argv[1];
     string maskFileName = argv[2];
     string referenceFileName = argv[3];
 
     MITK_INFO << "DTI file: " << dtiFileName;
     MITK_INFO << "Mask file: " << maskFileName;
     MITK_INFO << "Reference fiber file: " << referenceFileName;
 
     float minFA = 0.05;
     float minCurv = -1;
     float stepSize = -1;
     float tendf = 1;
     float tendg = 0;
     float minLength = 20;
     int numSeeds = 1;
     bool interpolate = true;
 
     try
     {
         MITK_INFO << "Loading tensor image ...";
         typedef itk::Image< itk::DiffusionTensor3D<float>, 3 >    ItkTensorImage;
         mitk::TensorImage::Pointer mitkTensorImage = dynamic_cast<mitk::TensorImage*>(mitk::IOUtil::LoadDataNode(dtiFileName)->GetData());
         ItkTensorImage::Pointer itk_dti = ItkTensorImage::New();
         mitk::CastToItkImage(mitkTensorImage, itk_dti);
 
         MITK_INFO << "Loading seed image ...";
         typedef itk::Image< unsigned char, 3 >    ItkUCharImageType;
         mitk::Image::Pointer mitkSeedImage = mitk::IOUtil::LoadImage(maskFileName);
 
         MITK_INFO << "Loading mask image ...";
         mitk::Image::Pointer mitkMaskImage = mitk::IOUtil::LoadImage(maskFileName);
 
         // instantiate tracker
         typedef itk::StreamlineTrackingFilter< float > FilterType;
         FilterType::Pointer filter = FilterType::New();
         filter->SetInput(itk_dti);
         filter->SetSeedsPerVoxel(numSeeds);
         filter->SetFaThreshold(minFA);
         filter->SetMinCurvatureRadius(minCurv);
         filter->SetStepSize(stepSize);
         filter->SetF(tendf);
         filter->SetG(tendg);
         filter->SetInterpolate(interpolate);
         filter->SetMinTractLength(minLength);
         filter->SetNumberOfThreads(1);
 
         if (mitkSeedImage.IsNotNull())
         {
             ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
             mitk::CastToItkImage(mitkSeedImage, mask);
             filter->SetSeedImage(mask);
         }
 
         if (mitkMaskImage.IsNotNull())
         {
             ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
             mitk::CastToItkImage(mitkMaskImage, mask);
             filter->SetMaskImage(mask);
         }
 
         filter->Update();
 
         vtkSmartPointer<vtkPolyData> fiberBundle = filter->GetFiberPolyData();
-        mitk::FiberBundleX::Pointer fib1 = mitk::FiberBundleX::New(fiberBundle);
+        mitk::FiberBundle::Pointer fib1 = mitk::FiberBundle::New(fiberBundle);
 
-        mitk::FiberBundleX::Pointer fib2 = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(referenceFileName)->GetData());
+        mitk::FiberBundle::Pointer fib2 = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(referenceFileName)->GetData());
         MITK_TEST_CONDITION_REQUIRED(fib2.IsNotNull(), "Check if reference tractogram is not null.");
         bool ok = fib1->Equals(fib2);
         if (!ok)
         {
             MITK_WARN << "TEST FAILED. TRACTOGRAMS ARE NOT EQUAL!";
             mitk::IOUtil::SaveBaseData(fib1, mitk::IOUtil::GetTempPath()+"testBundle.fib");
             mitk::IOUtil::SaveBaseData(fib2, mitk::IOUtil::GetTempPath()+"refBundle.fib");
             MITK_INFO << "OUTPUT: " << mitk::IOUtil::GetTempPath();
         }
         MITK_TEST_CONDITION_REQUIRED(ok, "Check if tractograms are equal.");
     }
     catch (itk::ExceptionObject e)
     {
         MITK_INFO << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         MITK_INFO << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         MITK_INFO << "ERROR!?!";
         return EXIT_FAILURE;
     }
 
     MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/files.cmake b/Modules/DiffusionImaging/FiberTracking/files.cmake
index 71bb1066a5..adc2368cf2 100644
--- a/Modules/DiffusionImaging/FiberTracking/files.cmake
+++ b/Modules/DiffusionImaging/FiberTracking/files.cmake
@@ -1,78 +1,78 @@
 set(CPP_FILES
 
   mitkFiberTrackingModuleActivator.cpp
 
   ## IO datastructures
-  IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
-  IODataStructures/FiberBundleX/mitkTrackvis.cpp
+  IODataStructures/FiberBundle/mitkFiberBundle.cpp
+  IODataStructures/FiberBundle/mitkTrackvis.cpp
   IODataStructures/PlanarFigureComposite/mitkPlanarFigureComposite.cpp
 
   # Interactions
   Interactions/mitkFiberBundleInteractor.cpp
 
   # Tractography
   Algorithms/GibbsTracking/mitkParticleGrid.cpp
   Algorithms/GibbsTracking/mitkMetropolisHastingsSampler.cpp
   Algorithms/GibbsTracking/mitkEnergyComputer.cpp
   Algorithms/GibbsTracking/mitkGibbsEnergyComputer.cpp
   Algorithms/GibbsTracking/mitkFiberBuilder.cpp
   Algorithms/GibbsTracking/mitkSphereInterpolator.cpp
 )
 
 set(H_FILES
-  # DataStructures -> FiberBundleX
-  IODataStructures/FiberBundleX/mitkFiberBundleX.h
-  IODataStructures/FiberBundleX/mitkTrackvis.h
+  # DataStructures -> FiberBundle
+  IODataStructures/FiberBundle/mitkFiberBundle.h
+  IODataStructures/FiberBundle/mitkTrackvis.h
   IODataStructures/mitkFiberfoxParameters.h
 
   # Algorithms
   Algorithms/itkTractDensityImageFilter.h
   Algorithms/itkTractsToFiberEndingsImageFilter.h
   Algorithms/itkTractsToRgbaImageFilter.h
   # moved to DiffusionCore
   #Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.h
   Algorithms/itkFibersFromPlanarFiguresFilter.h
   Algorithms/itkTractsToDWIImageFilter.h
   Algorithms/itkTractsToVectorImageFilter.h
   Algorithms/itkKspaceImageFilter.h
   Algorithms/itkDftImageFilter.h
   Algorithms/itkAddArtifactsToDwiImageFilter.h
   Algorithms/itkFieldmapGeneratorFilter.h
   Algorithms/itkEvaluateDirectionImagesFilter.h
   Algorithms/itkEvaluateTractogramDirectionsFilter.h
   Algorithms/itkFiberCurvatureFilter.h
 
   # (old) Tractography
   Algorithms/itkGibbsTrackingFilter.h
   Algorithms/itkStochasticTractographyFilter.h
   Algorithms/itkStreamlineTrackingFilter.h
   Algorithms/GibbsTracking/mitkParticle.h
   Algorithms/GibbsTracking/mitkParticleGrid.h
   Algorithms/GibbsTracking/mitkMetropolisHastingsSampler.h
   Algorithms/GibbsTracking/mitkSimpSamp.h
   Algorithms/GibbsTracking/mitkEnergyComputer.h
   Algorithms/GibbsTracking/mitkGibbsEnergyComputer.h
   Algorithms/GibbsTracking/mitkSphereInterpolator.h
   Algorithms/GibbsTracking/mitkFiberBuilder.h
 
   # Signal Models
   SignalModels/mitkDiffusionSignalModel.h
   SignalModels/mitkTensorModel.h
   SignalModels/mitkBallModel.h
   SignalModels/mitkDotModel.h
   SignalModels/mitkAstroStickModel.h
   SignalModels/mitkStickModel.h
   SignalModels/mitkRawShModel.h
   SignalModels/mitkDiffusionNoiseModel.h
   SignalModels/mitkRicianNoiseModel.h
   SignalModels/mitkChiSquareNoiseModel.h
 )
 
 set(RESOURCE_FILES
   # Binary directory resources
   FiberTrackingLUTBaryCoords.bin
   FiberTrackingLUTIndices.bin
 
   # Shaders
   Shaders/mitkShaderFiberClipping.xml
 )
diff --git a/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp b/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp
index 1bf5305501..b7e01c9e99 100755
--- a/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp
@@ -1,173 +1,173 @@
 /*===================================================================
 
 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 <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <metaCommand.h>
 #include "mitkCommandLineParser.h"
 #include <usAny.h>
 #include <itkImageFileWriter.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <itkEvaluateDirectionImagesFilter.h>
 #include <itkTractsToVectorImageFilter.h>
 #include <mitkCoreObjectFactory.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Fiber Direction Extraction");
     parser.setCategory("Fiber Tracking and Processing Methods");
     parser.setDescription(" ");
     parser.setContributor("MBI");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input tractogram (.fib/.trk)", us::Any(), false);
     parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
     parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask:", "mask image");
     parser.addArgument("athresh", "a", mitkCommandLineParser::Float, "Angular threshold:", "angular threshold in degrees. closer fiber directions are regarded as one direction and clustered together.", 25, true);
     parser.addArgument("peakthresh", "t", mitkCommandLineParser::Float, "Peak size threshold:", "peak size threshold relative to largest peak in voxel", 0.2, true);
     parser.addArgument("verbose", "v", mitkCommandLineParser::Bool, "Verbose:", "output optional and intermediate calculation results");
     parser.addArgument("numdirs", "d", mitkCommandLineParser::Int, "Max. num. directions:", "maximum number of fibers per voxel", 3, true);
     parser.addArgument("normalize", "n", mitkCommandLineParser::Bool, "Normalize:", "normalize vectors");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     string fibFile = us::any_cast<string>(parsedArgs["input"]);
 
     string maskImage("");
     if (parsedArgs.count("mask"))
         maskImage = us::any_cast<string>(parsedArgs["mask"]);
 
     float peakThreshold = 0.2;
     if (parsedArgs.count("peakthresh"))
         peakThreshold = us::any_cast<float>(parsedArgs["peakthresh"]);
 
     float angularThreshold = 25;
     if (parsedArgs.count("athresh"))
         angularThreshold = us::any_cast<float>(parsedArgs["athresh"]);
 
     string outRoot = us::any_cast<string>(parsedArgs["out"]);
 
     bool verbose = false;
     if (parsedArgs.count("verbose"))
         verbose = us::any_cast<bool>(parsedArgs["verbose"]);
 
     int maxNumDirs = 3;
     if (parsedArgs.count("numdirs"))
         maxNumDirs = us::any_cast<int>(parsedArgs["numdirs"]);
 
     bool normalize = false;
     if (parsedArgs.count("normalize"))
         normalize = us::any_cast<bool>(parsedArgs["normalize"]);
 
     try
     {
         typedef itk::Image<unsigned char, 3>                                    ItkUcharImgType;
         typedef itk::Image< itk::Vector< float, 3>, 3 >                         ItkDirectionImage3DType;
         typedef itk::VectorContainer< unsigned int, ItkDirectionImage3DType::Pointer >   ItkDirectionImageContainerType;
 
         // load fiber bundle
-        mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
+        mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
 
         // load/create mask image
         ItkUcharImgType::Pointer itkMaskImage = NULL;
         if (maskImage.compare("")!=0)
         {
             std::cout << "Using mask image";
             itkMaskImage = ItkUcharImgType::New();
             mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(maskImage)->GetData());
             mitk::CastToItkImage(mitkMaskImage, itkMaskImage);
         }
 
         // extract directions from fiber bundle
         itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
         fOdfFilter->SetFiberBundle(inputTractogram);
         fOdfFilter->SetMaskImage(itkMaskImage);
         fOdfFilter->SetAngularThreshold(cos(angularThreshold*M_PI/180));
         fOdfFilter->SetNormalizeVectors(normalize);
         fOdfFilter->SetUseWorkingCopy(false);
         fOdfFilter->SetSizeThreshold(peakThreshold);
         fOdfFilter->SetMaxNumDirections(maxNumDirs);
         fOdfFilter->Update();
         ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
 
         // write direction images
         for (unsigned int i=0; i<directionImageContainer->Size(); i++)
         {
             itk::TractsToVectorImageFilter<float>::ItkDirectionImageType::Pointer itkImg = directionImageContainer->GetElement(i);
             typedef itk::ImageFileWriter< itk::TractsToVectorImageFilter<float>::ItkDirectionImageType > WriterType;
             WriterType::Pointer writer = WriterType::New();
 
             string outfilename = outRoot;
             outfilename.append("_DIRECTION_");
             outfilename.append(boost::lexical_cast<string>(i));
             outfilename.append(".nrrd");
 
             writer->SetFileName(outfilename.c_str());
             writer->SetInput(itkImg);
             writer->Update();
         }
 
         if (verbose)
         {
             // write vector field
-            mitk::FiberBundleX::Pointer directions = fOdfFilter->GetOutputFiberBundle();
+            mitk::FiberBundle::Pointer directions = fOdfFilter->GetOutputFiberBundle();
 
             string outfilename = outRoot;
             outfilename.append("_VECTOR_FIELD.fib");
 
             mitk::IOUtil::SaveBaseData(directions.GetPointer(), outfilename );
 
             // write num direction image
             {
                 ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
                 typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
 
                 string outfilename = outRoot;
                 outfilename.append("_NUM_DIRECTIONS.nrrd");
 
                 writer->SetFileName(outfilename.c_str());
                 writer->SetInput(numDirImage);
                 writer->Update();
             }
         }
     }
     catch (itk::ExceptionObject e)
     {
         std::cout << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         std::cout << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         std::cout << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/FiberExtraction.cpp b/Modules/DiffusionImaging/MiniApps/FiberExtraction.cpp
index b3426f2f64..b038c2526c 100755
--- a/Modules/DiffusionImaging/MiniApps/FiberExtraction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/FiberExtraction.cpp
@@ -1,154 +1,154 @@
 /*===================================================================
 
 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 <metaCommand.h>
 #include "mitkCommandLineParser.h"
 #include <usAny.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <mitkCoreObjectFactory.h>
 #include <mitkPlanarFigure.h>
 #include <mitkPlanarFigureComposite.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Fiber Extraction");
     parser.setCategory("Fiber Tracking and Processing Methods");
     parser.setContributor("MBI");
     parser.setDescription(" ");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::String, "Input:", "input tractogram (.fib/.trk)", us::Any(), false);
     parser.addArgument("out", "o", mitkCommandLineParser::String, "Output:", "output tractogram", us::Any(), false);
     parser.addArgument("planfirgure1", "pf1", mitkCommandLineParser::String, "Figure 1:", "first ROI", us::Any(), false);
     parser.addArgument("planfirgure2", "pf2", mitkCommandLineParser::String, "Figure 2:", "second ROI", us::Any());
     parser.addArgument("operation", "op", mitkCommandLineParser::String, "Operation:", "logical operation (AND, OR, NOT)", us::Any());
 
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     string inFib = us::any_cast<string>(parsedArgs["input"]);
     string outFib = us::any_cast<string>(parsedArgs["out"]);
     string pf1_path = us::any_cast<string>(parsedArgs["planfirgure1"]);
 
     string operation("");
     string pf2_path("");
     if (parsedArgs.count("operation"))
     {
         operation = us::any_cast<string>(parsedArgs["operation"]);
         if (parsedArgs.count("planfirgure2") && (operation=="AND" || operation=="OR"))
             pf2_path = us::any_cast<string>(parsedArgs["planfirgure2"]);
     }
 
     try
     {
         typedef itk::Image<unsigned char, 3>                                    ItkUcharImgType;
 
         // load fiber bundle
-        mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(inFib)->GetData());
-        mitk::FiberBundleX::Pointer result;
+        mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(inFib)->GetData());
+        mitk::FiberBundle::Pointer result;
 
         mitk::BaseData::Pointer input1 = mitk::IOUtil::LoadDataNode(pf1_path)->GetData();
         mitk::PlanarFigure::Pointer pf1 = dynamic_cast<mitk::PlanarFigure*>(input1.GetPointer());
 
         if (pf1.IsNotNull())
         {
             mitk::BaseData::Pointer input2;
             mitk::PlanarFigure::Pointer pf2;
             if (!pf2_path.empty())
             {
                 input2 = mitk::IOUtil::LoadDataNode(pf2_path)->GetData();
                 pf2 = dynamic_cast<mitk::PlanarFigure*>(input2.GetPointer());
             }
 
             mitk::PlanarFigureComposite::Pointer pfc = mitk::PlanarFigureComposite::New();
 
             if (operation.empty())
             {
                 result = inputTractogram->ExtractFiberSubset(input1);
             }
             else if (operation=="NOT")
             {
                 pfc->setOperationType(mitk::PFCOMPOSITION_NOT_OPERATION);
                 pfc->addPlanarFigure(input1);
                 result = inputTractogram->ExtractFiberSubset(pfc);
             }
             else if (operation=="AND" && pf2.IsNotNull())
             {
                 pfc->setOperationType(mitk::PFCOMPOSITION_AND_OPERATION);
                 pfc->addPlanarFigure(input1);
                 pfc->addPlanarFigure(input2);
                 result = inputTractogram->ExtractFiberSubset(pfc);
             }
             else if (operation=="OR" && pf2.IsNotNull())
             {
                 pfc->setOperationType(mitk::PFCOMPOSITION_OR_OPERATION);
                 pfc->addPlanarFigure(input1);
                 pfc->addPlanarFigure(input2);
                 result = inputTractogram->ExtractFiberSubset(pfc);
             }
             else
             {
                 std::cout << "Could not process input:";
                 std::cout << pf1_path;
                 std::cout << pf2_path;
                 std::cout << operation;
             }
         }
         else
         {
             ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
             mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(pf1_path)->GetData());
             mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, itkMaskImage);
 
             if (operation=="NOT")
                 result = inputTractogram->ExtractFiberSubset(itkMaskImage, true, true);
             else
                 result = inputTractogram->ExtractFiberSubset(itkMaskImage, true, false);
         }
 
         if (result.IsNotNull())
             mitk::IOUtil::SaveBaseData(result, outFib);
         else
             std::cout << "No valid fiber bundle extracted.";
     }
     catch (itk::ExceptionObject e)
     {
         std::cout << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         std::cout << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         std::cout << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/FiberJoin.cpp b/Modules/DiffusionImaging/MiniApps/FiberJoin.cpp
index 5e8dd0c7c3..6cbeb3248b 100755
--- a/Modules/DiffusionImaging/MiniApps/FiberJoin.cpp
+++ b/Modules/DiffusionImaging/MiniApps/FiberJoin.cpp
@@ -1,89 +1,89 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "MiniAppManager.h"
 #include <mitkBaseDataIOFactory.h>
 #include <metaCommand.h>
 #include "ctkCommandLineParser.h"
 #include <usAny.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <mitkCoreObjectFactory.h>
 #include <mitkPlanarFigure.h>
 #include <mitkPlanarFigureComposite.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 int FiberJoin(int argc, char* argv[])
   {
     mitkCommandLineParser parser;
 
     parser.setTitle("Fiber Join");
     parser.setCategory("Fiber Tracking and Processing Methods");
     parser.setContributor("MBI");
     parser.setDescription("");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::StringList, "Input:", "input tractograms (.fib, vtk file format)", us::Any(), false);
     parser.addArgument("out", "o", mitkCommandLineParser::String, "Output:", "output tractogram", us::Any(), false);
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     mitkCommandLineParser::StringContainerType inFibs = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["input"]);
     string outFib = us::any_cast<string>(parsedArgs["out"]);
 
     if (inFibs.size()<=1)
     {
         std::cout << "More than one input tractogram required!";
         return EXIT_FAILURE;
     }
 
     try
     {
-        mitk::FiberBundleX::Pointer result = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(inFibs.at(0))->GetData());
+        mitk::FiberBundle::Pointer result = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(inFibs.at(0))->GetData());
         for (int i=1; i<inFibs.size(); i++)
         {
             try
             {
-                mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(inFibs.at(i))->GetData());
+                mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(inFibs.at(i))->GetData());
                 result = result->AddBundle(inputTractogram);
             }
             catch(...){ std::cout << "could not load: " << inFibs.at(i); }
         }
         mitk::IOUtil::SaveBaseData(result, outFib);
     }
     catch (itk::ExceptionObject e)
     {
         std::cout << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         std::cout << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         std::cout << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
 RegisterDiffusionMiniApp(FiberJoin);
diff --git a/Modules/DiffusionImaging/MiniApps/FiberProcessing.cpp b/Modules/DiffusionImaging/MiniApps/FiberProcessing.cpp
index b2c1e2883c..4314696bd2 100644
--- a/Modules/DiffusionImaging/MiniApps/FiberProcessing.cpp
+++ b/Modules/DiffusionImaging/MiniApps/FiberProcessing.cpp
@@ -1,203 +1,203 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <vector>
 #include <iostream>
 #include <fstream>
 #include <algorithm>
 #include <string>
 
 #include <itkImageFileWriter.h>
 #include <itkMetaDataObject.h>
 #include <itkVectorImage.h>
 
 #include <mitkBaseData.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include "mitkCommandLineParser.h"
 #include <boost/lexical_cast.hpp>
 #include <mitkCoreObjectFactory.h>
 #include <mitkIOUtil.h>
 
 
-mitk::FiberBundleX::Pointer LoadFib(std::string filename)
+mitk::FiberBundle::Pointer LoadFib(std::string filename)
 {
     std::vector<mitk::BaseData::Pointer> fibInfile = mitk::IOUtil::Load(filename);
     if( fibInfile.empty() )
         std::cout << "File " << filename << " could not be read!";
     mitk::BaseData::Pointer baseData = fibInfile.at(0);
-    return dynamic_cast<mitk::FiberBundleX*>(baseData.GetPointer());
+    return dynamic_cast<mitk::FiberBundle*>(baseData.GetPointer());
 }
 
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Fiber Processing");
     parser.setCategory("Fiber Tracking and Processing Methods");
     parser.setDescription(" ");
     parser.setContributor("MBI");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input fiber bundle (.fib)", us::Any(), false);
     parser.addArgument("outFile", "o", mitkCommandLineParser::OutputFile, "Output:", "output fiber bundle (.fib)", us::Any(), false);
 
     parser.addArgument("smooth", "s", mitkCommandLineParser::Float, "Spline resampling:", "Resample fiber using splines with the given point distance (in mm)");
     parser.addArgument("compress", "c", mitkCommandLineParser::Float, "Compress:", "Compress fiber using the given error threshold (in mm)");
     parser.addArgument("minLength", "l", mitkCommandLineParser::Float, "Minimum length:", "Minimum fiber length (in mm)");
     parser.addArgument("maxLength", "m", mitkCommandLineParser::Float, "Maximum length:", "Maximum fiber length (in mm)");
     parser.addArgument("minCurv", "a", mitkCommandLineParser::Float, "Minimum curvature radius:", "Minimum curvature radius (in mm)");
     parser.addArgument("mirror", "p", mitkCommandLineParser::Int, "Invert coordinates:", "Invert fiber coordinates XYZ (e.g. 010 to invert y-coordinate of each fiber point)");
 
     parser.addArgument("rotate-x", "rx", mitkCommandLineParser::Float, "Rotate x-axis:", "Rotate around x-axis (if copy is given the copy is rotated, in deg)");
     parser.addArgument("rotate-y", "ry", mitkCommandLineParser::Float, "Rotate y-axis:", "Rotate around y-axis (if copy is given the copy is rotated, in deg)");
     parser.addArgument("rotate-z", "rz", mitkCommandLineParser::Float, "Rotate z-axis:", "Rotate around z-axis (if copy is given the copy is rotated, in deg)");
 
     parser.addArgument("scale-x", "sx", mitkCommandLineParser::Float, "Scale x-axis:", "Scale in direction of x-axis (if copy is given the copy is scaled)");
     parser.addArgument("scale-y", "sy", mitkCommandLineParser::Float, "Scale y-axis:", "Scale in direction of y-axis (if copy is given the copy is scaled)");
     parser.addArgument("scale-z", "sz", mitkCommandLineParser::Float, "Scale z-axis", "Scale in direction of z-axis (if copy is given the copy is scaled)");
 
     parser.addArgument("translate-x", "tx", mitkCommandLineParser::Float, "Translate x-axis:", "Translate in direction of x-axis (if copy is given the copy is translated, in mm)");
     parser.addArgument("translate-y", "ty", mitkCommandLineParser::Float, "Translate y-axis:", "Translate in direction of y-axis (if copy is given the copy is translated, in mm)");
     parser.addArgument("translate-z", "tz", mitkCommandLineParser::Float, "Translate z-axis:", "Translate in direction of z-axis (if copy is given the copy is translated, in mm)");
 
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     float smoothDist = -1;
     if (parsedArgs.count("smooth"))
         smoothDist = us::any_cast<float>(parsedArgs["smooth"]);
 
     float compress = -1;
     if (parsedArgs.count("compress"))
         compress = us::any_cast<float>(parsedArgs["compress"]);
 
     float minFiberLength = -1;
     if (parsedArgs.count("minLength"))
         minFiberLength = us::any_cast<float>(parsedArgs["minLength"]);
 
     float maxFiberLength = -1;
     if (parsedArgs.count("maxLength"))
         maxFiberLength = us::any_cast<float>(parsedArgs["maxLength"]);
 
     float curvThres = -1;
     if (parsedArgs.count("minCurv"))
         curvThres = us::any_cast<float>(parsedArgs["minCurv"]);
 
     int axis = 0;
     if (parsedArgs.count("mirror"))
         axis = us::any_cast<int>(parsedArgs["mirror"]);
 
     float rotateX = 0;
     if (parsedArgs.count("rotate-x"))
         rotateX = us::any_cast<float>(parsedArgs["rotate-x"]);
 
     float rotateY = 0;
     if (parsedArgs.count("rotate-y"))
         rotateY = us::any_cast<float>(parsedArgs["rotate-y"]);
 
     float rotateZ = 0;
     if (parsedArgs.count("rotate-z"))
         rotateZ = us::any_cast<float>(parsedArgs["rotate-z"]);
 
     float scaleX = 0;
     if (parsedArgs.count("scale-x"))
         scaleX = us::any_cast<float>(parsedArgs["scale-x"]);
 
     float scaleY = 0;
     if (parsedArgs.count("scale-y"))
         scaleY = us::any_cast<float>(parsedArgs["scale-y"]);
 
     float scaleZ = 0;
     if (parsedArgs.count("scale-z"))
         scaleZ = us::any_cast<float>(parsedArgs["scale-z"]);
 
     float translateX = 0;
     if (parsedArgs.count("translate-x"))
         translateX = us::any_cast<float>(parsedArgs["translate-x"]);
 
     float translateY = 0;
     if (parsedArgs.count("translate-y"))
         translateY = us::any_cast<float>(parsedArgs["translate-y"]);
 
     float translateZ = 0;
     if (parsedArgs.count("translate-z"))
         translateZ = us::any_cast<float>(parsedArgs["translate-z"]);
 
 
     string inFileName = us::any_cast<string>(parsedArgs["input"]);
     string outFileName = us::any_cast<string>(parsedArgs["outFile"]);
 
     try
     {
-        mitk::FiberBundleX::Pointer fib = LoadFib(inFileName);
+        mitk::FiberBundle::Pointer fib = LoadFib(inFileName);
 
         if (minFiberLength>0)
             fib->RemoveShortFibers(minFiberLength);
 
         if (maxFiberLength>0)
             fib->RemoveLongFibers(maxFiberLength);
 
         if (curvThres>0)
             fib->ApplyCurvatureThreshold(curvThres, false);
 
         if (smoothDist>0)
             fib->ResampleSpline(smoothDist);
 
         if (compress>0)
             fib->Compress(compress);
 
         if (axis/100==1)
             fib->MirrorFibers(0);
 
         if ((axis%100)/10==1)
             fib->MirrorFibers(1);
 
         if (axis%10==1)
             fib->MirrorFibers(2);
 
 
         if (rotateX > 0 || rotateY > 0 || rotateZ > 0){
             std::cout << "Rotate " << rotateX << " " << rotateY << " " << rotateZ;
             fib->RotateAroundAxis(rotateX, rotateY, rotateZ);
         }
         if (translateX > 0 || translateY > 0 || translateZ > 0){
             fib->TranslateFibers(translateX, translateY, translateZ);
         }
         if (scaleX > 0 || scaleY > 0 || scaleZ > 0)
             fib->ScaleFibers(scaleX, scaleY, scaleZ);
 
         mitk::IOUtil::SaveBaseData(fib.GetPointer(), outFileName );
 
     }
     catch (itk::ExceptionObject e)
     {
         std::cout << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         std::cout << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         std::cout << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/Fiberfox.cpp b/Modules/DiffusionImaging/MiniApps/Fiberfox.cpp
index 341ecc55ef..d47a1db705 100755
--- a/Modules/DiffusionImaging/MiniApps/Fiberfox.cpp
+++ b/Modules/DiffusionImaging/MiniApps/Fiberfox.cpp
@@ -1,83 +1,83 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 #include <mitkProperties.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <mitkFiberfoxParameters.h>
 #include "mitkCommandLineParser.h"
 
 #include <itkAddArtifactsToDwiImageFilter.h>
 #include <itkTractsToDWIImageFilter.h>
 
 #include "boost/property_tree/ptree.hpp"
 #include "boost/property_tree/xml_parser.hpp"
 #include "boost/foreach.hpp"
 
 /** TODO: Proritype signal komplett speichern oder bild mit speichern. */
 /** TODO: Tarball aus images und parametern? */
 /** TODO: Artefakte auf bild in miniapp */
 
 using namespace mitk;
 
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
     parser.setTitle("FiberFox");
     parser.setCategory("Fiber Tracking and Processing Methods");
     parser.setContributor("MBI");
     parser.setDescription(" ");
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("out", "o", mitkCommandLineParser::OutputFile, "Output root:", "output root", us::Any(), false);
     parser.addArgument("parameters", "p", mitkCommandLineParser::InputFile, "Parameter file:", "fiberfox parameter file", us::Any(), false);
     parser.addArgument("fiberbundle", "f", mitkCommandLineParser::String, "Fiberbundle:", "", us::Any(), false);
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     string outName = us::any_cast<string>(parsedArgs["out"]);
     string paramName = us::any_cast<string>(parsedArgs["parameters"]);
 
     string fibFile = "";
     if (parsedArgs.count("fiberbundle"))
         fibFile = us::any_cast<string>(parsedArgs["fiberbundle"]);
 
     {
         FiberfoxParameters<double> parameters;
         parameters.LoadParameters(paramName);
 
-        mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
+        mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
 
         itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
         tractsToDwiFilter->SetParameters(parameters);
         tractsToDwiFilter->SetFiberBundle(inputTractogram);
         tractsToDwiFilter->Update();
 
         mitk::Image::Pointer image = mitk::GrabItkImageMemory( tractsToDwiFilter->GetOutput() );
         image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( parameters.m_SignalGen.GetGradientDirections() ) );
         image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( parameters.m_SignalGen.m_Bvalue ) );
         mitk::DiffusionPropertyHelper propertyHelper( image );
         propertyHelper.InitializeImage();
 
         mitk::IOUtil::Save(image, outName.c_str());
     }
     return EXIT_SUCCESS;
 }
 
diff --git a/Modules/DiffusionImaging/MiniApps/FileFormatConverter.cpp b/Modules/DiffusionImaging/MiniApps/FileFormatConverter.cpp
index e9ae47d575..7aa93838d2 100644
--- a/Modules/DiffusionImaging/MiniApps/FileFormatConverter.cpp
+++ b/Modules/DiffusionImaging/MiniApps/FileFormatConverter.cpp
@@ -1,77 +1,77 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkImageCast.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include "mitkCommandLineParser.h"
 
 using namespace mitk;
 
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Format Converter");
     parser.setCategory("Fiber Tracking and Processing Methods");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("in", "i", mitkCommandLineParser::InputFile, "Input:", "input file", us::Any(), false);
     parser.addArgument("out", "o", mitkCommandLineParser::OutputFile, "Output:", "output file", us::Any(), false);
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     // mandatory arguments
     string inName = us::any_cast<string>(parsedArgs["in"]);
     string outName = us::any_cast<string>(parsedArgs["out"]);
 
     try
     {
         std::vector<mitk::BaseData::Pointer> baseData = mitk::IOUtil::Load(inName);
 
         if ( baseData.size()>0 && dynamic_cast<Image*>(baseData[0].GetPointer()) )
         {
             mitk::IOUtil::Save(dynamic_cast<Image*>(baseData[0].GetPointer()), outName.c_str());
         }
-        else if ( baseData.size()>0 && dynamic_cast<FiberBundleX*>(baseData[0].GetPointer()) )
+        else if ( baseData.size()>0 && dynamic_cast<FiberBundle*>(baseData[0].GetPointer()) )
         {
-            mitk::IOUtil::Save(dynamic_cast<FiberBundleX*>(baseData[0].GetPointer()) ,outName.c_str());
+            mitk::IOUtil::Save(dynamic_cast<FiberBundle*>(baseData[0].GetPointer()) ,outName.c_str());
         }
         else
             std::cout << "File type currently not supported!";
     }
     catch (itk::ExceptionObject e)
     {
         std::cout << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         std::cout << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         std::cout << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/GibbsTracking.cpp b/Modules/DiffusionImaging/MiniApps/GibbsTracking.cpp
index 7c25e1af86..881014cba2 100755
--- a/Modules/DiffusionImaging/MiniApps/GibbsTracking.cpp
+++ b/Modules/DiffusionImaging/MiniApps/GibbsTracking.cpp
@@ -1,237 +1,237 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkImageCast.h>
 #include <mitkQBallImage.h>
 #include <mitkTensorImage.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <itkGibbsTrackingFilter.h>
 #include <itkDiffusionTensor3D.h>
 #include <itkShCoefficientImageImporter.h>
 #include <mitkImageToItk.h>
 #include <mitkIOUtil.h>
 #include "mitkCommandLineParser.h"
 #include <boost/algorithm/string.hpp>
 #include <itkFlipImageFilter.h>
 #include <mitkCoreObjectFactory.h>
 
 template<int shOrder>
 typename itk::ShCoefficientImageImporter< float, shOrder >::QballImageType::Pointer TemplatedConvertShCoeffs(mitk::Image* mitkImg, int toolkit, bool noFlip = false)
 {
     typedef itk::ShCoefficientImageImporter< float, shOrder > FilterType;
     typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
     CasterType::Pointer caster = CasterType::New();
     caster->SetInput(mitkImg);
     caster->Update();
     itk::Image< float, 4 >::Pointer itkImage = caster->GetOutput();
     typename FilterType::Pointer filter = FilterType::New();
 
     if (noFlip)
     {
         filter->SetInputImage(itkImage);
     }
     else
     {
         std::cout << "Flipping image";
         itk::FixedArray<bool, 4> flipAxes;
         flipAxes[0] = true;
         flipAxes[1] = true;
         flipAxes[2] = false;
         flipAxes[3] = false;
         itk::FlipImageFilter< itk::Image< float, 4 > >::Pointer flipper = itk::FlipImageFilter< itk::Image< float, 4 > >::New();
         flipper->SetInput(itkImage);
         flipper->SetFlipAxes(flipAxes);
         flipper->Update();
         itk::Image< float, 4 >::Pointer flipped = flipper->GetOutput();
         itk::Matrix< double,4,4 > m = itkImage->GetDirection(); m[0][0] *= -1; m[1][1] *= -1;
         flipped->SetDirection(m);
 
         itk::Point< float, 4 > o = itkImage->GetOrigin();
         o[0] -= (flipped->GetLargestPossibleRegion().GetSize(0)-1);
         o[1] -= (flipped->GetLargestPossibleRegion().GetSize(1)-1);
         flipped->SetOrigin(o);
         filter->SetInputImage(flipped);
     }
 
     switch (toolkit)
     {
     case 0:
         filter->SetToolkit(FilterType::FSL);
         break;
     case 1:
         filter->SetToolkit(FilterType::MRTRIX);
         break;
     default:
         filter->SetToolkit(FilterType::FSL);
     }
     filter->GenerateData();
     return filter->GetQballImage();
 }
 
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Gibbs Tracking");
     parser.setCategory("Fiber Tracking and Processing Methods");
     parser.setDescription(" ");
     parser.setContributor("MBI");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input image (tensor, Q-ball or FSL/MRTrix SH-coefficient image)", us::Any(), false);
     parser.addArgument("parameters", "p", mitkCommandLineParser::InputFile, "Parameters:", "parameter file (.gtp)", us::Any(), false);
     parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask:", "binary mask image");
     parser.addArgument("shConvention", "s", mitkCommandLineParser::String, "SH coefficient:", "sh coefficient convention (FSL, MRtrix)", string("FSL"), true);
     parser.addArgument("outFile", "o", mitkCommandLineParser::OutputFile, "Output:", "output fiber bundle (.fib)", us::Any(), false);
     parser.addArgument("noFlip", "f", mitkCommandLineParser::Bool, "No flip:", "do not flip input image to match MITK coordinate convention");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     string inFileName = us::any_cast<string>(parsedArgs["input"]);
     string paramFileName = us::any_cast<string>(parsedArgs["parameters"]);
     string outFileName = us::any_cast<string>(parsedArgs["outFile"]);
 
     bool noFlip = false;
     if (parsedArgs.count("noFlip"))
         noFlip = us::any_cast<bool>(parsedArgs["noFlip"]);
 
     try
     {
         // instantiate gibbs tracker
         typedef itk::Vector<float, QBALL_ODFSIZE>   OdfVectorType;
         typedef itk::Image<OdfVectorType,3>         ItkQballImageType;
         typedef itk::GibbsTrackingFilter<ItkQballImageType> GibbsTrackingFilterType;
         GibbsTrackingFilterType::Pointer gibbsTracker = GibbsTrackingFilterType::New();
 
         // load input image
         mitk::Image::Pointer mitkImage = mitk::IOUtil::LoadImage(inFileName);
 
         // try to cast to qball image
         if( boost::algorithm::ends_with(inFileName, ".qbi") )
         {
             std::cout << "Loading qball image ...";
             mitk::QBallImage::Pointer mitkQballImage = dynamic_cast<mitk::QBallImage*>(mitkImage.GetPointer());
             ItkQballImageType::Pointer itk_qbi = ItkQballImageType::New();
             mitk::CastToItkImage(mitkQballImage, itk_qbi);
             gibbsTracker->SetQBallImage(itk_qbi.GetPointer());
         }
         else if( boost::algorithm::ends_with(inFileName, ".dti") )
         {
             std::cout << "Loading tensor image ...";
             typedef itk::Image< itk::DiffusionTensor3D<float>, 3 >    ItkTensorImage;
             mitk::TensorImage::Pointer mitkTensorImage = dynamic_cast<mitk::TensorImage*>(mitkImage.GetPointer());
             ItkTensorImage::Pointer itk_dti = ItkTensorImage::New();
             mitk::CastToItkImage(mitkTensorImage, itk_dti);
             gibbsTracker->SetTensorImage(itk_dti);
         }
         else if ( boost::algorithm::ends_with(inFileName, ".nii") )
         {
             std::cout << "Loading sh-coefficient image ...";
             int nrCoeffs = mitkImage->GetLargestPossibleRegion().GetSize()[3];
             int c=3, d=2-2*nrCoeffs;
             double D = c*c-4*d;
             int shOrder;
             if (D>0)
             {
                 shOrder = (-c+sqrt(D))/2.0;
                 if (shOrder<0)
                     shOrder = (-c-sqrt(D))/2.0;
             }
             else if (D==0)
                 shOrder = -c/2.0;
 
             std::cout << "using SH-order " << shOrder;
 
             int toolkitConvention = 0;
 
             if (parsedArgs.count("shConvention"))
             {
                 string convention = us::any_cast<string>(parsedArgs["shConvention"]).c_str();
 
                 if ( boost::algorithm::equals(convention, "MRtrix") )
                 {
                     toolkitConvention = 1;
                     std::cout << "Using MRtrix style sh-coefficient convention";
                 }
                 else
                     std::cout << "Using FSL style sh-coefficient convention";
             }
             else
                 std::cout << "Using FSL style sh-coefficient convention";
 
             switch (shOrder)
             {
             case 4:
                 gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<4>(mitkImage, toolkitConvention, noFlip));
                 break;
             case 6:
                 gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<6>(mitkImage, toolkitConvention, noFlip));
                 break;
             case 8:
                 gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<8>(mitkImage, toolkitConvention, noFlip));
                 break;
             case 10:
                 gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<10>(mitkImage, toolkitConvention, noFlip));
                 break;
             case 12:
                 gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<12>(mitkImage, toolkitConvention, noFlip));
                 break;
             default:
                 std::cout << "SH-order " << shOrder << " not supported";
             }
         }
         else
             return EXIT_FAILURE;
 
         // global tracking
         if (parsedArgs.count("mask"))
         {
             typedef itk::Image<float,3> MaskImgType;
             mitk::Image::Pointer mitkMaskImage = mitk::IOUtil::LoadImage(us::any_cast<string>(parsedArgs["mask"]));
             MaskImgType::Pointer itk_mask = MaskImgType::New();
             mitk::CastToItkImage(mitkMaskImage, itk_mask);
             gibbsTracker->SetMaskImage(itk_mask);
         }
 
         gibbsTracker->SetDuplicateImage(false);
         gibbsTracker->SetLoadParameterFile( paramFileName );
 //        gibbsTracker->SetLutPath( "" );
         gibbsTracker->Update();
 
-        mitk::FiberBundleX::Pointer mitkFiberBundle = mitk::FiberBundleX::New(gibbsTracker->GetFiberBundle());
+        mitk::FiberBundle::Pointer mitkFiberBundle = mitk::FiberBundle::New(gibbsTracker->GetFiberBundle());
         mitkFiberBundle->SetReferenceGeometry(mitkImage->GetGeometry());
 
         mitk::IOUtil::SaveBaseData(mitkFiberBundle.GetPointer(), outFileName );
     }
     catch (itk::ExceptionObject e)
     {
         std::cout << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         std::cout << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         std::cout << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/LocalDirectionalFiberPlausibility.cpp b/Modules/DiffusionImaging/MiniApps/LocalDirectionalFiberPlausibility.cpp
index bd42f2f931..326838cef7 100755
--- a/Modules/DiffusionImaging/MiniApps/LocalDirectionalFiberPlausibility.cpp
+++ b/Modules/DiffusionImaging/MiniApps/LocalDirectionalFiberPlausibility.cpp
@@ -1,300 +1,300 @@
 /*===================================================================
 
 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 <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <itkEvaluateDirectionImagesFilter.h>
 #include <metaCommand.h>
 #include "mitkCommandLineParser.h"
 #include <itkTractsToVectorImageFilter.h>
 #include <usAny.h>
 #include <itkImageFileWriter.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <iostream>
 #include <fstream>
 #include <itksys/SystemTools.hxx>
 #include <mitkCoreObjectFactory.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Local Directional Fiber Plausibility");
     parser.setCategory("Fiber Tracking and Processing Methods");
     parser.setDescription(" ");
     parser.setContributor("MBI");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input tractogram (.fib, vtk ascii file format)", us::Any(), false);
     parser.addArgument("reference", "r", mitkCommandLineParser::StringList, "Reference images:", "reference direction images", us::Any(), false);
     parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
     parser.addArgument("mask", "m", mitkCommandLineParser::StringList, "Masks:", "mask images");
     parser.addArgument("athresh", "a", mitkCommandLineParser::Float, "Angular threshold:", "angular threshold in degrees. closer fiber directions are regarded as one direction and clustered together.", 25, true);
     parser.addArgument("verbose", "v", mitkCommandLineParser::Bool, "Verbose:", "output optional and intermediate calculation results");
     parser.addArgument("ignore", "n", mitkCommandLineParser::Bool, "Ignore:", "don't increase error for missing or too many directions");
     parser.addArgument("fileID", "id", mitkCommandLineParser::String, "ID:", "optional ID field");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     mitkCommandLineParser::StringContainerType referenceImages = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["reference"]);
     mitkCommandLineParser::StringContainerType maskImages;
     if (parsedArgs.count("mask"))
         maskImages = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["mask"]);
 
     string fibFile = us::any_cast<string>(parsedArgs["input"]);
 
     float angularThreshold = 25;
     if (parsedArgs.count("athresh"))
         angularThreshold = us::any_cast<float>(parsedArgs["athresh"]);
 
     string outRoot = us::any_cast<string>(parsedArgs["out"]);
 
     bool verbose = false;
     if (parsedArgs.count("verbose"))
         verbose = us::any_cast<bool>(parsedArgs["verbose"]);
 
     bool ignore = false;
     if (parsedArgs.count("ignore"))
         ignore = us::any_cast<bool>(parsedArgs["ignore"]);
 
     string fileID = "";
     if (parsedArgs.count("fileID"))
         fileID = us::any_cast<string>(parsedArgs["fileID"]);
 
 
     try
     {
         typedef itk::Image<unsigned char, 3>                                    ItkUcharImgType;
         typedef itk::Image< itk::Vector< float, 3>, 3 >                         ItkDirectionImage3DType;
         typedef itk::VectorContainer< unsigned int, ItkDirectionImage3DType::Pointer >   ItkDirectionImageContainerType;
         typedef itk::EvaluateDirectionImagesFilter< float >                     EvaluationFilterType;
 
         // load fiber bundle
-        mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
+        mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
 
         // load reference directions
         ItkDirectionImageContainerType::Pointer referenceImageContainer = ItkDirectionImageContainerType::New();
         for (unsigned int i=0; i<referenceImages.size(); i++)
         {
             try
             {
                 mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(referenceImages.at(i))->GetData());
                 typedef mitk::ImageToItk< ItkDirectionImage3DType > CasterType;
                 CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(img);
                 caster->Update();
                 ItkDirectionImage3DType::Pointer itkImg = caster->GetOutput();
                 referenceImageContainer->InsertElement(referenceImageContainer->Size(),itkImg);
             }
             catch(...){ std::cout << "could not load: " << referenceImages.at(i); }
         }
 
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         ItkDirectionImage3DType::Pointer dirImg = referenceImageContainer->GetElement(0);
         itkMaskImage->SetSpacing( dirImg->GetSpacing() );
         itkMaskImage->SetOrigin( dirImg->GetOrigin() );
         itkMaskImage->SetDirection( dirImg->GetDirection() );
         itkMaskImage->SetLargestPossibleRegion( dirImg->GetLargestPossibleRegion() );
         itkMaskImage->SetBufferedRegion( dirImg->GetLargestPossibleRegion() );
         itkMaskImage->SetRequestedRegion( dirImg->GetLargestPossibleRegion() );
         itkMaskImage->Allocate();
         itkMaskImage->FillBuffer(1);
 
         // extract directions from fiber bundle
         itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
         fOdfFilter->SetFiberBundle(inputTractogram);
         fOdfFilter->SetMaskImage(itkMaskImage);
         fOdfFilter->SetAngularThreshold(cos(angularThreshold*M_PI/180));
         fOdfFilter->SetNormalizeVectors(true);
         fOdfFilter->SetUseWorkingCopy(false);
         fOdfFilter->Update();
         ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
 
         if (verbose)
         {
             // write vector field
-            mitk::FiberBundleX::Pointer directions = fOdfFilter->GetOutputFiberBundle();
+            mitk::FiberBundle::Pointer directions = fOdfFilter->GetOutputFiberBundle();
 
             string outfilename = outRoot;
             outfilename.append("_VECTOR_FIELD.fib");
 
             mitk::IOUtil::SaveBaseData(directions.GetPointer(), outfilename );
 
             // write direction images
             for (unsigned int i=0; i<directionImageContainer->Size(); i++)
             {
                 itk::TractsToVectorImageFilter<float>::ItkDirectionImageType::Pointer itkImg = directionImageContainer->GetElement(i);
                 typedef itk::ImageFileWriter< itk::TractsToVectorImageFilter<float>::ItkDirectionImageType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
 
                 string outfilename = outRoot;
                 outfilename.append("_DIRECTION_");
                 outfilename.append(boost::lexical_cast<string>(i));
                 outfilename.append(".nrrd");
 
                 writer->SetFileName(outfilename.c_str());
                 writer->SetInput(itkImg);
                 writer->Update();
             }
 
             // write num direction image
             {
                 ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
                 typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
 
                 string outfilename = outRoot;
                 outfilename.append("_NUM_DIRECTIONS.nrrd");
 
                 writer->SetFileName(outfilename.c_str());
                 writer->SetInput(numDirImage);
                 writer->Update();
             }
         }
 
         string logFile = outRoot;
         logFile.append("_ANGULAR_ERROR.csv");
         ofstream file;
         file.open (logFile.c_str());
 
         if (maskImages.size()>0)
         {
             for (unsigned int i=0; i<maskImages.size(); i++)
             {
                 mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(maskImages.at(i))->GetData());
                 mitk::CastToItkImage(mitkMaskImage, itkMaskImage);
 
                 // evaluate directions
                 EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
                 evaluationFilter->SetImageSet(directionImageContainer);
                 evaluationFilter->SetReferenceImageSet(referenceImageContainer);
                 evaluationFilter->SetMaskImage(itkMaskImage);
                 evaluationFilter->SetIgnoreMissingDirections(ignore);
                 evaluationFilter->Update();
 
                 if (verbose)
                 {
                     EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
                     typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
                     WriterType::Pointer writer = WriterType::New();
 
                     string outfilename = outRoot;
                     outfilename.append("_ERROR_IMAGE.nrrd");
 
                     writer->SetFileName(outfilename.c_str());
                     writer->SetInput(angularErrorImage);
                     writer->Update();
                 }
 
                 string maskFileName = itksys::SystemTools::GetFilenameWithoutExtension(maskImages.at(i));
                 unsigned found = maskFileName.find_last_of("_");
 
                 string sens = itksys::SystemTools::GetFilenameWithoutLastExtension(fibFile);
                 if (!fileID.empty())
                     sens = fileID;
                 sens.append(",");
 
                 sens.append(maskFileName.substr(found+1));
                 sens.append(",");
 
                 sens.append(boost::lexical_cast<string>(evaluationFilter->GetMeanAngularError()));
                 sens.append(",");
 
                 sens.append(boost::lexical_cast<string>(evaluationFilter->GetMedianAngularError()));
                 sens.append(",");
 
                 sens.append(boost::lexical_cast<string>(evaluationFilter->GetMaxAngularError()));
                 sens.append(",");
 
                 sens.append(boost::lexical_cast<string>(evaluationFilter->GetMinAngularError()));
                 sens.append(",");
 
                 sens.append(boost::lexical_cast<string>(std::sqrt(evaluationFilter->GetVarAngularError())));
                 sens.append(";\n");
                 file << sens;
             }
         }
         else
         {
             // evaluate directions
             EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
             evaluationFilter->SetImageSet(directionImageContainer);
             evaluationFilter->SetReferenceImageSet(referenceImageContainer);
             evaluationFilter->SetMaskImage(itkMaskImage);
             evaluationFilter->SetIgnoreMissingDirections(ignore);
             evaluationFilter->Update();
 
             if (verbose)
             {
                 EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
                 typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
 
                 string outfilename = outRoot;
                 outfilename.append("_ERROR_IMAGE.nrrd");
 
                 writer->SetFileName(outfilename.c_str());
                 writer->SetInput(angularErrorImage);
                 writer->Update();
             }
 
             string sens = itksys::SystemTools::GetFilenameWithoutLastExtension(fibFile);
             if (!fileID.empty())
                 sens = fileID;
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(evaluationFilter->GetMeanAngularError()));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(evaluationFilter->GetMedianAngularError()));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(evaluationFilter->GetMaxAngularError()));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(evaluationFilter->GetMinAngularError()));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(std::sqrt(evaluationFilter->GetVarAngularError())));
             sens.append(";\n");
             file << sens;
         }
         file.close();
     }
     catch (itk::ExceptionObject e)
     {
         std::cout << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         std::cout << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         std::cout << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/MultishellMethods.cpp b/Modules/DiffusionImaging/MiniApps/MultishellMethods.cpp
index 0b99f56cae..368b967924 100644
--- a/Modules/DiffusionImaging/MiniApps/MultishellMethods.cpp
+++ b/Modules/DiffusionImaging/MiniApps/MultishellMethods.cpp
@@ -1,216 +1,216 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #include <vector>
 #include <iostream>
 #include <fstream>
 #include <algorithm>
 #include <string>
 
 #include <itkImage.h>
 #include <itkImageFileReader.h>
 #include <itkExceptionObject.h>
 #include <itkImageFileWriter.h>
 #include <itkMetaDataObject.h>
 #include <itkVectorImage.h>
 #include <itkResampleImageFilter.h>
 
 #include <mitkImage.h>
 #include <mitkQBallImage.h>
 #include <mitkBaseData.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include "mitkCommandLineParser.h"
 #include <boost/lexical_cast.hpp>
 
 #include <itkRadialMultishellToSingleshellImageFilter.h>
 #include <itkADCAverageFunctor.h>
 #include <itkBiExpFitFunctor.h>
 #include <itkKurtosisFitFunctor.h>
 #include <itkDwiGradientLengthCorrectionFilter.h>
 #include <mitkIOUtil.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkProperties.h>
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Multishell Methods");
   parser.setCategory("Fiber Tracking and Processing Methods");
   parser.setDescription("");
   parser.setContributor("MBI");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("in", "i", mitkCommandLineParser::InputFile, "Input:", "input file", us::Any(), false);
   parser.addArgument("out", "o", mitkCommandLineParser::OutputFile, "Output:", "output file", us::Any(), false);
   parser.addArgument("adc", "D", mitkCommandLineParser::Bool, "ADC:", "ADC Average", us::Any(), false);
   parser.addArgument("akc", "K", mitkCommandLineParser::Bool, "Kurtosis fit:", "Kurtosis Fit", us::Any(), false);
   parser.addArgument("biexp", "B", mitkCommandLineParser::Bool, "BiExp fit:", "BiExp fit", us::Any(), false);
   parser.addArgument("targetbvalue", "b", mitkCommandLineParser::String, "b Value:", "target bValue (mean, min, max)", us::Any(), false);
 
   map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   // mandatory arguments
   string inName = us::any_cast<string>(parsedArgs["in"]);
   string outName = us::any_cast<string>(parsedArgs["out"]);
   bool applyADC = us::any_cast<bool>(parsedArgs["adc"]);
   bool applyAKC = us::any_cast<bool>(parsedArgs["akc"]);
   bool applyBiExp = us::any_cast<bool>(parsedArgs["biexp"]);
   string targetType = us::any_cast<string>(parsedArgs["targetbvalue"]);
 
   try
   {
     std::cout << "Loading " << inName;
 
     mitk::Image::Pointer dwi = mitk::IOUtil::LoadImage(inName);
 
     if ( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dwi ) )
     {
       typedef itk::RadialMultishellToSingleshellImageFilter<short, short> FilterType;
 
       typedef itk::DwiGradientLengthCorrectionFilter  CorrectionFilterType;
 
       CorrectionFilterType::Pointer roundfilter = CorrectionFilterType::New();
       roundfilter->SetRoundingValue( 1000 );
       roundfilter->SetReferenceBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi ));
       roundfilter->SetReferenceGradientDirectionContainer(mitk::DiffusionPropertyHelper::GetGradientContainer(dwi));
       roundfilter->Update();
 
       dwi->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( roundfilter->GetNewBValue()  ) );
       dwi->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( roundfilter->GetOutputGradientDirectionContainer() ) );
 
       // filter input parameter
       const mitk::DiffusionPropertyHelper::BValueMapType
         &originalShellMap  = mitk::DiffusionPropertyHelper::GetBValueMap(dwi);
 
       mitk::DiffusionPropertyHelper::ImageType::Pointer vectorImage = mitk::DiffusionPropertyHelper::ImageType::New();
       mitk::CastToItkImage(dwi, vectorImage);
 
       const mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer
           gradientContainer = mitk::DiffusionPropertyHelper::GetGradientContainer(dwi);
 
       const unsigned int
           &bValue            = mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi );
 
       // filter call
 
 
       vnl_vector<double> bValueList(originalShellMap.size()-1);
       double targetBValue = bValueList.mean();
 
       mitk::DiffusionPropertyHelper::BValueMapType::const_iterator it = originalShellMap.begin();
       ++it; int i = 0 ;
       for(; it != originalShellMap.end(); ++it)
         bValueList.put(i++,it->first);
 
       if( targetType == "mean" )
         targetBValue = bValueList.mean();
       else if( targetType == "min" )
         targetBValue = bValueList.min_value();
       else if( targetType == "max" )
         targetBValue = bValueList.max_value();
 
       if(applyADC)
       {
         FilterType::Pointer filter = FilterType::New();
         filter->SetInput(vectorImage);
         filter->SetOriginalGradientDirections(gradientContainer);
         filter->SetOriginalBValueMap(originalShellMap);
         filter->SetOriginalBValue(bValue);
 
         itk::ADCAverageFunctor::Pointer functor = itk::ADCAverageFunctor::New();
         functor->setListOfBValues(bValueList);
         functor->setTargetBValue(targetBValue);
 
         filter->SetFunctor(functor);
         filter->Update();
         // create new DWI image
         mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
         outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( targetBValue  ) );
         outImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
         mitk::DiffusionPropertyHelper propertyHelper( outImage );
         propertyHelper.InitializeImage();
 
         mitk::IOUtil::Save(outImage, (outName + "_ADC.dwi").c_str());
       }
       if(applyAKC)
       {
         FilterType::Pointer filter = FilterType::New();
         filter->SetInput(vectorImage);
         filter->SetOriginalGradientDirections(gradientContainer);
         filter->SetOriginalBValueMap(originalShellMap);
         filter->SetOriginalBValue(bValue);
 
         itk::KurtosisFitFunctor::Pointer functor = itk::KurtosisFitFunctor::New();
         functor->setListOfBValues(bValueList);
         functor->setTargetBValue(targetBValue);
 
         filter->SetFunctor(functor);
         filter->Update();
         // create new DWI image
         mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
         outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( targetBValue  ) );
         outImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
         mitk::DiffusionPropertyHelper propertyHelper( outImage );
         propertyHelper.InitializeImage();
 
         mitk::IOUtil::Save(outImage, (string(outName) + "_AKC.dwi").c_str());
       }
       if(applyBiExp)
       {
         FilterType::Pointer filter = FilterType::New();
         filter->SetInput(vectorImage);
         filter->SetOriginalGradientDirections(gradientContainer);
         filter->SetOriginalBValueMap(originalShellMap);
         filter->SetOriginalBValue(bValue);
 
         itk::BiExpFitFunctor::Pointer functor = itk::BiExpFitFunctor::New();
         functor->setListOfBValues(bValueList);
         functor->setTargetBValue(targetBValue);
 
         filter->SetFunctor(functor);
         filter->Update();
         // create new DWI image
         mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
         outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( targetBValue  ) );
         outImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
         mitk::DiffusionPropertyHelper propertyHelper( outImage );
         propertyHelper.InitializeImage();
 
         mitk::IOUtil::Save(outImage, (string(outName) + "_BiExp.dwi").c_str());
       }
     }
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/NetworkCreation.cpp b/Modules/DiffusionImaging/MiniApps/NetworkCreation.cpp
index 197472997c..757326ccf5 100644
--- a/Modules/DiffusionImaging/MiniApps/NetworkCreation.cpp
+++ b/Modules/DiffusionImaging/MiniApps/NetworkCreation.cpp
@@ -1,138 +1,138 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // std includes
 #include <string>
 
 // CTK includes
 #include "mitkCommandLineParser.h"
 
 // MITK includes
 #include "mitkConnectomicsNetworkCreator.h"
 #include <mitkCoreObjectFactory.h>
 #include <mitkIOUtil.h>
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Network Creation");
   parser.setCategory("Connectomics");
   parser.setDescription("");
   parser.setContributor("MBI");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("fiberImage", "f", mitkCommandLineParser::InputFile, "Input image", "input fiber image (.fib)", us::Any(), false);
   parser.addArgument("parcellation", "p", mitkCommandLineParser::InputFile, "Parcellation image", "parcellation image", us::Any(), false);
   parser.addArgument("outputNetwork", "o", mitkCommandLineParser::String, "Output network", "where to save the output (.cnf)", us::Any(), false);
 
   parser.addArgument("radius", "r", mitkCommandLineParser::Int, "Radius", "Search radius in mm", 15, true);
   parser.addArgument("noCenterOfMass", "com", mitkCommandLineParser::Bool, "No center of mass", "Do not use center of mass for node positions");
 
   parser.setCategory("Connectomics");
   parser.setTitle("Network Creation");
   parser.setDescription("");
   parser.setContributor("MBI");
 
   map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   //default values
   int searchRadius( 15 );
   bool noCenterOfMass( false );
 
   // parse command line arguments
   std::string fiberFilename = us::any_cast<std::string>(parsedArgs["fiberImage"]);
   std::string parcellationFilename = us::any_cast<std::string>(parsedArgs["parcellation"]);
   std::string outputFilename = us::any_cast<std::string>(parsedArgs["outputNetwork"]);
 
   if (parsedArgs.count("radius"))
     searchRadius = us::any_cast<int>(parsedArgs["radius"]);
 
 
   if (parsedArgs.count("noCenterOfMass"))
     noCenterOfMass = us::any_cast<bool>(parsedArgs["noCenterOfMass"]);
 
   try
   {
 
     const std::string s1="", s2="";
 
     // load fiber image
     std::vector<mitk::BaseData::Pointer> fiberInfile =
       mitk::IOUtil::Load( fiberFilename);
     if( fiberInfile.empty() )
     {
       std::string errorMessage = "Fiber Image at " + fiberFilename + " could not be read. Aborting.";
       MITK_ERROR << errorMessage;
       return EXIT_FAILURE;
     }
     mitk::BaseData* fiberBaseData = fiberInfile.at(0);
-    mitk::FiberBundleX* fiberBundle = dynamic_cast<mitk::FiberBundleX*>( fiberBaseData );
+    mitk::FiberBundle* fiberBundle = dynamic_cast<mitk::FiberBundle*>( fiberBaseData );
 
     // load parcellation
     std::vector<mitk::BaseData::Pointer> parcellationInFile =
       mitk::IOUtil::Load( parcellationFilename);
     if( parcellationInFile.empty() )
     {
       std::string errorMessage = "Parcellation at " + parcellationFilename + " could not be read. Aborting.";
       MITK_ERROR << errorMessage;
       return EXIT_FAILURE;
     }
     mitk::BaseData* parcellationBaseData = parcellationInFile.at(0);
     mitk::Image* parcellationImage = dynamic_cast<mitk::Image*>( parcellationBaseData );
 
 
 
     // do creation
     mitk::ConnectomicsNetworkCreator::Pointer connectomicsNetworkCreator = mitk::ConnectomicsNetworkCreator::New();
     connectomicsNetworkCreator->SetSegmentation( parcellationImage );
     connectomicsNetworkCreator->SetFiberBundle( fiberBundle );
     if( !noCenterOfMass )
     {
       connectomicsNetworkCreator->CalculateCenterOfMass();
     }
     connectomicsNetworkCreator->SetEndPointSearchRadius( searchRadius );
     connectomicsNetworkCreator->CreateNetworkFromFibersAndSegmentation();
 
 
     mitk::ConnectomicsNetwork::Pointer network = connectomicsNetworkCreator->GetNetwork();
 
     std::cout << "searching writer";
 
     mitk::IOUtil::SaveBaseData(network.GetPointer(), outputFilename );
 
     return EXIT_SUCCESS;
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   std::cout << "DONE";
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp b/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp
index fcec556ffc..25145658c4 100755
--- a/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp
@@ -1,355 +1,355 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <itkImageFileWriter.h>
 #include <itkResampleImageFilter.h>
 #include <itkFiniteDiffOdfMaximaExtractionFilter.h>
 
 #include <mitkImage.h>
 #include <mitkQBallImage.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkTensorImage.h>
 
 #include <mitkCoreObjectFactory.h>
 #include "mitkCommandLineParser.h"
 #include <itkShCoefficientImageImporter.h>
 #include <itkFlipImageFilter.h>
 #include <boost/lexical_cast.hpp>
 #include <boost/algorithm/string.hpp>
 
 #include <mitkIOUtil.h>
 
 template<int shOrder>
 int StartPeakExtraction(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("image", "i", mitkCommandLineParser::InputFile, "Input image", "sh coefficient image", us::Any(), false);
     parser.addArgument("outroot", "o", mitkCommandLineParser::OutputDirectory, "Output directory", "output root", us::Any(), false);
     parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask", "mask image");
     parser.addArgument("normalization", "n", mitkCommandLineParser::Int, "Normalization", "0=no norm, 1=max norm, 2=single vec norm", 1, true);
     parser.addArgument("numpeaks", "p", mitkCommandLineParser::Int, "Max. number of peaks", "maximum number of extracted peaks", 2, true);
     parser.addArgument("peakthres", "r", mitkCommandLineParser::Float, "Peak threshold", "peak threshold relative to largest peak", 0.4, true);
     parser.addArgument("abspeakthres", "a", mitkCommandLineParser::Float, "Absolute peak threshold", "absolute peak threshold weighted with local GFA value", 0.06, true);
     parser.addArgument("shConvention", "s", mitkCommandLineParser::String, "Use specified SH-basis", "use specified SH-basis (MITK, FSL, MRtrix)", string("MITK"), true);
     parser.addArgument("noFlip", "f", mitkCommandLineParser::Bool, "No flip", "do not flip input image to match MITK coordinate convention");
 
     parser.setCategory("Preprocessing Tools");
     parser.setTitle("Peak Extraction");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     // mandatory arguments
     string imageName = us::any_cast<string>(parsedArgs["image"]);
     string outRoot = us::any_cast<string>(parsedArgs["outroot"]);
 
     // optional arguments
     string maskImageName("");
     if (parsedArgs.count("mask"))
         maskImageName = us::any_cast<string>(parsedArgs["mask"]);
 
     int normalization = 1;
     if (parsedArgs.count("normalization"))
         normalization = us::any_cast<int>(parsedArgs["normalization"]);
 
     int numPeaks = 2;
     if (parsedArgs.count("numpeaks"))
         numPeaks = us::any_cast<int>(parsedArgs["numpeaks"]);
 
     float peakThres = 0.4;
     if (parsedArgs.count("peakthres"))
         peakThres = us::any_cast<float>(parsedArgs["peakthres"]);
 
     float absPeakThres = 0.06;
     if (parsedArgs.count("abspeakthres"))
         absPeakThres = us::any_cast<float>(parsedArgs["abspeakthres"]);
 
     bool noFlip = false;
     if (parsedArgs.count("noFlip"))
         noFlip = us::any_cast<bool>(parsedArgs["noFlip"]);
 
     std::cout << "image: " << imageName;
     std::cout << "outroot: " << outRoot;
     if (!maskImageName.empty())
         std::cout << "mask: " << maskImageName;
     else
         std::cout << "no mask image selected";
     std::cout << "numpeaks: " << numPeaks;
     std::cout << "peakthres: " << peakThres;
     std::cout << "abspeakthres: " << absPeakThres;
     std::cout << "shOrder: " << shOrder;
 
     try
     {
         mitk::Image::Pointer image = mitk::IOUtil::LoadImage(imageName);
         mitk::Image::Pointer mask = mitk::IOUtil::LoadImage(maskImageName);
 
         typedef itk::Image<unsigned char, 3>  ItkUcharImgType;
         typedef itk::FiniteDiffOdfMaximaExtractionFilter< float, shOrder, 20242 > MaximaExtractionFilterType;
         typename MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
 
         int toolkitConvention = 0;
 
         if (parsedArgs.count("shConvention"))
         {
             string convention = us::any_cast<string>(parsedArgs["shConvention"]).c_str();
             if ( boost::algorithm::equals(convention, "FSL") )
             {
                 toolkitConvention = 1;
                 std::cout << "Using FSL SH-basis";
             }
             else if ( boost::algorithm::equals(convention, "MRtrix") )
             {
                 toolkitConvention = 2;
                 std::cout << "Using MRtrix SH-basis";
             }
             else
                 std::cout << "Using MITK SH-basis";
         }
         else
             std::cout << "Using MITK SH-basis";
 
         ItkUcharImgType::Pointer itkMaskImage = NULL;
         if (mask.IsNotNull())
         {
             try{
                 itkMaskImage = ItkUcharImgType::New();
                 mitk::CastToItkImage(mask, itkMaskImage);
                 filter->SetMaskImage(itkMaskImage);
             }
             catch(...)
             {
 
             }
         }
 
         if (toolkitConvention>0)
         {
             std::cout << "Converting coefficient image to MITK format";
             typedef itk::ShCoefficientImageImporter< float, shOrder > ConverterType;
             typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
             CasterType::Pointer caster = CasterType::New();
             caster->SetInput(image);
             caster->Update();
             itk::Image< float, 4 >::Pointer itkImage = caster->GetOutput();
 
             typename ConverterType::Pointer converter = ConverterType::New();
 
             if (noFlip)
             {
                 converter->SetInputImage(itkImage);
             }
             else
             {
                 std::cout << "Flipping image";
                 itk::FixedArray<bool, 4> flipAxes;
                 flipAxes[0] = true;
                 flipAxes[1] = true;
                 flipAxes[2] = false;
                 flipAxes[3] = false;
                 itk::FlipImageFilter< itk::Image< float, 4 > >::Pointer flipper = itk::FlipImageFilter< itk::Image< float, 4 > >::New();
                 flipper->SetInput(itkImage);
                 flipper->SetFlipAxes(flipAxes);
                 flipper->Update();
                 itk::Image< float, 4 >::Pointer flipped = flipper->GetOutput();
                 itk::Matrix< double,4,4 > m = itkImage->GetDirection(); m[0][0] *= -1; m[1][1] *= -1;
                 flipped->SetDirection(m);
 
                 itk::Point< float, 4 > o = itkImage->GetOrigin();
                 o[0] -= (flipped->GetLargestPossibleRegion().GetSize(0)-1);
                 o[1] -= (flipped->GetLargestPossibleRegion().GetSize(1)-1);
                 flipped->SetOrigin(o);
                 converter->SetInputImage(flipped);
             }
 
             std::cout << "Starting conversion";
             switch (toolkitConvention)
             {
             case 1:
                 converter->SetToolkit(ConverterType::FSL);
                 filter->SetToolkit(MaximaExtractionFilterType::FSL);
                 break;
             case 2:
                 converter->SetToolkit(ConverterType::MRTRIX);
                 filter->SetToolkit(MaximaExtractionFilterType::MRTRIX);
                 break;
             default:
                 converter->SetToolkit(ConverterType::FSL);
                 filter->SetToolkit(MaximaExtractionFilterType::FSL);
                 break;
             }
             converter->GenerateData();
             filter->SetInput(converter->GetCoefficientImage());
         }
         else
         {
             try{
                 typedef mitk::ImageToItk< typename MaximaExtractionFilterType::CoefficientImageType > CasterType;
                 typename CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(image);
                 caster->Update();
                 filter->SetInput(caster->GetOutput());
             }
             catch(...)
             {
                 std::cout << "wrong image type";
                 return EXIT_FAILURE;
             }
         }
 
         filter->SetMaxNumPeaks(numPeaks);
         filter->SetPeakThreshold(peakThres);
         filter->SetAbsolutePeakThreshold(absPeakThres);
         filter->SetAngularThreshold(1);
 
         switch (normalization)
         {
         case 0:
             filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
             break;
         case 1:
             filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
             break;
         case 2:
             filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
             break;
         }
 
         std::cout << "Starting extraction";
         filter->Update();
 
         // write direction images
         {
             typedef typename MaximaExtractionFilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
             typename ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
             for (unsigned int i=0; i<container->Size(); i++)
             {
                 typename MaximaExtractionFilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
 
                 if (itkMaskImage.IsNotNull())
                 {
                     itkImg->SetDirection(itkMaskImage->GetDirection());
                     itkImg->SetOrigin(itkMaskImage->GetOrigin());
                 }
 
                 string outfilename = outRoot;
                 outfilename.append("_DIRECTION_");
                 outfilename.append(boost::lexical_cast<string>(i));
                 outfilename.append(".nrrd");
 
                 typedef itk::ImageFileWriter< typename MaximaExtractionFilterType::ItkDirectionImage > WriterType;
                 typename WriterType::Pointer writer = WriterType::New();
                 writer->SetFileName(outfilename);
                 writer->SetInput(itkImg);
                 writer->Update();
             }
         }
 
         // write num directions image
         {
             ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
 
             if (itkMaskImage.IsNotNull())
             {
                 numDirImage->SetDirection(itkMaskImage->GetDirection());
                 numDirImage->SetOrigin(itkMaskImage->GetOrigin());
             }
 
             string outfilename = outRoot.c_str();
             outfilename.append("_NUM_DIRECTIONS.nrrd");
             typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
             WriterType::Pointer writer = WriterType::New();
             writer->SetFileName(outfilename);
             writer->SetInput(numDirImage);
             writer->Update();
         }
 
         // write vector field
         {
-            mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
+            mitk::FiberBundle::Pointer directions = filter->GetOutputFiberBundle();
 
             string outfilename = outRoot.c_str();
             outfilename.append("_VECTOR_FIELD.fib");
             mitk::IOUtil::Save(directions.GetPointer(),outfilename.c_str());
         }
     }
     catch (itk::ExceptionObject e)
     {
         std::cout << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         std::cout << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         std::cout << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
 
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("image", "i", mitkCommandLineParser::InputFile, "Input image", "sh coefficient image", us::Any(), false);
     parser.addArgument("shOrder", "sh", mitkCommandLineParser::Int, "Spherical harmonics order", "spherical harmonics order");
     parser.addArgument("outroot", "o", mitkCommandLineParser::OutputDirectory, "Output directory", "output root", us::Any(), false);
     parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask", "mask image");
     parser.addArgument("normalization", "n", mitkCommandLineParser::Int, "Normalization", "0=no norm, 1=max norm, 2=single vec norm", 1, true);
     parser.addArgument("numpeaks", "p", mitkCommandLineParser::Int, "Max. number of peaks", "maximum number of extracted peaks", 2, true);
     parser.addArgument("peakthres", "r", mitkCommandLineParser::Float, "Peak threshold", "peak threshold relative to largest peak", 0.4, true);
     parser.addArgument("abspeakthres", "a", mitkCommandLineParser::Float, "Absolute peak threshold", "absolute peak threshold weighted with local GFA value", 0.06, true);
     parser.addArgument("shConvention", "s", mitkCommandLineParser::String, "Use specified SH-basis", "use specified SH-basis (MITK, FSL, MRtrix)", string("MITK"), true);
     parser.addArgument("noFlip", "f", mitkCommandLineParser::Bool, "No flip", "do not flip input image to match MITK coordinate convention");
 
     parser.setCategory("Preprocessing Tools");
     parser.setTitle("Peak Extraction");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
 
     int shOrder = -1;
     if (parsedArgs.count("shOrder"))
         shOrder = us::any_cast<int>(parsedArgs["shOrder"]);
 
     switch (shOrder)
     {
     case 4:
         return StartPeakExtraction<4>(argc, argv);
     case 6:
         return StartPeakExtraction<6>(argc, argv);
     case 8:
         return StartPeakExtraction<8>(argc, argv);
     case 10:
         return StartPeakExtraction<10>(argc, argv);
     case 12:
         return StartPeakExtraction<12>(argc, argv);
     }
     return EXIT_FAILURE;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/StreamlineTracking.cpp b/Modules/DiffusionImaging/MiniApps/StreamlineTracking.cpp
index 607300171c..328d7d0528 100755
--- a/Modules/DiffusionImaging/MiniApps/StreamlineTracking.cpp
+++ b/Modules/DiffusionImaging/MiniApps/StreamlineTracking.cpp
@@ -1,176 +1,176 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkImageCast.h>
 #include <mitkTensorImage.h>
 #include <mitkIOUtil.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <itkStreamlineTrackingFilter.h>
 #include <itkDiffusionTensor3D.h>
 #include "mitkCommandLineParser.h"
 #include <mitkCoreObjectFactory.h>
 
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::StringList, "Input image", "input tensor image (.dti)", us::Any(), false);
     parser.addArgument("seed", "si", mitkCommandLineParser::InputFile, "Seed image", "binary seed image", us::Any(), true);
     parser.addArgument("mask", "mi", mitkCommandLineParser::InputFile, "Mask", "binary mask image", us::Any(), true);
     parser.addArgument("faImage", "fai", mitkCommandLineParser::InputFile, "FA image", "FA image", us::Any(), true);
     parser.addArgument("minFA", "fa", mitkCommandLineParser::Float, "Min. FA threshold", "minimum fractional anisotropy threshold", 0.15, true);
     parser.addArgument("minCurv", "c", mitkCommandLineParser::Float, "Min. curvature radius", "minimum curvature radius in mm (default = 0.5*minimum-spacing)");
     parser.addArgument("stepSize", "s", mitkCommandLineParser::Float, "Step size", "step size in mm (default = 0.1*minimum-spacing)");
     parser.addArgument("tendf", "f", mitkCommandLineParser::Float, "Weight f", "Weighting factor between first eigenvector (f=1 equals FACT tracking) and input vector dependent direction (f=0).", 1.0, true);
     parser.addArgument("tendg", "g", mitkCommandLineParser::Float, "Weight g", "Weighting factor between input vector (g=0) and tensor deflection (g=1 equals TEND tracking)", 0.0, true);
     parser.addArgument("numSeeds", "n", mitkCommandLineParser::Int, "Seeds per voxel", "Number of seeds per voxel.", 1, true);
     parser.addArgument("minLength", "l", mitkCommandLineParser::Float, "Min. fiber length", "minimum fiber length in mm", 20, true);
 
     parser.addArgument("interpolate", "ip", mitkCommandLineParser::Bool, "Interpolate", "Use linear interpolation", false, true);
     parser.addArgument("outFile", "o", mitkCommandLineParser::String, "Output file", "output fiber bundle (.fib)", us::Any(), false);
 
     parser.setCategory("Fiber Tracking and Processing Methods");
     parser.setTitle("Streamline Tracking");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     mitkCommandLineParser::StringContainerType inputImages = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["input"]);
     string dtiFileName;
     string outFileName = us::any_cast<string>(parsedArgs["outFile"]);
 
     float minFA = 0.15;
     float minCurv = -1;
     float stepSize = -1;
     float tendf = 1;
     float tendg = 0;
     float minLength = 20;
     int numSeeds = 1;
     bool interpolate = false;
 
     if (parsedArgs.count("minCurv"))
         minCurv = us::any_cast<float>(parsedArgs["minCurv"]);
     if (parsedArgs.count("minFA"))
         minFA = us::any_cast<float>(parsedArgs["minFA"]);
     if (parsedArgs.count("stepSize"))
         stepSize = us::any_cast<float>(parsedArgs["stepSize"]);
     if (parsedArgs.count("tendf"))
         tendf = us::any_cast<float>(parsedArgs["tendf"]);
     if (parsedArgs.count("tendg"))
         tendg = us::any_cast<float>(parsedArgs["tendg"]);
     if (parsedArgs.count("minLength"))
         minLength = us::any_cast<float>(parsedArgs["minLength"]);
     if (parsedArgs.count("numSeeds"))
         numSeeds = us::any_cast<int>(parsedArgs["numSeeds"]);
 
 
     if (parsedArgs.count("interpolate"))
         interpolate = us::any_cast<bool>(parsedArgs["interpolate"]);
 
 
 
     try
     {
         typedef itk::StreamlineTrackingFilter< float > FilterType;
         FilterType::Pointer filter = FilterType::New();
 
         mitk::Image::Pointer mitkImage = NULL;
 
         std::cout << "Loading tensor images ...";
         typedef itk::Image< itk::DiffusionTensor3D<float>, 3 >    ItkTensorImage;
         dtiFileName = inputImages.at(0);
         for (unsigned int i=0; i<inputImages.size(); i++)
         {
             try
             {
                 mitkImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(inputImages.at(i))->GetData());
                 mitk::TensorImage::Pointer img = dynamic_cast<mitk::TensorImage*>(mitk::IOUtil::LoadDataNode(inputImages.at(i))->GetData());
                 ItkTensorImage::Pointer itk_dti = ItkTensorImage::New();
                 mitk::CastToItkImage(img, itk_dti);
                 filter->SetInput(i, itk_dti);
             }
             catch(...){ std::cout << "could not load: " << inputImages.at(i); }
         }
 
         std::cout << "Loading seed image ...";
         typedef itk::Image< unsigned char, 3 >    ItkUCharImageType;
         mitk::Image::Pointer mitkSeedImage = NULL;
         if (parsedArgs.count("seed"))
             mitkSeedImage = mitk::IOUtil::LoadImage(us::any_cast<string>(parsedArgs["seed"]));
 
         std::cout << "Loading mask image ...";
         mitk::Image::Pointer mitkMaskImage = NULL;
         if (parsedArgs.count("mask"))
             mitkMaskImage = mitk::IOUtil::LoadImage(us::any_cast<string>(parsedArgs["mask"]));
 
         // instantiate tracker
         filter->SetSeedsPerVoxel(numSeeds);
         filter->SetFaThreshold(minFA);
         filter->SetMinCurvatureRadius(minCurv);
         filter->SetStepSize(stepSize);
         filter->SetF(tendf);
         filter->SetG(tendg);
         filter->SetInterpolate(interpolate);
         filter->SetMinTractLength(minLength);
 
         if (mitkSeedImage.IsNotNull())
         {
             ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
             mitk::CastToItkImage(mitkSeedImage, mask);
             filter->SetSeedImage(mask);
         }
 
         if (mitkMaskImage.IsNotNull())
         {
             ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
             mitk::CastToItkImage(mitkMaskImage, mask);
             filter->SetMaskImage(mask);
         }
 
         filter->Update();
 
         vtkSmartPointer<vtkPolyData> fiberBundle = filter->GetFiberPolyData();
         if ( fiberBundle->GetNumberOfLines()==0 )
         {
             std::cout << "No fibers reconstructed. Check parametrization.";
             return EXIT_FAILURE;
         }
-        mitk::FiberBundleX::Pointer fib = mitk::FiberBundleX::New(fiberBundle);
+        mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(fiberBundle);
         fib->SetReferenceGeometry(mitkImage->GetGeometry());
 
         mitk::IOUtil::SaveBaseData(fib.GetPointer(), outFileName );
 
     }
     catch (itk::ExceptionObject e)
     {
         std::cout << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         std::cout << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         std::cout << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/TractogramAngularError.cpp b/Modules/DiffusionImaging/MiniApps/TractogramAngularError.cpp
index aa2a25ef82..39fb8c85ef 100755
--- a/Modules/DiffusionImaging/MiniApps/TractogramAngularError.cpp
+++ b/Modules/DiffusionImaging/MiniApps/TractogramAngularError.cpp
@@ -1,202 +1,202 @@
 /*===================================================================
 
 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 "MiniAppManager.h"
 #include <mitkBaseDataIOFactory.h>
 #include <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkDiffusionCoreObjectFactory.h>
 #include <mitkFiberTrackingObjectFactory.h>
 #include <metaCommand.h>
 #include "ctkCommandLineParser.h"
 #include <usAny.h>
 #include <itkImageFileWriter.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <iostream>
 #include <fstream>
 #include <itkEvaluateTractogramDirectionsFilter.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 int TractogramAngularError(int argc, char* argv[])
 {
     ctkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", ctkCommandLineParser::String, "input tractogram (.fib, vtk ascii file format)", us::Any(), false);
     parser.addArgument("reference", "r", ctkCommandLineParser::StringList, "reference direction images", us::Any(), false);
     parser.addArgument("out", "o", ctkCommandLineParser::String, "output root", us::Any(), false);
     parser.addArgument("mask", "m", ctkCommandLineParser::String, "mask image");
     parser.addArgument("verbose", "v", ctkCommandLineParser::Bool, "output optional and intermediate calculation results");
     parser.addArgument("ignore", "n", ctkCommandLineParser::Bool, "don't increase error for missing or too many directions");
     parser.addArgument("trilinear", "t", ctkCommandLineParser::Bool, "use trilinear instead of nearest neighbor interpolation");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     ctkCommandLineParser::StringContainerType referenceImages = us::any_cast<ctkCommandLineParser::StringContainerType>(parsedArgs["reference"]);
 
     string fibFile = us::any_cast<string>(parsedArgs["input"]);
 
     string maskImage("");
     if (parsedArgs.count("mask"))
         maskImage = us::any_cast<string>(parsedArgs["mask"]);
 
     string outRoot = us::any_cast<string>(parsedArgs["out"]);
 
     bool verbose = false;
     if (parsedArgs.count("verbose"))
         verbose = us::any_cast<bool>(parsedArgs["verbose"]);
 
     bool ignore = false;
     if (parsedArgs.count("ignore"))
         ignore = us::any_cast<bool>(parsedArgs["ignore"]);
 
     bool interpolate = false;
     if (parsedArgs.count("interpolate"))
         interpolate = us::any_cast<bool>(parsedArgs["interpolate"]);
 
     try
     {
         RegisterDiffusionCoreObjectFactory();
         RegisterFiberTrackingObjectFactory();
 
         typedef itk::Image<unsigned char, 3>                                    ItkUcharImgType;
         typedef itk::Image< itk::Vector< float, 3>, 3 >                         ItkDirectionImage3DType;
         typedef itk::VectorContainer< int, ItkDirectionImage3DType::Pointer >   ItkDirectionImageContainerType;
         typedef itk::EvaluateTractogramDirectionsFilter< float >                EvaluationFilterType;
 
         // load fiber bundle
-        mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
+        mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
         if (!inputTractogram)
             return EXIT_FAILURE;
 
         // load reference directions
         ItkDirectionImageContainerType::Pointer referenceImageContainer = ItkDirectionImageContainerType::New();
         for (int i=0; i<referenceImages.size(); i++)
         {
             try
             {
                 mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(referenceImages.at(i))->GetData());
                 typedef mitk::ImageToItk< ItkDirectionImage3DType > CasterType;
                 CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(img);
                 caster->Update();
                 ItkDirectionImage3DType::Pointer itkImg = caster->GetOutput();
                 referenceImageContainer->InsertElement(referenceImageContainer->Size(),itkImg);
             }
             catch(...){ MITK_INFO << "could not load: " << referenceImages.at(i); }
         }
 
         // load/create mask image
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         if (maskImage.compare("")==0)
         {
             ItkDirectionImage3DType::Pointer dirImg = referenceImageContainer->GetElement(0);
             itkMaskImage->SetSpacing( dirImg->GetSpacing() );
             itkMaskImage->SetOrigin( dirImg->GetOrigin() );
             itkMaskImage->SetDirection( dirImg->GetDirection() );
             itkMaskImage->SetLargestPossibleRegion( dirImg->GetLargestPossibleRegion() );
             itkMaskImage->SetBufferedRegion( dirImg->GetLargestPossibleRegion() );
             itkMaskImage->SetRequestedRegion( dirImg->GetLargestPossibleRegion() );
             itkMaskImage->Allocate();
             itkMaskImage->FillBuffer(1);
         }
         else
         {
             mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(maskImage)->GetData());
             mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, itkMaskImage);
         }
 
         // evaluate directions
         EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
         evaluationFilter->SetTractogram(inputTractogram);
         evaluationFilter->SetReferenceImageSet(referenceImageContainer);
         evaluationFilter->SetMaskImage(itkMaskImage);
         evaluationFilter->SetIgnoreMissingDirections(ignore);
         evaluationFilter->SetUseInterpolation(interpolate);
         evaluationFilter->Update();
 
         if (verbose)
         {
             EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
             typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
             WriterType::Pointer writer = WriterType::New();
 
             string outfilename = outRoot;
             outfilename.append("_ERROR_IMAGE.nrrd");
 
             writer->SetFileName(outfilename.c_str());
             writer->SetInput(angularErrorImage);
             writer->Update();
         }
 
         string logFile = outRoot;
         logFile.append("_ANGULAR_ERROR.csv");
 
         ofstream file;
         file.open (logFile.c_str());
 
         string sens = "Mean:";
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMeanAngularError()));
         sens.append(";\n");
 
         sens.append("Median:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMedianAngularError()));
         sens.append(";\n");
 
         sens.append("Maximum:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMaxAngularError()));
         sens.append(";\n");
 
         sens.append("Minimum:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMinAngularError()));
         sens.append(";\n");
 
         sens.append("STDEV:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(std::sqrt(evaluationFilter->GetVarAngularError())));
         sens.append(";\n");
 
         file << sens;
 
         file.close();
     }
     catch (itk::ExceptionObject e)
     {
         MITK_INFO << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         MITK_INFO << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         MITK_INFO << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
 RegisterDiffusionMiniApp(TractogramAngularError);
diff --git a/Modules/DiffusionImaging/MiniApps/TractometerMetrics.cpp b/Modules/DiffusionImaging/MiniApps/TractometerMetrics.cpp
index 40033dd2fc..d37e7c3980 100755
--- a/Modules/DiffusionImaging/MiniApps/TractometerMetrics.cpp
+++ b/Modules/DiffusionImaging/MiniApps/TractometerMetrics.cpp
@@ -1,414 +1,414 @@
 /*===================================================================
 
 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 <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <itkEvaluateDirectionImagesFilter.h>
 #include <metaCommand.h>
 #include "mitkCommandLineParser.h"
 #include <itkTractsToVectorImageFilter.h>
 #include <usAny.h>
 #include <itkImageFileWriter.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <iostream>
 #include <fstream>
 #include <itksys/SystemTools.hxx>
 #include <mitkCoreObjectFactory.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Tractometer Metrics");
     parser.setCategory("Fiber Tracking and Processing Methods");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input tractogram (.fib, vtk ascii file format)", us::Any(), false);
     parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
     parser.addArgument("labels", "l", mitkCommandLineParser::StringList, "Label pairs:", "label pairs", false);
     parser.addArgument("labelimage", "li", mitkCommandLineParser::String, "Label image:", "label image", false);
     parser.addArgument("verbose", "v", mitkCommandLineParser::Bool, "Verbose:", "output valid, invalid and no connections as fiber bundles");
 
     parser.addArgument("fileID", "id", mitkCommandLineParser::String, "ID:", "optional ID field");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     mitkCommandLineParser::StringContainerType labelpairs = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["labels"]);
 
     string fibFile = us::any_cast<string>(parsedArgs["input"]);
     string labelImageFile = us::any_cast<string>(parsedArgs["labelimage"]);
 
     string outRoot = us::any_cast<string>(parsedArgs["out"]);
 
     string fileID = "";
     if (parsedArgs.count("fileID"))
         fileID = us::any_cast<string>(parsedArgs["fileID"]);
 
     bool verbose = false;
     if (parsedArgs.count("verbose"))
         verbose = us::any_cast<bool>(parsedArgs["verbose"]);
 
     try
     {
         typedef itk::Image<short, 3>    ItkShortImgType;
         typedef itk::Image<unsigned char, 3>    ItkUcharImgType;
 
         // load fiber bundle
-        mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
+        mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
 
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(labelImageFile)->GetData());
         typedef mitk::ImageToItk< ItkShortImgType > CasterType;
         CasterType::Pointer caster = CasterType::New();
         caster->SetInput(img);
         caster->Update();
         ItkShortImgType::Pointer labelImage = caster->GetOutput();
 
         string path = itksys::SystemTools::GetFilenamePath(labelImageFile);
 
         std::vector< bool > detected;
         std::vector< std::pair< int, int > > labelsvector;
         std::vector< ItkUcharImgType::Pointer > bundleMasks;
         std::vector< ItkUcharImgType::Pointer > bundleMasksCoverage;
         short max = 0;
         for (unsigned int i=0; i<labelpairs.size()-1; i+=2)
         {
             std::pair< short, short > l;
             l.first = boost::lexical_cast<short>(labelpairs.at(i));
             l.second = boost::lexical_cast<short>(labelpairs.at(i+1));
             std::cout << labelpairs.at(i);
             std::cout << labelpairs.at(i+1);
             if (l.first>max)
                 max=l.first;
             if (l.second>max)
                 max=l.second;
 
             labelsvector.push_back(l);
             detected.push_back(false);
 
             {
                 mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(path+"/Bundle"+boost::lexical_cast<string>(labelsvector.size())+"_MASK.nrrd")->GetData());
                 typedef mitk::ImageToItk< ItkUcharImgType > CasterType;
                 CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(img);
                 caster->Update();
                 ItkUcharImgType::Pointer bundle = caster->GetOutput();
                 bundleMasks.push_back(bundle);
             }
 
             {
                 mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(path+"/Bundle"+boost::lexical_cast<string>(labelsvector.size())+"_MASK_COVERAGE.nrrd")->GetData());
                 typedef mitk::ImageToItk< ItkUcharImgType > CasterType;
                 CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(img);
                 caster->Update();
                 ItkUcharImgType::Pointer bundle = caster->GetOutput();
                 bundleMasksCoverage.push_back(bundle);
             }
         }
         vnl_matrix< unsigned char > matrix; matrix.set_size(max, max); matrix.fill(0);
 
         vtkSmartPointer<vtkPolyData> polyData = inputTractogram->GetFiberPolyData();
 
         int validConnections = 0;
         int noConnection = 0;
         int validBundles = 0;
         int invalidBundles = 0;
         int invalidConnections = 0;
 
         ItkUcharImgType::Pointer coverage = ItkUcharImgType::New();
         coverage->SetSpacing(labelImage->GetSpacing());
         coverage->SetOrigin(labelImage->GetOrigin());
         coverage->SetDirection(labelImage->GetDirection());
         coverage->SetLargestPossibleRegion(labelImage->GetLargestPossibleRegion());
         coverage->SetBufferedRegion( labelImage->GetLargestPossibleRegion() );
         coverage->SetRequestedRegion( labelImage->GetLargestPossibleRegion() );
         coverage->Allocate();
         coverage->FillBuffer(0);
 
         vtkSmartPointer<vtkPoints> noConnPoints = vtkSmartPointer<vtkPoints>::New();
         vtkSmartPointer<vtkCellArray> noConnCells = vtkSmartPointer<vtkCellArray>::New();
 
         vtkSmartPointer<vtkPoints> invalidPoints = vtkSmartPointer<vtkPoints>::New();
         vtkSmartPointer<vtkCellArray> invalidCells = vtkSmartPointer<vtkCellArray>::New();
 
         vtkSmartPointer<vtkPoints> validPoints = vtkSmartPointer<vtkPoints>::New();
         vtkSmartPointer<vtkCellArray> validCells = vtkSmartPointer<vtkCellArray>::New();
 
         boost::progress_display disp(inputTractogram->GetNumFibers());
         for (int i=0; i<inputTractogram->GetNumFibers(); i++)
         {
             ++disp;
 
             vtkCell* cell = polyData->GetCell(i);
             int numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
 
             if (numPoints>1)
             {
                 double* start = points->GetPoint(0);
                 itk::Point<float, 3> itkStart;
                 itkStart[0] = start[0]; itkStart[1] = start[1]; itkStart[2] = start[2];
                 itk::Index<3> idxStart;
                 labelImage->TransformPhysicalPointToIndex(itkStart, idxStart);
 
                 double* end = points->GetPoint(numPoints-1);
                 itk::Point<float, 3> itkEnd;
                 itkEnd[0] = end[0]; itkEnd[1] = end[1]; itkEnd[2] = end[2];
                 itk::Index<3> idxEnd;
                 labelImage->TransformPhysicalPointToIndex(itkEnd, idxEnd);
 
 
                 if ( labelImage->GetPixel(idxStart)==0 || labelImage->GetPixel(idxEnd)==0 )
                 {
                     noConnection++;
 
                     if (verbose)
                     {
                         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
                         for (int j=0; j<numPoints; j++)
                         {
                             double* p = points->GetPoint(j);
                             vtkIdType id = noConnPoints->InsertNextPoint(p);
                             container->GetPointIds()->InsertNextId(id);
                         }
                         noConnCells->InsertNextCell(container);
                     }
                 }
                 else
                 {
                     bool invalid = true;
                     for (unsigned int i=0; i<labelsvector.size(); i++)
                     {
                         bool outside = false;
                         ItkUcharImgType::Pointer bundle = bundleMasks.at(i);
                         std::pair< short, short > l = labelsvector.at(i);
                         if ( (labelImage->GetPixel(idxStart)==l.first && labelImage->GetPixel(idxEnd)==l.second) ||
                              (labelImage->GetPixel(idxStart)==l.second && labelImage->GetPixel(idxEnd)==l.first) )
                         {
                             for (int j=0; j<numPoints; j++)
                             {
                                 double* p = points->GetPoint(j);
 
                                 itk::Point<float, 3> itkP;
                                 itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
                                 itk::Index<3> idx;
                                 bundle->TransformPhysicalPointToIndex(itkP, idx);
 
                                 if ( !bundle->GetPixel(idx)>0 && bundle->GetLargestPossibleRegion().IsInside(idx) )
                                 {
                                     outside=true;
                                 }
                             }
 
                             if (!outside)
                             {
                                 validConnections++;
                                 if (detected.at(i)==false)
                                     validBundles++;
                                 detected.at(i) = true;
                                 invalid = false;
 
 
                                 vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
                                 for (int j=0; j<numPoints; j++)
                                 {
                                     double* p = points->GetPoint(j);
                                     vtkIdType id = validPoints->InsertNextPoint(p);
                                     container->GetPointIds()->InsertNextId(id);
 
                                     itk::Point<float, 3> itkP;
                                     itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
                                     itk::Index<3> idx;
                                     coverage->TransformPhysicalPointToIndex(itkP, idx);
                                     if ( coverage->GetLargestPossibleRegion().IsInside(idx) )
                                         coverage->SetPixel(idx, 1);
                                 }
                                 validCells->InsertNextCell(container);
                             }
                             break;
                         }
                     }
                     if (invalid==true)
                     {
                         invalidConnections++;
                         int x = labelImage->GetPixel(idxStart)-1;
                         int y = labelImage->GetPixel(idxEnd)-1;
                         if (x>=0 && y>0 && x<matrix.cols() && y<matrix.rows() && (matrix[x][y]==0 || matrix[y][x]==0) )
                         {
                             invalidBundles++;
                             matrix[x][y]=1;
                             matrix[y][x]=1;
                         }
 
                         if (verbose)
                         {
                             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
                             for (int j=0; j<numPoints; j++)
                             {
                                 double* p = points->GetPoint(j);
                                 vtkIdType id = invalidPoints->InsertNextPoint(p);
                                 container->GetPointIds()->InsertNextId(id);
                             }
                             invalidCells->InsertNextCell(container);
                         }
                     }
                 }
             }
         }
 
         if (verbose)
         {
             mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
             vtkSmartPointer<vtkPolyData> noConnPolyData = vtkSmartPointer<vtkPolyData>::New();
             noConnPolyData->SetPoints(noConnPoints);
             noConnPolyData->SetLines(noConnCells);
-            mitk::FiberBundleX::Pointer noConnFib = mitk::FiberBundleX::New(noConnPolyData);
+            mitk::FiberBundle::Pointer noConnFib = mitk::FiberBundle::New(noConnPolyData);
 
             string ncfilename = outRoot;
             ncfilename.append("_NC.fib");
 
             mitk::IOUtil::SaveBaseData(noConnFib.GetPointer(), ncfilename );
 
             vtkSmartPointer<vtkPolyData> invalidPolyData = vtkSmartPointer<vtkPolyData>::New();
             invalidPolyData->SetPoints(invalidPoints);
             invalidPolyData->SetLines(invalidCells);
-            mitk::FiberBundleX::Pointer invalidFib = mitk::FiberBundleX::New(invalidPolyData);
+            mitk::FiberBundle::Pointer invalidFib = mitk::FiberBundle::New(invalidPolyData);
 
             string icfilename = outRoot;
             icfilename.append("_IC.fib");
 
             mitk::IOUtil::SaveBaseData(invalidFib.GetPointer(), icfilename );
 
             vtkSmartPointer<vtkPolyData> validPolyData = vtkSmartPointer<vtkPolyData>::New();
             validPolyData->SetPoints(validPoints);
             validPolyData->SetLines(validCells);
-            mitk::FiberBundleX::Pointer validFib = mitk::FiberBundleX::New(validPolyData);
+            mitk::FiberBundle::Pointer validFib = mitk::FiberBundle::New(validPolyData);
 
             string vcfilename = outRoot;
             vcfilename.append("_VC.fib");
 
             mitk::IOUtil::SaveBaseData(validFib.GetPointer(), vcfilename );
 
             {
                 typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
                 writer->SetFileName(outRoot+"_ABC.nrrd");
                 writer->SetInput(coverage);
                 writer->Update();
             }
         }
 
         // calculate coverage
         int wmVoxels = 0;
         int coveredVoxels = 0;
         itk::ImageRegionIterator<ItkUcharImgType> it (coverage, coverage->GetLargestPossibleRegion());
         while(!it.IsAtEnd())
         {
             bool wm = false;
             for (unsigned int i=0; i<bundleMasksCoverage.size(); i++)
             {
                 ItkUcharImgType::Pointer bundle = bundleMasksCoverage.at(i);
                 if (bundle->GetPixel(it.GetIndex())>0)
                 {
                     wm = true;
                     wmVoxels++;
                     break;
                 }
             }
             if (wm && it.Get()>0)
                 coveredVoxels++;
             ++it;
         }
 
         int numFibers = inputTractogram->GetNumFibers();
         double nc = (double)noConnection/numFibers;
         double vc = (double)validConnections/numFibers;
         double ic = (double)invalidConnections/numFibers;
         if (numFibers==0)
         {
             nc = 0.0;
             vc = 0.0;
             ic = 0.0;
         }
         int vb = validBundles;
         int ib = invalidBundles;
         double abc = (double)coveredVoxels/wmVoxels;
 
         std::cout << "NC: " << nc;
         std::cout << "VC: " << vc;
         std::cout << "IC: " << ic;
         std::cout << "VB: " << vb;
         std::cout << "IB: " << ib;
         std::cout << "ABC: " << abc;
 
         string logFile = outRoot;
         logFile.append("_TRACTOMETER.csv");
         ofstream file;
         file.open (logFile.c_str());
         {
             string sens = itksys::SystemTools::GetFilenameWithoutLastExtension(fibFile);
             if (!fileID.empty())
                 sens = fileID;
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(nc));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(vc));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(ic));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(validBundles));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(invalidBundles));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(abc));
             sens.append(";\n");
             file << sens;
         }
         file.close();
     }
     catch (itk::ExceptionObject e)
     {
         std::cout << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         std::cout << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         std::cout << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
diff --git a/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp b/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
index 210aa03fc6..45dc13083a 100644
--- a/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
+++ b/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
@@ -1,64 +1,61 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkDiffusionImagingActivator.h"
 
 #include "QmitkNodeDescriptorManager.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkNodePredicateIsDWI.h"
 #include <mitkDiffusionPropertyHelper.h>
 
 #include <QtPlugin>
 
 void
 mitk::DiffusionImagingActivator::start(ctkPluginContext* context)
 {
   Q_UNUSED(context)
 
   QmitkNodeDescriptorManager* manager =
     QmitkNodeDescriptorManager::GetInstance();
 
   mitk::NodePredicateIsDWI::Pointer isDiffusionImage = mitk::NodePredicateIsDWI::New();
   QmitkNodeDescriptor* desc = new QmitkNodeDescriptor(QObject::tr("DiffusionImage"), QString(":/QmitkDiffusionImaging/QBallData24.png"), isDiffusionImage, manager);
   manager->AddDescriptor(desc);
 
   mitk::NodePredicateDataType::Pointer isTensorImage = mitk::NodePredicateDataType::New("TensorImage");
   manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("TensorImage"), QString(":/QmitkDiffusionImaging/recontensor.png"), isTensorImage, manager));
 
   mitk::NodePredicateDataType::Pointer isQBallImage = mitk::NodePredicateDataType::New("QBallImage");
   manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("QBallImage"), QString(":/QmitkDiffusionImaging/reconodf.png"), isQBallImage, manager));
 
   mitk::NodePredicateDataType::Pointer isFiberBundle = mitk::NodePredicateDataType::New("FiberBundle");
   manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("FiberBundle"), QString(":/QmitkDiffusionImaging/FiberBundle.png"), isFiberBundle, manager));
 
-  mitk::NodePredicateDataType::Pointer isFiberBundleX = mitk::NodePredicateDataType::New("FiberBundleX");
-  manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("FiberBundleX"), QString(":/QmitkDiffusionImaging/FiberBundleX.png"), isFiberBundleX, manager));
-
   mitk::NodePredicateDataType::Pointer isConnectomicsNetwork = mitk::NodePredicateDataType::New("ConnectomicsNetwork");
   manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("ConnectomicsNetwork"), QString(":/QmitkDiffusionImaging/ConnectomicsNetwork.png"), isConnectomicsNetwork, manager));
 
 }
 
 void
 mitk::DiffusionImagingActivator::stop(ctkPluginContext* context)
 {
   Q_UNUSED(context)
 }
 
 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
   Q_EXPORT_PLUGIN2(org_mitk_diffusionimaging, mitk::DiffusionImagingActivator)
 #endif
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/resources/FiberBundleX.png b/Plugins/org.mitk.gui.qt.diffusionimaging/resources/FiberBundleX.png
deleted file mode 100644
index 76ee67c6e7..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging/resources/FiberBundleX.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/resources/QmitkDiffusionImaging.qrc b/Plugins/org.mitk.gui.qt.diffusionimaging/resources/QmitkDiffusionImaging.qrc
index 433010c36f..68ea118057 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/resources/QmitkDiffusionImaging.qrc
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/resources/QmitkDiffusionImaging.qrc
@@ -1,64 +1,64 @@
 <RCC>
     <qresource prefix="/QmitkDiffusionImaging">
         <file>qball.png</file>
         <file>tensor.png</file>
         <file>dwi.png</file>
         <file>dwiimport.png</file>
         <file>quantification.png</file>
         <file>reconodf.png</file>
         <file>recontensor.png</file>
         <file>texIntONIcon.png</file>
         <file>texIntOFFIcon.png</file>
         <file>vizControls.png</file>
         <file>Refresh_48.png</file>
         <file>QBallData24.png</file>
         <file>glyphsoff_C.png</file>
         <file>glyphsoff_S.png</file>
         <file>glyphsoff_T.png</file>
         <file>glyphson_C.png</file>
         <file>glyphson_S.png</file>
         <file>glyphson_T.png</file>
         <file>FiberBundle.png</file>
-        <file>FiberBundleX.png</file>
+        <file>FiberBundle.png</file>
         <file>connectomics/ConnectomicsNetwork.png</file>
         <file>connectomics/QmitkRandomParcellationIcon.png</file>
         <file>rectangle.png</file>
         <file>circle.png</file>
         <file>polygon.png</file>
         <file>color24.gif</file>
         <file>color48.gif</file>
         <file>color64.gif</file>
         <file>crosshair.png</file>
         <file>paint2.png</file>
         <file>IVIM_48.png</file>
         <file>reset.png</file>
         <file>MapperEfx2D.png</file>
         <file>refresh.xpm</file>
         <file>odf.png</file>
         <file>general_icons/download.ico</file>
         <file>general_icons/play.ico</file>
         <file>general_icons/plus.ico</file>
         <file>general_icons/refresh.ico</file>
         <file>general_icons/right.ico</file>
         <file>general_icons/save.ico</file>
         <file>general_icons/undo.ico</file>
         <file>general_icons/upload.ico</file>
         <file>general_icons/abort.ico</file>
         <file>general_icons/copy1.ico</file>
         <file>general_icons/copy2.ico</file>
         <file>general_icons/cut.ico</file>
         <file>general_icons/deny1.ico</file>
         <file>general_icons/deny2.ico</file>
         <file>general_icons/down.ico</file>
         <file>general_icons/left.ico</file>
         <file>general_icons/magn_minus.ico</file>
         <file>general_icons/magn_plus.ico</file>
         <file>general_icons/search.ico</file>
         <file>general_icons/stop.ico</file>
         <file>general_icons/up.ico</file>
         <file>general_icons/help.ico</file>
         <file>general_icons/pencil.ico</file>
         <file>general_icons/edit.ico</file>
         <file>denoisingicon.png</file>
     </qresource>
 </RCC>
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.cpp
index 372a08f150..f25b4d7561 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.cpp
@@ -1,967 +1,967 @@
 /*===================================================================
 
 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 "QmitkTbssRoiAnalysisWidget.h"
 #include "mitkImagePixelReadAccessor.h"
 #include "mitkPixelTypeMultiplex.h"
 
 #include <qwt_plot_marker.h>
 #include <qwt_plot_picker.h>
 #include <qwt_picker_machine.h>
 
 #include <vtkCellArray.h>
 
 QmitkTbssRoiAnalysisWidget::QmitkTbssRoiAnalysisWidget( QWidget * parent )
   : QmitkPlotWidget(parent)
 {
   m_PlotPicker = new QwtPlotPicker(m_Plot->canvas());
   m_PlotPicker->setStateMachine(new QwtPickerDragPointMachine());
   m_PlotPicker->setTrackerMode(QwtPicker::ActiveOnly);
 
   m_PlottingFiberBundle = false;
 }
 
 
 
-void QmitkTbssRoiAnalysisWidget::DoPlotFiberBundles(mitk::FiberBundleX *fib, mitk::Image* img,
+void QmitkTbssRoiAnalysisWidget::DoPlotFiberBundles(mitk::FiberBundle *fib, mitk::Image* img,
                                                     mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi, bool avg, int number)
 {
 
   TractContainerType tracts = CreateTracts(fib, startRoi, endRoi);
 
   TractContainerType resampledTracts = ParameterizeTracts(tracts, number);
 
   // Now we have the resampled tracts. Next we should use these points to read out the values
 
 
 
   mitkPixelTypeMultiplex3(PlotFiberBundles,img->GetImageDescriptor()->GetChannelTypeById(0),resampledTracts, img, avg);
   m_CurrentTracts = resampledTracts;
 }
 
 
-TractContainerType QmitkTbssRoiAnalysisWidget::CreateTracts(mitk::FiberBundleX *fib,
+TractContainerType QmitkTbssRoiAnalysisWidget::CreateTracts(mitk::FiberBundle *fib,
                                                             mitk::PlanarFigure *startRoi,
                                                             mitk::PlanarFigure *endRoi)
 {
     mitk::PlaneGeometry* startGeometry2D = const_cast<mitk::PlaneGeometry*>(startRoi->GetPlaneGeometry());
     mitk::PlaneGeometry* endGeometry2D = const_cast<mitk::PlaneGeometry*>(endRoi->GetPlaneGeometry());
 
 
     mitk::Point3D startCenter = startRoi->GetWorldControlPoint(0); //center Point of start roi
     mitk::Point3D endCenter = endRoi->GetWorldControlPoint(0); //center Point of end roi
 
-    mitk::FiberBundleX::Pointer inStart = fib->ExtractFiberSubset(startRoi);
-    mitk::FiberBundleX::Pointer inBoth = inStart->ExtractFiberSubset(endRoi);
+    mitk::FiberBundle::Pointer inStart = fib->ExtractFiberSubset(startRoi);
+    mitk::FiberBundle::Pointer inBoth = inStart->ExtractFiberSubset(endRoi);
 
 
 
     int num = inBoth->GetNumFibers();
 
 
     TractContainerType tracts;
 
 
     vtkSmartPointer<vtkPolyData> fiberPolyData = inBoth->GetFiberPolyData();
     vtkCellArray* lines = fiberPolyData->GetLines();
     lines->InitTraversal();
 
 
 
     // Now find out for each fiber which ROI is encountered first. If this is the startRoi, the direction is ok
     // Otherwise the plot should be in the reverse direction
     for( int fiberID( 0 ); fiberID < num; fiberID++ )
     {
       vtkIdType   numPointsInCell(0);
       vtkIdType*  pointsInCell(NULL);
       lines->GetNextCell ( numPointsInCell, pointsInCell );
 
       int startId = 0;
       int endId = 0;
 
       mitk::ScalarType minDistStart = std::numeric_limits<mitk::ScalarType>::max();
       mitk::ScalarType minDistEnd = std::numeric_limits<mitk::ScalarType>::max();
 
 
 
       for( int pointInCellID( 0 ); pointInCellID < numPointsInCell ; pointInCellID++)
       {
 
 
         mitk::ScalarType *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
 
         mitk::Point3D point;
         point[0] = p[0];
         point[1] = p[1];
         point[2] = p[2];
 
         mitk::ScalarType distanceToStart = point.EuclideanDistanceTo(startCenter);
         mitk::ScalarType distanceToEnd = point.EuclideanDistanceTo(endCenter);
 
         if(distanceToStart < minDistStart)
         {
           minDistStart = distanceToStart;
           startId = pointInCellID;
         }
 
         if(distanceToEnd < minDistEnd)
         {
           minDistEnd = distanceToEnd;
           endId = pointInCellID;
         }
 
 
 
       }
 
       /* We found the start and end points of of the part that should be plottet for
          the current fiber. now we need to plot them. If the endId is smaller than the startId the plot order
          must be reversed*/
 
       TractType singleTract;
       PointType point;
 
       if(startId < endId)
       {
 
         // Calculate the intersection of the ROI with the startRoi and decide if the startId is part of the roi or must be cut of
         mitk::ScalarType *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
         mitk::Vector3D p0;
         p0[0] = p[0];      p0[1] = p[1];      p0[2] = p[2];
 
         p = fiberPolyData->GetPoint( pointsInCell[ startId+1 ] );
         mitk::Vector3D p1;
         p1[0] = p[0];       p1[1] = p[1];       p1[2] = p[2];
 
         // Check if p and p2 are both on the same side of the plane
         mitk::Vector3D normal = startGeometry2D->GetNormal();
 
         mitk::Point3D pStart;
         pStart[0] = p0[0];      pStart[1] = p0[1];      pStart[2] = p0[2];
 
         mitk::Point3D pSecond;
         pSecond[0] = p1[0];      pSecond[1] = p1[1];      pSecond[2] = p1[2];
 
         bool startOnPositive = startGeometry2D->IsAbove(pStart);
         bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
 
 
         mitk::Vector3D onPlane;
         onPlane[0] = startCenter[0];      onPlane[1] = startCenter[1];      onPlane[2] = startCenter[2];
 
 
 
         if(! (secondOnPositive ^ startOnPositive) )
         {
           /* startId and startId+1 lie on the same side of the plane, so we need
              need startId-1 to calculate the intersection with the planar figure*/
           p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
           p1[0] = p[0];        p1[1] = p[1];        p1[2] = p[2];
         }
 
 
         mitk::ScalarType d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
         mitk::Vector3D newPoint = (p0-p1);
 
         point[0] = d*newPoint[0] + p0[0];
         point[1] = d*newPoint[1] + p0[1];
         point[2] = d*newPoint[2] + p0[2];
 
         singleTract.push_back(point);
 
         if(! (secondOnPositive ^ startOnPositive) )
         {
           /* StartId and startId+1 lie on the same side of the plane
              so startId is also part of the ROI*/
 
           mitk::ScalarType *start = fiberPolyData->GetPoint( pointsInCell[startId] );
           point[0] = start[0]; point[1] = start[1]; point[2] = start[2];
           singleTract.push_back(point);
         }
 
 
 
         for( int pointInCellID( startId+1 ); pointInCellID < endId ; pointInCellID++)
         {
           // push back point
           mitk::ScalarType *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
           point[0] = p[0]; point[1] = p[1]; point[2] = p[2];
           singleTract.push_back( point );
 
         }
 
         /* endId must be included if endId and endId-1 lie on the same side of the
                  plane defined by endRoi*/
 
 
         p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
         p0[0] = p[0];      p0[1] = p[1];      p0[2] = p[2];
 
         p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
         p1[0] = p[0];      p1[1] = p[1];      p1[2] = p[2];
 
         mitk::Point3D pLast;
         pLast[0] = p0[0];      pLast[1] = p0[1];      pLast[2] = p0[2];
 
         mitk::Point3D pBeforeLast;
         pBeforeLast[0] = p1[0];      pBeforeLast[1] = p1[1];      pBeforeLast[2] = p1[2];
 
         normal = endGeometry2D->GetNormal();
         bool lastOnPositive = endGeometry2D->IsAbove(pLast);
         bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
 
 
         onPlane[0] = endCenter[0];
         onPlane[1] = endCenter[1];
         onPlane[2] = endCenter[2];
 
         if(! (lastOnPositive ^ secondLastOnPositive) )
         {
           /* endId and endId-1 lie on the same side of the plane, so we need
              need endId+1 to calculate the intersection with the planar figure.
              this should exist since we know that the fiber crosses the planar figure
              endId is also part of the tract and can be inserted here */
 
           p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
           point[0] = p[0]; point[1] = p[1]; point[2] = p[2];
           singleTract.push_back( point );
 
           p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
         }
 
         d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
 
         newPoint = (p0-p1);
 
         point[0] = d*newPoint[0] + p0[0];
         point[1] = d*newPoint[1] + p0[1];
         point[2] = d*newPoint[2] + p0[2];
 
         singleTract.push_back(point);
 
 
 
       }
       else{
 
         // Calculate the intersection of the ROI with the startRoi and decide if the startId is part of the roi or must be cut of
         mitk::ScalarType *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
         mitk::Vector3D p0;
         p0[0] = p[0];      p0[1] = p[1];      p0[2] = p[2];
 
         p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
         mitk::Vector3D p1;
         p1[0] = p[0];       p1[1] = p[1];       p1[2] = p[2];
 
         // Check if p and p2 are both on the same side of the plane
         mitk::Vector3D normal = startGeometry2D->GetNormal();
 
         mitk::Point3D pStart;
         pStart[0] = p0[0];      pStart[1] = p0[1];      pStart[2] = p0[2];
 
         mitk::Point3D pSecond;
         pSecond[0] = p1[0];      pSecond[1] = p1[1];      pSecond[2] = p1[2];
 
         bool startOnPositive = startGeometry2D->IsAbove(pStart);
         bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
 
         mitk::Vector3D onPlane;
         onPlane[0] = startCenter[0];      onPlane[1] = startCenter[1];      onPlane[2] = startCenter[2];
 
 
         if(! (secondOnPositive ^ startOnPositive) )
         {
           /* startId and startId+1 lie on the same side of the plane, so we need
              need startId-1 to calculate the intersection with the planar figure*/
           p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
           p1[0] = p[0];        p1[1] = p[1];        p1[2] = p[2];
         }
 
 
         mitk::ScalarType d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
         mitk::Vector3D newPoint = (p0-p1);
 
 
         point[0] = d*newPoint[0] + p0[0];
         point[1] = d*newPoint[1] + p0[1];
         point[2] = d*newPoint[2] + p0[2];
 
 
         singleTract.push_back(point);
 
         if(! (secondOnPositive ^ startOnPositive) )
         {
           /* StartId and startId+1 lie on the same side of the plane
              so startId is also part of the ROI*/
 
           mitk::ScalarType *start = fiberPolyData->GetPoint( pointsInCell[startId] );
           point[0] = start[0]; point[1] = start[1]; point[2] = start[2];
           singleTract.push_back(point);
         }
 
 
 
         for( int pointInCellID( startId-1 ); pointInCellID > endId ; pointInCellID--)
         {
           // push back point
           mitk::ScalarType *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
           point[0] = p[0]; point[1] = p[1]; point[2] = p[2];
           singleTract.push_back( point );
 
         }
 
         /* endId must be included if endId and endI+1 lie on the same side of the
                  plane defined by endRoi*/
 
 
         p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
         p0[0] = p[0];      p0[1] = p[1];      p0[2] = p[2];
 
         p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
         p1[0] = p[0];      p1[1] = p[1];      p1[2] = p[2];
 
         mitk::Point3D pLast;
         pLast[0] = p0[0];      pLast[1] = p0[1];      pLast[2] = p0[2];
 
         mitk::Point3D pBeforeLast;
         pBeforeLast[0] = p1[0];      pBeforeLast[1] = p1[1];      pBeforeLast[2] = p1[2];
 
         bool lastOnPositive = endGeometry2D->IsAbove(pLast);
         bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
         normal = endGeometry2D->GetNormal();
 
 
 
         onPlane[0] = endCenter[0];
         onPlane[1] = endCenter[1];
         onPlane[2] = endCenter[2];
 
         if(! (lastOnPositive ^ secondLastOnPositive) )
         {
           /* endId and endId+1 lie on the same side of the plane, so we need
              need endId-1 to calculate the intersection with the planar figure.
              this should exist since we know that the fiber crosses the planar figure
              endId is also part of the tract and can be inserted here */
 
           p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
           point[0] = p[0]; point[1] = p[1]; point[2] = p[2];
           singleTract.push_back( point );
 
           p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
         }
 
         d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
 
         newPoint = (p0-p1);
 
         point[0] = d*newPoint[0] + p0[0];
         point[1] = d*newPoint[1] + p0[1];
         point[2] = d*newPoint[2] + p0[2];
 
         singleTract.push_back(point);
 
       }
 
 
       tracts.push_back(singleTract);
 
 
     }
 
     return tracts;
 }
 
-void QmitkTbssRoiAnalysisWidget::PlotFiberBetweenRois(mitk::FiberBundleX *fib, mitk::Image* img,
+void QmitkTbssRoiAnalysisWidget::PlotFiberBetweenRois(mitk::FiberBundle *fib, mitk::Image* img,
                                 mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi, bool avg, int number)
 {
 
   if(fib == NULL || img == NULL || startRoi == NULL || endRoi == NULL)
     return;
 
 
   m_Fib = fib;
   m_CurrentImage = img;
   m_CurrentStartRoi = startRoi;
   m_CurrentEndRoi = endRoi;
 
 
   DoPlotFiberBundles(fib, img, startRoi, endRoi, avg, number);
 }
 
 
 
 void QmitkTbssRoiAnalysisWidget::ModifyPlot(int number, bool avg)
 {
   if(m_Fib == NULL || m_CurrentTbssImage == NULL || m_CurrentStartRoi == NULL || m_CurrentEndRoi == NULL)
     return;
 
   if(m_PlottingFiberBundle)
   {
     DoPlotFiberBundles(m_Fib, m_CurrentImage, m_CurrentStartRoi, m_CurrentEndRoi, avg, number);
   }
   else
   {
     PlotFiber4D(m_CurrentTbssImage, m_Fib, m_CurrentStartRoi, m_CurrentEndRoi, number);
   }
 }
 
 
 
 TractContainerType QmitkTbssRoiAnalysisWidget::ParameterizeTracts(TractContainerType tracts, int number)
 {
   TractContainerType resampledTracts;
 
 
 
   for(TractContainerType::iterator it = tracts.begin(); it != tracts.end(); ++it)
   {
     TractType resampledTract;
     TractType tract = *it;
 
     // Calculate the total length
     mitk::ScalarType totalLength = 0;
 
     if(tract.size() < 2)
       continue;
 
     PointType p0 = tract.at(0);
     for(unsigned int i = 1; i<tract.size(); i++)
     {
       PointType p1 = tract.at(i);
       mitk::ScalarType length = p0.EuclideanDistanceTo(p1);
       totalLength += length;
       p0 = p1;
     }
 
     mitk::ScalarType stepSize = totalLength / number;
 
 
 
     p0 = tract.at(0);
     PointType p1 = tract.at(1);
     unsigned int tractCounter = 2;
     mitk::ScalarType distance = p0.EuclideanDistanceTo(p1);
     mitk::ScalarType locationBetween = 0;
 
     for(mitk::ScalarType position = 0;
         position <= totalLength+0.001 && resampledTract.size() <= (number+1);
         position+=stepSize)
     {
 
       /* In case we walked to far we need to find the next segment we are on and on what relative position on that
          tract we are on. Small correction for rounding errors */
       while(locationBetween > distance+0.001)
       {
 
         if(tractCounter == tract.size())
           std::cout << "problem";
 
         // Determine by what distance we are no on the next segment
         locationBetween = locationBetween - distance;
         p0 = p1;
         p1 = tract.at(tractCounter);
         tractCounter++;
 
         distance = p0.EuclideanDistanceTo(p1);
 
       }
 
       // Direction
       PointType::VectorType direction = p1-p0;
       direction.Normalize();
 
       PointType newSample = p0 + direction*locationBetween;
       resampledTract.push_back(newSample);
 
 
       locationBetween += stepSize;
 
 
     }
 
     resampledTracts.push_back(resampledTract);
 
 
   }
   return resampledTracts;
 }
 
 
 mitk::Point3D QmitkTbssRoiAnalysisWidget::GetPositionInWorld(int index)
 {
 
 
   mitk::ScalarType xSum = 0.0;
   mitk::ScalarType ySum = 0.0;
   mitk::ScalarType zSum = 0.0;
   for(TractContainerType::iterator it = m_CurrentTracts.begin();
       it!=m_CurrentTracts.end(); ++it)
   {
     TractType tract = *it;
     PointType p = tract.at(index);
     xSum += p[0];
     ySum += p[1];
     zSum += p[2];
   }
 
   int number = m_CurrentTracts.size();
 
   mitk::ScalarType xPos = xSum / number;
   mitk::ScalarType yPos = ySum / number;
   mitk::ScalarType zPos = zSum / number;
 
 
   mitk::Point3D pos;
   pos[0] = xPos;
   pos[1] = yPos;
   pos[2] = zPos;
 
   return pos;
 }
 
 
 std::vector< std::vector<mitk::ScalarType> > QmitkTbssRoiAnalysisWidget::CalculateGroupProfiles()
 {
   MITK_INFO << "make profiles!";
   std::vector< std::vector<mitk::ScalarType> > profiles;
 
 
   int size = m_Projections->GetVectorLength();
   for(int s=0; s<size; s++)
   {
     // Iterate trough the roi
     std::vector<mitk::ScalarType> profile;
     RoiType::iterator it;
     it = m_Roi.begin();
     while(it != m_Roi.end())
     {
       itk::Index<3> ix = *it;
       profile.push_back(m_Projections->GetPixel(ix).GetElement(s));
       it++;
     }
 
     profiles.push_back(profile);
   }
 
 
 
   m_IndividualProfiles = profiles;
   // Calculate the averages
 
   // Here a check could be build in to check whether all profiles have
   // the same length, but this should normally be the case if the input
   // data were corrected with the TBSS Module.
 
   std::vector< std::vector<mitk::ScalarType> > groupProfiles;
 
   std::vector< std::pair<std::string, int> >::iterator it;
   it = m_Groups.begin();
 
   int c = 0; //the current profile number
 
   while(it != m_Groups.end() && profiles.size() > 0)
   {
     std::pair<std::string, int> p = *it;
     int size = p.second;
 
     //initialize a vector of the right length with zeroes
     std::vector<mitk::ScalarType> averageProfile;
     for(unsigned int i=0; i<profiles.at(0).size(); i++)
     {
       averageProfile.push_back(0.0);
     }
 
     // Average the right number of profiles
 
     for(int i=0; i<size; i++)
     {
       for(unsigned int j=0; j<averageProfile.size(); ++j)
       {
         averageProfile.at(j) = averageProfile.at(j) + profiles.at(c).at(j);
       }
       c++;
     }
 
     // Divide by the number of profiles to get group average
     for(unsigned int i=0; i<averageProfile.size(); i++)
     {
       averageProfile.at(i) = averageProfile.at(i) / size;
     }
 
     groupProfiles.push_back(averageProfile);
 
     ++it;
   }
 
   return groupProfiles;
 }
 
 
 void QmitkTbssRoiAnalysisWidget::DrawProfiles()
 {
   std::vector <std::vector<mitk::ScalarType> > groupProfiles = CalculateGroupProfiles();
   Plot(groupProfiles);
 }
 
 void QmitkTbssRoiAnalysisWidget::Plot(std::vector <std::vector<mitk::ScalarType> > groupProfiles)
 {
     this->Clear();
     m_Vals.clear();
     std::vector<mitk::ScalarType> v1;
 
 
     std::vector<mitk::ScalarType> xAxis;
     for(unsigned int i=0; i<groupProfiles.at(0).size(); ++i)
     {
       xAxis.push_back((mitk::ScalarType)i);
     }
 
 
     // fill m_Vals. This might be used by the user to copy data to the clipboard
     for(unsigned int i=0; i<groupProfiles.size(); i++)
     {
 
       v1.clear();
 
 
       for(unsigned int j=0; j<groupProfiles.at(i).size(); j++)
       {
         v1.push_back(groupProfiles.at(i).at(j));
       }
 
       m_Vals.push_back(v1);
 
     }
 
     std::string title = m_Measure + " profiles on the ";
     title.append(m_Structure);
     this->SetPlotTitle( title.c_str() );
     QPen pen( Qt::SolidLine );
     pen.setWidth(2);
 
 
 
     std::vector< std::pair<std::string, int> >::iterator it;
     it = m_Groups.begin();
 
     int c = 0; //the current profile number
 
     QColor colors[4] = {Qt::green, Qt::blue, Qt::yellow, Qt::red};
 
     while(it != m_Groups.end() && groupProfiles.size() > 0)
     {
 
       std::pair< std::string, int > group = *it;
 
       pen.setColor(colors[c]);
       int curveId = this->InsertCurve( group.first.c_str() );
       this->SetCurveData( curveId, xAxis, groupProfiles.at(c) );
 
 
       this->SetCurvePen( curveId, pen );
 
       c++;
       it++;
 
     }
 
 
     QwtLegend *legend = new QwtLegend;
     this->SetLegend(legend, QwtPlot::RightLegend, 0.5);
 
 
     std::cout << m_Measure << std::endl;
     this->m_Plot->setAxisTitle(0, m_Measure.c_str());
     this->m_Plot->setAxisTitle(3, "Position");
 
     this->Replot();
 }
 
 
 std::vector< std::vector<mitk::ScalarType> > QmitkTbssRoiAnalysisWidget::CalculateGroupProfilesFibers(mitk::TbssImage::Pointer tbssImage,
-                                                                                            mitk::FiberBundleX *fib,
+                                                                                            mitk::FiberBundle *fib,
                                                                                             mitk::PlanarFigure* startRoi,
                                                                                             mitk::PlanarFigure* endRoi,
                                                                                             int number)
 {
     TractContainerType tracts = CreateTracts(fib, startRoi, endRoi);
 
     TractContainerType resampledTracts = ParameterizeTracts(tracts, number);
 
     int nTracts = resampledTracts.size();
 
     this->Clear();
 
 
     // For every group we have m fibers * n subjects of profiles to fill
 
     std::vector< std::vector<mitk::ScalarType> > profiles;
 
     // calculate individual profiles by going through all n subjects
     int size = m_Projections->GetVectorLength();
     for(int s=0; s<size; s++)
     {
 
       // Iterate through all tracts
 
       for(int t=0; t<nTracts; t++)
       {
         // Iterate trough the tract
         std::vector<mitk::ScalarType> profile;
         TractType::iterator it = resampledTracts[t].begin();
         while(it != resampledTracts[t].end())
         {
           PointType p = *it;
           PointType index;
           tbssImage->GetGeometry()->WorldToIndex(p, index);
 
           itk::Index<3> ix;
           ix[0] = index[0];
           ix[1] = index[1];
           ix[2] = index[2];
           // Get value from image
 
           profile.push_back(m_Projections->GetPixel(ix).GetElement(s));
 
           it++;
         }
         profiles.push_back(profile);
       }
 
 
     }
 
     m_IndividualProfiles = profiles;
 
     // Now create the group averages (every group contains m fibers * n_i group members
 
     std::vector< std::pair<std::string, int> >::iterator it;
     it = m_Groups.begin();
     int c = 0; //the current profile number
 
     // Calculate the group averages
     std::vector< std::vector<mitk::ScalarType> > groupProfiles;
 
     while(it != m_Groups.end() && profiles.size() > 0)
     {
       std::pair<std::string, int> p = *it;
       int size = p.second;
 
       //initialize a vector of the right length with zeroes
       std::vector<mitk::ScalarType> averageProfile;
       for(unsigned int i=0; i<profiles.at(0).size(); i++)
       {
         averageProfile.push_back(0.0);
       }
 
       // Average the right number of profiles
 
       for(int i=0; i<size*nTracts; i++)
       {
         for(unsigned int j=0; j<averageProfile.size(); ++j)
         {
           averageProfile.at(j) = averageProfile.at(j) + profiles.at(c).at(j);
         }
         c++;
       }
 
       // Divide by the number of profiles to get group average
       for(unsigned int i=0; i<averageProfile.size(); i++)
       {
         averageProfile.at(i) = averageProfile.at(i) / (size*nTracts);
       }
 
       groupProfiles.push_back(averageProfile);
 
       ++it;
     }
 
     return groupProfiles;
 }
 
 
 void QmitkTbssRoiAnalysisWidget::PlotFiber4D(mitk::TbssImage::Pointer tbssImage,
-                                             mitk::FiberBundleX *fib,
+                                             mitk::FiberBundle *fib,
                                              mitk::PlanarFigure* startRoi,
                                              mitk::PlanarFigure* endRoi,
                                              int number)
 {
   m_PlottingFiberBundle = false;
   m_Fib = fib;
   m_CurrentStartRoi = startRoi;
   m_CurrentEndRoi = endRoi;
   m_CurrentTbssImage = tbssImage;
   std::vector <std::vector<mitk::ScalarType> > groupProfiles = CalculateGroupProfilesFibers(tbssImage, fib, startRoi, endRoi, number);
   Plot(groupProfiles);
 
 }
 
 
 template <typename T>
 void QmitkTbssRoiAnalysisWidget::PlotFiberBundles(const mitk::PixelType ptype, TractContainerType tracts, mitk::Image *img, bool avg)
 {
 
   m_PlottingFiberBundle = true;
 
   this->Clear();
   std::vector<TractType>::iterator it = tracts.begin();
 
 
   std::vector< std::vector <mitk::ScalarType > > profiles;
 
   mitk::ImagePixelReadAccessor<T,3> imAccess(img,img->GetVolumeData(0));
 
   it = tracts.begin();
   while(it != tracts.end())
   {
 
     TractType tract = *it;
     TractType::iterator tractIt = tract.begin();
 
     std::vector<mitk::ScalarType> profile;
 
     while(tractIt != tract.end())
     {
       PointType p = *tractIt;
 
       // Get value from image
       profile.push_back( (mitk::ScalarType) imAccess.GetPixelByWorldCoordinates(p) );
 
       ++tractIt;
     }
 
     profiles.push_back(profile);
     std::cout << std::endl;
 
     ++it;
   }
 
 
   if(profiles.size() == 0)
     return;
 
   m_IndividualProfiles = profiles;
 
 
   std::string title = "Fiber bundle plot";
   this->SetPlotTitle( title.c_str() );
 
 
   // initialize average profile
   std::vector<mitk::ScalarType> averageProfile;
   std::vector<mitk::ScalarType> profile = profiles.at(0); // can do this because we checked the size of profiles before
   for(unsigned int i=0; i<profile.size(); ++i)
   {
     averageProfile.push_back(0.0);
   }
 
 
   std::vector< std::vector<mitk::ScalarType> >::iterator profit = profiles.begin();
 
   int id=0;
   while(profit != profiles.end())
   {
     std::vector<mitk::ScalarType> profile = *profit;
 
 
 
     std::vector<mitk::ScalarType> xAxis;
     for(unsigned int i=0; i<profile.size(); ++i)
     {
       xAxis.push_back((mitk::ScalarType)i);
       averageProfile.at(i) += profile.at(i) / profiles.size();
     }
 
     int curveId = this->InsertCurve( "" );
 
     this->SetCurveData( curveId, xAxis, profile );
 
     ++profit;
     id++;
 
 
   }
 
   m_Average = averageProfile;
 
 
   if(avg)
   {
 
     // Draw the average profile
     std::vector<mitk::ScalarType> xAxis;
     for(unsigned int i=0; i<averageProfile.size(); ++i)
     {
       xAxis.push_back((mitk::ScalarType)i);
     }
 
     int curveId = this->InsertCurve( "" );
     this->SetCurveData( curveId, xAxis, averageProfile );
 
 
 
 
     QPen pen( Qt::SolidLine );
     pen.setWidth(3);
     pen.setColor(Qt::red);
 
     this->SetCurvePen( curveId, pen );
 
 
 
     id++;
 
 
   }
 
   this->Replot();
 
 
 
 
 
 }
 
 
 void QmitkTbssRoiAnalysisWidget::drawBar(int x)
 {
 
   m_Plot->detachItems(QwtPlotItem::Rtti_PlotMarker, true);
 
 
   QwtPlotMarker *mX = new QwtPlotMarker();
   //mX->setLabel(QString::fromLatin1("selected point"));
   mX->setLabelAlignment(Qt::AlignLeft | Qt::AlignBottom);
   mX->setLabelOrientation(Qt::Vertical);
   mX->setLineStyle(QwtPlotMarker::VLine);
   mX->setLinePen(QPen(Qt::black, 0, Qt::SolidLine));
   mX->setXValue(x);
   mX->attach(m_Plot);
 
 
   this->Replot();
 
 }
 
 QmitkTbssRoiAnalysisWidget::~QmitkTbssRoiAnalysisWidget()
 {
   delete m_PlotPicker;
 
 }
 
 
 
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.h
index 162ce829d8..8e020ed842 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.h
@@ -1,230 +1,230 @@
 /*===================================================================
 
 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 QmitkTbssRoiAnalysisWidget_H_
 #define QmitkTbssRoiAnalysisWidget_H_
 
 #include "QmitkPlotWidget.h"
 
 #include <org_mitk_gui_qt_diffusionimaging_Export.h>
 
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <mitkTbssImage.h>
 
 #include <itkVectorImage.h>
 
 typedef itk::VectorImage<float,3>     VectorImageType;
 typedef std::vector< itk::Index<3> > RoiType;
 
 typedef mitk::Point3D                     PointType;
 typedef std::vector< PointType>           TractType;
 typedef std::vector< TractType > TractContainerType;
 
 class QwtPlotPicker;
 
 /**
  * \brief Plot widget for TBSS Data
  * This widget can plot regions of interest on TBSS projection data. The projection data is created by importing FSL TBSS subject data and
  * completing it with patient data using the QmitkTractbasedSpatialStatisticsView.
  * The region of interest is a vector of indices from which data for plotting should be obtained.
  */
 
 class DIFFUSIONIMAGING_EXPORT QmitkTbssRoiAnalysisWidget : public QmitkPlotWidget
 {
 
 Q_OBJECT
 
 public:
 
 
   QmitkTbssRoiAnalysisWidget( QWidget * parent);
   virtual ~QmitkTbssRoiAnalysisWidget();
 
 
   /* \brief Set group information as a vector of pairs of group name and number of group members */
   void SetGroups(std::vector< std::pair<std::string, int> > groups)
   {
     m_Groups = groups;
   }
 
   /* \brief Draws the group averaged profiles */
   void DrawProfiles();
 
 
   void PlotFiber4D(mitk::TbssImage::Pointer tbssImage,
-                   mitk::FiberBundleX *fib,
+                   mitk::FiberBundle *fib,
                    mitk::PlanarFigure* startRoi,
                    mitk::PlanarFigure* endRoi,
                    int number);
 
 
   template <typename T>
   void PlotFiberBundles(const mitk::PixelType, TractContainerType tracts, mitk::Image* img, bool avg=false);
 
 
   /* \brief Sets the projections of the individual subjects */
   void SetProjections(VectorImageType::Pointer projections)
   {
     m_Projections = projections;
   }
 
   /* \brief Set the region of interest*/
   void SetRoi(RoiType roi)
   {
     m_Roi = roi;
   }
 
   /* \brief Set structure information to display in the plot */
   void SetStructure(std::string structure)
   {
     m_Structure = structure;
   }
 
   /* \brief Set measurement type for display in the plot */
   void SetMeasure(std::string measure)
   {
     m_Measure = measure;
   }
 
   /* \brief Draws a bar to indicate were the user clicked in the plot */
   void drawBar(int x);
 
 
 
   /* \brief Returns the values of the group averaged profiles */
   std::vector <std::vector<double> > GetVals()
   {
     return m_Vals;
   }
 
 
   /* \brief Returns the values of the individual subjects profiles */
   std::vector <std::vector<double> > GetIndividualProfiles()
   {
     return m_IndividualProfiles;
   }
 
 
   std::vector<double> GetAverageProfile()
   {
     return m_Average;
   }
 
 
   void SetPlottingFiber(bool b)
   {
     m_PlottingFiberBundle = b;
   }
 
   bool IsPlottingFiber()
   {
     return m_PlottingFiberBundle;
   }
 
 
-  void PlotFiberBetweenRois(mitk::FiberBundleX *fib, mitk::Image* img,
+  void PlotFiberBetweenRois(mitk::FiberBundle *fib, mitk::Image* img,
                             mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi, bool avg=-1, int number=25);
 
 
 
 
   // Takes an index which is an x coordinate from the plot and finds the corresponding position in world space
   mitk::Point3D GetPositionInWorld(int index);
   void ModifyPlot(int number, bool avg);
 
 
 
   QwtPlotPicker* m_PlotPicker;
 
 protected:
 
-  mitk::FiberBundleX* m_Fib;
+  mitk::FiberBundle* m_Fib;
 
 
   std::vector< std::vector<double> > m_Vals;
 
   std::vector< std::vector<double> > m_IndividualProfiles;
   std::vector< double > m_Average;
 
 
 
   std::vector< std::vector<double> > CalculateGroupProfiles();
   std::vector< std::vector<double> > CalculateGroupProfilesFibers(mitk::TbssImage::Pointer tbssImage,
-                                                                  mitk::FiberBundleX *fib,
+                                                                  mitk::FiberBundle *fib,
                                                                   mitk::PlanarFigure* startRoi,
                                                                   mitk::PlanarFigure* endRoi,
                                                                   int number);
 
   void Plot(std::vector <std::vector<double> > groupProfiles);
 
 
   void Tokenize(const std::string& str,
                 std::vector<std::string>& tokens,
                 const std::string& delimiters = " ")
   {
     // Skip delimiters at beginning.
     std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
     // Find first "non-delimiter".
     std::string::size_type pos     = str.find_first_of(delimiters, lastPos);
 
     while (std::string::npos != pos || std::string::npos != lastPos)
     {
         // Found a token, add it to the vector.
         tokens.push_back(str.substr(lastPos, pos - lastPos));
         // Skip delimiters.  Note the "not_of"
         lastPos = str.find_first_not_of(delimiters, pos);
         // Find next "non-delimiter"
         pos = str.find_first_of(delimiters, lastPos);
     }
   }
 
   std::vector< std::pair<std::string, int> > m_Groups;
 
   VectorImageType::Pointer m_Projections;
   RoiType m_Roi;
   std::string m_Structure;
   std::string m_Measure;
 
   bool m_PlottingFiberBundle; // true when the plot results from a fiber tracking result (vtk .fib file)
 
 
   // Resample a collection of tracts so that every tract contains #number equidistant samples
   TractContainerType ParameterizeTracts(TractContainerType tracts, int number);
 
 
   TractContainerType m_CurrentTracts;
 
 
   mitk::Image* m_CurrentImage;
   mitk::TbssImage* m_CurrentTbssImage;
 
   mitk::PlanarFigure* m_CurrentStartRoi;
   mitk::PlanarFigure* m_CurrentEndRoi;
 
 
-  void DoPlotFiberBundles(mitk::FiberBundleX *fib, mitk::Image* img,
+  void DoPlotFiberBundles(mitk::FiberBundle *fib, mitk::Image* img,
                           mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi, bool avg=false, int number=25);
 
 
 
-  /* \brief Creates tracts from a mitk::FiberBundleX and two planar figures indicating the start end end point */
-  TractContainerType CreateTracts(mitk::FiberBundleX *fib, mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi);
+  /* \brief Creates tracts from a mitk::FiberBundle and two planar figures indicating the start end end point */
+  TractContainerType CreateTracts(mitk::FiberBundle *fib, mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi);
 
 
 
 };
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.cpp
index ec259e9142..7a2eb21bfa 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.cpp
@@ -1,404 +1,404 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // ####### Blueberry includes #######
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // ####### Qmitk includes #######
 #include "QmitkConnectomicsDataView.h"
 #include "QmitkStdMultiWidget.h"
 
 // ####### Qt includes #######
 #include <QMessageBox>
 
 // ####### ITK includes #######
 #include <itkRGBAPixel.h>
 
 // ####### MITK includes #######
 
 #include <mitkConnectomicsConstantsManager.h>
 #include "mitkConnectomicsSyntheticNetworkGenerator.h"
 #include "mitkConnectomicsSimulatedAnnealingManager.h"
 #include "mitkConnectomicsSimulatedAnnealingPermutationModularity.h"
 #include "mitkConnectomicsSimulatedAnnealingCostFunctionModularity.h"
 
 // Includes for image casting between ITK and MITK
 #include "mitkImageCast.h"
 #include "mitkITKImageImport.h"
 #include "mitkImageAccessByItk.h"
 
 const std::string QmitkConnectomicsDataView::VIEW_ID = "org.mitk.views.connectomicsdata";
 
 QmitkConnectomicsDataView::QmitkConnectomicsDataView()
 : QmitkFunctionality()
 , m_Controls( 0 )
 , m_MultiWidget( NULL )
 , m_ConnectomicsNetworkCreator( mitk::ConnectomicsNetworkCreator::New() )
 , m_demomode( false )
 , m_currentIndex( 0 )
 {
 }
 
 QmitkConnectomicsDataView::~QmitkConnectomicsDataView()
 {
 }
 
 
 void QmitkConnectomicsDataView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkConnectomicsDataViewControls;
     m_Controls->setupUi( parent );
 
     QObject::connect( m_Controls->networkifyPushButton, SIGNAL(clicked()), this, SLOT(OnNetworkifyPushButtonClicked()) );
     QObject::connect( m_Controls->syntheticNetworkCreationPushButton, SIGNAL(clicked()), this, SLOT(OnSyntheticNetworkCreationPushButtonClicked()) );
     QObject::connect( (QObject*)( m_Controls->syntheticNetworkComboBox ), SIGNAL(currentIndexChanged (int)),  this, SLOT(OnSyntheticNetworkComboBoxCurrentIndexChanged(int)) );
   }
 
   // GUI is different for developer and demo mode
   m_demomode = true;
   if( m_demomode )
   {
     this->m_Controls->networkifyPushButton->show();
     this->m_Controls->networkifyPushButton->setText( "Create Network" );
     this->m_Controls->syntheticNetworkOptionsGroupBox->show();
     //--------------------------- fill comboBox---------------------------
     this->m_Controls->syntheticNetworkComboBox->insertItem(0,"Regular lattice");
     this->m_Controls->syntheticNetworkComboBox->insertItem(1,"Heterogenic sphere");
     this->m_Controls->syntheticNetworkComboBox->insertItem(2,"Random network");
 
     this->m_Controls->mappingStrategyComboBox->insertItem(m_ConnectomicsNetworkCreator->EndElementPosition, "Use label of end position of fibers");
     this->m_Controls->mappingStrategyComboBox->insertItem(m_ConnectomicsNetworkCreator->EndElementPositionAvoidingWhiteMatter, "Extrapolate label");
   }
   else
   {
     this->m_Controls->networkifyPushButton->show();
     this->m_Controls->networkifyPushButton->setText( "Networkify" );
     this->m_Controls->syntheticNetworkOptionsGroupBox->show();
     //--------------------------- fill comboBox---------------------------
     this->m_Controls->syntheticNetworkComboBox->insertItem(0,"Regular lattice");
     this->m_Controls->syntheticNetworkComboBox->insertItem(1,"Heterogenic sphere");
     this->m_Controls->syntheticNetworkComboBox->insertItem(2,"Random network");
     this->m_Controls->syntheticNetworkComboBox->insertItem(3,"Scale free network");
     this->m_Controls->syntheticNetworkComboBox->insertItem(4,"Small world network");
 
     this->m_Controls->mappingStrategyComboBox->insertItem(m_ConnectomicsNetworkCreator->EndElementPosition, "Use label of end position of fibers");
     this->m_Controls->mappingStrategyComboBox->insertItem(m_ConnectomicsNetworkCreator->EndElementPositionAvoidingWhiteMatter, "Extrapolate label");
     this->m_Controls->mappingStrategyComboBox->insertItem(m_ConnectomicsNetworkCreator->JustEndPointVerticesNoLabel, "Use end position of fibers, no label");
   }
 
   this->WipeDisplay();
 }
 
 
 void QmitkConnectomicsDataView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkConnectomicsDataView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkConnectomicsDataView::WipeDisplay()
 {
   m_Controls->lblWarning->setVisible( true );
   m_Controls->inputImageOneNameLabel->setText( mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_DASH );
   m_Controls->inputImageOneNameLabel->setVisible( false );
   m_Controls->inputImageOneLabel->setVisible( false );
   m_Controls->inputImageTwoNameLabel->setText( mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_DASH );
   m_Controls->inputImageTwoNameLabel->setVisible( false );
   m_Controls->inputImageTwoLabel->setVisible( false );
 }
 
 void QmitkConnectomicsDataView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
   this->WipeDisplay();
 
   // Valid options are either
   // 1 image (parcellation)
   //
   // 1 image (parcellation)
   // 1 fiber bundle
   //
   // 1 network
   if( nodes.size() > 2 )
   {
     return;
   }
 
   bool alreadyFiberBundleSelected( false ), alreadyImageSelected( false ), currentFormatUnknown( true );
   // iterate all selected objects, adjust warning visibility
   for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
        it != nodes.end();
        ++it )
   {
     mitk::DataNode::Pointer node = *it;
     currentFormatUnknown = true;
 
     if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
     {
       currentFormatUnknown = false;
       if( alreadyImageSelected )
       {
         this->WipeDisplay();
         return;
       }
       alreadyImageSelected = true;
       m_Controls->lblWarning->setVisible( false );
       m_Controls->inputImageOneNameLabel->setText(node->GetName().c_str());
       m_Controls->inputImageOneNameLabel->setVisible( true );
       m_Controls->inputImageOneLabel->setVisible( true );
     }
 
-    if( node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
+    if( node.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
     {
       currentFormatUnknown = false;
       // a fiber bundle has to be in conjunction with a parcellation
       if( nodes.size() != 2 || alreadyFiberBundleSelected )
       {
         this->WipeDisplay();
         return;
       }
       alreadyFiberBundleSelected = true;
       m_Controls->lblWarning->setVisible( false );
       m_Controls->inputImageTwoNameLabel->setText(node->GetName().c_str());
       m_Controls->inputImageTwoNameLabel->setVisible( true );
       m_Controls->inputImageTwoLabel->setVisible( true );
     }
 
     { // network section
       mitk::ConnectomicsNetwork* network = dynamic_cast<mitk::ConnectomicsNetwork*>( node->GetData() );
       if( node.IsNotNull() && network )
       {
         currentFormatUnknown = false;
         if( nodes.size() != 1 )
         {
           // only valid option is a single network
           this->WipeDisplay();
           return;
         }
         m_Controls->lblWarning->setVisible( false );
         m_Controls->inputImageOneNameLabel->setText(node->GetName().c_str());
         m_Controls->inputImageOneNameLabel->setVisible( true );
         m_Controls->inputImageOneLabel->setVisible( true );
       }
     } // end network section
 
     if ( currentFormatUnknown )
     {
       this->WipeDisplay();
       return;
     }
   } // end for loop
 }
 
 void QmitkConnectomicsDataView::OnSyntheticNetworkComboBoxCurrentIndexChanged(int currentIndex)
 {
   m_currentIndex = currentIndex;
 
     switch (m_currentIndex) {
   case 0:
     this->m_Controls->parameterOneLabel->setText( "Nodes per side" );
     this->m_Controls->parameterTwoLabel->setText( "Internode distance" );
     this->m_Controls->parameterOneSpinBox->setEnabled( true );
     this->m_Controls->parameterOneSpinBox->setValue( 5 );
     this->m_Controls->parameterTwoDoubleSpinBox->setEnabled( true );
     this->m_Controls->parameterTwoDoubleSpinBox->setMaximum( 999.999 );
     this->m_Controls->parameterTwoDoubleSpinBox->setValue( 10.0 );
     break;
   case 1:
     this->m_Controls->parameterOneLabel->setText( "Number of nodes" );
     this->m_Controls->parameterTwoLabel->setText( "Radius" );
     this->m_Controls->parameterOneSpinBox->setEnabled( true );
     this->m_Controls->parameterOneSpinBox->setValue( 1000 );
     this->m_Controls->parameterTwoDoubleSpinBox->setEnabled( true );
     this->m_Controls->parameterTwoDoubleSpinBox->setMaximum( 999.999 );
     this->m_Controls->parameterTwoDoubleSpinBox->setValue( 50.0 );
     break;
   case 2:
     this->m_Controls->parameterOneLabel->setText( "Number of nodes" );
     this->m_Controls->parameterTwoLabel->setText( "Edge percentage" );
     this->m_Controls->parameterOneSpinBox->setEnabled( true );
     this->m_Controls->parameterOneSpinBox->setValue( 100 );
     this->m_Controls->parameterTwoDoubleSpinBox->setEnabled( true );
     this->m_Controls->parameterTwoDoubleSpinBox->setMaximum( 1.0 );
     this->m_Controls->parameterTwoDoubleSpinBox->setValue( 0.5 );
     break;
   case 3:
     //GenerateSyntheticScaleFreeNetwork( network, 1000 );
     break;
   case 4:
     //GenerateSyntheticSmallWorldNetwork( network, 1000 );
     break;
   default:
     this->m_Controls->parameterOneLabel->setText( "Parameter 1" );
     this->m_Controls->parameterTwoLabel->setText( "Paramater 2" );
     this->m_Controls->parameterOneSpinBox->setEnabled( false );
     this->m_Controls->parameterOneSpinBox->setValue( 0 );
     this->m_Controls->parameterTwoDoubleSpinBox->setEnabled( false );
     this->m_Controls->parameterTwoDoubleSpinBox->setValue( 0.0 );
     }
 }
 
 void QmitkConnectomicsDataView::OnSyntheticNetworkCreationPushButtonClicked()
 {
   // warn if trying to create a very big network
   // big network is a network with > 5000 nodes (estimate)
   // this might fill up the memory to the point it freezes
   int numberOfNodes( 0 );
   switch (m_currentIndex) {
   case 0:
     numberOfNodes = this->m_Controls->parameterOneSpinBox->value()
       * this->m_Controls->parameterOneSpinBox->value()
       * this->m_Controls->parameterOneSpinBox->value();
     break;
   case 1:
     numberOfNodes = this->m_Controls->parameterOneSpinBox->value();
     break;
   case 2:
     numberOfNodes = this->m_Controls->parameterOneSpinBox->value();
     break;
   case 3:
     // not implemented yet
     break;
   case 4:
     // not implemented yet
     break;
   default:
     break;
   }
 
   if( numberOfNodes > 5000 )
   {
     QMessageBox msgBox;
     msgBox.setText("Trying to generate very large network.");
     msgBox.setIcon( QMessageBox::Warning );
     msgBox.setInformativeText("You are trying to generate a network with more than 5000 nodes, this is very resource intensive and might lead to program instability. Proceed with network generation?");
     msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
     msgBox.setDefaultButton(QMessageBox::No);
     int ret = msgBox.exec();
 
     switch (ret) {
   case QMessageBox::Yes:
     // continue
     break;
   case QMessageBox::No:
     // stop
     return;
     break;
 
   default:
     // should never be reached
     break;
     }
   }
 
   // proceed
   mitk::ConnectomicsSyntheticNetworkGenerator::Pointer generator = mitk::ConnectomicsSyntheticNetworkGenerator::New();
 
   mitk::DataNode::Pointer networkNode = mitk::DataNode::New();
   int parameterOne = this->m_Controls->parameterOneSpinBox->value();
   double parameterTwo = this->m_Controls->parameterTwoDoubleSpinBox->value();
   //add network to datastorage
   networkNode->SetData( generator->CreateSyntheticNetwork( m_currentIndex, parameterOne, parameterTwo ) );
   networkNode->SetName( mitk::ConnectomicsConstantsManager::CONNECTOMICS_PROPERTY_DEFAULT_CNF_NAME );
   if( generator->WasGenerationSuccessfull() )
   {
     this->GetDefaultDataStorage()->Add( networkNode );
   }
   else
   {
     MITK_WARN << "Problem occured during synthetic network generation.";
   }
 
   mitk::RenderingManager::GetInstance()->InitializeViews(
     networkNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   return;
 }
 
 void QmitkConnectomicsDataView::OnNetworkifyPushButtonClicked()
 {
   std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
   if ( nodes.empty() )
   {
     QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS_CREATION, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_SELECTION_WARNING);
     return;
   }
 
   if (! ( nodes.size() == 2 ) )
   {
     QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS_CREATION, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_SELECTION_WARNING);
     return;
   }
   mitk::DataNode* firstNode = nodes.front();
   mitk::DataNode* secondNode = nodes.at(1);
 
   if (!firstNode)
   {
     // Nothing selected. Inform the user and return
     QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS_CREATION, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_SELECTION_WARNING);
     return;
   }
 
   // here we have a valid mitk::DataNode
 
   // a node itself is not very useful, we need its data item (the image)
   mitk::BaseData* firstData = firstNode->GetData();
   mitk::BaseData* secondData = secondNode->GetData();
   if (firstData && secondData)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>( firstData );
-    mitk::FiberBundleX* fiberBundle = dynamic_cast<mitk::FiberBundleX*>( secondData );
+    mitk::FiberBundle* fiberBundle = dynamic_cast<mitk::FiberBundle*>( secondData );
 
     // check whether order was switched
     if (! (image && fiberBundle) )
     {
       image = dynamic_cast<mitk::Image*>( secondData );
-      fiberBundle = dynamic_cast<mitk::FiberBundleX*>( firstData );
+      fiberBundle = dynamic_cast<mitk::FiberBundle*>( firstData );
     }
 
     if (image && fiberBundle)
     {
       mitk::ConnectomicsNetworkCreator::MappingStrategy mappingStrategy =
         static_cast<mitk::ConnectomicsNetworkCreator::MappingStrategy>(this->m_Controls->mappingStrategyComboBox->currentIndex());
 
       m_ConnectomicsNetworkCreator->SetSegmentation( image );
       m_ConnectomicsNetworkCreator->SetFiberBundle( fiberBundle );
       m_ConnectomicsNetworkCreator->CalculateCenterOfMass();
       m_ConnectomicsNetworkCreator->SetEndPointSearchRadius( 15 );
       m_ConnectomicsNetworkCreator->SetMappingStrategy( mappingStrategy );
       m_ConnectomicsNetworkCreator->CreateNetworkFromFibersAndSegmentation();
       mitk::DataNode::Pointer networkNode = mitk::DataNode::New();
 
       //add network to datastorage
       networkNode->SetData( m_ConnectomicsNetworkCreator->GetNetwork() );
       networkNode->SetName( mitk::ConnectomicsConstantsManager::CONNECTOMICS_PROPERTY_DEFAULT_CNF_NAME );
       this->GetDefaultDataStorage()->Add( networkNode );
     }
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
index 0ce6c56d4a..869cce17b8 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
@@ -1,1036 +1,1036 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkControlVisualizationPropertiesView.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include "mitkResliceMethodProperty.h"
 #include "mitkRenderingManager.h"
 
 #include "mitkTbssImage.h"
 #include "mitkPlanarFigure.h"
-#include "mitkFiberBundleX.h"
+#include "mitkFiberBundle.h"
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 #include "mitkFiberBundleInteractor.h"
 #include "mitkPlanarFigureInteractor.h"
 #include <mitkQBallImage.h>
 #include <mitkTensorImage.h>
 #include <mitkImage.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkConnectomicsNetwork.h>
 #include "mitkGlobalInteraction.h"
 #include "usModuleRegistry.h"
 
 #include "mitkPlaneGeometry.h"
 
 #include "berryIWorkbenchWindow.h"
 #include "berryIWorkbenchPage.h"
 #include "berryISelectionService.h"
 #include "berryConstants.h"
 #include "berryPlatformUI.h"
 
 #include "itkRGBAPixel.h"
 #include <itkTractDensityImageFilter.h>
 
 #include "qwidgetaction.h"
 #include "qcolordialog.h"
 #include <QRgb>
 #include <itkMultiThreader.h>
 
 #define ROUND(a) ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
 
 const std::string QmitkControlVisualizationPropertiesView::VIEW_ID = "org.mitk.views.controlvisualizationpropertiesview";
 
 using namespace berry;
 
 QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView()
     : QmitkFunctionality(),
       m_Controls(NULL),
       m_MultiWidget(NULL),
       m_NodeUsedForOdfVisualization(NULL),
       m_IconTexOFF(new QIcon(":/QmitkDiffusionImaging/texIntOFFIcon.png")),
       m_IconTexON(new QIcon(":/QmitkDiffusionImaging/texIntONIcon.png")),
       m_IconGlyOFF_T(new QIcon(":/QmitkDiffusionImaging/glyphsoff_T.png")),
       m_IconGlyON_T(new QIcon(":/QmitkDiffusionImaging/glyphson_T.png")),
       m_IconGlyOFF_C(new QIcon(":/QmitkDiffusionImaging/glyphsoff_C.png")),
       m_IconGlyON_C(new QIcon(":/QmitkDiffusionImaging/glyphson_C.png")),
       m_IconGlyOFF_S(new QIcon(":/QmitkDiffusionImaging/glyphsoff_S.png")),
       m_IconGlyON_S(new QIcon(":/QmitkDiffusionImaging/glyphson_S.png")),
       m_CurrentSelection(0),
       m_CurrentPickingNode(0),
       m_GlyIsOn_S(false),
       m_GlyIsOn_C(false),
       m_GlyIsOn_T(false),
       m_FiberBundleObserverTag(0),
       m_FiberBundleObserveOpacityTag(0),
       m_Color(NULL)
 {
     currentThickSlicesMode = 1;
     m_MyMenu = NULL;
     int numThread = itk::MultiThreader::GetGlobalMaximumNumberOfThreads();
     if (numThread > 12)
         numThread = 12;
     itk::MultiThreader::SetGlobalDefaultNumberOfThreads(numThread);
 }
 
 QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView(const QmitkControlVisualizationPropertiesView& other)
 {
     Q_UNUSED(other)
     throw std::runtime_error("Copy constructor not implemented");
 }
 
 QmitkControlVisualizationPropertiesView::~QmitkControlVisualizationPropertiesView()
 {
     if(m_SlicesRotationObserverTag1 )
     {
         mitk::SlicesCoordinator::Pointer coordinator = m_MultiWidget->GetSlicesRotator();
         if( coordinator.IsNotNull() )
             coordinator->RemoveObserver(m_SlicesRotationObserverTag1);
     }
     if( m_SlicesRotationObserverTag2)
     {
         mitk::SlicesCoordinator::Pointer coordinator = m_MultiWidget->GetSlicesRotator();
         if( coordinator.IsNotNull() )
             coordinator->RemoveObserver(m_SlicesRotationObserverTag1);
     }
 
     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
 }
 
 void QmitkControlVisualizationPropertiesView::OnThickSlicesModeSelected( QAction* action )
 {
     currentThickSlicesMode = action->data().toInt();
 
     switch(currentThickSlicesMode)
     {
     default:
     case 1:
         this->m_Controls->m_TSMenu->setText("MIP");
         break;
     case 2:
         this->m_Controls->m_TSMenu->setText("SUM");
         break;
     case 3:
         this->m_Controls->m_TSMenu->setText("WEIGH");
         break;
     }
 
     mitk::DataNode* n;
     n = this->m_MultiWidget->GetWidgetPlane1(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
     n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
     n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
 
     mitk::BaseRenderer::Pointer renderer =
             this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
     if(renderer.IsNotNull())
     {
         renderer->SendUpdateSlice();
     }
     renderer = this->GetActiveStdMultiWidget()->GetRenderWindow2()->GetRenderer();
     if(renderer.IsNotNull())
     {
         renderer->SendUpdateSlice();
     }
     renderer = this->GetActiveStdMultiWidget()->GetRenderWindow3()->GetRenderer();
     if(renderer.IsNotNull())
     {
         renderer->SendUpdateSlice();
     }
     renderer->GetRenderingManager()->RequestUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::OnTSNumChanged(int num)
 {
     if(num==0)
     {
         mitk::DataNode* n;
         n = this->m_MultiWidget->GetWidgetPlane1();
         if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
         if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
         if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
 
         n = this->m_MultiWidget->GetWidgetPlane2();
         if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
         if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
         if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
 
         n = this->m_MultiWidget->GetWidgetPlane3();
         if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
         if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
         if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
     }
     else
     {
         mitk::DataNode* n;
         n = this->m_MultiWidget->GetWidgetPlane1();
         if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
         if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
         if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
 
         n = this->m_MultiWidget->GetWidgetPlane2();
         if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
         if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
         if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
 
         n = this->m_MultiWidget->GetWidgetPlane3();
         if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
         if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
         if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
     }
 
     m_TSLabel->setText(QString::number(num*2+1));
 
     mitk::BaseRenderer::Pointer renderer = this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
     if(renderer.IsNotNull())
         renderer->SendUpdateSlice();
 
     renderer = this->GetActiveStdMultiWidget()->GetRenderWindow2()->GetRenderer();
     if(renderer.IsNotNull())
         renderer->SendUpdateSlice();
 
     renderer = this->GetActiveStdMultiWidget()->GetRenderWindow3()->GetRenderer();
     if(renderer.IsNotNull())
         renderer->SendUpdateSlice();
 
     renderer->GetRenderingManager()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
 }
 
 void QmitkControlVisualizationPropertiesView::CreateQtPartControl(QWidget *parent)
 {
     if (!m_Controls)
     {
         // create GUI widgets
         m_Controls = new Ui::QmitkControlVisualizationPropertiesViewControls;
         m_Controls->setupUi(parent);
         this->CreateConnections();
 
         // hide warning (ODFs in rotated planes)
         m_Controls->m_lblRotatedPlanesWarning->hide();
 
         m_MyMenu = new QMenu(parent);
         m_Controls->m_TSMenu->setMenu( m_MyMenu );
 
         QIcon iconFiberFade(":/QmitkDiffusionImaging/MapperEfx2D.png");
         m_Controls->m_FiberFading2D->setIcon(iconFiberFade);
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
         int size = m_Controls->m_AdditionalScaling->count();
         for(int t=0; t<size; t++)
         {
             if(m_Controls->m_AdditionalScaling->itemText(t).toStdString() == "Scale by ASR")
             {
                 m_Controls->m_AdditionalScaling->removeItem(t);
             }
         }
 #endif
 
         m_Controls->m_ScalingFrame->setVisible(false);
         m_Controls->m_NormalizationFrame->setVisible(false);
     }
 }
 
 void QmitkControlVisualizationPropertiesView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 
     if (m_MultiWidget)
     {
         mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
         if (coordinator)
         {
             itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
             command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SliceRotation );
             m_SlicesRotationObserverTag1 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
         }
 
         coordinator = m_MultiWidget->GetSlicesSwiveller();
         if (coordinator)
         {
             itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
             command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SliceRotation );
             m_SlicesRotationObserverTag2 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
         }
     }
 }
 
 void QmitkControlVisualizationPropertiesView::SliceRotation(const itk::EventObject&)
 {
     // test if plane rotated
     if( m_GlyIsOn_T || m_GlyIsOn_C || m_GlyIsOn_S )
     {
         if( this->IsPlaneRotated() )
         {
             // show label
             m_Controls->m_lblRotatedPlanesWarning->show();
         }
         else
         {
             //hide label
             m_Controls->m_lblRotatedPlanesWarning->hide();
         }
     }
 }
 
 void QmitkControlVisualizationPropertiesView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 void QmitkControlVisualizationPropertiesView::NodeRemoved(const mitk::DataNode* node)
 {
 }
 
 #include <mitkMessage.h>
 void QmitkControlVisualizationPropertiesView::CreateConnections()
 {
     if ( m_Controls )
     {
         connect( (QObject*)(m_Controls->m_VisibleOdfsON_T), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_T()) );
         connect( (QObject*)(m_Controls->m_VisibleOdfsON_S), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_S()) );
         connect( (QObject*)(m_Controls->m_VisibleOdfsON_C), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_C()) );
         connect( (QObject*)(m_Controls->m_ShowMaxNumber), SIGNAL(editingFinished()), this, SLOT(ShowMaxNumberChanged()) );
         connect( (QObject*)(m_Controls->m_NormalizationDropdown), SIGNAL(currentIndexChanged(int)), this, SLOT(NormalizationDropdownChanged(int)) );
         connect( (QObject*)(m_Controls->m_ScalingFactor), SIGNAL(valueChanged(double)), this, SLOT(ScalingFactorChanged(double)) );
         connect( (QObject*)(m_Controls->m_AdditionalScaling), SIGNAL(currentIndexChanged(int)), this, SLOT(AdditionalScaling(int)) );
         connect( (QObject*)(m_Controls->m_ScalingCheckbox), SIGNAL(clicked()), this, SLOT(ScalingCheckbox()) );
         connect((QObject*) m_Controls->m_ResetColoring, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationResetColoring()));
         connect((QObject*) m_Controls->m_FiberFading2D, SIGNAL(clicked()), (QObject*) this, SLOT( Fiber2DfadingEFX() ) );
         connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(sliderReleased()), (QObject*) this, SLOT( FiberSlicingThickness2D() ) );
         connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(valueChanged(int)), (QObject*) this, SLOT( FiberSlicingUpdateLabel(int) ));
         connect((QObject*) m_Controls->m_Crosshair, SIGNAL(clicked()), (QObject*) this, SLOT(SetInteractor()));
         connect((QObject*) m_Controls->m_LineWidth, SIGNAL(editingFinished()), (QObject*) this, SLOT(LineWidthChanged()));
         connect((QObject*) m_Controls->m_TubeWidth, SIGNAL(editingFinished()), (QObject*) this, SLOT(TubeRadiusChanged()));
     }
 }
 
 void QmitkControlVisualizationPropertiesView::Activated()
 {
 
 }
 
 void QmitkControlVisualizationPropertiesView::Deactivated()
 {
 
 }
 
 // set diffusion image channel to b0 volume
 void QmitkControlVisualizationPropertiesView::NodeAdded(const mitk::DataNode *node)
 {
     mitk::DataNode* notConst = const_cast<mitk::DataNode*>(node);
 
     bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
 
     if (isDiffusionImage)
     {
         mitk::Image::Pointer dimg = dynamic_cast<mitk::Image*>(notConst->GetData());
 
         // if there is no b0 image in the dataset, the GetB0Indices() returns a vector of size 0
         // and hence we cannot set the Property directly to .front()
         int displayChannelPropertyValue = 0;
         mitk::BValueMapProperty* bmapproperty = static_cast<mitk::BValueMapProperty*>(dimg->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() );
         mitk::DiffusionPropertyHelper::BValueMapType map = bmapproperty->GetBValueMap();
         if( map[0].size() > 0)
             displayChannelPropertyValue = map[0].front();
 
         notConst->SetIntProperty("DisplayChannel", displayChannelPropertyValue );
     }
 }
 
 /* OnSelectionChanged is registered to SelectionService, therefore no need to
 implement SelectionService Listener explicitly */
 void QmitkControlVisualizationPropertiesView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     m_Controls->m_BundleControlsFrame->setVisible(false);
     m_Controls->m_ImageControlsFrame->setVisible(false);
 
     if (nodes.size()>1) // only do stuff if one node is selected
         return;
 
     m_Controls->m_NumberGlyphsFrame->setVisible(false);
     m_Controls->m_GlyphFrame->setVisible(false);
     m_Controls->m_TSMenu->setVisible(false);
 
     m_SelectedNode = NULL;
 
     int numOdfImages = 0;
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
         if(node.IsNull())
             continue;
 
         mitk::BaseData* nodeData = node->GetData();
         if(nodeData == NULL)
             continue;
 
         m_SelectedNode = node;
 
-        if (dynamic_cast<mitk::FiberBundleX*>(nodeData))
+        if (dynamic_cast<mitk::FiberBundle*>(nodeData))
         {
             // handle fiber bundle property observers
             if (m_Color.IsNotNull())
                 m_Color->RemoveObserver(m_FiberBundleObserverTag);
             itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
             command->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor );
             m_Color = dynamic_cast<mitk::ColorProperty*>(node->GetProperty("color", NULL));
             if (m_Color.IsNotNull())
                 m_FiberBundleObserverTag = m_Color->AddObserver( itk::ModifiedEvent(), command );
 
             if (m_Opacity.IsNotNull())
                 m_Opacity->RemoveObserver(m_FiberBundleObserveOpacityTag);
             itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
             command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SetFiberBundleOpacity );
             m_Opacity = dynamic_cast<mitk::FloatProperty*>(node->GetProperty("opacity", NULL));
             if (m_Opacity.IsNotNull())
                 m_FiberBundleObserveOpacityTag = m_Opacity->AddObserver( itk::ModifiedEvent(), command2 );
 
             m_Controls->m_BundleControlsFrame->setVisible(true);
 
             // ???
             if(m_CurrentPickingNode != 0 && node.GetPointer() != m_CurrentPickingNode)
                 m_Controls->m_Crosshair->setEnabled(false);
             else
                 m_Controls->m_Crosshair->setEnabled(true);
 
             int width;
             node->GetIntProperty("LineWidth", width);
             m_Controls->m_LineWidth->setValue(width);
 
             float radius;
             node->GetFloatProperty("TubeRadius", radius);
             m_Controls->m_TubeWidth->setValue(radius);
 
             float range;
             node->GetFloatProperty("Fiber2DSliceThickness",range);
-            mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
+            mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
             mitk::BaseGeometry::Pointer geo = fib->GetGeometry();
             mitk::ScalarType max = geo->GetExtentInMM(0);
             max = std::max(max, geo->GetExtentInMM(1));
             max = std::max(max, geo->GetExtentInMM(2));
 
             m_Controls->m_FiberThicknessSlider->setMaximum(max * 10);
             m_Controls->m_FiberThicknessSlider->setValue(range * 10);
             m_Controls->m_FiberThicknessSlider->setFocus();
         }
         else if(dynamic_cast<mitk::QBallImage*>(nodeData) || dynamic_cast<mitk::TensorImage*>(nodeData))
         {
             m_Controls->m_ImageControlsFrame->setVisible(true);
             m_Controls->m_NumberGlyphsFrame->setVisible(true);
             m_Controls->m_GlyphFrame->setVisible(true);
 
             if(m_NodeUsedForOdfVisualization.IsNotNull())
             {
                 m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", false);
                 m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", false);
                 m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", false);
             }
             m_NodeUsedForOdfVisualization = node;
             m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
             m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
             m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
 
             int val;
             node->GetIntProperty("ShowMaxNumber", val);
             m_Controls->m_ShowMaxNumber->setValue(val);
 
             m_Controls->m_NormalizationDropdown->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("Normalization"))->GetValueAsId());
 
             float fval;
             node->GetFloatProperty("Scaling",fval);
             m_Controls->m_ScalingFactor->setValue(fval);
 
             m_Controls->m_AdditionalScaling->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("ScaleBy"))->GetValueAsId());
 
             numOdfImages++;
         }
         else if(dynamic_cast<mitk::PlanarFigure*>(nodeData))
         {
             PlanarFigureFocus();
         }
         else if( dynamic_cast<mitk::Image*>(nodeData) )
         {
             m_Controls->m_ImageControlsFrame->setVisible(true);
             m_Controls->m_TSMenu->setVisible(true);
         }
     }
 
     if( nodes.empty() )
         return;
 
     mitk::DataNode::Pointer node = nodes.at(0);
 
     if( node.IsNull() )
         return;
 
     QMenu *myMenu = m_MyMenu;
     myMenu->clear();
 
     QActionGroup* thickSlicesActionGroup = new QActionGroup(myMenu);
     thickSlicesActionGroup->setExclusive(true);
 
     int currentTSMode = 0;
     {
         mitk::ResliceMethodProperty::Pointer m = dynamic_cast<mitk::ResliceMethodProperty*>(node->GetProperty( "reslice.thickslices" ));
         if( m.IsNotNull() )
             currentTSMode = m->GetValueAsId();
     }
 
     int maxTS = 30;
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::Image* image = dynamic_cast<mitk::Image*>((*it)->GetData());
         if (image)
         {
             int size = std::max(image->GetDimension(0), std::max(image->GetDimension(1), image->GetDimension(2)));
             if (size>maxTS)
                 maxTS=size;
         }
     }
     maxTS /= 2;
 
     int currentNum = 0;
     {
         mitk::IntProperty::Pointer m = dynamic_cast<mitk::IntProperty*>(node->GetProperty( "reslice.thickslices.num" ));
         if( m.IsNotNull() )
         {
             currentNum = m->GetValue();
             if(currentNum < 0) currentNum = 0;
             if(currentNum > maxTS) currentNum = maxTS;
         }
     }
 
     if(currentTSMode==0)
         currentNum=0;
 
     QSlider *m_TSSlider = new QSlider(myMenu);
     m_TSSlider->setMinimum(0);
     m_TSSlider->setMaximum(maxTS-1);
     m_TSSlider->setValue(currentNum);
 
     m_TSSlider->setOrientation(Qt::Horizontal);
 
     connect( m_TSSlider, SIGNAL( valueChanged(int) ), this, SLOT( OnTSNumChanged(int) ) );
 
     QHBoxLayout* _TSLayout = new QHBoxLayout;
     _TSLayout->setContentsMargins(4,4,4,4);
     _TSLayout->addWidget(m_TSSlider);
     _TSLayout->addWidget(m_TSLabel=new QLabel(QString::number(currentNum*2+1),myMenu));
 
     QWidget* _TSWidget = new QWidget;
     _TSWidget->setLayout(_TSLayout);
 
     QActionGroup* thickSliceModeActionGroup = new QActionGroup(myMenu);
     thickSliceModeActionGroup->setExclusive(true);
 
     QWidgetAction *m_TSSliderAction = new QWidgetAction(myMenu);
     m_TSSliderAction->setDefaultWidget(_TSWidget);
     myMenu->addAction(m_TSSliderAction);
 
     QAction* mipThickSlicesAction = new QAction(myMenu);
     mipThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
     mipThickSlicesAction->setText("MIP (max. intensity proj.)");
     mipThickSlicesAction->setCheckable(true);
     mipThickSlicesAction->setChecked(currentThickSlicesMode==1);
     mipThickSlicesAction->setData(1);
     myMenu->addAction( mipThickSlicesAction );
 
     QAction* sumThickSlicesAction = new QAction(myMenu);
     sumThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
     sumThickSlicesAction->setText("SUM (sum intensity proj.)");
     sumThickSlicesAction->setCheckable(true);
     sumThickSlicesAction->setChecked(currentThickSlicesMode==2);
     sumThickSlicesAction->setData(2);
     myMenu->addAction( sumThickSlicesAction );
 
     QAction* weightedThickSlicesAction = new QAction(myMenu);
     weightedThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
     weightedThickSlicesAction->setText("WEIGHTED (gaussian proj.)");
     weightedThickSlicesAction->setCheckable(true);
     weightedThickSlicesAction->setChecked(currentThickSlicesMode==3);
     weightedThickSlicesAction->setData(3);
     myMenu->addAction( weightedThickSlicesAction );
 
     connect( thickSliceModeActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(OnThickSlicesModeSelected(QAction*)) );
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_S()
 {
     m_GlyIsOn_S = m_Controls->m_VisibleOdfsON_S->isChecked();
     if (m_NodeUsedForOdfVisualization.IsNull())
     {
         MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
         return;
     }
     m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_T()
 {
     m_GlyIsOn_T = m_Controls->m_VisibleOdfsON_T->isChecked();
     if (m_NodeUsedForOdfVisualization.IsNull())
     {
         MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
         return;
     }
     m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_C()
 {
     m_GlyIsOn_C = m_Controls->m_VisibleOdfsON_C->isChecked();
     if (m_NodeUsedForOdfVisualization.IsNull())
     {
         MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
         return;
     }
     m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 bool QmitkControlVisualizationPropertiesView::IsPlaneRotated()
 {
     mitk::Image* currentImage = dynamic_cast<mitk::Image* >( m_NodeUsedForOdfVisualization->GetData() );
     if( currentImage == NULL )
     {
         MITK_ERROR << " Casting problems. Returning false";
         return false;
     }
 
     mitk::Vector3D imageNormal0 = currentImage->GetSlicedGeometry()->GetAxisVector(0);
     mitk::Vector3D imageNormal1 = currentImage->GetSlicedGeometry()->GetAxisVector(1);
     mitk::Vector3D imageNormal2 = currentImage->GetSlicedGeometry()->GetAxisVector(2);
     imageNormal0.Normalize();
     imageNormal1.Normalize();
     imageNormal2.Normalize();
 
     double eps = 0.000001;
     // for all 2D renderwindows of m_MultiWidget check alignment
     {
         mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast<const mitk::PlaneGeometry*>( m_MultiWidget->GetRenderWindow1()->GetRenderer()->GetCurrentWorldGeometry2D() );
         if (displayPlane.IsNull()) return false;
         mitk::Vector3D normal       = displayPlane->GetNormal();
         normal.Normalize();
         int test = 0;
         if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal0.GetVnlVector()))-1) > eps )
             test++;
         if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal1.GetVnlVector()))-1) > eps )
             test++;
         if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal2.GetVnlVector()))-1) > eps )
             test++;
         if (test==3)
             return true;
     }
     {
         mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast<const mitk::PlaneGeometry*>( m_MultiWidget->GetRenderWindow2()->GetRenderer()->GetCurrentWorldGeometry2D() );
         if (displayPlane.IsNull()) return false;
         mitk::Vector3D normal       = displayPlane->GetNormal();
         normal.Normalize();
         int test = 0;
         if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal0.GetVnlVector()))-1) > eps )
             test++;
         if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal1.GetVnlVector()))-1) > eps )
             test++;
         if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal2.GetVnlVector()))-1) > eps )
             test++;
         if (test==3)
             return true;
     }
     {
         mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast<const mitk::PlaneGeometry*>( m_MultiWidget->GetRenderWindow3()->GetRenderer()->GetCurrentWorldGeometry2D() );
         if (displayPlane.IsNull()) return false;
         mitk::Vector3D normal       = displayPlane->GetNormal();
         normal.Normalize();
         int test = 0;
         if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal0.GetVnlVector()))-1) > eps )
             test++;
         if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal1.GetVnlVector()))-1) > eps )
             test++;
         if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal2.GetVnlVector()))-1) > eps )
             test++;
         if (test==3)
             return true;
     }
 
     return false;
 }
 
 void QmitkControlVisualizationPropertiesView::ShowMaxNumberChanged()
 {
     int maxNr = m_Controls->m_ShowMaxNumber->value();
     if ( maxNr < 1 )
     {
         m_Controls->m_ShowMaxNumber->setValue( 1 );
         maxNr = 1;
     }
 
     if (dynamic_cast<mitk::QBallImage*>(m_SelectedNode->GetData()) || dynamic_cast<mitk::TensorImage*>(m_SelectedNode->GetData()))
         m_SelectedNode->SetIntProperty("ShowMaxNumber", maxNr);
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::NormalizationDropdownChanged(int normDropdown)
 {
     typedef mitk::OdfNormalizationMethodProperty PropType;
     PropType::Pointer normMeth = PropType::New();
 
     switch(normDropdown)
     {
     case 0:
         normMeth->SetNormalizationToMinMax();
         break;
     case 1:
         normMeth->SetNormalizationToMax();
         break;
     case 2:
         normMeth->SetNormalizationToNone();
         break;
     case 3:
         normMeth->SetNormalizationToGlobalMax();
         break;
     default:
         normMeth->SetNormalizationToMinMax();
     }
 
     if (dynamic_cast<mitk::QBallImage*>(m_SelectedNode->GetData()) || dynamic_cast<mitk::TensorImage*>(m_SelectedNode->GetData()))
         m_SelectedNode->SetProperty("Normalization", normMeth.GetPointer());
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::ScalingFactorChanged(double scalingFactor)
 {
     if (dynamic_cast<mitk::QBallImage*>(m_SelectedNode->GetData()) || dynamic_cast<mitk::TensorImage*>(m_SelectedNode->GetData()))
         m_SelectedNode->SetFloatProperty("Scaling", scalingFactor);
 
     if(m_MultiWidget)
         m_MultiWidget->RequestUpdate();
 }
 
 void QmitkControlVisualizationPropertiesView::AdditionalScaling(int additionalScaling)
 {
 
     typedef mitk::OdfScaleByProperty PropType;
     PropType::Pointer scaleBy = PropType::New();
 
     switch(additionalScaling)
     {
     case 0:
         scaleBy->SetScaleByNothing();
         break;
     case 1:
         scaleBy->SetScaleByGFA();
         //m_Controls->params_frame->setVisible(true);
         break;
 #ifdef DIFFUSION_IMAGING_EXTENDED
     case 2:
         scaleBy->SetScaleByPrincipalCurvature();
         // commented in for SPIE paper, Principle curvature scaling
         //m_Controls->params_frame->setVisible(true);
         break;
 #endif
     default:
         scaleBy->SetScaleByNothing();
     }
 
     if (dynamic_cast<mitk::QBallImage*>(m_SelectedNode->GetData()) || dynamic_cast<mitk::TensorImage*>(m_SelectedNode->GetData()))
         m_SelectedNode->SetProperty("Normalization", scaleBy.GetPointer());
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::ScalingCheckbox()
 {
     m_Controls->m_ScalingFrame->setVisible(
                 m_Controls->m_ScalingCheckbox->isChecked());
 
     if(!m_Controls->m_ScalingCheckbox->isChecked())
     {
         m_Controls->m_AdditionalScaling->setCurrentIndex(0);
         m_Controls->m_ScalingFactor->setValue(1.0);
     }
 }
 
 void QmitkControlVisualizationPropertiesView::Fiber2DfadingEFX()
 {
-    if (m_SelectedNode && dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData()) )
+    if (m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()) )
     {
         bool currentMode;
         m_SelectedNode->GetBoolProperty("Fiber2DfadeEFX", currentMode);
         m_SelectedNode->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(!currentMode));
-        dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData())->RequestUpdate2D();
+        dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData())->RequestUpdate2D();
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
 
 void QmitkControlVisualizationPropertiesView::FiberSlicingThickness2D()
 {
-    if (m_SelectedNode && dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData()))
+    if (m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
     {
         float fibThickness = m_Controls->m_FiberThicknessSlider->value() * 0.1;
         float currentThickness = 0;
         m_SelectedNode->GetFloatProperty("Fiber2DSliceThickness", currentThickness);
         if (fabs(fibThickness-currentThickness)<0.001)
             return;
         m_SelectedNode->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(fibThickness));
-        dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData())->RequestUpdate2D();
+        dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData())->RequestUpdate2D();
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
 
 void QmitkControlVisualizationPropertiesView::FiberSlicingUpdateLabel(int value)
 {
     QString label = "Range %1 mm";
     label = label.arg(value * 0.1);
     m_Controls->label_range->setText(label);
     FiberSlicingThickness2D();
 }
 
 void QmitkControlVisualizationPropertiesView::SetFiberBundleOpacity(const itk::EventObject& /*e*/)
 {
     if(m_SelectedNode)
     {
-        mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
+        mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData());
         fib->RequestUpdate();
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
 
 void QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor(const itk::EventObject& /*e*/)
 {
-    if(m_SelectedNode && dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData()))
+    if(m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
     {
         float color[3];
         m_SelectedNode->GetColor(color);
-        mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
+        mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData());
         fib->SetFiberColors(color[0]*255, color[1]*255, color[2]*255);
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
 
 void QmitkControlVisualizationPropertiesView::BundleRepresentationResetColoring()
 {
-    if(m_SelectedNode && dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData()))
+    if(m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
     {
-        mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
+        mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData());
         fib->DoColorCodingOrientationBased();
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
 
 void QmitkControlVisualizationPropertiesView::PlanarFigureFocus()
 {
     if(m_SelectedNode)
     {
         mitk::PlanarFigure* _PlanarFigure = 0;
         _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (m_SelectedNode->GetData());
 
         if (_PlanarFigure && _PlanarFigure->GetPlaneGeometry())
         {
 
             QmitkRenderWindow* selectedRenderWindow = 0;
             bool PlanarFigureInitializedWindow = false;
 
             QmitkRenderWindow* RenderWindow1 =
                     this->GetActiveStdMultiWidget()->GetRenderWindow1();
 
             if (m_SelectedNode->GetBoolProperty("PlanarFigureInitializedWindow",
                                                 PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
             {
                 selectedRenderWindow = RenderWindow1;
             }
 
             QmitkRenderWindow* RenderWindow2 =
                     this->GetActiveStdMultiWidget()->GetRenderWindow2();
 
             if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
                         "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
                         RenderWindow2->GetRenderer()))
             {
                 selectedRenderWindow = RenderWindow2;
             }
 
             QmitkRenderWindow* RenderWindow3 =
                     this->GetActiveStdMultiWidget()->GetRenderWindow3();
 
             if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
                         "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
                         RenderWindow3->GetRenderer()))
             {
                 selectedRenderWindow = RenderWindow3;
             }
 
             QmitkRenderWindow* RenderWindow4 =
                     this->GetActiveStdMultiWidget()->GetRenderWindow4();
 
             if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
                         "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
                         RenderWindow4->GetRenderer()))
             {
                 selectedRenderWindow = RenderWindow4;
             }
 
             const mitk::PlaneGeometry* _PlaneGeometry = _PlanarFigure->GetPlaneGeometry();
 
             mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl();
 
             mitk::Geometry2D::ConstPointer worldGeometry1 =
                     RenderWindow1->GetRenderer()->GetCurrentWorldGeometry2D();
             mitk::PlaneGeometry::ConstPointer _Plane1 =
                     dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry1.GetPointer() );
             mitk::VnlVector normal1 = _Plane1->GetNormalVnl();
 
             mitk::Geometry2D::ConstPointer worldGeometry2 =
                     RenderWindow2->GetRenderer()->GetCurrentWorldGeometry2D();
             mitk::PlaneGeometry::ConstPointer _Plane2 =
                     dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry2.GetPointer() );
             mitk::VnlVector normal2 = _Plane2->GetNormalVnl();
 
             mitk::Geometry2D::ConstPointer worldGeometry3 =
                     RenderWindow3->GetRenderer()->GetCurrentWorldGeometry2D();
             mitk::PlaneGeometry::ConstPointer _Plane3 =
                     dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry3.GetPointer() );
             mitk::VnlVector normal3 = _Plane3->GetNormalVnl();
 
             normal[0]  = fabs(normal[0]);  normal[1]  = fabs(normal[1]);  normal[2]  = fabs(normal[2]);
             normal1[0] = fabs(normal1[0]); normal1[1] = fabs(normal1[1]); normal1[2] = fabs(normal1[2]);
             normal2[0] = fabs(normal2[0]); normal2[1] = fabs(normal2[1]); normal2[2] = fabs(normal2[2]);
             normal3[0] = fabs(normal3[0]); normal3[1] = fabs(normal3[1]); normal3[2] = fabs(normal3[2]);
 
             double ang1 = angle(normal, normal1);
             double ang2 = angle(normal, normal2);
             double ang3 = angle(normal, normal3);
 
             if(ang1 < ang2 && ang1 < ang3)
             {
                 selectedRenderWindow = RenderWindow1;
             }
             else
             {
                 if(ang2 < ang3)
                 {
                     selectedRenderWindow = RenderWindow2;
                 }
                 else
                 {
                     selectedRenderWindow = RenderWindow3;
                 }
             }
 
             // make node visible
             if (selectedRenderWindow)
             {
                 const mitk::Point3D& centerP = _PlaneGeometry->GetOrigin();
                 selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
                             centerP, _PlaneGeometry->GetNormal());
             }
         }
 
         // set interactor for new node (if not already set)
         mitk::PlanarFigureInteractor::Pointer figureInteractor
                 = dynamic_cast<mitk::PlanarFigureInteractor*>(m_SelectedNode->GetDataInteractor().GetPointer());
 
         if(figureInteractor.IsNull())
         {
             figureInteractor = mitk::PlanarFigureInteractor::New();
             us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
             figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
             figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
             figureInteractor->SetDataNode( m_SelectedNode );
         }
 
         m_SelectedNode->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
     }
 }
 
 void QmitkControlVisualizationPropertiesView::SetInteractor()
 {
     typedef std::vector<mitk::DataNode*> Container;
     Container _NodeSet = this->GetDataManagerSelection();
     mitk::DataNode* node = 0;
-    mitk::FiberBundleX* bundle = 0;
+    mitk::FiberBundle* bundle = 0;
     mitk::FiberBundleInteractor::Pointer bundleInteractor = 0;
 
     // finally add all nodes to the model
     for(Container::const_iterator it=_NodeSet.begin(); it!=_NodeSet.end()
         ; it++)
     {
         node = const_cast<mitk::DataNode*>(*it);
-        bundle = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
+        bundle = dynamic_cast<mitk::FiberBundle*>(node->GetData());
 
         if(bundle)
         {
             bundleInteractor = dynamic_cast<mitk::FiberBundleInteractor*>(node->GetInteractor());
 
             if(bundleInteractor.IsNotNull())
                 mitk::GlobalInteraction::GetInstance()->RemoveInteractor(bundleInteractor);
 
             if(!m_Controls->m_Crosshair->isChecked())
             {
                 m_Controls->m_Crosshair->setChecked(false);
                 this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::ArrowCursor);
                 m_CurrentPickingNode = 0;
             }
             else
             {
                 m_Controls->m_Crosshair->setChecked(true);
                 bundleInteractor = mitk::FiberBundleInteractor::New("FiberBundleInteractor", node);
                 mitk::GlobalInteraction::GetInstance()->AddInteractor(bundleInteractor);
                 this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::CrossCursor);
                 m_CurrentPickingNode = node;
             }
 
         }
     }
 }
 
 void QmitkControlVisualizationPropertiesView::TubeRadiusChanged()
 {
-    if(m_SelectedNode && dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData()))
+    if(m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
     {
         float newRadius = m_Controls->m_TubeWidth->value();
         m_SelectedNode->SetFloatProperty("TubeRadius", newRadius);
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
 
 void QmitkControlVisualizationPropertiesView::LineWidthChanged()
 {
-    if(m_SelectedNode && dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData()))
+    if(m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
     {
         int newWidth = m_Controls->m_LineWidth->value();
         int currentWidth = 0;
         m_SelectedNode->GetIntProperty("LineWidth", currentWidth);
         if (currentWidth==newWidth)
             return;
         m_SelectedNode->SetIntProperty("LineWidth", newWidth);
-        dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData())->RequestUpdate();
+        dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData())->RequestUpdate();
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
 
 void QmitkControlVisualizationPropertiesView::Welcome()
 {
     berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
                 GetSite()->GetWorkbenchWindow(), false);
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp
index ff342de343..339079fe8e 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp
@@ -1,499 +1,499 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Qmitk
 #include "QmitkDwiSoftwarePhantomView.h"
 
 // MITK
 #include <mitkImage.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkITKImageImport.h>
 #include <mitkImageToItk.h>
 #include <mitkImageCast.h>
 #include <itkDwiPhantomGenerationFilter.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 const std::string QmitkDwiSoftwarePhantomView::VIEW_ID = "org.mitk.views.dwisoftwarephantomview";
 
 QmitkDwiSoftwarePhantomView::QmitkDwiSoftwarePhantomView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
 {
 
 }
 
 // Destructor
 QmitkDwiSoftwarePhantomView::~QmitkDwiSoftwarePhantomView()
 {
 
 }
 
 
 void QmitkDwiSoftwarePhantomView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkDwiSoftwarePhantomViewControls;
         m_Controls->setupUi( parent );
         m_Controls->m_SignalRegionBox->setVisible(false);
 
         connect((QObject*) m_Controls->m_GeneratePhantomButton, SIGNAL(clicked()), (QObject*) this, SLOT(GeneratePhantom()));
         connect((QObject*) m_Controls->m_SimulateBaseline, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnSimulateBaselineToggle(int)));
     }
 }
 
 QmitkDwiSoftwarePhantomView::GradientListType QmitkDwiSoftwarePhantomView::GenerateHalfShell(int NPoints)
 {
     NPoints *= 2;
     vnl_vector<double> theta; theta.set_size(NPoints);
 
     vnl_vector<double> phi; phi.set_size(NPoints);
 
     double C = sqrt(4*M_PI);
 
     phi(0) = 0.0;
     phi(NPoints-1) = 0.0;
 
     for(int i=0; i<NPoints; i++)
     {
         theta(i) = acos(-1.0+2.0*i/(NPoints-1.0)) - M_PI / 2.0;
         if( i>0 && i<NPoints-1)
         {
             phi(i) = (phi(i-1) + C /
                       sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
             // % (2*DIST_POINTSHELL_PI);
         }
     }
 
     GradientListType pointshell;
 
     int numB0 = NPoints/10;
     if (numB0==0)
         numB0=1;
     GradientType g;
     g.Fill(0.0);
     for (int i=0; i<numB0; i++)
         pointshell.push_back(g);
 
     for(int i=0; i<NPoints; i++)
     {
         g[2] = sin(theta(i));
         if (g[2]<0)
             continue;
         g[0] = cos(theta(i)) * cos(phi(i));
         g[1] = cos(theta(i)) * sin(phi(i));
         pointshell.push_back(g);
     }
 
     return pointshell;
 }
 
 template<int ndirs>
 std::vector<itk::Vector<double,3> > QmitkDwiSoftwarePhantomView::MakeGradientList()
 {
     std::vector<itk::Vector<double,3> > retval;
     vnl_matrix_fixed<double, 3, ndirs>* U =
             itk::PointShell<ndirs, vnl_matrix_fixed<double, 3, ndirs> >::DistributePointShell();
 
 
     // Add 0 vector for B0
     int numB0 = ndirs/10;
     if (numB0==0)
         numB0=1;
     itk::Vector<double,3> v;
     v.Fill(0.0);
     for (int i=0; i<numB0; i++)
     {
         retval.push_back(v);
     }
 
     for(int i=0; i<ndirs;i++)
     {
         itk::Vector<double,3> v;
         v[0] = U->get(0,i); v[1] = U->get(1,i); v[2] = U->get(2,i);
         retval.push_back(v);
     }
 
     return retval;
 }
 
 void QmitkDwiSoftwarePhantomView::OnSimulateBaselineToggle(int state)
 {
     if (state)
     {
         m_Controls->m_NoiseLabel->setText("Noise Variance:");
         m_Controls->m_NoiseLevel->setValue(1.0/(m_Controls->m_NoiseLevel->value()*m_Controls->m_NoiseLevel->value()));
         m_Controls->m_NoiseLevel->setToolTip("Variance of Rician noise.");
     }
     else
     {
         m_Controls->m_NoiseLabel->setText("SNR:");
         if (m_Controls->m_NoiseLevel->value()>0)
             m_Controls->m_NoiseLevel->setValue(1.0/(sqrt(m_Controls->m_NoiseLevel->value())));
         else
             m_Controls->m_NoiseLevel->setValue(0.0001);
         m_Controls->m_NoiseLevel->setToolTip("Signal to noise ratio (for values > 99, no noise at all is added to the image).");
     }
 }
 
 void QmitkDwiSoftwarePhantomView::GeneratePhantom()
 {
     typedef itk::DwiPhantomGenerationFilter< short > FilterType;
     FilterType::GradientListType gradientList;
 
     m_SignalRegions.clear();
     for (int i=0; i<m_SignalRegionNodes.size(); i++)
     {
         mitk::Image::Pointer mitkBinaryImg = dynamic_cast<mitk::Image*>(m_SignalRegionNodes.at(i)->GetData());
         ItkUcharImgType::Pointer signalRegion = ItkUcharImgType::New();
         mitk::CastToItkImage(mitkBinaryImg, signalRegion);
         m_SignalRegions.push_back(signalRegion);
     }
 
     gradientList = GenerateHalfShell(m_Controls->m_NumGradientsBox->value());
 
     //    switch(m_Controls->m_NumGradientsBox->value())
     //    {
     //    case 0:
     //        gradientList = MakeGradientList<12>();
     //        break;
     //    case 1:
     //        gradientList = MakeGradientList<42>();
     //        break;
     //    case 2:
     //        gradientList = MakeGradientList<92>();
     //        break;
     //    case 3:
     //        gradientList = MakeGradientList<162>();
     //        break;
     //    case 4:
     //        gradientList = MakeGradientList<252>();
     //        break;
     //    case 5:
     //        gradientList = MakeGradientList<362>();
     //        break;
     //    case 6:
     //        gradientList = MakeGradientList<492>();
     //        break;
     //    case 7:
     //        gradientList = MakeGradientList<642>();
     //        break;
     //    case 8:
     //        gradientList = MakeGradientList<812>();
     //        break;
     //    case 9:
     //        gradientList = MakeGradientList<1002>();
     //        break;
     //    default:
     //        gradientList = MakeGradientList<92>();
     //    }
 
     double bVal = m_Controls->m_TensorsToDWIBValueEdit->value();
     itk::ImageRegion<3> imageRegion;
     imageRegion.SetSize(0, m_Controls->m_SizeX->value());
     imageRegion.SetSize(1, m_Controls->m_SizeY->value());
     imageRegion.SetSize(2, m_Controls->m_SizeZ->value());
     mitk::Vector3D spacing;
     spacing[0] = m_Controls->m_SpacingX->value();
     spacing[1] = m_Controls->m_SpacingY->value();
     spacing[2] = m_Controls->m_SpacingZ->value();
 
     FilterType::Pointer filter = FilterType::New();
     filter->SetGradientList(gradientList);
     filter->SetBValue(bVal);
     filter->SetNoiseVariance(m_Controls->m_NoiseLevel->value());
     filter->SetImageRegion(imageRegion);
     filter->SetSpacing(spacing);
     filter->SetSignalRegions(m_SignalRegions);
     filter->SetGreyMatterAdc(m_Controls->m_GmAdc->value());
 
     std::vector< float >                            tensorFA;
     std::vector< float >                            tensorADC;
     std::vector< float >                            tensorWeight;
     std::vector< vnl_vector_fixed<double, 3> >      tensorDirection;
     for (int i=0; i<m_SpinFa.size(); i++)
     {
         tensorFA.push_back(m_SpinFa.at(i)->value());
         tensorADC.push_back(m_SpinAdc.at(i)->value());
         vnl_vector_fixed<double, 3> dir;
         dir[0] = m_SpinX.at(i)->value();
         dir[1] = m_SpinY.at(i)->value();
         dir[2] = m_SpinZ.at(i)->value();
         dir.normalize();
         tensorDirection.push_back(dir);
         tensorWeight.push_back(m_SpinWeight.at(i)->value());
     }
     filter->SetTensorFA(tensorFA);
     filter->SetTensorADC(tensorADC);
     filter->SetTensorWeight(tensorWeight);
     filter->SetTensorDirection(tensorDirection);
     if (!m_Controls->m_SimulateBaseline->isChecked())
         filter->SetSimulateBaseline(false);
     else
         filter->SetSimulateBaseline(true);
     filter->Update();
 
     mitk::Image::Pointer image = mitk::GrabItkImageMemory(filter->GetOutput());
     image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( gradientList ) );
     image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( bVal ) );
     mitk::DiffusionPropertyHelper propertyHelper( image );
     propertyHelper.InitializeImage();
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( image );
     node->SetName(m_Controls->m_ImageName->text().toStdString());
     GetDataStorage()->Add(node);
 
     mitk::BaseData::Pointer basedata = node->GetData();
     if (basedata.IsNotNull())
     {
         mitk::RenderingManager::GetInstance()->InitializeViews(
                     basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     if (m_Controls->m_OutputNumDirectionsBox->isChecked())
     {
         ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
         mitk::Image::Pointer image = mitk::Image::New();
         image->InitializeByItk( numDirImage.GetPointer() );
         image->SetVolume( numDirImage->GetBufferPointer() );
         mitk::DataNode::Pointer node2 = mitk::DataNode::New();
         node2->SetData(image);
         QString name(m_Controls->m_ImageName->text());
         name += "_NumDirections";
         node2->SetName(name.toStdString().c_str());
         GetDataStorage()->Add(node2);
     }
 
     if (m_Controls->m_OutputSnrImageBox->isChecked())
     {
         ItkFloatImgType::Pointer snrImage = filter->GetSNRImage();
         mitk::Image::Pointer image = mitk::Image::New();
         image->InitializeByItk( snrImage.GetPointer() );
         image->SetVolume( snrImage->GetBufferPointer() );
         mitk::DataNode::Pointer node2 = mitk::DataNode::New();
         node2->SetData(image);
         QString name(m_Controls->m_ImageName->text());
         name += "_SNR";
         node2->SetName(name.toStdString().c_str());
         GetDataStorage()->Add(node2);
     }
 
     if (m_SignalRegionNodes.size()==0)
         return;
 
     if (m_Controls->m_OutputDirectionImagesBox->isChecked())
     {
         typedef FilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
         ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
         for (int i=0; i<container->Size(); i++)
         {
             FilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
             mitk::Image::Pointer img = mitk::Image::New();
             img->InitializeByItk( itkImg.GetPointer() );
             img->SetVolume( itkImg->GetBufferPointer() );
             mitk::DataNode::Pointer node = mitk::DataNode::New();
             node->SetData(img);
             QString name(m_Controls->m_ImageName->text());
             name += "_Direction";
             name += QString::number(i+1);
             node->SetName(name.toStdString().c_str());
             GetDataStorage()->Add(node);
         }
     }
 
     if (m_Controls->m_OutputVectorFieldBox->isChecked())
     {
         mitk::BaseGeometry::Pointer geometry = image->GetGeometry();
         mitk::Vector3D outImageSpacing = geometry->GetSpacing();
         float minSpacing = 1;
         if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
             minSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] < outImageSpacing[2])
             minSpacing = outImageSpacing[1];
         else
             minSpacing = outImageSpacing[2];
 
-        mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
+        mitk::FiberBundle::Pointer directions = filter->GetOutputFiberBundle();
         directions->SetGeometry(geometry);
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData(directions);
         QString name(m_Controls->m_ImageName->text());
         name += "_VectorField";
         node->SetName(name.toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
     }
 }
 
 void QmitkDwiSoftwarePhantomView::UpdateGui()
 {
     if (!m_SignalRegionNodes.empty())
     {
         m_Controls->m_SignalRegionBox->setVisible(true);
         m_Controls->m_Instruction->setVisible(false);
     }
     else
     {
         m_Controls->m_SignalRegionBox->setVisible(false);
         m_Controls->m_Instruction->setVisible(true);
     }
 
     QLayout* layout = m_Controls->m_SignalRegionBox->layout();
 
     for (int i=0; i<m_Labels.size(); i++)
     {
         delete m_Labels.at(i);
     }
     for (int i=0; i<m_SpinFa.size(); i++)
     {
         delete m_SpinFa.at(i);
         delete m_SpinAdc.at(i);
         delete m_SpinX.at(i);
         delete m_SpinY.at(i);
         delete m_SpinZ.at(i);
         delete m_SpinWeight.at(i);
     }
     m_Labels.clear();
     m_SpinFa.clear();
     m_SpinAdc.clear();
     m_SpinX.clear();
     m_SpinY.clear();
     m_SpinZ.clear();
     m_SpinWeight.clear();
 
     if (layout)
         delete layout;
 
     QGridLayout* newlayout = new QGridLayout();
 
     m_Controls->m_SignalRegionBox->setLayout(newlayout);
 
     if (!m_SignalRegionNodes.empty())
     {
         QLabel* label1 = new QLabel("Image");
         newlayout->addWidget(label1,0,0);
         m_Labels.push_back(label1);
         QLabel* label2 = new QLabel("FA");
         newlayout->addWidget(label2,0,1);
         m_Labels.push_back(label2);
         QLabel* label3 = new QLabel("ADC");
         newlayout->addWidget(label3,0,2);
         m_Labels.push_back(label3);
         QLabel* label4 = new QLabel("X");
         newlayout->addWidget(label4,0,03);
         m_Labels.push_back(label4);
         QLabel* label5 = new QLabel("Y");
         newlayout->addWidget(label5,0,4);
         m_Labels.push_back(label5);
         QLabel* label6 = new QLabel("Z");
         newlayout->addWidget(label6,0,5);
         m_Labels.push_back(label6);
         QLabel* label7 = new QLabel("Weight");
         newlayout->addWidget(label7,0,6);
         m_Labels.push_back(label7);
     }
     for (int i=0; i<m_SignalRegionNodes.size(); i++)
     {
         QLabel* label = new QLabel(m_SignalRegionNodes.at(i)->GetName().c_str());
         newlayout->addWidget(label,i+1,0);
         m_Labels.push_back(label);
 
         QDoubleSpinBox* spinFa = new QDoubleSpinBox();
         spinFa->setValue(0.7);
         spinFa->setMinimum(0);
         spinFa->setMaximum(1);
         spinFa->setSingleStep(0.1);
         newlayout->addWidget(spinFa,i+1,1);
         m_SpinFa.push_back(spinFa);
 
         QDoubleSpinBox* spinAdc = new QDoubleSpinBox();
         newlayout->addWidget(spinAdc,i+1,2);
         spinAdc->setMinimum(0);
         spinAdc->setMaximum(1);
         spinAdc->setSingleStep(0.001);
         spinAdc->setDecimals(3);
         spinAdc->setValue(0.001); ///// ???????????????????????????
         m_SpinAdc.push_back(spinAdc);
 
         QDoubleSpinBox* spinX = new QDoubleSpinBox();
         newlayout->addWidget(spinX,i+1,3);
         spinX->setValue(1);
         spinX->setMinimum(-1);
         spinX->setMaximum(1);
         spinX->setSingleStep(0.1);
         m_SpinX.push_back(spinX);
 
         QDoubleSpinBox* spinY = new QDoubleSpinBox();
         newlayout->addWidget(spinY,i+1,4);
         spinY->setMinimum(-1);
         spinY->setMaximum(1);
         spinY->setSingleStep(0.1);
         m_SpinY.push_back(spinY);
 
         QDoubleSpinBox* spinZ = new QDoubleSpinBox();
         newlayout->addWidget(spinZ,i+1,5);
         spinZ->setMinimum(-1);
         spinZ->setMaximum(1);
         spinZ->setSingleStep(0.1);
         m_SpinZ.push_back(spinZ);
 
         QDoubleSpinBox* spinWeight = new QDoubleSpinBox();
         newlayout->addWidget(spinWeight,i+1,6);
         spinWeight->setMinimum(0);
         spinWeight->setMaximum(1);
         spinWeight->setSingleStep(0.1);
         spinWeight->setValue(1.0);
         m_SpinWeight.push_back(spinWeight);
     }
 }
 
 void QmitkDwiSoftwarePhantomView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkDwiSoftwarePhantomView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 void QmitkDwiSoftwarePhantomView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     m_SignalRegionNodes.clear();
 
     // iterate all selected objects, adjust warning visibility
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             bool isBinary = false;
             node->GetPropertyValue<bool>("binary", isBinary);
             if (isBinary)
                 m_SignalRegionNodes.push_back(node);
         }
     }
     UpdateGui();
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
index 021b60383f..3f78250193 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
@@ -1,1816 +1,1816 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 //=========FOR TESTING==========
 //random generation, number of points equal requested points
 
 
 
 // Blueberry application and interaction service
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberBundleDeveloperView.h"
 #include <QmitkStdMultiWidget.h>
 
 // Qt
 #include <QTimer>
 
 // MITK
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkGlobalInteraction.h>
 
 //===needed when timeGeometry is null to invoke rendering mechansims ====
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 
 #include "mitkModuleRegistry.h"
 
 
 // VTK
 #include <vtkPointSource.h> //for randomized FiberStructure
 #include <vtkPolyLine.h>  //for fiberStructure
 #include <vtkCellArray.h> //for fiberStructure
 #include <vtkMatrix4x4.h> //for geometry
 
 //ITK
 #include <itkTimeProbe.h>
 
 //==============================================
 //======== W O R K E R S ____ S T A R T ========
 //==============================================
 /*===================================================================================
  * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
  * --generate FiberIDs--*/
 
 QmitkFiberIDWorker::QmitkFiberIDWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
     : m_itemPackage(itemPackage),
       m_hostingThread(hostingThread)
 {
 
 }
 void QmitkFiberIDWorker::run()
 {
     if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
         m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS
    * accurate time measurement using ITK timeProbe*/
     itk::TimeProbe clock;
     clock.Start();
     //set GUI representation of timer to 0, is essential for correct timer incrementation
     m_itemPackage.st_Controls->infoTimerGenerateFiberIds->setText(QString::number(0));
     m_itemPackage.st_FancyGUITimer1->start();
 
     //do processing
     m_itemPackage.st_FBX->GenerateFiberIds();
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
     clock.Stop();
     m_itemPackage.st_FancyGUITimer1->stop();
     m_itemPackage.st_Controls->infoTimerGenerateFiberIds->setText( QString::number(clock.GetTotal()) );
     delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
     m_hostingThread->quit();
 
 }
 
 /*===================================================================================
  * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
  * -- extract fibers by given PlanarFigure --*/
 QmitkFiberExtractorWorker::QmitkFiberExtractorWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
     : m_itemPackage(itemPackage),
       m_hostingThread(hostingThread)
 {
 
 }
 void QmitkFiberExtractorWorker::run()
 {
     if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
         m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS
    * accurate time measurement using ITK timeProbe*/
     itk::TimeProbe clock;
     clock.Start();
     //set GUI representation of timer to 0, is essential for correct timer incrementation
     m_itemPackage.st_Controls->infoTimerExtractFibers->setText(QString::number(0));
     m_itemPackage.st_FancyGUITimer1->start();
 
     //do processing
     std::vector<long> fibIds = m_itemPackage.st_FBX->ExtractFiberIdSubset(m_itemPackage.st_PlanarFigure);
 
     //generate new fiberbundle by fiber iDs
     vtkSmartPointer<vtkPolyData> newFBPolyData = m_itemPackage.st_FBX->GeneratePolyDataByIds(fibIds);
 
-    // call function to convert fiberstructure into fiberbundleX and pass it to datastorage
+    // call function to convert fiberstructure into FiberBundle and pass it to datastorage
     (m_itemPackage.st_host->*m_itemPackage.st_pntr_to_Method_PutFibersToDataStorage)(newFBPolyData);
 
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
     clock.Stop();
     m_itemPackage.st_FancyGUITimer1->stop();
     m_itemPackage.st_Controls->infoTimerExtractFibers->setText( QString::number(clock.GetTotal()) );
     delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
     m_hostingThread->quit();
 
 }
 
 /*===================================================================================
  * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
  * --set FA values to fiberbundle--*/
 QmitkFiberColoringWorker::QmitkFiberColoringWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
     : m_itemPackage(itemPackage)
     , m_hostingThread(hostingThread)
 {
 
 }
 void QmitkFiberColoringWorker::run()
 {
     if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
         m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS
    * accurate time measurement using ITK timeProbe*/
     itk::TimeProbe clock;
     clock.Start();
 
     //set GUI representation of timer to 0, is essential for correct timer incrementation
     m_itemPackage.st_Controls->infoTimerColorCoding->setText(QString::number(0));
     m_itemPackage.st_FancyGUITimer1->start();
 
     //do processing
     if(m_itemPackage.st_Controls->radioButton_ColorOrient->isChecked()) {
         m_itemPackage.st_FBX->DoColorCodingOrientationBased();
 
     } else if(m_itemPackage.st_Controls->radioButton_ColorFA->isChecked()) {
         m_itemPackage.st_FBX->DoColorCodingFaBased();
 
     } else if(m_itemPackage.st_Controls->radioButton_OpacityFA->isChecked()) {
         //        m_itemPackage.st_FBX->SetColorCoding("");
         m_itemPackage.st_PassedDataNode->SetOpacity(0.999);
         m_itemPackage.st_FBX->DoUseFaFiberOpacity();
     } else if(m_itemPackage.st_Controls->radioButton_ColorCustom->isChecked()){
-        m_itemPackage.st_FBX->SetColorCoding(mitk::FiberBundleX::COLORCODING_CUSTOM);
+        m_itemPackage.st_FBX->SetColorCoding(mitk::FiberBundle::COLORCODING_CUSTOM);
     }
 
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
     clock.Stop();
     m_itemPackage.st_FancyGUITimer1->stop();
     m_itemPackage.st_Controls->infoTimerColorCoding->setText( QString::number(clock.GetTotal()) );
     delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
     m_hostingThread->quit();
 
 }
 
 
 QmitkFiberFeederFAWorker::QmitkFiberFeederFAWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
     : m_itemPackage(itemPackage),
       m_hostingThread(hostingThread)
 {
 
 }
 void QmitkFiberFeederFAWorker::run()
 {
     if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
         m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS
      * accurate time measurement using ITK timeProbe */
     itk::TimeProbe clock;
     clock.Start();
     //set GUI representation of timer to 0, is essential for correct timer incrementation
     m_itemPackage.st_Controls->infoTimerSetFA->setText(QString::number(0));
     m_itemPackage.st_FancyGUITimer1->start();
 
     //do processing
     mitk::Image::Pointer FAImg = dynamic_cast<mitk::Image*>(m_itemPackage.st_PassedDataNode->GetData());
     if(FAImg.IsNotNull())
         m_itemPackage.st_FBX->SetFAMap(FAImg);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
     clock.Stop();
     m_itemPackage.st_FancyGUITimer1->stop();
     m_itemPackage.st_Controls->infoTimerSetFA->setText( QString::number(clock.GetTotal()) );
 
     disconnect(m_itemPackage.st_FancyGUITimer1);
     delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
     m_hostingThread->quit();
 
 }
 
 
 /*===================================================================================
  * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
  * --generate random fibers--*/
 QmitkFiberGenerateRandomWorker::QmitkFiberGenerateRandomWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
     : m_itemPackage(itemPackage),
       m_hostingThread(hostingThread)
 {
 
 }
 void QmitkFiberGenerateRandomWorker::run()
 {
     if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
         m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS */
     //MAKE SURE by yourself THAT NOTHING ELSE THAN A NUMBER IS SET IN THAT LABEL
     m_itemPackage.st_Controls->infoTimerGenerateFiberBundle->setText(QString::number(0));
     m_itemPackage.st_FancyGUITimer1->start();
 
     //do processing, generateRandomFibers
     int numOfFibers = m_itemPackage.st_Controls->boxFiberNumbers->value();
     int distrRadius = m_itemPackage.st_Controls->boxDistributionRadius->value();
     int numOfPoints = numOfFibers * distrRadius;
 
     std::vector< std::vector<int> > fiberStorage;
     for (int i=0; i<numOfFibers; ++i) {
         std::vector<int> a;
         fiberStorage.push_back( a );
     }
 
     /* Generate Point Cloud */
     vtkSmartPointer<vtkPointSource> randomPoints = vtkSmartPointer<vtkPointSource>::New();
     randomPoints->SetCenter(0.0, 0.0, 0.0);
     randomPoints->SetNumberOfPoints(numOfPoints);
     randomPoints->SetRadius(distrRadius);
     randomPoints->Update();
     vtkPoints* pnts = randomPoints->GetOutput()->GetPoints();
 
     /* ASSIGN EACH POINT TO A RANDOM FIBER */
     srand((unsigned)time(0)); // init randomizer
     for (int i=0; i<pnts->GetNumberOfPoints(); ++i) {
 
         //generate random number between 0 and numOfFibers-1
         int random_integer;
         random_integer = (rand()%numOfFibers);
 
         //add current point to random fiber
         fiberStorage.at(random_integer).push_back(i);
         //    MITK_INFO << "point" << i << " |" << pnts->GetPoint(random_integer)[0] << "|" << pnts->GetPoint(random_integer)[1]<< "|" << pnts->GetPoint(random_integer)[2] << "| into fiber" << random_integer;
     }
 
     // initialize accurate time measurement
     itk::TimeProbe clock;
     clock.Start();
 
     /* GENERATE VTK POLYLINES OUT OF FIBERSTORAGE */
     vtkSmartPointer<vtkCellArray> linesCell = vtkSmartPointer<vtkCellArray>::New(); // Host vtkPolyLines
     linesCell->Allocate(pnts->GetNumberOfPoints()*2); //allocate for each cellindex also space for the pointId, e.g. [idx | pntID]
     for (long i=0; i<fiberStorage.size(); ++i)
     {
         std::vector<int> singleFiber = fiberStorage.at(i);
         vtkSmartPointer<vtkPolyLine> fiber = vtkSmartPointer<vtkPolyLine>::New();
         fiber->GetPointIds()->SetNumberOfIds((int)singleFiber.size());
 
         for (long si=0; si<singleFiber.size(); ++si)
         {  //hopefully long to double works fine in VTK ;-)
             fiber->GetPointIds()->SetId( si, singleFiber.at(si) );
         }
 
         linesCell->InsertNextCell(fiber);
     }
 
     /* checkpoint for cellarray allocation */
     if ( (linesCell->GetSize()/pnts->GetNumberOfPoints()) != 2 ) //e.g. size: 12, number of points:6 .... each cell hosts point ids (6 ids) + cell index for each idPoint. 6 * 2 = 12
     {
         MITK_INFO << "RANDOM FIBER ALLOCATION CAN NOT BE TRUSTED ANYMORE! Correct leak or remove command: linesCell->Allocate(pnts->GetNumberOfPoints()*2) but be aware of possible loss in performance.";
     }
 
     /* HOSTING POLYDATA FOR RANDOM FIBERSTRUCTURE */
     vtkSmartPointer<vtkPolyData> PDRandom = vtkSmartPointer<vtkPolyData>::New(); //could also be a standard pointer instead of smartpointer cuz ther is no need to delete because data is managed in datastorage.
     PDRandom->SetPoints(pnts);
     PDRandom->SetLines(linesCell);
 
     // accurate timer measurement stop
     clock.Stop();
     //MITK_INFO << "=====Assambling random Fibers to Polydata======\nMean: " << clock.GetMean() << " Total: " << clock.GetTotal() << std::endl;
 
-    // call function to convert fiberstructure into fiberbundleX and pass it to datastorage
+    // call function to convert fiberstructure into FiberBundle and pass it to datastorage
     (m_itemPackage.st_host->*m_itemPackage.st_pntr_to_Method_PutFibersToDataStorage)(PDRandom);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
     m_itemPackage.st_FancyGUITimer1->stop();
     m_itemPackage.st_Controls->infoTimerGenerateFiberBundle->setText( QString::number(clock.GetTotal()) );
     delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
     m_hostingThread->quit();
 
 }
 
 
 /*===================================================================================
  * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
  * --update GUI elements of thread monitor--
  * implementation not thread safe, not needed so far because
  * there exists only 1 thread for fiberprocessing
  * for threadsafety, you need to implement checking mechanisms in methods "::threadFor...." */
 QmitkFiberThreadMonitorWorker::QmitkFiberThreadMonitorWorker( QThread* hostingThread, Package4WorkingThread itemPackage )
     : m_itemPackage(itemPackage)
     , m_hostingThread(hostingThread)
     , m_pixelstepper(10) //for next rendering call, move object 10px
     , m_steppingDistance(220) //use only a multiple value of pixelstepper, x-axis border for fancy stuff
 {
 
 
     //set timers
     m_thtimer_initMonitor = new QTimer;
     m_thtimer_initMonitor->setInterval(10);
 
     m_thtimer_initMonitorSetFinalPosition = new QTimer;
     m_thtimer_initMonitorSetFinalPosition->setInterval(10);
 
     m_thtimer_initMonitorSetMasks = new QTimer;
     m_thtimer_initMonitorSetFinalPosition->setInterval(10);
 
 
     m_thtimer_threadStarted  = new QTimer;
     m_thtimer_threadStarted->setInterval(50);
 
     m_thtimer_threadFinished = new QTimer;
     m_thtimer_threadFinished->setInterval(50);
 
     m_thtimer_threadTerminated = new QTimer;
     m_thtimer_threadTerminated->setInterval(50);
 
 
 
     connect (m_thtimer_initMonitor, SIGNAL( timeout()), this, SLOT( fancyMonitorInitialization() ) );
     connect ( m_thtimer_initMonitorSetFinalPosition, SIGNAL( timeout() ), this, SLOT( fancyMonitorInitializationFinalPos() ) );
     connect ( m_thtimer_initMonitorSetMasks, SIGNAL( timeout() ), this, SLOT( fancyMonitorInitializationMask() ) );
 
     connect (m_thtimer_threadStarted, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadStarted() ) );
     connect (m_thtimer_threadFinished, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadFinished() ) );
     connect (m_thtimer_threadTerminated, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadTerminated() ) );
 
     //first, the current text shall turn transparent
     m_decreaseOpacity_threadStarted = true;
     m_decreaseOpacity_threadFinished = true;
     m_decreaseOpacity_threadTerminated = true;
 
 
 
 
 }
 void QmitkFiberThreadMonitorWorker::run()
 {
 
 }
 
 void QmitkFiberThreadMonitorWorker::initializeMonitor()
 {
     //fancy configuration of animation start
     mitk::Point2D pntOpen;
     pntOpen[0] = 118;
     pntOpen[1] = 10;
 
     mitk::Point2D headPos;
     headPos[0] = 19;
     headPos[1] = 10;
 
     mitk::Point2D statusPos;
     statusPos[0] = 105;
     statusPos[1] = 23;
 
     mitk::Point2D startedPos;
     startedPos[0] = 68;
     startedPos[1] = 10;
 
     mitk::Point2D finishedPos;
     finishedPos[0] = 143;
     finishedPos[1] = 10;
 
     mitk::Point2D terminatedPos;
     terminatedPos[0] = 240;
     terminatedPos[1] = 10;
 
     m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntOpen);
     m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen);
     m_itemPackage.st_FBX_Monitor->setHeadingPosition(headPos);
     m_itemPackage.st_FBX_Monitor->setMaskPosition(headPos);
     m_itemPackage.st_FBX_Monitor->setStatusPosition(statusPos);
     m_itemPackage.st_FBX_Monitor->setStartedPosition(startedPos);
     m_itemPackage.st_FBX_Monitor->setFinishedPosition(finishedPos);
     m_itemPackage.st_FBX_Monitor->setTerminatedPosition(terminatedPos);
 
 
     m_thtimer_initMonitor->start();
 }
 
 void QmitkFiberThreadMonitorWorker::setThreadStatus(QString status)
 {
     m_itemPackage.st_FBX_Monitor->setStatus(status);
     m_itemPackage.st_ThreadMonitorDataNode->Modified();
     m_itemPackage.st_MultiWidget->RequestUpdate();
 }
 
 /* Methods to set status of running threads
  * Following three methods are usually called
  - before a thread starts and
  - a thread is finished or terminated */
 void QmitkFiberThreadMonitorWorker::threadForFiberProcessingStarted()
 {
     if(!m_thtimer_threadStarted->isActive())  {
         m_thtimer_threadStarted->start();
     } else {
         //fast change without fancy stuff, needed to keep threaddebugger info up to date
         int counter = m_itemPackage.st_FBX_Monitor->getStarted();
         m_itemPackage.st_FBX_Monitor->setStarted(++counter);
 
     }
 
 
 }
 
 void QmitkFiberThreadMonitorWorker::threadForFiberProcessingFinished()
 {
     if(!m_thtimer_threadFinished->isActive())  {
         m_thtimer_threadFinished->start();
     } else {
         //fast change without fancy stuff
         int counter = m_itemPackage.st_FBX_Monitor->getFinished();
         m_itemPackage.st_FBX_Monitor->setFinished(++counter);
 
     }
 
 }
 
 void QmitkFiberThreadMonitorWorker::threadForFiberProcessingTerminated()
 {
     if(!m_thtimer_threadTerminated->isActive())  {
         m_thtimer_threadTerminated->start();
     } else {
         //fast change without fancy stuff
         int counter = m_itemPackage.st_FBX_Monitor->getTerminated();
         m_itemPackage.st_FBX_Monitor->setTerminated(++counter);
 
     }
 
 }
 
 
 /* Helper methods for fancy fading efx for thread monitor */
 void QmitkFiberThreadMonitorWorker::fancyTextFading_threadStarted()
 {
 
     if (m_decreaseOpacity_threadStarted) {
         int startedOpacity = m_itemPackage.st_FBX_Monitor->getStartedOpacity();
         m_itemPackage.st_FBX_Monitor->setStartedOpacity( --startedOpacity );
 
         if (startedOpacity == 0) {
             int counter = m_itemPackage.st_FBX_Monitor->getStarted();
             m_itemPackage.st_FBX_Monitor->setStarted(++counter);
             m_decreaseOpacity_threadStarted = false;
         }
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     } else {
 
         int startedOpacity = m_itemPackage.st_FBX_Monitor->getStartedOpacity();
         m_itemPackage.st_FBX_Monitor->setStartedOpacity( ++startedOpacity );
 
         if (startedOpacity >= 10) {
             m_thtimer_threadStarted->stop();
             m_decreaseOpacity_threadStarted = true; //set back to true, cuz next iteration shall decrease opacity as well
         }
 
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     }
 
 
 }
 
 void QmitkFiberThreadMonitorWorker::fancyTextFading_threadFinished()
 {
     if (m_decreaseOpacity_threadFinished) {
         int finishedOpacity = m_itemPackage.st_FBX_Monitor->getFinishedOpacity();
         m_itemPackage.st_FBX_Monitor->setFinishedOpacity( --finishedOpacity );
 
         if (finishedOpacity == 0) {
             int counter = m_itemPackage.st_FBX_Monitor->getFinished();
             m_itemPackage.st_FBX_Monitor->setFinished(++counter);
             m_decreaseOpacity_threadFinished = false;
         }
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     } else {
 
         int finishedOpacity = m_itemPackage.st_FBX_Monitor->getFinishedOpacity();
         m_itemPackage.st_FBX_Monitor->setFinishedOpacity( ++finishedOpacity );
 
         if (finishedOpacity >= 10) {
             m_thtimer_threadFinished->stop();
             m_decreaseOpacity_threadFinished = true; //set back to true, cuz next iteration shall decrease opacity as well
         }
 
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     }
 
 }
 
 void QmitkFiberThreadMonitorWorker::fancyTextFading_threadTerminated()
 {
     if (m_decreaseOpacity_threadTerminated) {
         int terminatedOpacity = m_itemPackage.st_FBX_Monitor->getTerminatedOpacity();
         m_itemPackage.st_FBX_Monitor->setTerminatedOpacity( --terminatedOpacity );
 
         if (terminatedOpacity == 0) {
             int counter = m_itemPackage.st_FBX_Monitor->getTerminated();
             m_itemPackage.st_FBX_Monitor->setTerminated(++counter);
             m_decreaseOpacity_threadTerminated = false;
         }
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     } else {
 
         int terminatedOpacity = m_itemPackage.st_FBX_Monitor->getTerminatedOpacity();
         m_itemPackage.st_FBX_Monitor->setTerminatedOpacity( ++terminatedOpacity );
 
         if (terminatedOpacity >= 10) {
             m_thtimer_threadTerminated->stop();
             m_decreaseOpacity_threadTerminated = true; //set back to true, cuz next iteration shall decrease opacity as well
         }
 
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     }
 
 
 
 }
 
 void QmitkFiberThreadMonitorWorker::fancyMonitorInitialization()
 {
 
     mitk::Point2D pntClose = m_itemPackage.st_FBX_Monitor->getBracketClosePosition(); //possible bottleneck, set pntClose to member
     mitk::Point2D pntOpen = m_itemPackage.st_FBX_Monitor->getBracketOpenPosition(); //possible bottleneck, set pntClose to member
 
     pntClose[0] += m_pixelstepper;
     pntOpen[0] -= m_pixelstepper;
     //MITK_INFO << pntClose[0] << " " << pntOpen[0];
 
     m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntClose);
     m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen);
 
     int opacity = m_itemPackage.st_FBX_Monitor->getHeadingOpacity() + 1;
     if (opacity > 10)
         opacity = 10;
     m_itemPackage.st_FBX_Monitor->setHeadingOpacity(opacity);
 
 
     if (pntClose[0] >= m_steppingDistance)
     {
         if (m_itemPackage.st_FBX_Monitor->getHeadingOpacity() != 10 )
         {
             m_itemPackage.st_FBX_Monitor->setHeadingOpacity(10);
             m_itemPackage.st_ThreadMonitorDataNode->Modified();
             m_itemPackage.st_MultiWidget->RequestUpdate();
         }
 
         m_thtimer_initMonitor->stop();
 
         //position them to obt y=25
         m_thtimer_initMonitorSetFinalPosition->start();
     }
 
     m_itemPackage.st_ThreadMonitorDataNode->Modified();
     m_itemPackage.st_MultiWidget->RequestUpdate();
 
 
 }
 
 void QmitkFiberThreadMonitorWorker::fancyMonitorInitializationFinalPos()
 {
     //get y pos of
     mitk::Point2D pntClose = m_itemPackage.st_FBX_Monitor->getBracketClosePosition();
     mitk::Point2D pntOpen = m_itemPackage.st_FBX_Monitor->getBracketOpenPosition();
     mitk::Point2D pntHead = m_itemPackage.st_FBX_Monitor->getHeadingPosition();
 
     pntClose[1] += 5;
     pntOpen[1] += 5;
     pntHead[1] += 5;
 
     m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntClose);
     m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen);
     m_itemPackage.st_FBX_Monitor->setHeadingPosition(pntHead);
 
 
     if (pntClose[1] >= 35) { //35 = y position
         m_thtimer_initMonitorSetFinalPosition->stop();
         //now init mask of labels
         m_thtimer_initMonitorSetMasks->start();
     }
 
     m_itemPackage.st_ThreadMonitorDataNode->Modified();
     m_itemPackage.st_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkFiberThreadMonitorWorker::fancyMonitorInitializationMask()
 {
     //increase opacity
     int opacity = m_itemPackage.st_FBX_Monitor->getMaskOpacity();
     opacity++;
     m_itemPackage.st_FBX_Monitor->setMaskOpacity(opacity);
     m_itemPackage.st_FBX_Monitor->setStartedOpacity(opacity);
     m_itemPackage.st_FBX_Monitor->setFinishedOpacity(opacity);
     m_itemPackage.st_FBX_Monitor->setTerminatedOpacity(opacity);
     m_itemPackage.st_FBX_Monitor->setStatusOpacity(opacity);
 
     if (opacity >=10) {
         m_thtimer_initMonitorSetMasks->stop();
     }
 
     m_itemPackage.st_ThreadMonitorDataNode->Modified();
     m_itemPackage.st_MultiWidget->RequestUpdate();
 
 }
 
 //==============================================
 //======== W O R K E R S ________ E N D ========
 //==============================================
 
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //                   HERE STARTS THE ACTUAL FIBERBUNDLE DEVELOPER VIEW IMPLEMENTATION
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 
 
 
 const std::string QmitkFiberBundleDeveloperView::VIEW_ID = "org.mitk.views.fiberbundledeveloper";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace berry;
 
 
 QmitkFiberBundleDeveloperView::QmitkFiberBundleDeveloperView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
     , m_FiberIDGenerator( NULL)
     , m_GeneratorFibersRandom( NULL )
     , m_FiberFeederFASlave( NULL )
     , m_FiberColoringSlave(NULL)
     , m_FiberExtractor(NULL)
     , m_fiberMonitorIsOn( false )
     , m_CircleCounter( 0 )
     , m_suppressSignal(false)
 {
     m_hostThread = new QThread;
     m_threadInProgress = false;
 
 }
 
 // Destructor
 QmitkFiberBundleDeveloperView::~QmitkFiberBundleDeveloperView()
 {
-    //m_FiberBundleX->Delete(); using weakPointer, therefore no delete necessary
+    //m_FiberBundle->Delete(); using weakPointer, therefore no delete necessary
     delete m_hostThread;
 }
 
 
 void QmitkFiberBundleDeveloperView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done in QtDesigner, etc.
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFiberBundleDeveloperViewControls;
         m_Controls->setupUi( parent );
 
         /*=========INITIALIZE BUTTON CONFIGURATION ================*/
         m_Controls->radioButton_directionX->setEnabled(false);
         m_Controls->radioButton_directionY->setEnabled(false);
         m_Controls->radioButton_directionZ->setEnabled(false);
         m_Controls->buttonGenerateFiberIds->setEnabled(false);
         m_Controls->buttonGenerateFibers->setEnabled(true);
         m_Controls->buttonColorFibers->setEnabled(false);
         m_Controls->ddAvailableColorcodings->setEnabled(false);
         m_Controls->buttonExtractFibers->setEnabled(false);
         m_Controls->button_FAMap->setEnabled(true);
 
         m_Controls->buttonSMFibers->setEnabled(false);//not yet implemented
         m_Controls->buttonVtkDecimatePro->setEnabled(false);//not yet implemented
         m_Controls->buttonVtkSmoothPD->setEnabled(false);//not yet implemented
         m_Controls->buttonGenerateTubes->setEnabled(false);//not yet implemented
 
 
         connect( m_Controls->buttonGenerateFibers, SIGNAL(clicked()), this, SLOT(DoGenerateFibers()) );
         connect( m_Controls->buttonGenerateFiberIds, SIGNAL(clicked()), this, SLOT(DoGenerateFiberIDs()) );
         connect( m_Controls->button_FAMapExecute, SIGNAL(clicked()), this, SLOT(DoSetFAValues()) );
         connect( m_Controls->button_FAMap, SIGNAL(clicked()), this, SLOT(DoSetFAMap()) );
         connect( m_Controls->buttonExtractFibers, SIGNAL(clicked()), this, SLOT(DoExtractFibers()) );
         connect( m_Controls->radioButton_directionRandom, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
         connect( m_Controls->radioButton_directionX, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
         connect( m_Controls->radioButton_directionY, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
         connect( m_Controls->radioButton_directionZ, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
         connect( m_Controls->toolBox, SIGNAL(currentChanged ( int ) ), this, SLOT(SelectionChangedToolBox(int)) );
 
 
         connect( m_Controls->m_CircleButton, SIGNAL( clicked() ), this, SLOT( ActionDrawEllipseTriggered() ) );
         connect( m_Controls->buttonColorFibers, SIGNAL(clicked()), this, SLOT(DoColorFibers()) );
         //        connect( m_Controls->ddAvailableColorcodings, SIGNAL(currentIndexChanged(int)), this, SLOT(SetCurrentColorCoding(int) ));
         connect( m_Controls->ddAvailableColorcodings, SIGNAL(currentIndexChanged(int)), this, SLOT(SetCurrentColorCoding(int) ));
 
         connect( m_Controls->checkBoxMonitorFiberThreads, SIGNAL(stateChanged(int)), this, SLOT(DoMonitorFiberThreads(int)) );
 
 
 
     }
 
     //  Checkpoint for fiber ORIENTATION
     if ( m_DirectionRadios.empty() )
     {
         m_DirectionRadios.insert(0, m_Controls->radioButton_directionRandom);
         m_DirectionRadios.insert(1, m_Controls->radioButton_directionX);
         m_DirectionRadios.insert(2, m_Controls->radioButton_directionY);
         m_DirectionRadios.insert(3, m_Controls->radioButton_directionZ);
     }
 
     // set GUI elements of FiberGenerator to according configuration
     DoUpdateGenerateFibersWidget();
 
 
 }
 /* THIS METHOD UPDATES ALL GUI ELEMENTS OF QGroupBox DEPENDING ON CURRENTLY SELECTED
  * RADIO BUTTONS
  */
 void QmitkFiberBundleDeveloperView::DoUpdateGenerateFibersWidget()
 {
     //get selected radioButton
     QString fibDirection; //stores the object_name of selected radiobutton
     QVector<QRadioButton*>::const_iterator i;
     for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i)
     {
         QRadioButton* rdbtn = *i;
         if (rdbtn->isChecked())
             fibDirection = rdbtn->objectName();
     }
 
     if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) {
         // disable radiobuttons
         if (m_Controls->boxFiberMinLength->isEnabled())
             m_Controls->boxFiberMinLength->setEnabled(false);
 
         if (m_Controls->labelFiberMinLength->isEnabled())
             m_Controls->labelFiberMinLength->setEnabled(false);
 
         if (m_Controls->boxFiberMaxLength->isEnabled())
             m_Controls->boxFiberMaxLength->setEnabled(false);
 
         if (m_Controls->labelFiberMaxLength->isEnabled())
             m_Controls->labelFiberMaxLength->setEnabled(false);
 
         //enable radiobuttons
         if (!m_Controls->labelFibersTotal->isEnabled())
             m_Controls->labelFibersTotal->setEnabled(true);
 
         if (!m_Controls->boxFiberNumbers->isEnabled())
             m_Controls->boxFiberNumbers->setEnabled(true);
 
         if (!m_Controls->labelDistrRadius->isEnabled())
             m_Controls->labelDistrRadius->setEnabled(true);
 
         if (!m_Controls->boxDistributionRadius->isEnabled())
             m_Controls->boxDistributionRadius->setEnabled(true);
 
 
     } else {
         // disable radiobuttons
         if (m_Controls->labelDistrRadius->isEnabled())
             m_Controls->labelDistrRadius->setEnabled(false);
 
         if (m_Controls->boxDistributionRadius->isEnabled())
             m_Controls->boxDistributionRadius->setEnabled(false);
 
 
         //enable radiobuttons
         if (!m_Controls->labelFibersTotal->isEnabled())
             m_Controls->labelFibersTotal->setEnabled(true);
 
         if (!m_Controls->boxFiberNumbers->isEnabled())
             m_Controls->boxFiberNumbers->setEnabled(true);
 
         if (!m_Controls->boxFiberMinLength->isEnabled())
             m_Controls->boxFiberMinLength->setEnabled(true);
 
         if (!m_Controls->labelFiberMinLength->isEnabled())
             m_Controls->labelFiberMinLength->setEnabled(true);
 
         if (!m_Controls->boxFiberMaxLength->isEnabled())
             m_Controls->boxFiberMaxLength->setEnabled(true);
 
         if (!m_Controls->labelFiberMaxLength->isEnabled())
             m_Controls->labelFiberMaxLength->setEnabled(true);
 
     }
 
 }
 
 void QmitkFiberBundleDeveloperView::DoGenerateFibers()
 {
 
     // GET SELECTED FIBER DIRECTION
     QString fibDirection; //stores the object_name of selected radiobutton
     QVector<QRadioButton*>::const_iterator i;
     for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i)
     {
         QRadioButton* rdbtn = *i;
         if (rdbtn->isChecked())
             fibDirection = rdbtn->objectName();
     }
 
     //  vtkPolyData* output; // FiberPD stores the generated PolyData... going to be generated in thread
     if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) {
         //    build polydata with random lines and fibers
         //    output =
         GenerateVtkFibersRandom();
 
     } else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_X ) {
         //    build polydata with XDirection fibers
         //output = GenerateVtkFibersDirectionX();
 
     } else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_Y ) {
         //    build polydata with YDirection fibers
         // output = GenerateVtkFibersDirectionY();
 
     } else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_Z ) {
         //    build polydata with ZDirection fibers
         //  output = GenerateVtkFibersDirectionZ();
 
     }
 
 
 }
 
 void QmitkFiberBundleDeveloperView::DoExtractFibers()
 {
 
     /* ===== TIMER CONFIGURATIONS for visual effect ======
    * start and stop is called in Thread */
     QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
     localTimer->setInterval( 10 );
     connect( localTimer, SIGNAL(timeout()), this, SLOT( UpdateExtractFibersTimer()) );
 
     struct Package4WorkingThread ItemPackageForExtractor;
-    ItemPackageForExtractor.st_FBX = m_FiberBundleX;
+    ItemPackageForExtractor.st_FBX = m_FiberBundle;
     ItemPackageForExtractor.st_Controls = m_Controls;
     ItemPackageForExtractor.st_FancyGUITimer1 = localTimer;
     ItemPackageForExtractor.st_host = this; //needed to access method "PutFibersToDataStorage()"
     ItemPackageForExtractor.st_pntr_to_Method_PutFibersToDataStorage = &QmitkFiberBundleDeveloperView::PutFibersToDataStorage; //actual functor calling method putFibersToDataStorage
     ItemPackageForExtractor.st_PlanarFigure = m_PlanarFigure;
 
     //set element for thread monitoring
     if (m_fiberMonitorIsOn)
         ItemPackageForExtractor.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
 
 
     if (m_threadInProgress)
         return; //maybe popup window saying, working thread still in progress...pls wait
 
     m_FiberExtractor = new QmitkFiberExtractorWorker(m_hostThread, ItemPackageForExtractor);
     m_FiberExtractor->moveToThread(m_hostThread);
 
     //connections
     connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_FiberExtraction() ));
     connect(m_hostThread, SIGNAL(started()), m_FiberExtractor, SLOT( run() ));
     connect(m_hostThread, SIGNAL(finished()), this, SLOT( AfterThread_FiberExtraction() ));
     connect(m_hostThread, SIGNAL(terminated()), this, SLOT( AfterThread_FiberExtraction() ));
 
     m_hostThread->start(QThread::HighestPriority) ;
 }
 
 void QmitkFiberBundleDeveloperView::UpdateExtractFibersTimer()
 {
     // Make sure that thread has set according info-label to number! here we do not check if value is numeric! shall be done in beforeThreadstarted()
     QString crntValue = m_Controls->infoTimerExtractFibers->text();
     int tmpVal = crntValue.toInt();
     m_Controls->infoTimerExtractFibers->setText(QString::number(++tmpVal));
     m_Controls->infoTimerExtractFibers->update();
 }
 
 void QmitkFiberBundleDeveloperView::BeforeThread_FiberExtraction()
 {
     m_threadInProgress = true;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
         //m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_STARTED);
     }
 }
 
 void QmitkFiberBundleDeveloperView::AfterThread_FiberExtraction()
 {
     m_threadInProgress = false;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
     }
     //    disconnect(m_hostThread, 0, 0, 0);
     m_hostThread->disconnect();
 
     //    m_FiberExtractor->disconnect();
     delete m_FiberExtractor;
 
     m_FiberBundleNode->Modified();
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkFiberBundleDeveloperView::PutFibersToDataStorage( vtkSmartPointer<vtkPolyData> threadOutput)
 {
 
     MITK_INFO << "lines: " << threadOutput->GetNumberOfLines() << "pnts: " << threadOutput->GetNumberOfPoints();
     //qthread mutex lock
-    mitk::FiberBundleX::Pointer FB = mitk::FiberBundleX::New(threadOutput);
+    mitk::FiberBundle::Pointer FB = mitk::FiberBundle::New(threadOutput);
     mitk::DataNode::Pointer FBNode;
     FBNode = mitk::DataNode::New();
-    FBNode->SetName("FiberBundleX");
+    FBNode->SetName("FiberBundle");
     FBNode->SetData(FB);
     FBNode->SetVisibility(true);
     FBNode->SetOpacity(1.0);
 
     GetDataStorage()->Add(FBNode);
     FBNode->Modified();
 
     const mitk::PlaneGeometry * tsgeo = m_MultiWidget->GetTimeNavigationController()->GetCurrentPlaneGeometry();
     if (tsgeo == NULL) {
         /* GetDataStorage()->Modified etc. have no effect, therefore proceed as followed below */
         // get all nodes that have not set "includeInBoundingBox" to false
         mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
                                                                                                             , mitk::BoolProperty::New(false)));
         mitk::DataStorage::SetOfObjects::ConstPointer rs = GetDataStorage()->GetSubset(pred);
         // calculate bounding geometry of these nodes
         mitk::TimeGeometry::Pointer bounds = GetDataStorage()->ComputeBoundingGeometry3D(rs);
         // initialize the views to the bounding geometry
         mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
 
     } else {
 
         GetDataStorage()->Modified();
         m_MultiWidget->RequestUpdate(); //necessary??
     }
 
     //qthread mutex unlock
 }
 
 void QmitkFiberBundleDeveloperView::PutFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name)
 {
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     newNode->SetName(name.toStdString());
     newNode->SetData(figure);
 
 
 
     std::vector<mitk::DataNode*> selectedNodes = GetDataManagerSelection();
     for(unsigned int i = 0; i < selectedNodes.size(); i++)
     {
         selectedNodes[i]->SetSelected(false);
     }
 
     newNode->SetSelected(true);
 
     newNode->AddProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(1.0,0.0,0.0));
     newNode->AddProperty( "planarfigure.line.width", mitk::FloatProperty::New(2.0));
     newNode->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true));
 
     newNode->AddProperty( "selected", mitk::BoolProperty::New(true) );
     newNode->AddProperty( "planarfigure.ishovering", mitk::BoolProperty::New(true) );
     newNode->AddProperty( "planarfigure.drawoutline", mitk::BoolProperty::New(true) );
     newNode->AddProperty( "planarfigure.drawquantities", mitk::BoolProperty::New(false) );
     newNode->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true) );
 
     newNode->AddProperty( "planarfigure.line.width", mitk::FloatProperty::New(3.0) );
     newNode->AddProperty( "planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.outline.width", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.helperline.width", mitk::FloatProperty::New(2.0) );
 
     newNode->AddProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
     newNode->AddProperty( "planarfigure.default.line.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.default.outline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.default.helperline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(0.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.default.markerline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(1.0,1.0,1.0)  );
     newNode->AddProperty( "planarfigure.default.marker.opacity",mitk::FloatProperty::New(2.0) );
 
     newNode->AddProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.line.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.outline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.helperline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.hover.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.markerline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.hover.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.marker.opacity", mitk::FloatProperty::New(2.0) );
 
     newNode->AddProperty( "planarfigure.selected.line.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.line.opacity",mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.outline.opacity", mitk::FloatProperty::New(2.0));
     newNode->AddProperty( "planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.helperline.opacity",mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.markerline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.marker.opacity",mitk::FloatProperty::New(2.0));
 
     // figure drawn on the topmost layer / image
     this->GetDataStorage()->Add(newNode);
 }
 
 /*
  * Generate polydata of random fibers
  */
 void QmitkFiberBundleDeveloperView::GenerateVtkFibersRandom()
 {
 
     /* ===== TIMER CONFIGURATIONS for visual effect ======
    * start and stop is called in Thread */
     QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
     localTimer->setInterval( 10 );
     connect( localTimer, SIGNAL(timeout()), this, SLOT(UpdateGenerateRandomFibersTimer()) );
 
     struct Package4WorkingThread ItemPackageForRandomGenerator;
-    ItemPackageForRandomGenerator.st_FBX = m_FiberBundleX;
+    ItemPackageForRandomGenerator.st_FBX = m_FiberBundle;
     ItemPackageForRandomGenerator.st_Controls = m_Controls;
     ItemPackageForRandomGenerator.st_FancyGUITimer1 = localTimer;
     ItemPackageForRandomGenerator.st_host = this; //needed to access method "PutFibersToDataStorage()"
     ItemPackageForRandomGenerator.st_pntr_to_Method_PutFibersToDataStorage = &QmitkFiberBundleDeveloperView::PutFibersToDataStorage; //actual functor calling method putFibersToDataStorage
 
     //set element for thread monitoring
     if (m_fiberMonitorIsOn)
         ItemPackageForRandomGenerator.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
 
 
     if (m_threadInProgress)
         return; //maybe popup window saying, working thread still in progress...pls wait
 
     m_GeneratorFibersRandom = new QmitkFiberGenerateRandomWorker(m_hostThread, ItemPackageForRandomGenerator);
     m_GeneratorFibersRandom->moveToThread(m_hostThread);
 
     connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_GenerateFibersRandom()) );
     connect(m_hostThread, SIGNAL(started()), m_GeneratorFibersRandom, SLOT(run()) );
     connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_GenerateFibersRandom()) );
     connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_GenerateFibersRandom()) );
 
     m_hostThread->start(QThread::LowestPriority);
 
 }
 
 void QmitkFiberBundleDeveloperView::UpdateColorFibersTimer()
 {
     // Make sure that thread has set according info-label to number! here we do not check if value is numeric!
     QString crntValue = m_Controls->infoTimerColorCoding->text();
     int tmpVal = crntValue.toInt();
     m_Controls->infoTimerColorCoding->setText(QString::number(++tmpVal));
     m_Controls->infoTimerColorCoding->update();
 }
 
 void QmitkFiberBundleDeveloperView::UpdateGenerateRandomFibersTimer()
 {
     // Make sure that thread has set according info-label to number! here we do not check if value is numeric!
     QString crntValue = m_Controls->infoTimerGenerateFiberBundle->text();
     int tmpVal = crntValue.toInt();
     m_Controls->infoTimerGenerateFiberBundle->setText(QString::number(++tmpVal));
     m_Controls->infoTimerGenerateFiberBundle->update();
 
 }
 
 void QmitkFiberBundleDeveloperView::UpdateSetFAValuesTimer()
 {
     // Make sure that thread has set according info-label to number! here we do not check if value is numeric!
     QString crntValue = m_Controls->infoTimerSetFA->text();
     int tmpVal = crntValue.toInt();
     m_Controls->infoTimerSetFA->setText(QString::number(++tmpVal));
     m_Controls->infoTimerSetFA->update();
 
 }
 
 void QmitkFiberBundleDeveloperView::BeforeThread_GenerateFibersRandom()
 {
     m_threadInProgress = true;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
         //m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_STARTED);
     }
 }
 
 void QmitkFiberBundleDeveloperView::AfterThread_GenerateFibersRandom()
 {
     m_threadInProgress = false;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
     }
     //    disconnect(m_hostThread, 0, 0, 0);
     m_hostThread->disconnect();
     delete m_GeneratorFibersRandom;
 
 
 }
 
 vtkSmartPointer<vtkPolyData> QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionX()
 {
     int numOfFibers = m_Controls->boxFiberNumbers->value();
     vtkSmartPointer<vtkCellArray> linesCell = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
 
     //insert Origin point, this point has index 0 in point array
     double originX = 0.0;
     double originY = 0.0;
     double originZ = 0.0;
 
     //after each iteration the origin of the new fiber increases
     //here you set which direction is affected.
     double increaseX = 0.0;
     double increaseY = 1.0;
     double increaseZ = 0.0;
 
 
     //walk along X axis
     //length of fibers increases in each iteration
     for (int i=0; i<numOfFibers; ++i) {
 
         vtkSmartPointer<vtkPolyLine> newFiber = vtkSmartPointer<vtkPolyLine>::New();
         newFiber->GetPointIds()->SetNumberOfIds(i+2);
 
         //create starting point and add it to pointset
         points->InsertNextPoint(originX + (double)i * increaseX , originY + (double)i * increaseY, originZ + (double)i * increaseZ);
 
         //add starting point to fiber
         newFiber->GetPointIds()->SetId(0,points->GetNumberOfPoints()-1);
 
         //insert remaining points for fiber
         for (int pj=0; pj<=i ; ++pj)
         { //generate next point on X axis
             points->InsertNextPoint( originX + (double)pj+1 , originY + (double)i * increaseY, originZ + (double)i * increaseZ );
             newFiber->GetPointIds()->SetId(pj+1,points->GetNumberOfPoints()-1);
         }
 
         linesCell->InsertNextCell(newFiber);
     }
 
     vtkSmartPointer<vtkPolyData> PDX = vtkSmartPointer<vtkPolyData>::New();
     PDX->SetPoints(points);
     PDX->SetLines(linesCell);
     return PDX;
 }
 
 vtkSmartPointer<vtkPolyData> QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionY()
 {
     vtkSmartPointer<vtkPolyData> PDY = vtkSmartPointer<vtkPolyData>::New();
     //todo
 
 
 
     return PDY;
 }
 
 vtkSmartPointer<vtkPolyData> QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionZ()
 {
     vtkSmartPointer<vtkPolyData> PDZ = vtkSmartPointer<vtkPolyData>::New();
     //todo
 
 
 
     return PDZ;
 }
 
 void QmitkFiberBundleDeveloperView::DoSetFAValues()
 {
 
     QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
     localTimer->setInterval( 10 );
     connect( localTimer, SIGNAL(timeout()), this, SLOT( UpdateSetFAValuesTimer() ) );
 
     // pack items which are needed by thread processing
     struct Package4WorkingThread ItemPackageToSetFAMap;
-    ItemPackageToSetFAMap.st_FBX = m_FiberBundleX;
+    ItemPackageToSetFAMap.st_FBX = m_FiberBundle;
     ItemPackageToSetFAMap.st_FancyGUITimer1 = localTimer;
     ItemPackageToSetFAMap.st_PassedDataNode = m_FANode;
     ItemPackageToSetFAMap.st_Controls = m_Controls;
 
     if (m_fiberMonitorIsOn)
         ItemPackageToSetFAMap.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
 
     if (m_threadInProgress)
         return; //maybe popup window saying, working thread still in progress...pls wait
 
     m_FiberFeederFASlave = new QmitkFiberFeederFAWorker(m_hostThread, ItemPackageToSetFAMap);
     m_FiberFeederFASlave->moveToThread(m_hostThread);
 
     connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_FiberSetFA()) );
     connect(m_hostThread, SIGNAL(started()), m_FiberFeederFASlave, SLOT(run()) );
     connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_FiberSetFA()));
     connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_FiberSetFA()));
     m_hostThread->start(QThread::LowestPriority);
 }
 
 void QmitkFiberBundleDeveloperView::DoSetFAMap()
 {
     std::vector<mitk::DataNode*> nodes = GetDataManagerSelection();
     if (nodes.empty())
     {
         m_Controls->lineEdit_FAMap->setText("N/A");
         return;
     }
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
          it != nodes.end();
          ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if (node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()))
         {
             // this node is what we want
             m_FANode = node;
             m_Controls->lineEdit_FAMap->setText(node->GetName().c_str());
             return;
         }
     }
 }
 
 void QmitkFiberBundleDeveloperView::BeforeThread_FiberSetFA()
 {
     m_threadInProgress = true;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
     }
 }
 
 void QmitkFiberBundleDeveloperView::AfterThread_FiberSetFA()
 {
     m_threadInProgress = false;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
     }
     disconnect(m_hostThread, 0, 0, 0);
     m_hostThread->disconnect();
     //update renderer
     m_FiberBundleNode->Modified();
     m_MultiWidget->ForceImmediateUpdate();
 
     //update QComboBox(dropDown menu) in view of available ColorCodings
     this->DoGatherColorCodings();
 
     delete m_FiberFeederFASlave;
 }
 
 void QmitkFiberBundleDeveloperView::DoColorFibers()
 {
     //
-    MITK_INFO << "call fibercoloring in fiberBundleX";
+    MITK_INFO << "call fibercoloring in FiberBundle";
     QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
     localTimer->setInterval( 10 );
     connect( localTimer, SIGNAL(timeout()), this, SLOT( UpdateColorFibersTimer() ) );
 
     // pack items which are needed by thread processing
     struct Package4WorkingThread ItemPackageForFiberColoring;
-    ItemPackageForFiberColoring.st_FBX = m_FiberBundleX;
+    ItemPackageForFiberColoring.st_FBX = m_FiberBundle;
     ItemPackageForFiberColoring.st_PassedDataNode = m_FiberBundleNode;
     ItemPackageForFiberColoring.st_FancyGUITimer1 = localTimer;
     ItemPackageForFiberColoring.st_Controls = m_Controls; //needed to catch up some selections and set options in GUI
 
     if (m_fiberMonitorIsOn)
         ItemPackageForFiberColoring.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
 
     if (m_threadInProgress)
         return; //maybe popup window saying, working thread still in progress...pls wait
 
     m_FiberColoringSlave = new QmitkFiberColoringWorker(m_hostThread, ItemPackageForFiberColoring);
     m_FiberColoringSlave->moveToThread(m_hostThread);
     connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_FiberColorCoding()) );
     connect(m_hostThread, SIGNAL(started()), m_FiberColoringSlave, SLOT(run()) );
     connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_FiberColorCoding()));
     connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_FiberColorCoding()));
     m_hostThread->start(QThread::LowestPriority);
 
 }
 
 void QmitkFiberBundleDeveloperView::BeforeThread_FiberColorCoding()
 {
     m_threadInProgress = true;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
     }
 }
 
 
 void QmitkFiberBundleDeveloperView::AfterThread_FiberColorCoding()
 {
     m_threadInProgress = false;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
     }
     disconnect(m_hostThread, 0, 0, 0);
     m_hostThread->disconnect();
     //update renderer
     m_FiberBundleNode->Modified();
     m_MultiWidget->ForceImmediateUpdate();
 
 
     //update QComboBox(dropDown menu) in view of available ColorCodings
     this->DoGatherColorCodings();
 
     delete m_FiberColoringSlave;
 }
 
 
 void QmitkFiberBundleDeveloperView::DoGatherColorCodings()
 {
-    QStringList fbxColorCodings = m_FiberBundleX->GetAvailableColorCodings();
+    QStringList fbxColorCodings = m_FiberBundle->GetAvailableColorCodings();
 
     //update dropDown Menu
     //remove all items from menu
     m_suppressSignal = true;
     int ddItems = m_Controls->ddAvailableColorcodings->count();
     for(int i=ddItems-1; i>=0; i--)
     {   //note, after each item remove, index in QComboBox is updated. sending signal: index changed
         m_Controls->ddAvailableColorcodings->removeItem(i);
     }
     //fill new data into menu
     m_Controls->ddAvailableColorcodings->addItems(fbxColorCodings);
-    m_Controls->ddAvailableColorcodings->addItem(m_FiberBundleX->COLORCODING_CUSTOM);
+    m_Controls->ddAvailableColorcodings->addItem(m_FiberBundle->COLORCODING_CUSTOM);
 
     //highlight current colorcoding
-    QString cc = m_FiberBundleX->GetCurrentColorCoding();
+    QString cc = m_FiberBundle->GetCurrentColorCoding();
     MITK_INFO << cc.toStdString().c_str() << " is at idx: " << m_Controls->ddAvailableColorcodings->findText(cc);
     m_Controls->ddAvailableColorcodings->setCurrentIndex( m_Controls->ddAvailableColorcodings->findText(cc) );
     m_Controls->ddAvailableColorcodings->update();
     m_suppressSignal = false;
 }
 
 
 void QmitkFiberBundleDeveloperView::SetCurrentColorCoding(int idx)
 {
     if(!m_suppressSignal){
         QString selectedColorCoding = m_Controls->ddAvailableColorcodings->itemText(idx);
-        m_FiberBundleX->SetColorCoding(selectedColorCoding.toStdString().c_str() ); //QString to char
+        m_FiberBundle->SetColorCoding(selectedColorCoding.toStdString().c_str() ); //QString to char
         // update rendering
         m_FiberBundleNode->Modified();
         m_MultiWidget->ForceImmediateUpdate();
     }
 }
 
 /* === OutSourcedMethod: THIS METHOD GENERATES ESSENTIAL GEOMETRY PARAMETERS FOR THE MITK FRAMEWORK ===
  * WITHOUT, the rendering mechanism will ignore objects without valid Geometry
  * for each object, MITK requires: ORIGIN, SPACING, TRANSFORM MATRIX, BOUNDING-BOX */
 mitk::Geometry3D::Pointer QmitkFiberBundleDeveloperView::GenerateStandardGeometryForMITK()
 {
     mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
 
     // generate origin
     mitk::Point3D origin;
     origin[0] = 0;
     origin[1] = 0;
     origin[2] = 0;
     geometry->SetOrigin(origin);
 
     // generate spacing
     float spacing[3] = {1,1,1};
     geometry->SetSpacing(spacing);
 
 
     // generate identity transform-matrix
     vtkSmartPointer<vtkMatrix4x4> m = vtkSmartPointer<vtkMatrix4x4>::New();
     geometry->SetIndexToWorldTransformByVtkMatrix(m);
 
     // generate boundingbox
     // for an usable bounding-box use gui parameters to estimate the boundingbox
     float bounds[] = {500, 500, 500, -500, -500, -500};
 
     // GET SELECTED FIBER DIRECTION
     QString fibDirection; //stores the object_name of selected radiobutton
     QVector<QRadioButton*>::const_iterator i;
     for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i)
     {
         QRadioButton* rdbtn = *i;
         if (rdbtn->isChecked())
             fibDirection = rdbtn->objectName();
     }
 
     if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) {
         // use information about distribution parameter to calculate bounding box
         int distrRadius = m_Controls->boxDistributionRadius->value();
         bounds[0] = distrRadius;
         bounds[1] = distrRadius;
         bounds[2] = distrRadius;
         bounds[3] = -distrRadius;
         bounds[4] = -distrRadius;
         bounds[5] = -distrRadius;
 
     } else {
         // so far only X,Y,Z directions are available
         MITK_INFO << "_______GEOMETRY ISSUE_____\n***BoundingBox for X, Y, Z fiber directions are not optimized yet!***";
 
         int maxFibLength = m_Controls->boxFiberMaxLength->value();
         bounds[0] = maxFibLength;
         bounds[1] = maxFibLength;
         bounds[2] = maxFibLength;
         bounds[3] = -maxFibLength;
         bounds[4] = -maxFibLength;
         bounds[5] = -maxFibLength;
     }
 
     geometry->SetFloatBounds(bounds);
     geometry->SetImageGeometry(true); //??
 
     return geometry;
 
 
 }
 
 void QmitkFiberBundleDeveloperView::UpdateFiberIDTimer()
 {
     //MAKE SURE by yourself THAT NOTHING ELSE THAN A NUMBER IS SET IN THAT LABEL
     QString crntValue = m_Controls->infoTimerGenerateFiberIds->text();
     int tmpVal = crntValue.toInt();
     m_Controls->infoTimerGenerateFiberIds->setText(QString::number(++tmpVal));
     m_Controls->infoTimerGenerateFiberIds->update();
 
 }
 
-/* Initialie ID dataset in FiberBundleX */
+/* Initialie ID dataset in FiberBundle */
 void QmitkFiberBundleDeveloperView::DoGenerateFiberIDs()
 {
 
     /* ===== TIMER CONFIGURATIONS for visual effect ======
    * start and stop is called in Thread */
     QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
     localTimer->setInterval( 10 );
     connect( localTimer, SIGNAL(timeout()), this, SLOT(UpdateFiberIDTimer()) );
 
 
     // pack items which are needed by thread processing
     struct Package4WorkingThread FiberIdPackage;
-    FiberIdPackage.st_FBX = m_FiberBundleX;
+    FiberIdPackage.st_FBX = m_FiberBundle;
     FiberIdPackage.st_FancyGUITimer1 = localTimer;
     FiberIdPackage.st_Controls = m_Controls;
 
     //set element for thread monitoring
     if (m_fiberMonitorIsOn)
         FiberIdPackage.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
 
 
     if (m_threadInProgress)
         return; //maybe popup window saying, working thread still in progress...pls wait
 
     // THREAD CONFIGURATION
     m_FiberIDGenerator = new QmitkFiberIDWorker(m_hostThread, FiberIdPackage);
     m_FiberIDGenerator->moveToThread(m_hostThread);
     connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_IdGenerate()) );
     connect(m_hostThread, SIGNAL(started()), m_FiberIDGenerator, SLOT(run()));
     connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_IdGenerate()));
     connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_IdGenerate()));
     m_hostThread->start(QThread::LowestPriority);
 
 
 
     // m_Controls->infoTimerGenerateFiberIds->setText(QString::number(clock.GetTotal()));
 
 }
 
 void QmitkFiberBundleDeveloperView::BeforeThread_IdGenerate()
 {
     m_threadInProgress = true;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_STARTED);
     }
 }
 
 void QmitkFiberBundleDeveloperView::AfterThread_IdGenerate()
 {
     m_threadInProgress = false;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
     }
     disconnect(m_hostThread, 0, 0, 0);
     m_hostThread->disconnect();
     delete m_FiberIDGenerator;
 
 }
 
 
 void  QmitkFiberBundleDeveloperView::ResetFiberInfoWidget()
 {
     if (m_Controls->infoAnalyseNumOfFibers->isEnabled()) {
         m_Controls->infoAnalyseNumOfFibers->setText("-");
         m_Controls->infoAnalyseNumOfPoints->setText("-");
         m_Controls->infoAnalyseNumOfFibers->setEnabled(false);
     }
 }
 
 void  QmitkFiberBundleDeveloperView::FeedFiberInfoWidget()
 {
     if (!m_Controls->infoAnalyseNumOfFibers->isEnabled())
         m_Controls->infoAnalyseNumOfFibers->setEnabled(true);
 
     QString numOfFibers;
-    numOfFibers.setNum( m_FiberBundleX->GetFiberPolyData()->GetNumberOfLines() );
+    numOfFibers.setNum( m_FiberBundle->GetFiberPolyData()->GetNumberOfLines() );
     QString numOfPoints;
-    numOfPoints.setNum( m_FiberBundleX->GetFiberPolyData()->GetNumberOfPoints() );
+    numOfPoints.setNum( m_FiberBundle->GetFiberPolyData()->GetNumberOfPoints() );
 
     m_Controls->infoAnalyseNumOfFibers->setText( numOfFibers );
     m_Controls->infoAnalyseNumOfPoints->setText( numOfPoints );
 }
 
 void QmitkFiberBundleDeveloperView::SelectionChangedToolBox(int idx)
 {
     // show/reset items of selected toolbox page FiberInfo
     if (m_Controls->page_FiberInfo->isVisible())
     {
-        if (m_FiberBundleX != NULL) {
+        if (m_FiberBundle != NULL) {
             FeedFiberInfoWidget();
 
         } else {
             //if infolables are disabled: return
             //else set info back to - and set label and info to disabled
             ResetFiberInfoWidget();
         }
     }
 
     // show/reset items of selected toolbox page FiberProcessing
     if (m_Controls->page_FiberProcessing->isVisible())
     {
-        if (m_FiberBundleX.IsNotNull() && m_PlanarFigure.IsNotNull() )
+        if (m_FiberBundle.IsNotNull() && m_PlanarFigure.IsNotNull() )
         {
             //show fiber extraction button
             m_Controls->buttonExtractFibers->setEnabled(true);
 
         } else {
             m_Controls->buttonExtractFibers->setEnabled(false);
         }
 
-        if (m_FiberBundleX.IsNotNull())
+        if (m_FiberBundle.IsNotNull())
         {
             //show button colorCoding
             m_Controls->buttonColorFibers->setEnabled(true);
             m_Controls->ddAvailableColorcodings->setEnabled(true);
             m_Controls->buttonGenerateFiberIds->setEnabled(true);
 
             //       m_Controls->buttonSMFibers->setEnabled(true);
             //       m_Controls->buttonVtkDecimatePro->setEnabled(true);
             //       m_Controls->buttonVtkSmoothPD->setEnabled(true);
             //       m_Controls->buttonGenerateTubes->setEnabled(true);
 
         } else {
             m_Controls->buttonColorFibers->setEnabled(false);
             m_Controls->ddAvailableColorcodings->setEnabled(false);
             m_Controls->buttonGenerateFiberIds->setEnabled(false);
             m_Controls->buttonSMFibers->setEnabled(false);
             m_Controls->buttonVtkDecimatePro->setEnabled(false);
             m_Controls->buttonVtkSmoothPD->setEnabled(false);
             m_Controls->buttonGenerateTubes->setEnabled(true);
 
         }
 
 
     }
 
 }
 
 void QmitkFiberBundleDeveloperView::FBXDependendGUIElementsConfigurator()
 {
     // ==== FIBER PROCESSING ELEMENTS and ALL ELEMENTS WHICH NEED A FBX DATANODE======
     //  m_Controls->buttonGenerateFiberIds->setEnabled(isVisible); moved to selectionChangedToolBox
 
     SelectionChangedToolBox(-1); //set gui elements with respect to active tab, widget, etc. -1 has no effect
 
 }
 
 
 void QmitkFiberBundleDeveloperView::DoMonitorFiberThreads(int checkStatus)
 {
-    //check if in datanode exists already a node of type mitkFiberBundleXThreadMonitor
+    //check if in datanode exists already a node of type mitkFiberBundleThreadMonitor
     //if not then put node to datastorage
 
     //if checkStatus is 1 then start qtimer using fading in starting text in datanode
     //if checkStatus is 0 then fade out dataNode using qtimer
 
     if (checkStatus)
     {
         m_fiberMonitorIsOn = true;
         // Generate Node hosting thread information
-        mitk::FiberBundleXThreadMonitor::Pointer FBXThreadMonitor = mitk::FiberBundleXThreadMonitor::New();
+        mitk::FiberBundleThreadMonitor::Pointer FBXThreadMonitor = mitk::FiberBundleThreadMonitor::New();
         FBXThreadMonitor->SetGeometry(this->GenerateStandardGeometryForMITK());
 
         m_MonitorNode = mitk::DataNode::New();
         m_MonitorNode->SetName("FBX_threadMonitor");
         m_MonitorNode->SetData(FBXThreadMonitor);
         m_MonitorNode->SetVisibility(true);
         m_MonitorNode->SetOpacity(1.0);
 
         GetDataStorage()->Add(m_MonitorNode);
 
         //following code is needed for rendering text in mitk! without geometry nothing is rendered
         const mitk::PlaneGeometry * tsgeo = m_MultiWidget->GetTimeNavigationController()->GetCurrentPlaneGeometry();
         if (tsgeo == NULL) {
             /* GetDataStorage()->Modified etc. have no effect, therefore proceed as followed below */
             // get all nodes that have not set "includeInBoundingBox" to false
             mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New( "includeInBoundingBox"
                                                                                                                  , mitk::BoolProperty::New(false)));
             mitk::DataStorage::SetOfObjects::ConstPointer rs = GetDataStorage()->GetSubset(pred);
             // calculate bounding geometry of these nodes
             mitk::TimeGeometry::Pointer bounds = GetDataStorage()->ComputeBoundingGeometry3D(rs);
             // initialize the views to the bounding geometry
             mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
         } else {
 
             GetDataStorage()->Modified();
             m_MultiWidget->RequestUpdate(); //necessary??
         }
         //__GEOMETRY FOR THREADMONITOR GENERATED
 
         /* ====== initialize thread for managing fiberThread information ========= */
         m_monitorThread = new QThread;
         // the package needs datastorage, MonitorDatanode, standardmultiwidget,
         struct Package4WorkingThread ItemPackageForThreadMonitor;
         ItemPackageForThreadMonitor.st_DataStorage = GetDataStorage();
         ItemPackageForThreadMonitor.st_ThreadMonitorDataNode = m_MonitorNode;
         ItemPackageForThreadMonitor.st_MultiWidget = m_MultiWidget;
         ItemPackageForThreadMonitor.st_FBX_Monitor = FBXThreadMonitor;
 
         m_fiberThreadMonitorWorker = new QmitkFiberThreadMonitorWorker(m_monitorThread, ItemPackageForThreadMonitor);
 
         m_fiberThreadMonitorWorker->moveToThread(m_monitorThread);
         connect ( m_monitorThread, SIGNAL( started() ), m_fiberThreadMonitorWorker, SLOT( run() ) );
         m_monitorThread->start(QThread::LowestPriority);
         m_fiberThreadMonitorWorker->initializeMonitor();//do some init animation ;-)
 
 
     } else {
         m_fiberMonitorIsOn = false;
 
         m_monitorThread->quit();
         //think about outsourcing following lines to quit / terminate slot of thread
         GetDataStorage()->Remove(m_MonitorNode);
         GetDataStorage()->Modified();
         m_MultiWidget->RequestUpdate(); //necessary??
     }
 
 
 
 }
 
 
 
 void QmitkFiberBundleDeveloperView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkFiberBundleDeveloperView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 /* OnSelectionChanged is registered to SelectionService, therefore no need to
  implement SelectionService Listener explicitly */
 void QmitkFiberBundleDeveloperView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
 
     if (nodes.empty())
         return;
-    /* ==== reset everyhing related to FiberBundleX ======
-   * - variable m_FiberBundleX
+    /* ==== reset everyhing related to FiberBundle ======
+   * - variable m_FiberBundle
    * - visualization of analysed fiberbundle
    */
     m_FiberBundleNode = NULL;
-    m_FiberBundleX = NULL; //reset pointer, so that member does not point to depricated locations
+    m_FiberBundle = NULL; //reset pointer, so that member does not point to depricated locations
     m_PlanarFigure = NULL;
     ResetFiberInfoWidget();
 
 
     //timer reset only when no thread is in progress
     if (!m_threadInProgress) {
         m_Controls->infoTimerGenerateFiberIds->setText("-"); //set GUI representation of timer to -
         m_Controls->infoTimerGenerateFiberBundle->setText( "-" );
         m_Controls->infoTimerColorCoding->setText( "-" );
     }
     //====================================================
 
 
 
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         /* CHECKPOINT: FIBERBUNDLE*/
-        if( node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
+        if( node.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
         {
             m_FiberBundleNode = node;
-            m_FiberBundleX = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
-            if (m_FiberBundleX.IsNull()){
-                MITK_INFO << "========ATTENTION=========\n unable to load selected FiberBundleX to FiberBundleDeveloper-plugin \n";
+            m_FiberBundle = dynamic_cast<mitk::FiberBundle*>(node->GetData());
+            if (m_FiberBundle.IsNull()){
+                MITK_INFO << "========ATTENTION=========\n unable to load selected FiberBundle to FiberBundleDeveloper-plugin \n";
                 m_FiberBundleNode = NULL;
             }
             // ==== FIBERBUNDLE_INFO ELEMENTS ====
             if ( m_Controls->page_FiberInfo->isVisible() )
                 FeedFiberInfoWidget();
 
-            // enable FiberBundleX related Gui Elements, such as buttons etc.
+            // enable FiberBundle related Gui Elements, such as buttons etc.
             this->FBXDependendGUIElementsConfigurator();
             this->DoGatherColorCodings();
 
         }
         /* CHECKPOINT: PLANARFIGURE */
         else if ( node.IsNotNull() && dynamic_cast<mitk::PlanarFigure*>(node->GetData()) )
         {
             m_PlanarFigure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
             MITK_INFO << "PF selected";
 
             if (m_PlanarFigure.IsNull())
                 MITK_INFO << "========ATTENTION=========\n unable to load selected Planarfigure to FiberBundleDeveloper-plugin \n";
 
         }
 
     }
     //update gui elements depending on given nodes
 
     FBXDependendGUIElementsConfigurator(); //every gui element which needs a FBX for processing is disabled
 }
 
 
 void QmitkFiberBundleDeveloperView::ActionDrawEllipseTriggered()
 {
     //    bool checked = m_Controls->m_CircleButton->isChecked();
     mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
     this->PutFigureToDataStorage(figure, QString("Circle%1").arg(++m_CircleCounter));
 
     MITK_INFO << "PlanarCircle created ...";
 
     mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDefaultDataStorage()->GetAll();
     mitk::DataNode* node = 0;
     mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
     mitk::PlanarFigure* figureP = 0;
 
     for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
         ; it++)
     {
         node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
         figureP = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
 
         if(figureP)
         {
           figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
           if(figureInteractor.IsNull())
           {
             figureInteractor = mitk::PlanarFigureInteractor::New();
             mitk::Module* planarFigureModule = mitk::ModuleRegistry::GetModule( "MitkPlanarFigure" );
             figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
             figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
             figureInteractor->SetDataNode( node );
           }
         }
     }
 
 }
 
 void QmitkFiberBundleDeveloperView::Activated()
 {
 
     MITK_INFO << "FB DevelopersV ACTIVATED()";
 
 
 }
 
 
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.h
index bc65c9e735..75d0d9e2f6 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.h
@@ -1,382 +1,382 @@
 /*===================================================================
 
 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 QmitkFiberBundleDeveloperView_h
 #define QmitkFiberBundleDeveloperView_h
 
 #include <berryISelectionListener.h>
 #include <berryIStructuredSelection.h>
 
 #include <QmitkFunctionality.h>
 #include "ui_QmitkFiberBundleDeveloperViewControls.h"
 
 #include <mitkDataStorage.h>
 #include <mitkDataStorageSelection.h>
 #include <mitkWeakPointer.h>
-#include <mitkFiberBundleXThreadMonitor.h>
+#include <mitkFiberBundleThreadMonitor.h>
 
 // Qt
 #include <QVector>
 #include <QRadioButton>
 #include <QString>
 
 // VTK
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 
 #include <QTimer>
 #include <QThread>
 
 class QmitkFiberThreadMonitorWorker; //include needed for struct element
 class QmitkFiberBundleDeveloperView; //this include is needed for the struct element, especially for functors to QmitkFiberBundleDeveloperView
 
 /* ==== THIS STRUCT CONTAINS ALL NECESSARY VARIABLES
  * TO EXECUTE AND UPDATE GUI ELEMENTS DURING PROCESSING OF A THREAD
  * why? either you add tons of friendclasses (e.g. FiberWorker objects), or you create a package containing all items needed. Otherwise you have to set all members etc. to public!
  */
 struct Package4WorkingThread
 {
-  mitk::FiberBundleX* st_FBX;
+  mitk::FiberBundle* st_FBX;
   QTimer* st_FancyGUITimer1;
   Ui::QmitkFiberBundleDeveloperViewControls* st_Controls;
 
 
 
   //functors to outdoor methods
   QmitkFiberBundleDeveloperView* st_host;
   void (QmitkFiberBundleDeveloperView::*st_pntr_to_Method_PutFibersToDataStorage) (vtkSmartPointer<vtkPolyData>);
 
 
   //==DO NOT TOUCH THIS SECTION=== you might extend this section, but do NOT shorten it! hai capito!
   //host MITK I/O elements, especially needed for thread monitoring
   QmitkFiberThreadMonitorWorker *st_fiberThreadMonitorWorker;
-  mitk::FiberBundleXThreadMonitor::Pointer st_FBX_Monitor; //needed for direct access do animation/fancy methods
+  mitk::FiberBundleThreadMonitor::Pointer st_FBX_Monitor; //needed for direct access do animation/fancy methods
   mitk::DataNode::Pointer st_ThreadMonitorDataNode; //needed for renderer to recognize node modifications
   mitk::DataNode::Pointer st_PassedDataNode; //put an extra node if needed
   mitk::DataStorage::Pointer st_DataStorage; //well that is discussable if needed ;-) probably not
   QmitkStdMultiWidget* st_MultiWidget; //needed for rendering update
   mitk::PlanarFigure::Pointer st_PlanarFigure; //needed for fiberextraction
 
 };
 
 
 // ====================================================================
 // ============= WORKER WHICH IS PASSED TO THREAD =====================
 // ====================================================================
 //## Documentation
 //## This class does the actual work for generating fiber ids.
 class QmitkFiberIDWorker : public QObject
 {
   Q_OBJECT
 
 public:
   QmitkFiberIDWorker( QThread*, Package4WorkingThread );
 
   public slots:
   void run();
 
 private:
   Package4WorkingThread m_itemPackage;
   QThread* m_hostingThread;
 
 
 };
 
 // ====================================================================
 // ============= WORKER WHICH IS PASSED TO THREAD =====================
 // ====================================================================
 //## Documentation
 //## This class does the actual work for colorcoding fibers.
 class QmitkFiberColoringWorker : public QObject
 {
   Q_OBJECT
 
 public:
   QmitkFiberColoringWorker( QThread*, Package4WorkingThread );
 
   public slots:
   void run();
 
 private:
   Package4WorkingThread m_itemPackage;
   QThread* m_hostingThread;
 
 };
 
 
 // ====================================================================
 // ============= WORKER WHICH IS PASSED TO THREAD =====================
 // ====================================================================
 class QmitkFiberGenerateRandomWorker : public QObject
 {
   Q_OBJECT
 
 public:
   QmitkFiberGenerateRandomWorker( QThread*, Package4WorkingThread );
 
   public slots:
   void run();
 
 private:
   Package4WorkingThread m_itemPackage;
   QThread* m_hostingThread;
 
 
 };
 
 // ====================================================================
 // ============= WORKER WHICH IS PASSED TO THREAD =====================
 // ====================================================================
 class QmitkFiberFeederFAWorker : public QObject
 {
   Q_OBJECT
 
 public:
   QmitkFiberFeederFAWorker( QThread*, Package4WorkingThread );
 
   public slots:
   void run();
 
 private:
   Package4WorkingThread m_itemPackage;
   QThread* m_hostingThread;
 
 
 };
 
 // ====================================================================
 // ============= WORKER WHICH IS PASSED TO THREAD =====================
 // ====================================================================
 class QmitkFiberExtractorWorker : public QObject
 {
     Q_OBJECT
 
 public:
     QmitkFiberExtractorWorker( QThread*, Package4WorkingThread );
 
 public slots:
     void run();
 
 private:
     Package4WorkingThread m_itemPackage;
     QThread* m_hostingThread;
 
 };
 
 // ====================================================================
 // ============= WORKER WHICH IS PASSED TO THREAD =====================
 // ====================================================================
 class QmitkFiberThreadMonitorWorker : public QObject
 {
   Q_OBJECT
 
 public:
 
 
   QmitkFiberThreadMonitorWorker( QThread*, Package4WorkingThread );
 
   void initializeMonitor();
   void threadForFiberProcessingStarted();
   void threadForFiberProcessingFinished();
   void threadForFiberProcessingTerminated();
   void setThreadStatus(QString);
 
 
   public slots:
   void run();
   void fancyMonitorInitialization();
   void fancyMonitorInitializationFinalPos();
   void fancyMonitorInitializationMask();
   void fancyTextFading_threadStarted();
   void fancyTextFading_threadFinished();
   void fancyTextFading_threadTerminated();
 
 private:
   Package4WorkingThread m_itemPackage;
   QThread* m_hostingThread;
   QTimer* m_thtimer_initMonitor;
   QTimer* m_thtimer_initMonitorSetFinalPosition;
   QTimer* m_thtimer_initMonitorSetMasks;
   QTimer* m_thtimer_threadStarted;
   QTimer* m_thtimer_threadFinished;
   QTimer* m_thtimer_threadTerminated;
 
   // flags for fancy fading
   bool m_decreaseOpacity_threadStarted;
   bool m_decreaseOpacity_threadFinished;
   bool m_decreaseOpacity_threadTerminated;
 
   // members for fancy animation
   int m_pixelstepper;
   int m_steppingDistance;
 
 
 };
 
 // strings to display fiber_thread monitor
 const QString FBX_STATUS_IDLE = "idle";
 const QString FBX_STATUS_STARTED = "starting";
 const QString FBX_STATUS_RUNNING = "running";
 
 
 
 // ========= HERE STARTS THE ACTUAL FIBERBUNDLE DEVELOPER VIEW =======
 
 const QString FIB_RADIOBUTTON_DIRECTION_RANDOM = "radioButton_directionRandom";
 const QString FIB_RADIOBUTTON_DIRECTION_X      = "radioButton_directionX";
 const QString FIB_RADIOBUTTON_DIRECTION_Y      = "radioButton_directionY";
 const QString FIB_RADIOBUTTON_DIRECTION_Z      = "radioButton_directionZ";
 
 
 /*!
  \brief QmitkFiberBundleView
 
  \warning  This application module is not yet documented. Use "svn blame/praise/annotate" and ask the author to provide basic documentation.
 
  \sa QmitkFunctionality
  \ingroup Functionalities
  */
 class QmitkFiberBundleDeveloperView : public QmitkFunctionality
 {
 
 
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   QmitkFiberBundleDeveloperView();
   virtual ~QmitkFiberBundleDeveloperView();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
   virtual void Activated();
 
   protected slots:
   void DoGenerateFibers();
   void DoGenerateFiberIDs();
   void DoExtractFibers();
   void DoUpdateGenerateFibersWidget();
   void SelectionChangedToolBox(int);
   void DoMonitorFiberThreads(int);
   void DoSetFAValues();
   void DoSetFAMap();
   void DoColorFibers();
   void DoGatherColorCodings();
   void SetCurrentColorCoding(int);
   void ActionDrawEllipseTriggered();
 
   //SLOTS FOR THREADS
   void BeforeThread_IdGenerate();
   void AfterThread_IdGenerate();
   void BeforeThread_GenerateFibersRandom();
   void AfterThread_GenerateFibersRandom();
   void BeforeThread_FiberSetFA();
   void AfterThread_FiberSetFA();
   void BeforeThread_FiberColorCoding();
   void AfterThread_FiberColorCoding();
   void BeforeThread_FiberExtraction();
   void AfterThread_FiberExtraction();
 
   //SLOTS FOR TIMERS
   void UpdateFiberIDTimer();
   void UpdateGenerateRandomFibersTimer();
   void UpdateColorFibersTimer();
   void UpdateExtractFibersTimer();
   void UpdateSetFAValuesTimer();
 
 
 
 protected:
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
 
   Ui::QmitkFiberBundleDeveloperViewControls* m_Controls;
 
   QmitkStdMultiWidget* m_MultiWidget;
 
 
 
 private:
 
   /* METHODS GENERATING FIBERSTRUCTURES */
   void GenerateVtkFibersRandom();
   vtkSmartPointer<vtkPolyData> GenerateVtkFibersDirectionX();
   vtkSmartPointer<vtkPolyData> GenerateVtkFibersDirectionY();
   vtkSmartPointer<vtkPolyData> GenerateVtkFibersDirectionZ();
 
   void PutFibersToDataStorage( vtkSmartPointer<vtkPolyData> );
   void PutFigureToDataStorage(mitk::PlanarFigure* , const QString& );
   /* METHODS FOR FIBER PROCESSING OR PREPROCESSING  */
 
 
   /* HELPERMETHODS */
   mitk::Geometry3D::Pointer GenerateStandardGeometryForMITK();
   void ResetFiberInfoWidget();
   void FeedFiberInfoWidget();
   void FBXDependendGUIElementsConfigurator();
 
   void SetGeneratedFBX();
 
 
   //contains the selected FiberBundle, PlanarFigure
   mitk::DataNode::Pointer m_FiberBundleNode;
-  mitk::WeakPointer<mitk::FiberBundleX> m_FiberBundleX;
+  mitk::WeakPointer<mitk::FiberBundle> m_FiberBundle;
   mitk::PlanarFigure::Pointer m_PlanarFigure;
 
   //  radiobutton groups
   QVector< QRadioButton* > m_DirectionRadios;
   QVector< QRadioButton* > m_FARadios;
   QVector< QRadioButton* > m_GARadios;
 
 
   // Thread based Workers which do some processing of fibers
   QmitkFiberIDWorker* m_FiberIDGenerator;
   QmitkFiberGenerateRandomWorker* m_GeneratorFibersRandom;
   QmitkFiberFeederFAWorker* m_FiberFeederFASlave;
   QmitkFiberColoringWorker* m_FiberColoringSlave;
   QmitkFiberExtractorWorker* m_FiberExtractor;
 
   QThread* m_hostThread;
   QThread* m_monitorThread;
   bool m_threadInProgress;
   mitk::DataNode::Pointer m_MonitorNode;
   QmitkFiberThreadMonitorWorker *m_fiberThreadMonitorWorker;
   bool m_fiberMonitorIsOn;
 
   // counters for ROI nodes
   int m_CircleCounter;
 
   mitk::DataNode::Pointer m_FANode;
 
   // flag to bypass signal from qcombobox "index changed(int)"
   bool m_suppressSignal;
 
 };
 
 
 
 #endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
index e116a924b7..c26ea6b4ae 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
@@ -1,1487 +1,1487 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberProcessingView.h"
 #include <QmitkStdMultiWidget.h>
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkNodePredicateProperty.h>
 #include <mitkImageCast.h>
 #include <mitkPointSet.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarRectangle.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkDataNodeObject.h>
 #include <mitkTensorImage.h>
 #include "usModuleRegistry.h"
 #include <itkFiberCurvatureFilter.h>
 
 #include "mitkNodePredicateDataType.h"
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 
 // ITK
 #include <itkResampleImageFilter.h>
 #include <itkGaussianInterpolateImageFunction.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkTractsToFiberEndingsImageFilter.h>
 #include <itkTractDensityImageFilter.h>
 #include <itkImageRegion.h>
 #include <itkTractsToRgbaImageFilter.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 
 const std::string QmitkFiberProcessingView::VIEW_ID = "org.mitk.views.fiberprocessing";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace mitk;
 
 QmitkFiberProcessingView::QmitkFiberProcessingView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
     , m_CircleCounter(0)
     , m_PolygonCounter(0)
     , m_UpsamplingFactor(1)
 {
 
 }
 
 // Destructor
 QmitkFiberProcessingView::~QmitkFiberProcessingView()
 {
 
 }
 
 void QmitkFiberProcessingView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFiberProcessingViewControls;
         m_Controls->setupUi( parent );
 
         connect( m_Controls->m_CircleButton, SIGNAL( clicked() ), this, SLOT( OnDrawCircle() ) );
         connect( m_Controls->m_PolygonButton, SIGNAL( clicked() ), this, SLOT( OnDrawPolygon() ) );
         connect(m_Controls->PFCompoANDButton, SIGNAL(clicked()), this, SLOT(GenerateAndComposite()) );
         connect(m_Controls->PFCompoORButton, SIGNAL(clicked()), this, SLOT(GenerateOrComposite()) );
         connect(m_Controls->PFCompoNOTButton, SIGNAL(clicked()), this, SLOT(GenerateNotComposite()) );
         connect(m_Controls->m_GenerateRoiImage, SIGNAL(clicked()), this, SLOT(GenerateRoiImage()) );
 
         connect(m_Controls->m_JoinBundles, SIGNAL(clicked()), this, SLOT(JoinBundles()) );
         connect(m_Controls->m_SubstractBundles, SIGNAL(clicked()), this, SLOT(SubstractBundles()) );
 
         connect(m_Controls->m_ExtractFibersButton, SIGNAL(clicked()), this, SLOT(Extract()));
         connect(m_Controls->m_RemoveButton, SIGNAL(clicked()), this, SLOT(Remove()));
         connect(m_Controls->m_ModifyButton, SIGNAL(clicked()), this, SLOT(Modify()));
 
         connect(m_Controls->m_ExtractionMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
         connect(m_Controls->m_RemovalMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
         connect(m_Controls->m_ModificationMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
 
         m_Controls->m_ColorMapBox->SetDataStorage(this->GetDataStorage());
         mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
         mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
         mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
         mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
         mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
         isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
         mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
         mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
         m_Controls->m_ColorMapBox->SetPredicate(finalPredicate);
     }
 
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::Modify()
 {
     switch (m_Controls->m_ModificationMethodBox->currentIndex())
     {
     case 0:
     {
         ResampleSelectedBundles();
         break;
     }
     case 1:
     {
         CompressSelectedBundles();
         break;
     }
     case 2:
     {
         DoImageColorCoding();
         break;
     }
     case 3:
     {
         MirrorFibers();
         break;
     }
     case 4:
     {
         WeightFibers();
         break;
     }
     }
 }
 
 void QmitkFiberProcessingView::WeightFibers()
 {
     float weight = this->m_Controls->m_BundleWeightBox->value();
     for (int i=0; i<m_SelectedFB.size(); i++)
     {
-        mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
+        mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(i)->GetData());
         fib->SetFiberWeights(weight);
     }
 
 }
 
 void QmitkFiberProcessingView::Remove()
 {
     switch (m_Controls->m_RemovalMethodBox->currentIndex())
     {
     case 0:
     {
         RemoveDir();
         break;
     }
     case 1:
     {
         PruneBundle();
         break;
     }
     case 2:
     {
         ApplyCurvatureThreshold();
         break;
     }
     case 3:
     {
         RemoveWithMask(false);
         break;
     }
     case 4:
     {
         RemoveWithMask(true);
         break;
     }
     }
 }
 
 void QmitkFiberProcessingView::Extract()
 {
     switch (m_Controls->m_ExtractionMethodBox->currentIndex())
     {
     case 0:
     {
         ExtractWithPlanarFigure();
         break;
     }
     case 1:
     {
         switch (m_Controls->m_ExtractionBoxMask->currentIndex())
         {
         {
         case 0:
             ExtractWithMask(true, false);
             break;
         }
         {
         case 1:
             ExtractWithMask(true, true);
             break;
         }
         {
         case 2:
             ExtractWithMask(false, false);
             break;
         }
         {
         case 3:
             ExtractWithMask(false, true);
             break;
         }
         }
         break;
     }
     }
 }
 
 void QmitkFiberProcessingView::PruneBundle()
 {
     int minLength = this->m_Controls->m_PruneFibersMinBox->value();
     int maxLength = this->m_Controls->m_PruneFibersMaxBox->value();
     for (int i=0; i<m_SelectedFB.size(); i++)
     {
-        mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
+        mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(i)->GetData());
         if (!fib->RemoveShortFibers(minLength))
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
         else if (!fib->RemoveLongFibers(maxLength))
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::ApplyCurvatureThreshold()
 {
     int angle = this->m_Controls->m_CurvSpinBox->value();
     int dist = this->m_Controls->m_CurvDistanceSpinBox->value();
     std::vector< DataNode::Pointer > nodes = m_SelectedFB;
     for (int i=0; i<nodes.size(); i++)
     {
-        mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(nodes.at(i)->GetData());
+        mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(nodes.at(i)->GetData());
 
         itk::FiberCurvatureFilter::Pointer filter = itk::FiberCurvatureFilter::New();
         filter->SetInputFiberBundle(fib);
         filter->SetAngularDeviation(angle);
         filter->SetDistance(dist);
         filter->SetRemoveFibers(m_Controls->m_RemoveCurvedFibersBox->isChecked());
         filter->Update();
-        mitk::FiberBundleX::Pointer newFib = filter->GetOutputFiberBundle();
+        mitk::FiberBundle::Pointer newFib = filter->GetOutputFiberBundle();
         if (newFib->GetNumFibers()>0)
         {
             nodes.at(i)->SetVisibility(false);
             DataNode::Pointer newNode = DataNode::New();
             newNode->SetData(newFib);
             newNode->SetName(nodes.at(i)->GetName()+"_Curvature");
             GetDefaultDataStorage()->Add(newNode, nodes.at(i));
         }
         else
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
 //        if (!fib->ApplyCurvatureThreshold(mm, this->m_Controls->m_RemoveCurvedFibersBox->isChecked()))
 //            QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::RemoveDir()
 {
     for (unsigned int i=0; i<m_SelectedFB.size(); i++)
     {
-        mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
+        mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(i)->GetData());
         vnl_vector_fixed<double,3> dir;
         dir[0] = m_Controls->m_ExtractDirX->value();
         dir[1] = m_Controls->m_ExtractDirY->value();
         dir[2] = m_Controls->m_ExtractDirZ->value();
         fib->RemoveDir(dir,cos((float)m_Controls->m_ExtractAngle->value()*M_PI/180));
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::RemoveWithMask(bool removeInside)
 {
     if (m_MaskImageNode.IsNull())
         return;
 
     mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
     for (unsigned int i=0; i<m_SelectedFB.size(); i++)
     {
-        mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
+        mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(i)->GetData());
         QString name(m_SelectedFB.at(i)->GetName().c_str());
 
         itkUCharImageType::Pointer mask = itkUCharImageType::New();
         mitk::CastToItkImage(mitkMask, mask);
-        mitk::FiberBundleX::Pointer newFib = fib->RemoveFibersOutside(mask, removeInside);
+        mitk::FiberBundle::Pointer newFib = fib->RemoveFibersOutside(mask, removeInside);
         if (newFib->GetNumFibers()<=0)
         {
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
             continue;
         }
         DataNode::Pointer newNode = DataNode::New();
         newNode->SetData(newFib);
         if (removeInside)
             name += "_Inside";
         else
             name += "_Outside";
         newNode->SetName(name.toStdString());
         GetDefaultDataStorage()->Add(newNode);
         m_SelectedFB.at(i)->SetVisibility(false);
     }
 }
 
 void QmitkFiberProcessingView::ExtractWithMask(bool onlyEnds, bool invert)
 {
     if (m_MaskImageNode.IsNull())
         return;
 
     mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
     for (unsigned int i=0; i<m_SelectedFB.size(); i++)
     {
-        mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
+        mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(i)->GetData());
         QString name(m_SelectedFB.at(i)->GetName().c_str());
 
         itkUCharImageType::Pointer mask = itkUCharImageType::New();
         mitk::CastToItkImage(mitkMask, mask);
-        mitk::FiberBundleX::Pointer newFib = fib->ExtractFiberSubset(mask, onlyEnds, invert);
+        mitk::FiberBundle::Pointer newFib = fib->ExtractFiberSubset(mask, onlyEnds, invert);
         if (newFib->GetNumFibers()<=0)
         {
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
             continue;
         }
 
         DataNode::Pointer newNode = DataNode::New();
         newNode->SetData(newFib);
 
         if (invert)
         {
             name += "_not";
 
             if (onlyEnds)
                 name += "-ending-in-mask";
             else
                 name += "-passing-mask";
         }
         else
         {
             if (onlyEnds)
                 name += "_ending-in-mask";
             else
                 name += "_passing-mask";
         }
 
         newNode->SetName(name.toStdString());
         GetDefaultDataStorage()->Add(newNode);
         m_SelectedFB.at(i)->SetVisibility(false);
     }
 }
 
 void QmitkFiberProcessingView::GenerateRoiImage()
 {
     if (m_SelectedPF.empty())
         return;
 
     mitk::BaseGeometry::Pointer geometry;
     if (!m_SelectedFB.empty())
     {
-        mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.front()->GetData());
+        mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.front()->GetData());
         geometry = fib->GetGeometry();
     }
     else if (m_SelectedImage)
         geometry = m_SelectedImage->GetGeometry();
     else
         return;
 
     itk::Vector<double,3> spacing = geometry->GetSpacing();
     spacing /= m_UpsamplingFactor;
 
     mitk::Point3D newOrigin = geometry->GetOrigin();
     mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
     newOrigin[0] += bounds.GetElement(0);
     newOrigin[1] += bounds.GetElement(2);
     newOrigin[2] += bounds.GetElement(4);
 
     itk::Matrix<double, 3, 3> direction;
     itk::ImageRegion<3> imageRegion;
     for (int i=0; i<3; i++)
         for (int j=0; j<3; j++)
             direction[j][i] = geometry->GetMatrixColumn(i)[j]/spacing[j];
     imageRegion.SetSize(0, geometry->GetExtent(0)*m_UpsamplingFactor);
     imageRegion.SetSize(1, geometry->GetExtent(1)*m_UpsamplingFactor);
     imageRegion.SetSize(2, geometry->GetExtent(2)*m_UpsamplingFactor);
 
     m_PlanarFigureImage = itkUCharImageType::New();
     m_PlanarFigureImage->SetSpacing( spacing );   // Set the image spacing
     m_PlanarFigureImage->SetOrigin( newOrigin );     // Set the image origin
     m_PlanarFigureImage->SetDirection( direction );  // Set the image direction
     m_PlanarFigureImage->SetRegions( imageRegion );
     m_PlanarFigureImage->Allocate();
     m_PlanarFigureImage->FillBuffer( 0 );
 
     Image::Pointer tmpImage = Image::New();
     tmpImage->InitializeByItk(m_PlanarFigureImage.GetPointer());
     tmpImage->SetVolume(m_PlanarFigureImage->GetBufferPointer());
 
     std::string name = m_SelectedPF.at(0)->GetName();
     WritePfToImage(m_SelectedPF.at(0), tmpImage);
     for (unsigned int i=1; i<m_SelectedPF.size(); i++)
     {
         name += "+";
         name += m_SelectedPF.at(i)->GetName();
         WritePfToImage(m_SelectedPF.at(i), tmpImage);
     }
 
     DataNode::Pointer node = DataNode::New();
     tmpImage = Image::New();
     tmpImage->InitializeByItk(m_PlanarFigureImage.GetPointer());
     tmpImage->SetVolume(m_PlanarFigureImage->GetBufferPointer());
     node->SetData(tmpImage);
     node->SetName(name);
     this->GetDefaultDataStorage()->Add(node);
 }
 
 void QmitkFiberProcessingView::WritePfToImage(mitk::DataNode::Pointer node, mitk::Image* image)
 {
     if (dynamic_cast<mitk::PlanarFigure*>(node->GetData()))
     {
         m_PlanarFigure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
         AccessFixedDimensionByItk_2(
                     image,
                     InternalReorientImagePlane, 3,
                     m_PlanarFigure->GetGeometry(), -1);
 
         AccessFixedDimensionByItk_2(
                     m_InternalImage,
                     InternalCalculateMaskFromPlanarFigure,
                     3, 2, node->GetName() );
     }
     else if (dynamic_cast<mitk::PlanarFigureComposite*>(node->GetData()))
     {
         mitk::PlanarFigureComposite* pfc = dynamic_cast<mitk::PlanarFigureComposite*>(node->GetData());
         for (int j=0; j<pfc->getNumberOfChildren(); j++)
         {
             WritePfToImage(pfc->getDataNodeAt(j), image);
         }
     }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkFiberProcessingView::InternalReorientImagePlane( const itk::Image< TPixel, VImageDimension > *image, mitk::BaseGeometry* planegeo3D, int additionalIndex )
 {
     typedef itk::Image< TPixel, VImageDimension > ImageType;
     typedef itk::Image< float, VImageDimension > FloatImageType;
 
     typedef itk::ResampleImageFilter<ImageType, FloatImageType, double> ResamplerType;
     typename ResamplerType::Pointer resampler = ResamplerType::New();
 
     mitk::PlaneGeometry* planegeo = dynamic_cast<mitk::PlaneGeometry*>(planegeo3D);
 
     float upsamp = m_UpsamplingFactor;
     float gausssigma = 0.5;
 
     // Spacing
     typename ResamplerType::SpacingType spacing = planegeo->GetSpacing();
     spacing[0] = image->GetSpacing()[0] / upsamp;
     spacing[1] = image->GetSpacing()[1] / upsamp;
     spacing[2] = image->GetSpacing()[2];
     resampler->SetOutputSpacing( spacing );
 
     // Size
     typename ResamplerType::SizeType size;
     size[0] = planegeo->GetExtentInMM(0) / spacing[0];
     size[1] = planegeo->GetExtentInMM(1) / spacing[1];
     size[2] = 1;
     resampler->SetSize( size );
 
     // Origin
     typename mitk::Point3D orig = planegeo->GetOrigin();
     typename mitk::Point3D corrorig;
     planegeo3D->WorldToIndex(orig,corrorig);
     corrorig[0] += 0.5/upsamp;
     corrorig[1] += 0.5/upsamp;
     corrorig[2] += 0;
     planegeo3D->IndexToWorld(corrorig,corrorig);
     resampler->SetOutputOrigin(corrorig );
 
     // Direction
     typename ResamplerType::DirectionType direction;
     typename mitk::AffineTransform3D::MatrixType matrix = planegeo->GetIndexToWorldTransform()->GetMatrix();
     for(int c=0; c<matrix.ColumnDimensions; c++)
     {
         double sum = 0;
         for(int r=0; r<matrix.RowDimensions; r++)
             sum += matrix(r,c)*matrix(r,c);
         for(int r=0; r<matrix.RowDimensions; r++)
             direction(r,c) = matrix(r,c)/sqrt(sum);
     }
     resampler->SetOutputDirection( direction );
 
     // Gaussian interpolation
     if(gausssigma != 0)
     {
         double sigma[3];
         for( unsigned int d = 0; d < 3; d++ )
             sigma[d] = gausssigma * image->GetSpacing()[d];
         double alpha = 2.0;
         typedef itk::GaussianInterpolateImageFunction<ImageType, double> GaussianInterpolatorType;
         typename GaussianInterpolatorType::Pointer interpolator = GaussianInterpolatorType::New();
         interpolator->SetInputImage( image );
         interpolator->SetParameters( sigma, alpha );
         resampler->SetInterpolator( interpolator );
     }
     else
     {
         typedef typename itk::LinearInterpolateImageFunction<ImageType, double> InterpolatorType;
         typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
         interpolator->SetInputImage( image );
         resampler->SetInterpolator( interpolator );
     }
 
     resampler->SetInput( image );
     resampler->SetDefaultPixelValue(0);
     resampler->Update();
 
     if(additionalIndex < 0)
     {
         this->m_InternalImage = mitk::Image::New();
         this->m_InternalImage->InitializeByItk( resampler->GetOutput() );
         this->m_InternalImage->SetVolume( resampler->GetOutput()->GetBufferPointer() );
     }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkFiberProcessingView::InternalCalculateMaskFromPlanarFigure( itk::Image< TPixel, VImageDimension > *image, unsigned int axis, std::string )
 {
     typedef itk::Image< TPixel, VImageDimension > ImageType;
     typedef itk::CastImageFilter< ImageType, itkUCharImageType > CastFilterType;
 
     // Generate mask image as new image with same header as input image and
     // initialize with "1".
     itkUCharImageType::Pointer newMaskImage = itkUCharImageType::New();
     newMaskImage->SetSpacing( image->GetSpacing() );   // Set the image spacing
     newMaskImage->SetOrigin( image->GetOrigin() );     // Set the image origin
     newMaskImage->SetDirection( image->GetDirection() );  // Set the image direction
     newMaskImage->SetRegions( image->GetLargestPossibleRegion() );
     newMaskImage->Allocate();
     newMaskImage->FillBuffer( 1 );
 
     // Generate VTK polygon from (closed) PlanarFigure polyline
     // (The polyline points are shifted by -0.5 in z-direction to make sure
     // that the extrusion filter, which afterwards elevates all points by +0.5
     // in z-direction, creates a 3D object which is cut by the the plane z=0)
     const PlaneGeometry *planarFigurePlaneGeometry = m_PlanarFigure->GetPlaneGeometry();
     const PlanarFigure::PolyLineType planarFigurePolyline = m_PlanarFigure->GetPolyLine( 0 );
     const BaseGeometry *imageGeometry3D = m_InternalImage->GetGeometry( 0 );
 
     vtkPolyData *polyline = vtkPolyData::New();
     polyline->Allocate( 1, 1 );
 
     // Determine x- and y-dimensions depending on principal axis
     int i0, i1;
     switch ( axis )
     {
     case 0:
         i0 = 1;
         i1 = 2;
         break;
     case 1:
         i0 = 0;
         i1 = 2;
         break;
     case 2:
     default:
         i0 = 0;
         i1 = 1;
         break;
     }
 
     // Create VTK polydata object of polyline contour
     vtkPoints *points = vtkPoints::New();
     PlanarFigure::PolyLineType::const_iterator it;
     unsigned int numberOfPoints = 0;
 
     for ( it = planarFigurePolyline.begin(); it != planarFigurePolyline.end(); ++it )
     {
         Point3D point3D;
 
         // Convert 2D point back to the local index coordinates of the selected image
         Point2D point2D = *it;
         planarFigurePlaneGeometry->WorldToIndex(point2D, point2D);
         point2D[0] -= 0.5/m_UpsamplingFactor;
         point2D[1] -= 0.5/m_UpsamplingFactor;
         planarFigurePlaneGeometry->IndexToWorld(point2D, point2D);
         planarFigurePlaneGeometry->Map( point2D, point3D );
 
         // Polygons (partially) outside of the image bounds can not be processed further due to a bug in vtkPolyDataToImageStencil
         if ( !imageGeometry3D->IsInside( point3D ) )
         {
             float bounds[2] = {0,0};
             bounds[0] =
                     this->m_InternalImage->GetLargestPossibleRegion().GetSize().GetElement(i0);
             bounds[1] =
                     this->m_InternalImage->GetLargestPossibleRegion().GetSize().GetElement(i1);
 
             imageGeometry3D->WorldToIndex( point3D, point3D );
 
             if (point3D[i0]<0)
                 point3D[i0] = 0.0;
             else if (point3D[i0]>bounds[0])
                 point3D[i0] = bounds[0]-0.001;
 
             if (point3D[i1]<0)
                 point3D[i1] = 0.0;
             else if (point3D[i1]>bounds[1])
                 point3D[i1] = bounds[1]-0.001;
 
             points->InsertNextPoint( point3D[i0], point3D[i1], -0.5 );
             numberOfPoints++;
         }
         else
         {
             imageGeometry3D->WorldToIndex( point3D, point3D );
             // Add point to polyline array
             points->InsertNextPoint( point3D[i0], point3D[i1], -0.5 );
             numberOfPoints++;
         }
     }
     polyline->SetPoints( points );
     points->Delete();
 
     vtkIdType *ptIds = new vtkIdType[numberOfPoints];
     for ( vtkIdType i = 0; i < numberOfPoints; ++i )
         ptIds[i] = i;
     polyline->InsertNextCell( VTK_POLY_LINE, numberOfPoints, ptIds );
 
     // Extrude the generated contour polygon
     vtkLinearExtrusionFilter *extrudeFilter = vtkLinearExtrusionFilter::New();
     extrudeFilter->SetInputData( polyline );
     extrudeFilter->SetScaleFactor( 1 );
     extrudeFilter->SetExtrusionTypeToNormalExtrusion();
     extrudeFilter->SetVector( 0.0, 0.0, 1.0 );
 
     // Make a stencil from the extruded polygon
     vtkPolyDataToImageStencil *polyDataToImageStencil = vtkPolyDataToImageStencil::New();
     polyDataToImageStencil->SetInputConnection( extrudeFilter->GetOutputPort() );
 
     // Export from ITK to VTK (to use a VTK filter)
     typedef itk::VTKImageImport< itkUCharImageType > ImageImportType;
     typedef itk::VTKImageExport< itkUCharImageType > ImageExportType;
 
     typename ImageExportType::Pointer itkExporter = ImageExportType::New();
     itkExporter->SetInput( newMaskImage );
 
     vtkImageImport *vtkImporter = vtkImageImport::New();
     this->ConnectPipelines( itkExporter, vtkImporter );
     vtkImporter->Update();
 
     // Apply the generated image stencil to the input image
     vtkImageStencil *imageStencilFilter = vtkImageStencil::New();
     imageStencilFilter->SetInputConnection( vtkImporter->GetOutputPort() );
     imageStencilFilter->SetStencilConnection(polyDataToImageStencil->GetOutputPort() );
     imageStencilFilter->ReverseStencilOff();
     imageStencilFilter->SetBackgroundValue( 0 );
     imageStencilFilter->Update();
 
     // Export from VTK back to ITK
     vtkImageExport *vtkExporter = vtkImageExport::New();
     vtkExporter->SetInputConnection( imageStencilFilter->GetOutputPort() );
     vtkExporter->Update();
 
     typename ImageImportType::Pointer itkImporter = ImageImportType::New();
     this->ConnectPipelines( vtkExporter, itkImporter );
     itkImporter->Update();
 
     // calculate cropping bounding box
     m_InternalImageMask3D = itkImporter->GetOutput();
     m_InternalImageMask3D->SetDirection(image->GetDirection());
 
     itk::ImageRegionConstIterator<itkUCharImageType>
             itmask(m_InternalImageMask3D, m_InternalImageMask3D->GetLargestPossibleRegion());
     itk::ImageRegionIterator<ImageType>
             itimage(image, image->GetLargestPossibleRegion());
 
     itmask.GoToBegin();
     itimage.GoToBegin();
 
     typename ImageType::SizeType lowersize = {{9999999999,9999999999,9999999999}};
     typename ImageType::SizeType uppersize = {{0,0,0}};
     while( !itmask.IsAtEnd() )
     {
         if(itmask.Get() == 0)
             itimage.Set(0);
         else
         {
             typename ImageType::IndexType index = itimage.GetIndex();
             typename ImageType::SizeType signedindex;
             signedindex[0] = index[0];
             signedindex[1] = index[1];
             signedindex[2] = index[2];
 
             lowersize[0] = signedindex[0] < lowersize[0] ? signedindex[0] : lowersize[0];
             lowersize[1] = signedindex[1] < lowersize[1] ? signedindex[1] : lowersize[1];
             lowersize[2] = signedindex[2] < lowersize[2] ? signedindex[2] : lowersize[2];
 
             uppersize[0] = signedindex[0] > uppersize[0] ? signedindex[0] : uppersize[0];
             uppersize[1] = signedindex[1] > uppersize[1] ? signedindex[1] : uppersize[1];
             uppersize[2] = signedindex[2] > uppersize[2] ? signedindex[2] : uppersize[2];
         }
 
         ++itmask;
         ++itimage;
     }
 
     typename ImageType::IndexType index;
     index[0] = lowersize[0];
     index[1] = lowersize[1];
     index[2] = lowersize[2];
 
     typename ImageType::SizeType size;
     size[0] = uppersize[0] - lowersize[0] + 1;
     size[1] = uppersize[1] - lowersize[1] + 1;
     size[2] = uppersize[2] - lowersize[2] + 1;
 
     itk::ImageRegion<3> cropRegion = itk::ImageRegion<3>(index, size);
 
     // crop internal mask
     typedef itk::RegionOfInterestImageFilter< itkUCharImageType, itkUCharImageType > ROIMaskFilterType;
     typename ROIMaskFilterType::Pointer roi2 = ROIMaskFilterType::New();
     roi2->SetRegionOfInterest(cropRegion);
     roi2->SetInput(m_InternalImageMask3D);
     roi2->Update();
     m_InternalImageMask3D = roi2->GetOutput();
 
     Image::Pointer tmpImage = Image::New();
     tmpImage->InitializeByItk(m_InternalImageMask3D.GetPointer());
     tmpImage->SetVolume(m_InternalImageMask3D->GetBufferPointer());
 
     Image::Pointer tmpImage2 = Image::New();
     tmpImage2->InitializeByItk(m_PlanarFigureImage.GetPointer());
     const BaseGeometry *pfImageGeometry3D = tmpImage2->GetGeometry( 0 );
 
     const BaseGeometry *intImageGeometry3D = tmpImage->GetGeometry( 0 );
 
     typedef itk::ImageRegionIteratorWithIndex<itkUCharImageType> IteratorType;
     IteratorType imageIterator (m_InternalImageMask3D, m_InternalImageMask3D->GetRequestedRegion());
     imageIterator.GoToBegin();
     while ( !imageIterator.IsAtEnd() )
     {
         unsigned char val = imageIterator.Value();
         if (val>0)
         {
             itk::Index<3> index = imageIterator.GetIndex();
             Point3D point;
             point[0] = index[0];
             point[1] = index[1];
             point[2] = index[2];
 
             intImageGeometry3D->IndexToWorld(point, point);
             pfImageGeometry3D->WorldToIndex(point, point);
 
             point[i0] += 0.5;
             point[i1] += 0.5;
 
             index[0] = point[0];
             index[1] = point[1];
             index[2] = point[2];
 
             if (pfImageGeometry3D->IsIndexInside(index))
                 m_PlanarFigureImage->SetPixel(index, 1);
         }
         ++imageIterator;
     }
 
     // Clean up VTK objects
     polyline->Delete();
     extrudeFilter->Delete();
     polyDataToImageStencil->Delete();
     vtkImporter->Delete();
     imageStencilFilter->Delete();
     //vtkExporter->Delete(); // TODO: crashes when outcommented; memory leak??
     delete[] ptIds;
 }
 
 void QmitkFiberProcessingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkFiberProcessingView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 void QmitkFiberProcessingView::UpdateGui()
 {
     m_Controls->m_FibLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_PfLabel->setText("<font color='grey'>needed for extraction</font>");
     m_Controls->m_InputData->setTitle("Please Select Input Data");
 
     m_Controls->m_RemoveButton->setEnabled(false);
 
     m_Controls->m_PlanarFigureButtonsFrame->setEnabled(false);
     m_Controls->PFCompoANDButton->setEnabled(false);
     m_Controls->PFCompoORButton->setEnabled(false);
     m_Controls->PFCompoNOTButton->setEnabled(false);
 
     m_Controls->m_GenerateRoiImage->setEnabled(false);
     m_Controls->m_ExtractFibersButton->setEnabled(false);
     m_Controls->m_ModifyButton->setEnabled(false);
 
     m_Controls->m_JoinBundles->setEnabled(false);
     m_Controls->m_SubstractBundles->setEnabled(false);
 
     // disable alle frames
     m_Controls->m_BundleWeightFrame->setVisible(false);
     m_Controls->m_ExtractionBoxMask->setVisible(false);
     m_Controls->m_ExtactionFramePF->setVisible(false);
     m_Controls->m_RemoveDirectionFrame->setVisible(false);
     m_Controls->m_RemoveLengthFrame->setVisible(false);
     m_Controls->m_RemoveCurvatureFrame->setVisible(false);
     m_Controls->m_SmoothFibersFrame->setVisible(false);
     m_Controls->m_CompressFibersFrame->setVisible(false);
     m_Controls->m_ColorFibersFrame->setVisible(false);
     m_Controls->m_MirrorFibersFrame->setVisible(false);
 
     bool pfSelected = !m_SelectedPF.empty();
     bool fibSelected = !m_SelectedFB.empty();
     bool multipleFibsSelected = (m_SelectedFB.size()>1);
     bool maskSelected = m_MaskImageNode.IsNotNull();
     bool imageSelected = m_SelectedImage.IsNotNull();
 
     // toggle visibility of elements according to selected method
     switch ( m_Controls->m_ExtractionMethodBox->currentIndex() )
     {
     case 0:
         m_Controls->m_ExtactionFramePF->setVisible(true);
         break;
     case 1:
         m_Controls->m_ExtractionBoxMask->setVisible(true);
         break;
     }
 
     switch ( m_Controls->m_RemovalMethodBox->currentIndex() )
     {
     case 0:
         m_Controls->m_RemoveDirectionFrame->setVisible(true);
         if ( fibSelected )
             m_Controls->m_RemoveButton->setEnabled(true);
         break;
     case 1:
         m_Controls->m_RemoveLengthFrame->setVisible(true);
         if ( fibSelected )
             m_Controls->m_RemoveButton->setEnabled(true);
         break;
     case 2:
         m_Controls->m_RemoveCurvatureFrame->setVisible(true);
         if ( fibSelected )
             m_Controls->m_RemoveButton->setEnabled(true);
         break;
     case 3:
         break;
     case 4:
         break;
     }
 
     switch ( m_Controls->m_ModificationMethodBox->currentIndex() )
     {
     case 0:
         m_Controls->m_SmoothFibersFrame->setVisible(true);
         break;
     case 1:
         m_Controls->m_CompressFibersFrame->setVisible(true);
         break;
     case 2:
         m_Controls->m_ColorFibersFrame->setVisible(true);
         break;
     case 3:
         m_Controls->m_MirrorFibersFrame->setVisible(true);
         break;
     case 4:
         m_Controls->m_BundleWeightFrame->setVisible(true);
     }
 
     // are fiber bundles selected?
     if ( fibSelected )
     {
         m_Controls->m_ModifyButton->setEnabled(true);
         m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
         m_Controls->m_FibLabel->setText(QString(m_SelectedFB.at(0)->GetName().c_str()));
 
         // one bundle and one planar figure needed to extract fibers
         if (pfSelected)
         {
             m_Controls->m_InputData->setTitle("Input Data");
             m_Controls->m_PfLabel->setText(QString(m_SelectedPF.at(0)->GetName().c_str()));
             m_Controls->m_ExtractFibersButton->setEnabled(true);
         }
 
         // more than two bundles needed to join/subtract
         if (multipleFibsSelected)
         {
             m_Controls->m_FibLabel->setText("multiple bundles selected");
 
             m_Controls->m_JoinBundles->setEnabled(true);
             m_Controls->m_SubstractBundles->setEnabled(true);
         }
 
         if (maskSelected)
         {
             m_Controls->m_RemoveButton->setEnabled(true);
             m_Controls->m_ExtractFibersButton->setEnabled(true);
         }
     }
 
     // are planar figures selected?
     if (pfSelected)
     {
         if ( fibSelected || m_SelectedImage.IsNotNull())
             m_Controls->m_GenerateRoiImage->setEnabled(true);
 
         if (m_SelectedPF.size() > 1)
         {
             m_Controls->PFCompoANDButton->setEnabled(true);
             m_Controls->PFCompoORButton->setEnabled(true);
         }
         else
             m_Controls->PFCompoNOTButton->setEnabled(true);
     }
 
     // is image selected
     if (imageSelected || maskSelected)
     {
         m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
     }
 }
 
 void QmitkFiberProcessingView::NodeRemoved(const mitk::DataNode* node)
 {
     std::vector<mitk::DataNode*> nodes;
     OnSelectionChanged(nodes);
 }
 
 void QmitkFiberProcessingView::NodeAdded(const mitk::DataNode* node)
 {
     std::vector<mitk::DataNode*> nodes;
     OnSelectionChanged(nodes);
 }
 
 void QmitkFiberProcessingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     //reset existing Vectors containing FiberBundles and PlanarFigures from a previous selection
     m_SelectedFB.clear();
     m_SelectedPF.clear();
     m_SelectedSurfaces.clear();
     m_SelectedImage = NULL;
     m_MaskImageNode = NULL;
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
-        if ( dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
+        if ( dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
             m_SelectedFB.push_back(node);
         else if (dynamic_cast<mitk::PlanarPolygon*>(node->GetData()) || dynamic_cast<mitk::PlanarFigureComposite*>(node->GetData()) || dynamic_cast<mitk::PlanarCircle*>(node->GetData()))
             m_SelectedPF.push_back(node);
         else if (dynamic_cast<mitk::Image*>(node->GetData()))
         {
             m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
             bool isBinary = false;
             node->GetPropertyValue<bool>("binary", isBinary);
             if (isBinary)
                 m_MaskImageNode = node;
         }
         else if (dynamic_cast<mitk::Surface*>(node->GetData()))
             m_SelectedSurfaces.push_back(dynamic_cast<mitk::Surface*>(node->GetData()));
     }
 
     if (m_SelectedFB.empty())
     {
         int maxLayer = 0;
         itk::VectorContainer<unsigned int, mitk::DataNode::Pointer>::ConstPointer nodes = this->GetDefaultDataStorage()->GetAll();
         for (unsigned int i=0; i<nodes->Size(); i++)
-            if (dynamic_cast<mitk::FiberBundleX*>(nodes->at(i)->GetData()))
+            if (dynamic_cast<mitk::FiberBundle*>(nodes->at(i)->GetData()))
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(nodes->at(i));
                 if (sources->Size()>0)
                     continue;
 
                 int layer = 0;
                 nodes->at(i)->GetPropertyValue("layer", layer);
                 if (layer>=maxLayer)
                 {
                     maxLayer = layer;
                     m_SelectedFB.clear();
                     m_SelectedFB.push_back(nodes->at(i));
                 }
             }
     }
 
     if (m_SelectedPF.empty())
     {
         int maxLayer = 0;
         itk::VectorContainer<unsigned int, mitk::DataNode::Pointer>::ConstPointer nodes = this->GetDefaultDataStorage()->GetAll();
         for (unsigned int i=0; i<nodes->Size(); i++)
             if (dynamic_cast<mitk::PlanarPolygon*>(nodes->at(i)->GetData()) || dynamic_cast<mitk::PlanarFigureComposite*>(nodes->at(i)->GetData()) || dynamic_cast<mitk::PlanarCircle*>(nodes->at(i)->GetData()))
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(nodes->at(i));
                 if (sources->Size()>0)
                     continue;
 
                 int layer = 0;
                 nodes->at(i)->GetPropertyValue("layer", layer);
                 if (layer>=maxLayer)
                 {
                     maxLayer = layer;
                     m_SelectedPF.clear();
                     m_SelectedPF.push_back(nodes->at(i));
                 }
             }
     }
 
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::OnDrawPolygon()
 {
     mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
     figure->ClosedOn();
     this->AddFigureToDataStorage(figure, QString("Polygon%1").arg(++m_PolygonCounter));
 }
 
 void QmitkFiberProcessingView::OnDrawCircle()
 {
     mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
     this->AddFigureToDataStorage(figure, QString("Circle%1").arg(++m_CircleCounter));
 }
 
 void QmitkFiberProcessingView::Activated()
 {
 
 }
 
 void QmitkFiberProcessingView::AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name, const char *, mitk::BaseProperty* )
 {
     // initialize figure's geometry with empty geometry
     mitk::PlaneGeometry::Pointer emptygeometry = mitk::PlaneGeometry::New();
     figure->SetPlaneGeometry( emptygeometry );
 
     //set desired data to DataNode where Planarfigure is stored
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     newNode->SetName(name.toStdString());
     newNode->SetData(figure);
     newNode->SetBoolProperty("planarfigure.3drendering", true);
 
     mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(newNode->GetDataInteractor().GetPointer());
     if(figureInteractor.IsNull())
     {
         figureInteractor = mitk::PlanarFigureInteractor::New();
         us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
         figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
         figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
         figureInteractor->SetDataNode(newNode);
     }
 
     // figure drawn on the topmost layer / image
     GetDataStorage()->Add(newNode );
 
     for(unsigned int i = 0; i < m_SelectedPF.size(); i++)
         m_SelectedPF[i]->SetSelected(false);
 
     newNode->SetSelected(true);
     m_SelectedPF.clear();
     m_SelectedPF.push_back(newNode);
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::ExtractWithPlanarFigure()
 {
     if ( m_SelectedFB.empty() || m_SelectedPF.empty() ){
         QMessageBox::information( NULL, "Warning", "No fibe bundle selected!");
         return;
     }
 
     std::vector<mitk::DataNode::Pointer> fiberBundles = m_SelectedFB;
     mitk::DataNode::Pointer planarFigure = m_SelectedPF.at(0);
     for (unsigned int i=0; i<fiberBundles.size(); i++)
     {
-        mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(fiberBundles.at(i)->GetData());
+        mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(fiberBundles.at(i)->GetData());
         mitk::BaseData::Pointer roi = planarFigure->GetData();
 
-        mitk::FiberBundleX::Pointer extFB = fib->ExtractFiberSubset(roi);
+        mitk::FiberBundle::Pointer extFB = fib->ExtractFiberSubset(roi);
         if (extFB->GetNumFibers()<=0)
         {
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
             continue;
         }
 
         mitk::DataNode::Pointer node;
         node = mitk::DataNode::New();
         node->SetData(extFB);
         QString name(fiberBundles.at(i)->GetName().c_str());
         name += "_";
         name += planarFigure->GetName().c_str();
         node->SetName(name.toStdString());
         fiberBundles.at(i)->SetVisibility(false);
         GetDataStorage()->Add(node);
     }
 }
 
 void QmitkFiberProcessingView::GenerateAndComposite()
 {
     mitk::PlanarFigureComposite::Pointer PFCAnd = mitk::PlanarFigureComposite::New();
     PFCAnd->setOperationType(mitk::PFCOMPOSITION_AND_OPERATION);
     for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin(); it != m_SelectedPF.end(); ++it )
     {
         mitk::DataNode::Pointer nodePF = *it;
         PFCAnd->addPlanarFigure( nodePF->GetData() );
         PFCAnd->addDataNode( nodePF );
         PFCAnd->setDisplayName("AND");
     }
     AddCompositeToDatastorage(PFCAnd);
 }
 
 void QmitkFiberProcessingView::GenerateOrComposite()
 {
     mitk::PlanarFigureComposite::Pointer PFCOr = mitk::PlanarFigureComposite::New();
     PFCOr->setOperationType(mitk::PFCOMPOSITION_OR_OPERATION);
     for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin(); it != m_SelectedPF.end(); ++it )
     {
         mitk::DataNode::Pointer nodePF = *it;
         PFCOr->addPlanarFigure( nodePF->GetData() );
         PFCOr->addDataNode( nodePF );
         PFCOr->setDisplayName("OR");
     }
     AddCompositeToDatastorage(PFCOr);
 }
 
 void QmitkFiberProcessingView::GenerateNotComposite()
 {
     mitk::PlanarFigureComposite::Pointer PFCNot = mitk::PlanarFigureComposite::New();
     PFCNot->setOperationType(mitk::PFCOMPOSITION_NOT_OPERATION);
     for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin(); it != m_SelectedPF.end(); ++it )
     {
         mitk::DataNode::Pointer nodePF = *it;
         PFCNot->addPlanarFigure( nodePF->GetData() );
         PFCNot->addDataNode( nodePF );
         PFCNot->setDisplayName("NOT");
     }
     AddCompositeToDatastorage(PFCNot);
 }
 
 /* CLEANUP NEEDED */
 void QmitkFiberProcessingView::AddCompositeToDatastorage(mitk::PlanarFigureComposite::Pointer pfc, mitk::DataNode::Pointer parentNode )
 {
     mitk::DataNode::Pointer newPFCNode;
     newPFCNode = mitk::DataNode::New();
     newPFCNode->SetName( pfc->getDisplayName() );
     newPFCNode->SetData(pfc);
 
     switch (pfc->getOperationType()) {
     case 0:
     {
         if (parentNode.IsNotNull())
             GetDataStorage()->Add(newPFCNode, parentNode);
         else
             GetDataStorage()->Add(newPFCNode);
 
         //iterate through its childs
         for(int i=0; i<pfc->getNumberOfChildren(); ++i)
         {
             mitk::BaseData::Pointer tmpPFchild = pfc->getChildAt(i);
             mitk::DataNode::Pointer savedPFchildNode = pfc->getDataNodeAt(i);
 
             mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
             if ( pfcompcast.IsNotNull() )
             {
                 // child is of type planar Figure composite
                 // make new node of the child, cuz later the child has to be removed of its old position in datamanager
                 // feed new dataNode with information of the savedDataNode, which is gonna be removed soon
                 mitk::DataNode::Pointer newChildPFCNode;
                 newChildPFCNode = mitk::DataNode::New();
                 newChildPFCNode->SetData(tmpPFchild);
                 newChildPFCNode->SetName( savedPFchildNode->GetName() );
                 pfcompcast->setDisplayName(  savedPFchildNode->GetName()  ); //name might be changed in DataManager by user
 
                 //update inside vector the dataNodePointer
                 pfc->replaceDataNodeAt(i, newChildPFCNode);
 
                 AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
 
                 // remove savedNode here, cuz otherwise its children will change their position in the dataNodeManager
                 // without having its parent anymore
                 GetDataStorage()->Remove(savedPFchildNode);
             }
             else
             {
                 // child is not of type PlanarFigureComposite, so its one of the planarFigures
                 // create new dataNode containing the data of the old dataNode, but position in dataManager will be
                 // modified cuz we re setting a (new) parent.
                 mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
                 newPFchildNode->SetName(savedPFchildNode->GetName() );
                 newPFchildNode->SetData(tmpPFchild);
                 newPFchildNode->SetVisibility(true);
                 newPFchildNode->SetBoolProperty("planarfigure.3drendering", true);
 
                 // replace the dataNode in PFComp DataNodeVector
                 pfc->replaceDataNodeAt(i, newPFchildNode);
 
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
 
                 //add new child to datamanager with its new position as child of newPFCNode parent
                 GetDataStorage()->Add(newPFchildNode, newPFCNode);
             }
         }
         break;
     }
     case 1:
     {
         if (!parentNode.IsNull())
             GetDataStorage()->Add(newPFCNode, parentNode);
         else
             GetDataStorage()->Add(newPFCNode);
 
         for(int i=0; i<pfc->getNumberOfChildren(); ++i)
         {
             mitk::BaseData::Pointer tmpPFchild = pfc->getChildAt(i);
             mitk::DataNode::Pointer savedPFchildNode = pfc->getDataNodeAt(i);
             mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
             if ( !pfcompcast.IsNull() )
             {
                 // child is of type planar Figure composite
                 // make new node of the child, cuz later the child has to be removed of its old position in datamanager
                 // feed new dataNode with information of the savedDataNode, which is gonna be removed soon
                 mitk::DataNode::Pointer newChildPFCNode;
                 newChildPFCNode = mitk::DataNode::New();
                 newChildPFCNode->SetData(tmpPFchild);
                 newChildPFCNode->SetName( savedPFchildNode->GetName() );
                 pfcompcast->setDisplayName(  savedPFchildNode->GetName()  ); //name might be changed in DataManager by user
 
                 //update inside vector the dataNodePointer
                 pfc->replaceDataNodeAt(i, newChildPFCNode);
 
                 AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
 
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
             }
             else
             {
                 // child is not of type PlanarFigureComposite, so its one of the planarFigures
                 // create new dataNode containing the data of the old dataNode, but position in dataManager will be
                 // modified cuz we re setting a (new) parent.
                 mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
                 newPFchildNode->SetName(savedPFchildNode->GetName() );
                 newPFchildNode->SetData(tmpPFchild);
                 newPFchildNode->SetVisibility(true);
                 newPFchildNode->SetBoolProperty("planarfigure.3drendering", true);
 
                 // replace the dataNode in PFComp DataNodeVector
                 pfc->replaceDataNodeAt(i, newPFchildNode);
 
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
 
                 //add new child to datamanager with its new position as child of newPFCNode parent
                 GetDataStorage()->Add(newPFchildNode, newPFCNode);
             }
         }
         break;
     }
     case 2:
     {
         if (!parentNode.IsNull())
             GetDataStorage()->Add(newPFCNode, parentNode);
         else
             GetDataStorage()->Add(newPFCNode);
 
         //iterate through its childs
         for(int i=0; i<pfc->getNumberOfChildren(); ++i)
         {
             mitk::BaseData::Pointer tmpPFchild = pfc->getChildAt(i);
             mitk::DataNode::Pointer savedPFchildNode = pfc->getDataNodeAt(i);
 
             mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
             if ( !pfcompcast.IsNull() )
             { // child is of type planar Figure composite
                 // makeRemoveBundle new node of the child, cuz later the child has to be removed of its old position in datamanager
                 // feed new dataNode with information of the savedDataNode, which is gonna be removed soon
                 mitk::DataNode::Pointer newChildPFCNode;
                 newChildPFCNode = mitk::DataNode::New();
                 newChildPFCNode->SetData(tmpPFchild);
                 newChildPFCNode->SetName( savedPFchildNode->GetName() );
                 pfcompcast->setDisplayName( savedPFchildNode->GetName() ); //name might be changed in DataManager by user
 
                 //update inside vector the dataNodePointer
                 pfc->replaceDataNodeAt(i, newChildPFCNode);
 
                 AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
 
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
             }
             else
             {
                 // child is not of type PlanarFigureComposite, so its one of the planarFigures
                 // create new dataNode containing the data of the old dataNode, but position in dataManager will be
                 // modified cuz we re setting a (new) parent.
                 mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
                 newPFchildNode->SetName(savedPFchildNode->GetName() );
                 newPFchildNode->SetData(tmpPFchild);
                 newPFchildNode->SetVisibility(true);
                 newPFchildNode->SetBoolProperty("planarfigure.3drendering", true);
 
                 // replace the dataNode in PFComp DataNodeVector
                 pfc->replaceDataNodeAt(i, newPFchildNode);
 
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
 
                 //add new child to datamanager with its new position as child of newPFCNode parent
                 GetDataStorage()->Add(newPFchildNode, newPFCNode);
             }
         }
         break;
     }
     default:
         MITK_DEBUG << "we have an UNDEFINED composition... ERROR" ;
         break;
     }
 
     for(unsigned int i = 0; i < m_SelectedPF.size(); i++)
         m_SelectedPF[i]->SetSelected(false);
 
     newPFCNode->SetSelected(true);
     m_SelectedPF.clear();
     m_SelectedPF.push_back(newPFCNode);
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::JoinBundles()
 {
     if ( m_SelectedFB.size()<2 ){
         QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
         MITK_WARN("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
         return;
     }
 
-    mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(0)->GetData());
+    mitk::FiberBundle::Pointer newBundle = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData());
     m_SelectedFB.at(0)->SetVisibility(false);
     QString name("");
     name += QString(m_SelectedFB.at(0)->GetName().c_str());
     for (unsigned int i=1; i<m_SelectedFB.size(); i++)
     {
-        newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData()));
+        newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(i)->GetData()));
         name += "+"+QString(m_SelectedFB.at(i)->GetName().c_str());
         m_SelectedFB.at(i)->SetVisibility(false);
     }
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newBundle);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode);
 }
 
 void QmitkFiberProcessingView::SubstractBundles()
 {
     if ( m_SelectedFB.size()<2 ){
         QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
         MITK_WARN("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
         return;
     }
 
-    mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(0)->GetData());
+    mitk::FiberBundle::Pointer newBundle = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData());
     m_SelectedFB.at(0)->SetVisibility(false);
     QString name("");
     name += QString(m_SelectedFB.at(0)->GetName().c_str());
     for (unsigned int i=1; i<m_SelectedFB.size(); i++)
     {
-        newBundle = newBundle->SubtractBundle(dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData()));
+        newBundle = newBundle->SubtractBundle(dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(i)->GetData()));
         if (newBundle.IsNull())
             break;
         name += "-"+QString(m_SelectedFB.at(i)->GetName().c_str());
         m_SelectedFB.at(i)->SetVisibility(false);
     }
     if (newBundle.IsNull())
     {
         QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers. Did you select the fiber bundles in the correct order? X-Y is not equal to Y-X!");
         return;
     }
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newBundle);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode);
 }
 
 void QmitkFiberProcessingView::ResampleSelectedBundles()
 {
     double factor = this->m_Controls->m_SmoothFibersBox->value();
     for (unsigned int i=0; i<m_SelectedFB.size(); i++)
     {
-        mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
+        mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(i)->GetData());
         fib->ResampleSpline(factor);
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::CompressSelectedBundles()
 {
     double factor = this->m_Controls->m_ErrorThresholdBox->value();
     for (unsigned int i=0; i<m_SelectedFB.size(); i++)
     {
-        mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
+        mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(i)->GetData());
         fib->Compress(factor);
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::DoImageColorCoding()
 {
     if (m_Controls->m_ColorMapBox->GetSelectedNode().IsNull())
     {
         QMessageBox::information(NULL, "Bundle coloring aborted:", "No image providing the scalar values for coloring the selected bundle available.");
         return;
     }
 
     for(unsigned int i=0; i<m_SelectedFB.size(); i++ )
     {
-        mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
+        mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(i)->GetData());
         fib->ColorFibersByScalarMap(dynamic_cast<mitk::Image*>(m_Controls->m_ColorMapBox->GetSelectedNode()->GetData()), m_Controls->m_FiberOpacityBox->isChecked());
     }
 
     if(m_MultiWidget)
         m_MultiWidget->RequestUpdate();
 }
 
 
 void QmitkFiberProcessingView::MirrorFibers()
 {
     unsigned int axis = this->m_Controls->m_MirrorFibersBox->currentIndex();
     for (int i=0; i<m_SelectedFB.size(); i++)
     {
-        mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
+        mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(i)->GetData());
         fib->MirrorFibers(axis);
     }
 
     if (m_SelectedSurfaces.size()>0)
     {
         for (int i=0; i<m_SelectedSurfaces.size(); i++)
         {
             mitk::Surface::Pointer surf = m_SelectedSurfaces.at(i);
             vtkSmartPointer<vtkPolyData> poly = surf->GetVtkPolyData();
             vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
 
             for (int i=0; i<poly->GetNumberOfPoints(); i++)
             {
                 double* point = poly->GetPoint(i);
                 point[axis] *= -1;
                 vtkNewPoints->InsertNextPoint(point);
             }
             poly->SetPoints(vtkNewPoints);
             surf->CalculateBoundingBox();
         }
     }
 
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.h
index 24d0569311..f94facd239 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.h
@@ -1,189 +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.
 
 ===================================================================*/
 
 #ifndef QmitkFiberProcessingView_h
 #define QmitkFiberProcessingView_h
 
 #include <QmitkFunctionality.h>
 #include "ui_QmitkFiberProcessingViewControls.h"
 
 #include <mitkPlanarFigureComposite.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <mitkSurface.h>
 
 #include <itkCastImageFilter.h>
 #include <itkVTKImageImport.h>
 #include <itkVTKImageExport.h>
 #include <itkRegionOfInterestImageFilter.h>
 
 #include <vtkLinearExtrusionFilter.h>
 #include <vtkPolyDataToImageStencil.h>
 #include <vtkSelectEnclosedPoints.h>
 #include <vtkImageImport.h>
 #include <vtkImageExport.h>
 #include <vtkImageStencil.h>
 #include <vtkSmartPointer.h>
 #include <vtkSelection.h>
 #include <vtkSelectionNode.h>
 #include <vtkExtractSelectedThresholds.h>
 #include <vtkFloatArray.h>
 
 /*!
 \brief View to process fiber bundles. Supplies methods to extract fibers from the bundle, join and subtract bundles and much more.
 
 \sa QmitkFunctionality
 \ingroup Functionalities
 */
 class QmitkFiberProcessingView : public QmitkFunctionality
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   typedef itk::Image< unsigned char, 3 >    itkUCharImageType;
 
   static const std::string VIEW_ID;
 
   QmitkFiberProcessingView();
   virtual ~QmitkFiberProcessingView();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
   virtual void Activated();
 
 protected slots:
 
   void OnDrawCircle();          ///< add circle interactors etc.
   void OnDrawPolygon();         ///< add circle interactors etc.
   void GenerateAndComposite();
   void GenerateOrComposite();
   void GenerateNotComposite();
 
   void JoinBundles();               ///< merge selected fiber bundles
   void SubstractBundles();          ///< subtract bundle A from bundle B. Not commutative! Defined by order of selection.
   void GenerateRoiImage();          ///< generate binary image of selected planar figures.
 
   void Remove();
   void Extract();
   void Modify();
   void UpdateGui();     ///< update button activity etc. dpending on current datamanager selection
 
   virtual void AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name, const char *propertyKey = NULL, mitk::BaseProperty *property = NULL );
 
 protected:
 
   void MirrorFibers();              ///< mirror bundle on the specified plane
   void ResampleSelectedBundles();   ///< smooth fiber bundle using the specified number of sampling points per cm.
   void DoImageColorCoding();        ///< color fibers by selected scalar image
   void CompressSelectedBundles();   ///< remove points below certain error threshold
   void WeightFibers();
 
   void RemoveWithMask(bool removeInside);
   void RemoveDir();
   void ApplyCurvatureThreshold();   ///< remove/split fibers with a too high curvature threshold
   void PruneBundle();               ///< remove too short/too long fibers
 
   void ExtractWithMask(bool onlyEnds, bool invert);
   void ExtractWithPlanarFigure();
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
 
   Ui::QmitkFiberProcessingViewControls* m_Controls;
   QmitkStdMultiWidget* m_MultiWidget;
 
   /** Connection from VTK to ITK */
   template <typename VTK_Exporter, typename ITK_Importer>
       void ConnectPipelines(VTK_Exporter* exporter, ITK_Importer importer)
   {
     importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
 
     importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
     importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
     importer->SetSpacingCallback(exporter->GetSpacingCallback());
     importer->SetOriginCallback(exporter->GetOriginCallback());
     importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
 
     importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
 
     importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
     importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
     importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
     importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
     importer->SetCallbackUserData(exporter->GetCallbackUserData());
   }
 
   template <typename ITK_Exporter, typename VTK_Importer>
       void ConnectPipelines(ITK_Exporter exporter, VTK_Importer* importer)
   {
     importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
 
     importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
     importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
     importer->SetSpacingCallback(exporter->GetSpacingCallback());
     importer->SetOriginCallback(exporter->GetOriginCallback());
     importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
 
     importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
 
     importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
     importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
     importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
     importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
     importer->SetCallbackUserData(exporter->GetCallbackUserData());
   }
 
   template < typename TPixel, unsigned int VImageDimension >
       void InternalCalculateMaskFromPlanarFigure(
           itk::Image< TPixel, VImageDimension > *image, unsigned int axis, std::string nodeName );
 
   template < typename TPixel, unsigned int VImageDimension >
       void InternalReorientImagePlane(
         const itk::Image< TPixel, VImageDimension > *image, mitk::BaseGeometry* planegeo3D, int additionalIndex );
 
   int m_CircleCounter;                                      ///< used for data node naming
   int m_PolygonCounter;                                     ///< used for data node naming
   std::vector<mitk::DataNode::Pointer>  m_SelectedFB;       ///< selected fiber bundle nodes
   std::vector<mitk::DataNode::Pointer>  m_SelectedPF;       ///< selected planar figure nodes
   std::vector<mitk::Surface::Pointer>   m_SelectedSurfaces;
   mitk::Image::Pointer                  m_SelectedImage;
   mitk::Image::Pointer                  m_InternalImage;
   mitk::PlanarFigure::Pointer           m_PlanarFigure;
   itkUCharImageType::Pointer            m_InternalImageMask3D;
   itkUCharImageType::Pointer            m_PlanarFigureImage;
   float                                 m_UpsamplingFactor; ///< upsampling factor for all image generations
   mitk::DataNode::Pointer               m_MaskImageNode;
 
   void AddCompositeToDatastorage(mitk::PlanarFigureComposite::Pointer pfc, mitk::DataNode::Pointer parentNode=NULL);
   void debugPFComposition(mitk::PlanarFigureComposite::Pointer , int );
   void WritePfToImage(mitk::DataNode::Pointer node, mitk::Image* image);
-  mitk::DataNode::Pointer GenerateTractDensityImage(mitk::FiberBundleX::Pointer fib, bool binary, bool absolute);
-  mitk::DataNode::Pointer GenerateColorHeatmap(mitk::FiberBundleX::Pointer fib);
-  mitk::DataNode::Pointer GenerateFiberEndingsImage(mitk::FiberBundleX::Pointer fib);
-  mitk::DataNode::Pointer GenerateFiberEndingsPointSet(mitk::FiberBundleX::Pointer fib);
+  mitk::DataNode::Pointer GenerateTractDensityImage(mitk::FiberBundle::Pointer fib, bool binary, bool absolute);
+  mitk::DataNode::Pointer GenerateColorHeatmap(mitk::FiberBundle::Pointer fib);
+  mitk::DataNode::Pointer GenerateFiberEndingsImage(mitk::FiberBundle::Pointer fib);
+  mitk::DataNode::Pointer GenerateFiberEndingsPointSet(mitk::FiberBundle::Pointer fib);
 
   void NodeAdded( const mitk::DataNode* node );
   void NodeRemoved(const mitk::DataNode* node);
 };
 
 
 
 #endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp
index e12f09e205..67114abb21 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp
@@ -1,442 +1,442 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberQuantificationView.h"
 #include <QmitkStdMultiWidget.h>
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkNodePredicateProperty.h>
 #include <mitkImageCast.h>
 #include <mitkPointSet.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarRectangle.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkDataNodeObject.h>
 #include <mitkTensorImage.h>
 
 // ITK
 #include <itkResampleImageFilter.h>
 #include <itkGaussianInterpolateImageFunction.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkTractsToFiberEndingsImageFilter.h>
 #include <itkTractDensityImageFilter.h>
 #include <itkImageRegion.h>
 #include <itkTractsToRgbaImageFilter.h>
 #include <itkTractsToVectorImageFilter.h>
 
 #include <math.h>
 #include <boost/lexical_cast.hpp>
 
 const std::string QmitkFiberQuantificationView::VIEW_ID = "org.mitk.views.fiberquantification";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace mitk;
 
 QmitkFiberQuantificationView::QmitkFiberQuantificationView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
     , m_UpsamplingFactor(5)
 {
 
 }
 
 // Destructor
 QmitkFiberQuantificationView::~QmitkFiberQuantificationView()
 {
 
 }
 
 void QmitkFiberQuantificationView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFiberQuantificationViewControls;
         m_Controls->setupUi( parent );
 
         connect( m_Controls->m_ProcessFiberBundleButton, SIGNAL(clicked()), this, SLOT(ProcessSelectedBundles()) );
         connect( m_Controls->m_ExtractFiberPeaks, SIGNAL(clicked()), this, SLOT(CalculateFiberDirections()) );
     }
 }
 
 void QmitkFiberQuantificationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkFiberQuantificationView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 void QmitkFiberQuantificationView::CalculateFiberDirections()
 {
     typedef itk::Image<unsigned char, 3>                                            ItkUcharImgType;
     typedef itk::Image< itk::Vector< float, 3>, 3 >                                 ItkDirectionImage3DType;
     typedef itk::VectorContainer< unsigned int, ItkDirectionImage3DType::Pointer >  ItkDirectionImageContainerType;
 
     // load fiber bundle
-    mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.back()->GetData());
+    mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.back()->GetData());
 
     itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
     if (m_SelectedImage.IsNotNull())
     {
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         mitk::CastToItkImage<ItkUcharImgType>(m_SelectedImage, itkMaskImage);
         fOdfFilter->SetMaskImage(itkMaskImage);
     }
 
     // extract directions from fiber bundle
     fOdfFilter->SetFiberBundle(inputTractogram);
     fOdfFilter->SetAngularThreshold(cos(m_Controls->m_AngularThreshold->value()*M_PI/180));
     fOdfFilter->SetNormalizeVectors(m_Controls->m_NormalizeDirectionsBox->isChecked());
     fOdfFilter->SetUseWorkingCopy(true);
     fOdfFilter->SetCreateDirectionImages(m_Controls->m_DirectionImagesBox->isChecked());
     fOdfFilter->SetSizeThreshold(m_Controls->m_PeakThreshold->value());
     fOdfFilter->SetMaxNumDirections(m_Controls->m_MaxNumDirections->value());
     fOdfFilter->Update();
 
     QString name = m_SelectedFB.back()->GetName().c_str();
 
     if (m_Controls->m_VectorFieldBox->isChecked())
     {
         float minSpacing = 1;
         if (m_SelectedImage.IsNotNull())
         {
             mitk::Vector3D outImageSpacing = m_SelectedImage->GetGeometry()->GetSpacing();
 
             if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
                 minSpacing = outImageSpacing[0];
             else if (outImageSpacing[1] < outImageSpacing[2])
                 minSpacing = outImageSpacing[1];
             else
                 minSpacing = outImageSpacing[2];
         }
 
-        mitk::FiberBundleX::Pointer directions = fOdfFilter->GetOutputFiberBundle();
+        mitk::FiberBundle::Pointer directions = fOdfFilter->GetOutputFiberBundle();
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData(directions);
         node->SetName((name+"_vectorfield").toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         node->SetProperty("color", mitk::ColorProperty::New(1.0f, 1.0f, 1.0f));
 
         GetDefaultDataStorage()->Add(node, m_SelectedFB.back());
     }
 
     if (m_Controls->m_NumDirectionsBox->isChecked())
     {
         mitk::Image::Pointer mitkImage = mitk::Image::New();
         mitkImage->InitializeByItk( fOdfFilter->GetNumDirectionsImage().GetPointer() );
         mitkImage->SetVolume( fOdfFilter->GetNumDirectionsImage()->GetBufferPointer() );
 
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData(mitkImage);
         node->SetName((name+"_numdirections").toStdString().c_str());
         GetDefaultDataStorage()->Add(node, m_SelectedFB.back());
     }
 
     if (m_Controls->m_DirectionImagesBox->isChecked())
     {
         ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
         for (unsigned int i=0; i<directionImageContainer->Size(); i++)
         {
             itk::TractsToVectorImageFilter<float>::ItkDirectionImageType::Pointer itkImg = directionImageContainer->GetElement(i);
 
             if (itkImg.IsNull())
                 return;
 
             mitk::Image::Pointer mitkImage = mitk::Image::New();
             mitkImage->InitializeByItk( itkImg.GetPointer() );
             mitkImage->SetVolume( itkImg->GetBufferPointer() );
 
             mitk::DataNode::Pointer node = mitk::DataNode::New();
             node->SetData(mitkImage);
             node->SetName( (name+"_direction_"+boost::lexical_cast<std::string>(i).c_str()).toStdString().c_str());
             node->SetVisibility(false);
             GetDefaultDataStorage()->Add(node, m_SelectedFB.back());
         }
     }
 }
 
 void QmitkFiberQuantificationView::UpdateGui()
 {
     m_Controls->m_ProcessFiberBundleButton->setEnabled(!m_SelectedFB.empty());
     m_Controls->m_ExtractFiberPeaks->setEnabled(!m_SelectedFB.empty());
 }
 
 void QmitkFiberQuantificationView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     //reset existing Vectors containing FiberBundles and PlanarFigures from a previous selection
     m_SelectedFB.clear();
     m_SelectedSurfaces.clear();
     m_SelectedImage = NULL;
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
-        if ( dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
+        if ( dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
         {
             m_SelectedFB.push_back(node);
         }
         else if (dynamic_cast<mitk::Image*>(node->GetData()))
             m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
         else if (dynamic_cast<mitk::Surface*>(node->GetData()))
         {
             m_SelectedSurfaces.push_back(dynamic_cast<mitk::Surface*>(node->GetData()));
         }
     }
     UpdateGui();
     GenerateStats();
 }
 
 void QmitkFiberQuantificationView::Activated()
 {
 
 }
 
 void QmitkFiberQuantificationView::GenerateStats()
 {
     if ( m_SelectedFB.empty() )
         return;
 
     QString stats("");
 
     for( int i=0; i<m_SelectedFB.size(); i++ )
     {
         mitk::DataNode::Pointer node = m_SelectedFB[i];
-        if (node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()))
+        if (node.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(node->GetData()))
         {
             if (i>0)
                 stats += "\n-----------------------------\n";
             stats += QString(node->GetName().c_str()) + "\n";
-            mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
+            mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
             stats += "Number of fibers: "+ QString::number(fib->GetNumFibers()) + "\n";
             stats += "Number of points: "+ QString::number(fib->GetNumberOfPoints()) + "\n";
             stats += "Min. length:         "+ QString::number(fib->GetMinFiberLength(),'f',1) + " mm\n";
             stats += "Max. length:         "+ QString::number(fib->GetMaxFiberLength(),'f',1) + " mm\n";
             stats += "Mean length:         "+ QString::number(fib->GetMeanFiberLength(),'f',1) + " mm\n";
             stats += "Median length:       "+ QString::number(fib->GetMedianFiberLength(),'f',1) + " mm\n";
             stats += "Standard deviation:  "+ QString::number(fib->GetLengthStDev(),'f',1) + " mm\n";
         }
     }
     this->m_Controls->m_StatsTextEdit->setText(stats);
 }
 
 void QmitkFiberQuantificationView::ProcessSelectedBundles()
 {
     if ( m_SelectedFB.empty() ){
         QMessageBox::information( NULL, "Warning", "No fibe bundle selected!");
         MITK_WARN("QmitkFiberQuantificationView") << "no fibe bundle selected";
         return;
     }
 
     int generationMethod = m_Controls->m_GenerationBox->currentIndex();
 
     for( int i=0; i<m_SelectedFB.size(); i++ )
     {
         mitk::DataNode::Pointer node = m_SelectedFB[i];
-        if (node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()))
+        if (node.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(node->GetData()))
         {
-            mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
+            mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
             QString name(node->GetName().c_str());
             DataNode::Pointer newNode = NULL;
             switch(generationMethod){
             case 0:
                 newNode = GenerateTractDensityImage(fib, false, true);
                 name += "_TDI";
                 break;
             case 1:
                 newNode = GenerateTractDensityImage(fib, false, false);
                 name += "_TDI";
                 break;
             case 2:
                 newNode = GenerateTractDensityImage(fib, true, false);
                 name += "_envelope";
                 break;
             case 3:
                 newNode = GenerateColorHeatmap(fib);
                 break;
             case 4:
                 newNode = GenerateFiberEndingsImage(fib);
                 name += "_fiber_endings";
                 break;
             case 5:
                 newNode = GenerateFiberEndingsPointSet(fib);
                 name += "_fiber_endings";
                 break;
             }
             if (newNode.IsNotNull())
             {
                 newNode->SetName(name.toStdString());
                 GetDataStorage()->Add(newNode);
             }
         }
     }
 }
 
 // generate pointset displaying the fiber endings
-mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateFiberEndingsPointSet(mitk::FiberBundleX::Pointer fib)
+mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateFiberEndingsPointSet(mitk::FiberBundle::Pointer fib)
 {
     mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
     vtkSmartPointer<vtkPolyData> fiberPolyData = fib->GetFiberPolyData();
     vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
     vLines->InitTraversal();
 
     int count = 0;
     int numFibers = fib->GetNumFibers();
     for( int i=0; i<numFibers; i++ )
     {
         vtkIdType   numPoints(0);
         vtkIdType*  points(NULL);
         vLines->GetNextCell ( numPoints, points );
 
         if (numPoints>0)
         {
             double* point = fiberPolyData->GetPoint(points[0]);
             itk::Point<float,3> itkPoint;
             itkPoint[0] = point[0];
             itkPoint[1] = point[1];
             itkPoint[2] = point[2];
             pointSet->InsertPoint(count, itkPoint);
             count++;
         }
         if (numPoints>2)
         {
             double* point = fiberPolyData->GetPoint(points[numPoints-1]);
             itk::Point<float,3> itkPoint;
             itkPoint[0] = point[0];
             itkPoint[1] = point[1];
             itkPoint[2] = point[2];
             pointSet->InsertPoint(count, itkPoint);
             count++;
         }
     }
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( pointSet );
     return node;
 }
 
 // generate image displaying the fiber endings
-mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateFiberEndingsImage(mitk::FiberBundleX::Pointer fib)
+mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateFiberEndingsImage(mitk::FiberBundle::Pointer fib)
 {
     typedef unsigned char OutPixType;
     typedef itk::Image<OutPixType,3> OutImageType;
 
     typedef itk::TractsToFiberEndingsImageFilter< OutImageType > ImageGeneratorType;
     ImageGeneratorType::Pointer generator = ImageGeneratorType::New();
     generator->SetFiberBundle(fib);
     generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
     if (m_SelectedImage.IsNotNull())
     {
         OutImageType::Pointer itkImage = OutImageType::New();
         CastToItkImage(m_SelectedImage, itkImage);
         generator->SetInputImage(itkImage);
         generator->SetUseImageGeometry(true);
     }
     generator->Update();
 
     // get output image
     OutImageType::Pointer outImg = generator->GetOutput();
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     // init data node
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(img);
     return node;
 }
 
 // generate rgba heatmap from fiber bundle
-mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateColorHeatmap(mitk::FiberBundleX::Pointer fib)
+mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateColorHeatmap(mitk::FiberBundle::Pointer fib)
 {
     typedef itk::RGBAPixel<unsigned char> OutPixType;
     typedef itk::Image<OutPixType, 3> OutImageType;
     typedef itk::TractsToRgbaImageFilter< OutImageType > ImageGeneratorType;
     ImageGeneratorType::Pointer generator = ImageGeneratorType::New();
     generator->SetFiberBundle(fib);
     generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
     if (m_SelectedImage.IsNotNull())
     {
         itk::Image<unsigned char, 3>::Pointer itkImage = itk::Image<unsigned char, 3>::New();
         CastToItkImage(m_SelectedImage, itkImage);
         generator->SetInputImage(itkImage);
         generator->SetUseImageGeometry(true);
     }
     generator->Update();
 
     // get output image
     typedef itk::Image<OutPixType,3> OutType;
     OutType::Pointer outImg = generator->GetOutput();
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     // init data node
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(img);
     return node;
 }
 
 // generate tract density image from fiber bundle
-mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateTractDensityImage(mitk::FiberBundleX::Pointer fib, bool binary, bool absolute)
+mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateTractDensityImage(mitk::FiberBundle::Pointer fib, bool binary, bool absolute)
 {
     typedef float OutPixType;
     typedef itk::Image<OutPixType, 3> OutImageType;
 
     itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
     generator->SetFiberBundle(fib);
     generator->SetBinaryOutput(binary);
     generator->SetOutputAbsoluteValues(absolute);
     generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
     if (m_SelectedImage.IsNotNull())
     {
         OutImageType::Pointer itkImage = OutImageType::New();
         CastToItkImage(m_SelectedImage, itkImage);
         generator->SetInputImage(itkImage);
         generator->SetUseImageGeometry(true);
 
     }
     generator->Update();
 
     // get output image
     typedef itk::Image<OutPixType,3> OutType;
     OutType::Pointer outImg = generator->GetOutput();
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     // init data node
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(img);
     return node;
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.h
index a8197d688b..b616fe62c9 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.h
@@ -1,150 +1,150 @@
 /*===================================================================
 
 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 QmitkFiberQuantificationView_h
 #define QmitkFiberQuantificationView_h
 
 #include <QmitkFunctionality.h>
 #include "ui_QmitkFiberQuantificationViewControls.h"
 
 #include <mitkPlanarFigureComposite.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <mitkSurface.h>
 
 #include <itkCastImageFilter.h>
 #include <itkVTKImageImport.h>
 #include <itkVTKImageExport.h>
 #include <itkRegionOfInterestImageFilter.h>
 
 #include <vtkLinearExtrusionFilter.h>
 #include <vtkPolyDataToImageStencil.h>
 #include <vtkSelectEnclosedPoints.h>
 #include <vtkImageImport.h>
 #include <vtkImageExport.h>
 #include <vtkImageStencil.h>
 #include <vtkSmartPointer.h>
 #include <vtkSelection.h>
 #include <vtkSelectionNode.h>
 #include <vtkExtractSelectedThresholds.h>
 #include <vtkFloatArray.h>
 
 /*!
 \brief View to process fiber bundles. Supplies methods to generate images from the selected bundle and much more.
 
 \sa QmitkFunctionality
 \ingroup Functionalities
 */
 class QmitkFiberQuantificationView : public QmitkFunctionality
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   typedef itk::Image< unsigned char, 3 >    itkUCharImageType;
 
   static const std::string VIEW_ID;
 
   QmitkFiberQuantificationView();
   virtual ~QmitkFiberQuantificationView();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
   virtual void Activated();
 
 protected slots:
 
   void ProcessSelectedBundles();    ///< start selected operation on fiber bundle (e.g. tract density image generation)
   void CalculateFiberDirections();  ///< Calculate main fiber directions from tractogram
 
 protected:
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
 
   Ui::QmitkFiberQuantificationViewControls* m_Controls;
   QmitkStdMultiWidget* m_MultiWidget;
 
   /** Connection from VTK to ITK */
   template <typename VTK_Exporter, typename ITK_Importer>
       void ConnectPipelines(VTK_Exporter* exporter, ITK_Importer importer)
   {
     importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
 
     importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
     importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
     importer->SetSpacingCallback(exporter->GetSpacingCallback());
     importer->SetOriginCallback(exporter->GetOriginCallback());
     importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
 
     importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
 
     importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
     importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
     importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
     importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
     importer->SetCallbackUserData(exporter->GetCallbackUserData());
   }
 
   template <typename ITK_Exporter, typename VTK_Importer>
       void ConnectPipelines(ITK_Exporter exporter, VTK_Importer* importer)
   {
     importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
 
     importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
     importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
     importer->SetSpacingCallback(exporter->GetSpacingCallback());
     importer->SetOriginCallback(exporter->GetOriginCallback());
     importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
 
     importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
 
     importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
     importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
     importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
     importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
     importer->SetCallbackUserData(exporter->GetCallbackUserData());
   }
 
   template < typename TPixel, unsigned int VImageDimension >
       void InternalCalculateMaskFromPlanarFigure(
           itk::Image< TPixel, VImageDimension > *image, unsigned int axis, std::string nodeName );
 
   template < typename TPixel, unsigned int VImageDimension >
       void InternalReorientImagePlane(
           const itk::Image< TPixel, VImageDimension > *image, mitk::Geometry3D* planegeo3D, int additionalIndex );
 
   void GenerateStats(); ///< generate statistics of selected fiber bundles
   void UpdateGui();     ///< update button activity etc. dpending on current datamanager selection
 
   std::vector<mitk::DataNode::Pointer>  m_SelectedFB;       ///< selected fiber bundle nodes
   mitk::Image::Pointer                  m_SelectedImage;
   float                                 m_UpsamplingFactor; ///< upsampling factor for all image generations
   std::vector<mitk::Surface::Pointer>   m_SelectedSurfaces;
 
-  mitk::DataNode::Pointer GenerateTractDensityImage(mitk::FiberBundleX::Pointer fib, bool binary, bool absolute);
-  mitk::DataNode::Pointer GenerateColorHeatmap(mitk::FiberBundleX::Pointer fib);
-  mitk::DataNode::Pointer GenerateFiberEndingsImage(mitk::FiberBundleX::Pointer fib);
-  mitk::DataNode::Pointer GenerateFiberEndingsPointSet(mitk::FiberBundleX::Pointer fib);
+  mitk::DataNode::Pointer GenerateTractDensityImage(mitk::FiberBundle::Pointer fib, bool binary, bool absolute);
+  mitk::DataNode::Pointer GenerateColorHeatmap(mitk::FiberBundle::Pointer fib);
+  mitk::DataNode::Pointer GenerateFiberEndingsImage(mitk::FiberBundle::Pointer fib);
+  mitk::DataNode::Pointer GenerateFiberEndingsPointSet(mitk::FiberBundle::Pointer fib);
 };
 
 
 
 #endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
index fd750f32f1..78a4210658 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
@@ -1,2694 +1,2694 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 //misc
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberfoxView.h"
 
 // MITK
 #include <mitkImage.h>
 #include <mitkImageToItk.h>
 #include <mitkImageCast.h>
 #include <mitkProperties.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkDataStorage.h>
 #include <itkFibersFromPlanarFiguresFilter.h>
 #include <itkTractsToDWIImageFilter.h>
 #include <mitkTensorImage.h>
 #include <mitkILinkedRenderWindowPart.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkImageToItk.h>
 #include <mitkImageCast.h>
 #include <mitkImageGenerator.h>
 #include <mitkNodePredicateDataType.h>
 #include <itkScalableAffineTransform.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateIsDWI.h>
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/xml_parser.hpp>
 #include <boost/foreach.hpp>
 #include <QFileDialog>
 #include <QMessageBox>
 #include "usModuleRegistry.h"
 #include <mitkChiSquareNoiseModel.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkIOUtil.h>
 #include <QScrollBar>
 #include <itkInvertIntensityImageFilter.h>
 #include <QDialogButtonBox>
 #include <itkAdcImageFilter.h>
 #include <itkShiftScaleImageFilter.h>
 #include <mitkITKImageImport.h>
 
 #include "mitkNodePredicateDataType.h"
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 QmitkFiberfoxWorker::QmitkFiberfoxWorker(QmitkFiberfoxView* view)
     : m_View(view)
 {
 
 }
 
 void QmitkFiberfoxWorker::run()
 {
     try{
         switch (m_FilterType)
         {
         case 0:
             m_View->m_TractsToDwiFilter->Update();
             break;
         case 1:
             m_View->m_ArtifactsToDwiFilter->Update();
             break;
         }
     }
     catch( ... )
     {
 
     }
     m_View->m_Thread.quit();
 }
 
 const std::string QmitkFiberfoxView::VIEW_ID = "org.mitk.views.fiberfoxview";
 
 QmitkFiberfoxView::QmitkFiberfoxView()
     : QmitkAbstractView()
     , m_Controls( 0 )
     , m_SelectedImage( NULL )
     , m_Worker(this)
     , m_ThreadIsRunning(false)
 {
     m_Worker.moveToThread(&m_Thread);
     connect(&m_Thread, SIGNAL(started()), this, SLOT(BeforeThread()));
     connect(&m_Thread, SIGNAL(started()), &m_Worker, SLOT(run()));
     connect(&m_Thread, SIGNAL(finished()), this, SLOT(AfterThread()));
     connect(&m_Thread, SIGNAL(terminated()), this, SLOT(AfterThread()));
     m_SimulationTimer = new QTimer(this);
 }
 
 void QmitkFiberfoxView::KillThread()
 {
     MITK_INFO << "Aborting DWI simulation.";
     switch (m_Worker.m_FilterType)
     {
     case 0:
         m_TractsToDwiFilter->SetAbortGenerateData(true);
         break;
     case 1:
         m_ArtifactsToDwiFilter->SetAbortGenerateData(true);
         break;
     }
     m_Controls->m_AbortSimulationButton->setEnabled(false);
     m_Controls->m_AbortSimulationButton->setText("Aborting simulation ...");
 }
 
 void QmitkFiberfoxView::BeforeThread()
 {
     m_SimulationTime = QTime::currentTime();
     m_SimulationTimer->start(100);
     m_Controls->m_AbortSimulationButton->setVisible(true);
     m_Controls->m_GenerateImageButton->setVisible(false);
     m_Controls->m_SimulationStatusText->setVisible(true);
     m_ThreadIsRunning = true;
 }
 
 void QmitkFiberfoxView::AfterThread()
 {
     UpdateSimulationStatus();
     m_SimulationTimer->stop();
     m_Controls->m_AbortSimulationButton->setVisible(false);
     m_Controls->m_AbortSimulationButton->setEnabled(true);
     m_Controls->m_AbortSimulationButton->setText("Abort simulation");
     m_Controls->m_GenerateImageButton->setVisible(true);
     m_ThreadIsRunning = false;
 
     QString statusText;
     FiberfoxParameters<double> parameters;
     mitk::Image::Pointer mitkImage = mitk::Image::New();
     switch (m_Worker.m_FilterType)
     {
     case 0:
     {
         statusText = QString(m_TractsToDwiFilter->GetStatusText().c_str());
         if (m_TractsToDwiFilter->GetAbortGenerateData())
         {
             MITK_INFO << "Simulation aborted.";
             return;
         }
 
         parameters = m_TractsToDwiFilter->GetParameters();
 
         mitkImage = mitk::GrabItkImageMemory( m_TractsToDwiFilter->GetOutput() );
         mitkImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New(  parameters.m_SignalGen.GetGradientDirections()  ));
         mitkImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( parameters.m_SignalGen.m_Bvalue ));
         mitk::DiffusionPropertyHelper propertyHelper( mitkImage );
         propertyHelper.InitializeImage();
         parameters.m_Misc.m_ResultNode->SetData( mitkImage );
 
         parameters.m_Misc.m_ResultNode->SetName(parameters.m_Misc.m_ParentNode->GetName()
                                                 +"_D"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(0)).toStdString()
                                                 +"-"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(1)).toStdString()
                                                 +"-"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(2)).toStdString()
                                                 +"_S"+QString::number(parameters.m_SignalGen.m_ImageSpacing[0]).toStdString()
                 +"-"+QString::number(parameters.m_SignalGen.m_ImageSpacing[1]).toStdString()
                 +"-"+QString::number(parameters.m_SignalGen.m_ImageSpacing[2]).toStdString()
                 +"_b"+QString::number(parameters.m_SignalGen.m_Bvalue).toStdString()
                 +"_"+parameters.m_Misc.m_SignalModelString
                 +parameters.m_Misc.m_ArtifactModelString);
 
         GetDataStorage()->Add(parameters.m_Misc.m_ResultNode, parameters.m_Misc.m_ParentNode);
 
         parameters.m_Misc.m_ResultNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New(m_TractsToDwiFilter->GetLevelWindow()) );
 
         if (m_Controls->m_VolumeFractionsBox->isChecked())
         {
             std::vector< itk::TractsToDWIImageFilter< short >::ItkDoubleImgType::Pointer > volumeFractions = m_TractsToDwiFilter->GetVolumeFractions();
             for (unsigned int k=0; k<volumeFractions.size(); k++)
             {
                 mitk::Image::Pointer image = mitk::Image::New();
                 image->InitializeByItk(volumeFractions.at(k).GetPointer());
                 image->SetVolume(volumeFractions.at(k)->GetBufferPointer());
 
                 mitk::DataNode::Pointer node = mitk::DataNode::New();
                 node->SetData( image );
                 node->SetName(parameters.m_Misc.m_ParentNode->GetName()+"_CompartmentVolume-"+QString::number(k).toStdString());
                 GetDataStorage()->Add(node, parameters.m_Misc.m_ParentNode);
             }
         }
         m_TractsToDwiFilter = NULL;
         break;
     }
     case 1:
     {
         statusText = QString(m_ArtifactsToDwiFilter->GetStatusText().c_str());
         if (m_ArtifactsToDwiFilter->GetAbortGenerateData())
         {
             MITK_INFO << "Simulation aborted.";
             return;
         }
 
         parameters = m_ArtifactsToDwiFilter->GetParameters().CopyParameters<double>();
 
         mitk::Image::Pointer diffImg = dynamic_cast<mitk::Image*>(parameters.m_Misc.m_ParentNode->GetData());
         mitkImage = mitk::GrabItkImageMemory( m_ArtifactsToDwiFilter->GetOutput() );
 
         mitkImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
         mitkImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
         mitk::DiffusionPropertyHelper propertyHelper( mitkImage );
         propertyHelper.InitializeImage();
 
         parameters.m_Misc.m_ResultNode->SetData( mitkImage );
         parameters.m_Misc.m_ResultNode->SetName(parameters.m_Misc.m_ParentNode->GetName()+parameters.m_Misc.m_ArtifactModelString);
         GetDataStorage()->Add(parameters.m_Misc.m_ResultNode, parameters.m_Misc.m_ParentNode);
         m_ArtifactsToDwiFilter = NULL;
         break;
     }
     }
 
     mitk::BaseData::Pointer basedata = parameters.m_Misc.m_ResultNode->GetData();
     if (basedata.IsNotNull())
     {
         mitk::RenderingManager::GetInstance()->InitializeViews(
                     basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     if (!parameters.m_Misc.m_OutputPath.empty())
     {
         try{
             QString outputFileName(parameters.m_Misc.m_OutputPath.c_str());
             outputFileName += parameters.m_Misc.m_ResultNode->GetName().c_str();
             outputFileName.replace(QString("."), QString("_"));
             outputFileName += ".dwi";
             QString status("Saving output image to ");
             status += outputFileName;
             m_Controls->m_SimulationStatusText->append(status);
             mitk::IOUtil::SaveBaseData(mitkImage, outputFileName.toStdString());
             m_Controls->m_SimulationStatusText->append("File saved successfully.");
         }
         catch (itk::ExceptionObject &e)
         {
             QString status("Exception during DWI writing: ");
             status += e.GetDescription();
             m_Controls->m_SimulationStatusText->append(status);
         }
         catch (...)
         {
             m_Controls->m_SimulationStatusText->append("Unknown exception during DWI writing!");
         }
     }
     parameters.m_SignalGen.m_FrequencyMap = NULL;
 }
 
 void QmitkFiberfoxView::UpdateSimulationStatus()
 {
     QString statusText;
     switch (m_Worker.m_FilterType)
     {
     case 0:
         statusText = QString(m_TractsToDwiFilter->GetStatusText().c_str());
         break;
     case 1:
         statusText = QString(m_ArtifactsToDwiFilter->GetStatusText().c_str());
         break;
     }
 
     if (QString::compare(m_SimulationStatusText,statusText)!=0)
     {
         m_Controls->m_SimulationStatusText->clear();
         statusText = "<pre>"+statusText+"</pre>";
         m_Controls->m_SimulationStatusText->setText(statusText);
         QScrollBar *vScrollBar = m_Controls->m_SimulationStatusText->verticalScrollBar();
         vScrollBar->triggerAction(QScrollBar::SliderToMaximum);
     }
 }
 
 // Destructor
 QmitkFiberfoxView::~QmitkFiberfoxView()
 {
     delete m_SimulationTimer;
 }
 
 void QmitkFiberfoxView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFiberfoxViewControls;
         m_Controls->setupUi( parent );
 
         // commented out
         m_Controls->m_DiffusionDirectionBox->setVisible(false);
         m_Controls->label_3->setVisible(false);
         m_Controls->m_SeparationAngleBox->setVisible(false);
         m_Controls->label_4->setVisible(false);
         //
 
         m_Controls->m_StickWidget1->setVisible(true);
         m_Controls->m_StickWidget2->setVisible(false);
         m_Controls->m_ZeppelinWidget1->setVisible(false);
         m_Controls->m_ZeppelinWidget2->setVisible(false);
         m_Controls->m_TensorWidget1->setVisible(false);
         m_Controls->m_TensorWidget2->setVisible(false);
 
         m_Controls->m_BallWidget1->setVisible(true);
         m_Controls->m_BallWidget2->setVisible(false);
         m_Controls->m_AstrosticksWidget1->setVisible(false);
         m_Controls->m_AstrosticksWidget2->setVisible(false);
         m_Controls->m_DotWidget1->setVisible(false);
         m_Controls->m_DotWidget2->setVisible(false);
 
         m_Controls->m_PrototypeWidget1->setVisible(false);
         m_Controls->m_PrototypeWidget2->setVisible(false);
         m_Controls->m_PrototypeWidget3->setVisible(false);
         m_Controls->m_PrototypeWidget4->setVisible(false);
 
         m_Controls->m_PrototypeWidget3->SetMinFa(0.0);
         m_Controls->m_PrototypeWidget3->SetMaxFa(0.15);
         m_Controls->m_PrototypeWidget4->SetMinFa(0.0);
         m_Controls->m_PrototypeWidget4->SetMaxFa(0.15);
         m_Controls->m_PrototypeWidget3->SetMinAdc(0.0);
         m_Controls->m_PrototypeWidget3->SetMaxAdc(0.001);
         m_Controls->m_PrototypeWidget4->SetMinAdc(0.003);
         m_Controls->m_PrototypeWidget4->SetMaxAdc(0.004);
 
         m_Controls->m_Comp4FractionFrame->setVisible(false);
         m_Controls->m_DiffusionPropsMessage->setVisible(false);
         m_Controls->m_GeometryMessage->setVisible(false);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
         m_Controls->m_VarianceBox->setVisible(false);
         m_Controls->m_NoiseFrame->setVisible(false);
         m_Controls->m_GhostFrame->setVisible(false);
         m_Controls->m_DistortionsFrame->setVisible(false);
         m_Controls->m_EddyFrame->setVisible(false);
         m_Controls->m_SpikeFrame->setVisible(false);
         m_Controls->m_AliasingFrame->setVisible(false);
         m_Controls->m_MotionArtifactFrame->setVisible(false);
         m_ParameterFile = QDir::currentPath()+"/param.ffp";
 
         m_Controls->m_AbortSimulationButton->setVisible(false);
         m_Controls->m_SimulationStatusText->setVisible(false);
 
         m_Controls->m_FrequencyMapBox->SetDataStorage(this->GetDataStorage());
         m_Controls->m_Comp4VolumeFraction->SetDataStorage(this->GetDataStorage());
         m_Controls->m_MaskComboBox->SetDataStorage(this->GetDataStorage());
         m_Controls->m_TemplateComboBox->SetDataStorage(this->GetDataStorage());
         m_Controls->m_FiberBundleComboBox->SetDataStorage(this->GetDataStorage());
 
-        mitk::TNodePredicateDataType<mitk::FiberBundleX>::Pointer isFiberBundle = mitk::TNodePredicateDataType<mitk::FiberBundleX>::New();
+        mitk::TNodePredicateDataType<mitk::FiberBundle>::Pointer isFiberBundle = mitk::TNodePredicateDataType<mitk::FiberBundle>::New();
         mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
         mitk::NodePredicateIsDWI::Pointer isDwi = mitk::NodePredicateIsDWI::New( );
         mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
         mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
         mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
         isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
         mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
         mitk::NodePredicateAnd::Pointer isNonDiffMitkImage = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
         mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
         mitk::NodePredicateAnd::Pointer isBinaryMitkImage = mitk::NodePredicateAnd::New( isNonDiffMitkImage, isBinaryPredicate );
 
         m_Controls->m_FrequencyMapBox->SetPredicate(isNonDiffMitkImage);
         m_Controls->m_Comp4VolumeFraction->SetPredicate(isNonDiffMitkImage);
         m_Controls->m_MaskComboBox->SetPredicate(isBinaryMitkImage);
         m_Controls->m_MaskComboBox->SetZeroEntryText("--");
         m_Controls->m_TemplateComboBox->SetPredicate(isMitkImage);
         m_Controls->m_TemplateComboBox->SetZeroEntryText("--");
         m_Controls->m_FiberBundleComboBox->SetPredicate(isFiberBundle);
         m_Controls->m_FiberBundleComboBox->SetZeroEntryText("--");
 
 //        mitk::NodePredicateDimension::Pointer dimensionPredicate = mitk::NodePredicateDimension::New(3);
 
         connect( m_SimulationTimer, SIGNAL(timeout()), this, SLOT(UpdateSimulationStatus()) );
         connect((QObject*) m_Controls->m_AbortSimulationButton, SIGNAL(clicked()), (QObject*) this, SLOT(KillThread()));
         connect((QObject*) m_Controls->m_GenerateImageButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateImage()));
         connect((QObject*) m_Controls->m_GenerateFibersButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateFibers()));
         connect((QObject*) m_Controls->m_CircleButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnDrawROI()));
         connect((QObject*) m_Controls->m_FlipButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnFlipButton()));
         connect((QObject*) m_Controls->m_JoinBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(JoinBundles()));
         connect((QObject*) m_Controls->m_VarianceBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnVarianceChanged(double)));
         connect((QObject*) m_Controls->m_DistributionBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnDistributionChanged(int)));
         connect((QObject*) m_Controls->m_FiberDensityBox, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(OnFiberDensityChanged(int)));
         connect((QObject*) m_Controls->m_FiberSamplingBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnFiberSamplingChanged(double)));
         connect((QObject*) m_Controls->m_TensionBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnTensionChanged(double)));
         connect((QObject*) m_Controls->m_ContinuityBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnContinuityChanged(double)));
         connect((QObject*) m_Controls->m_BiasBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnBiasChanged(double)));
         connect((QObject*) m_Controls->m_AddNoise, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddNoise(int)));
         connect((QObject*) m_Controls->m_AddGhosts, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddGhosts(int)));
         connect((QObject*) m_Controls->m_AddDistortions, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddDistortions(int)));
         connect((QObject*) m_Controls->m_AddEddy, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddEddy(int)));
         connect((QObject*) m_Controls->m_AddSpikes, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddSpikes(int)));
         connect((QObject*) m_Controls->m_AddAliasing, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddAliasing(int)));
         connect((QObject*) m_Controls->m_AddMotion, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddMotion(int)));
 
         connect((QObject*) m_Controls->m_ConstantRadiusBox, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnConstantRadius(int)));
         connect((QObject*) m_Controls->m_CopyBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(CopyBundles()));
         connect((QObject*) m_Controls->m_TransformBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(ApplyTransform()));
         connect((QObject*) m_Controls->m_AlignOnGrid, SIGNAL(clicked()), (QObject*) this, SLOT(AlignOnGrid()));
 
         connect((QObject*) m_Controls->m_Compartment1Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp1ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment2Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp2ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment3Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp3ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment4Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp4ModelFrameVisibility(int)));
 
         connect((QObject*) m_Controls->m_AdvancedOptionsBox, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
         connect((QObject*) m_Controls->m_AdvancedOptionsBox_2, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
 
         connect((QObject*) m_Controls->m_SaveParametersButton, SIGNAL(clicked()), (QObject*) this, SLOT(SaveParameters()));
         connect((QObject*) m_Controls->m_LoadParametersButton, SIGNAL(clicked()), (QObject*) this, SLOT(LoadParameters()));
         connect((QObject*) m_Controls->m_OutputPathButton, SIGNAL(clicked()), (QObject*) this, SLOT(SetOutputPath()));
 
         connect((QObject*) m_Controls->m_MaskComboBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnMaskSelected(int)));
         connect((QObject*) m_Controls->m_TemplateComboBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnTemplateSelected(int)));
         connect((QObject*) m_Controls->m_FiberBundleComboBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnFibSelected(int)));
     }
 }
 
 void QmitkFiberfoxView::OnMaskSelected(int value)
 {
     UpdateGui();
 }
 
 void QmitkFiberfoxView::OnTemplateSelected(int value)
 {
     UpdateGui();
 }
 
 void QmitkFiberfoxView::OnFibSelected(int value)
 {
     UpdateGui();
 }
 
 template< class ScalarType >
 FiberfoxParameters< ScalarType > QmitkFiberfoxView::UpdateImageParameters()
 {
     FiberfoxParameters< ScalarType > parameters;
     parameters.m_Misc.m_OutputPath = "";
     parameters.m_Misc.m_CheckAdvancedFiberOptionsBox = m_Controls->m_AdvancedOptionsBox->isChecked();
     parameters.m_Misc.m_CheckAdvancedSignalOptionsBox = m_Controls->m_AdvancedOptionsBox_2->isChecked();
     parameters.m_Misc.m_CheckOutputVolumeFractionsBox = m_Controls->m_VolumeFractionsBox->isChecked();
 
     string outputPath = m_Controls->m_SavePathEdit->text().toStdString();
     if (outputPath.compare("-")!=0)
     {
         parameters.m_Misc.m_OutputPath = outputPath;
         parameters.m_Misc.m_OutputPath += "/";
     }
 
     if (m_Controls->m_MaskComboBox->GetSelectedNode().IsNotNull())
     {
         mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(m_Controls->m_MaskComboBox->GetSelectedNode()->GetData());
         mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, parameters.m_SignalGen.m_MaskImage);
         itk::ImageDuplicator<ItkUcharImgType>::Pointer duplicator = itk::ImageDuplicator<ItkUcharImgType>::New();
         duplicator->SetInputImage(parameters.m_SignalGen.m_MaskImage);
         duplicator->Update();
         parameters.m_SignalGen.m_MaskImage = duplicator->GetOutput();
     }
 
     if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData())))  // use parameters of selected DWI
     {
         mitk::Image::Pointer dwi = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
 
         ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
         mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
         parameters.m_SignalGen.m_ImageRegion = itkVectorImagePointer->GetLargestPossibleRegion();
         parameters.m_SignalGen.m_ImageSpacing = itkVectorImagePointer->GetSpacing();
         parameters.m_SignalGen.m_ImageOrigin = itkVectorImagePointer->GetOrigin();
         parameters.m_SignalGen.m_ImageDirection = itkVectorImagePointer->GetDirection();
         parameters.m_SignalGen.m_Bvalue = static_cast<mitk::FloatProperty*>(dwi->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue();
         parameters.m_SignalGen.SetGradienDirections(static_cast<mitk::GradientDirectionsProperty*>( dwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer());
     }
     else if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull())   // use geometry of selected image
     {
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
         itk::Image< float, 3 >::Pointer itkImg = itk::Image< float, 3 >::New();
         CastToItkImage< itk::Image< float, 3 > >(img, itkImg);
 
         parameters.m_SignalGen.m_ImageRegion = itkImg->GetLargestPossibleRegion();
         parameters.m_SignalGen.m_ImageSpacing = itkImg->GetSpacing();
         parameters.m_SignalGen.m_ImageOrigin = itkImg->GetOrigin();
         parameters.m_SignalGen.m_ImageDirection = itkImg->GetDirection();
         parameters.m_SignalGen.SetNumWeightedVolumes(m_Controls->m_NumGradientsBox->value());
         parameters.m_SignalGen.m_Bvalue = m_Controls->m_BvalueBox->value();
     }
     else    // use GUI parameters
     {
         parameters.m_SignalGen.m_ImageRegion.SetSize(0, m_Controls->m_SizeX->value());
         parameters.m_SignalGen.m_ImageRegion.SetSize(1, m_Controls->m_SizeY->value());
         parameters.m_SignalGen.m_ImageRegion.SetSize(2, m_Controls->m_SizeZ->value());
         parameters.m_SignalGen.m_ImageSpacing[0] = m_Controls->m_SpacingX->value();
         parameters.m_SignalGen.m_ImageSpacing[1] = m_Controls->m_SpacingY->value();
         parameters.m_SignalGen.m_ImageSpacing[2] = m_Controls->m_SpacingZ->value();
         parameters.m_SignalGen.m_ImageOrigin[0] = parameters.m_SignalGen.m_ImageSpacing[0]/2;
         parameters.m_SignalGen.m_ImageOrigin[1] = parameters.m_SignalGen.m_ImageSpacing[1]/2;
         parameters.m_SignalGen.m_ImageOrigin[2] = parameters.m_SignalGen.m_ImageSpacing[2]/2;
         parameters.m_SignalGen.m_ImageDirection.SetIdentity();
         parameters.m_SignalGen.SetNumWeightedVolumes(m_Controls->m_NumGradientsBox->value());
         parameters.m_SignalGen.m_Bvalue = m_Controls->m_BvalueBox->value();
         parameters.m_SignalGen.GenerateGradientHalfShell();
     }
 
     // signal relaxation
     parameters.m_SignalGen.m_DoSimulateRelaxation = m_Controls->m_RelaxationBox->isChecked();
     parameters.m_SignalGen.m_SimulateKspaceAcquisition = parameters.m_SignalGen.m_DoSimulateRelaxation;
     if (parameters.m_SignalGen.m_DoSimulateRelaxation && m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNotNull() )
         parameters.m_Misc.m_ArtifactModelString += "_RELAX";
 
     // N/2 ghosts
     parameters.m_Misc.m_CheckAddGhostsBox = m_Controls->m_AddGhosts->isChecked();
     if (m_Controls->m_AddGhosts->isChecked())
     {
         parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
         parameters.m_Misc.m_ArtifactModelString += "_GHOST";
         parameters.m_SignalGen.m_KspaceLineOffset = m_Controls->m_kOffsetBox->value();
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Ghost", DoubleProperty::New(parameters.m_SignalGen.m_KspaceLineOffset));
     }
     else
         parameters.m_SignalGen.m_KspaceLineOffset = 0;
 
     // Aliasing
     parameters.m_Misc.m_CheckAddAliasingBox = m_Controls->m_AddAliasing->isChecked();
     if (m_Controls->m_AddAliasing->isChecked())
     {
         parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
         parameters.m_Misc.m_ArtifactModelString += "_ALIASING";
         parameters.m_SignalGen.m_CroppingFactor = (100-m_Controls->m_WrapBox->value())/100;
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Aliasing", DoubleProperty::New(m_Controls->m_WrapBox->value()));
     }
 
     // Spikes
     parameters.m_Misc.m_CheckAddSpikesBox = m_Controls->m_AddSpikes->isChecked();
     if (m_Controls->m_AddSpikes->isChecked())
     {
         parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
         parameters.m_SignalGen.m_Spikes = m_Controls->m_SpikeNumBox->value();
         parameters.m_SignalGen.m_SpikeAmplitude = m_Controls->m_SpikeScaleBox->value();
         parameters.m_Misc.m_ArtifactModelString += "_SPIKES";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Spikes.Number", IntProperty::New(parameters.m_SignalGen.m_Spikes));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Spikes.Amplitude", DoubleProperty::New(parameters.m_SignalGen.m_SpikeAmplitude));
     }
 
     // gibbs ringing
     parameters.m_SignalGen.m_DoAddGibbsRinging = m_Controls->m_AddGibbsRinging->isChecked();
     if (m_Controls->m_AddGibbsRinging->isChecked())
     {
         parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Ringing", BoolProperty::New(true));
         parameters.m_Misc.m_ArtifactModelString += "_RINGING";
     }
 
     // add distortions
     parameters.m_Misc.m_CheckAddDistortionsBox = m_Controls->m_AddDistortions->isChecked();
     if (m_Controls->m_AddDistortions->isChecked() && m_Controls->m_FrequencyMapBox->GetSelectedNode().IsNotNull())
     {
         mitk::DataNode::Pointer fMapNode = m_Controls->m_FrequencyMapBox->GetSelectedNode();
         mitk::Image* img = dynamic_cast<mitk::Image*>(fMapNode->GetData());
         ItkDoubleImgType::Pointer itkImg = ItkDoubleImgType::New();
         CastToItkImage< ItkDoubleImgType >(img, itkImg);
 
         if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNull())   // use geometry of frequency map
         {
             parameters.m_SignalGen.m_ImageRegion = itkImg->GetLargestPossibleRegion();
             parameters.m_SignalGen.m_ImageSpacing = itkImg->GetSpacing();
             parameters.m_SignalGen.m_ImageOrigin = itkImg->GetOrigin();
             parameters.m_SignalGen.m_ImageDirection = itkImg->GetDirection();
         }
 
         if (parameters.m_SignalGen.m_ImageRegion.GetSize(0)==itkImg->GetLargestPossibleRegion().GetSize(0) &&
                 parameters.m_SignalGen.m_ImageRegion.GetSize(1)==itkImg->GetLargestPossibleRegion().GetSize(1) &&
                 parameters.m_SignalGen.m_ImageRegion.GetSize(2)==itkImg->GetLargestPossibleRegion().GetSize(2))
         {
             parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
             itk::ImageDuplicator<ItkDoubleImgType>::Pointer duplicator = itk::ImageDuplicator<ItkDoubleImgType>::New();
             duplicator->SetInputImage(itkImg);
             duplicator->Update();
             parameters.m_SignalGen.m_FrequencyMap = duplicator->GetOutput();
             parameters.m_Misc.m_ArtifactModelString += "_DISTORTED";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Distortions", BoolProperty::New(true));
         }
     }
 
     parameters.m_SignalGen.m_EddyStrength = 0;
     parameters.m_Misc.m_CheckAddEddyCurrentsBox = m_Controls->m_AddEddy->isChecked();
     if (m_Controls->m_AddEddy->isChecked())
     {
         parameters.m_SignalGen.m_EddyStrength = m_Controls->m_EddyGradientStrength->value();
         parameters.m_Misc.m_ArtifactModelString += "_EDDY";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Eddy-strength", DoubleProperty::New(parameters.m_SignalGen.m_EddyStrength));
     }
 
     // Motion
     parameters.m_SignalGen.m_DoAddMotion = m_Controls->m_AddMotion->isChecked();
     parameters.m_SignalGen.m_DoRandomizeMotion = m_Controls->m_RandomMotion->isChecked();
     parameters.m_SignalGen.m_Translation[0] = m_Controls->m_MaxTranslationBoxX->value();
     parameters.m_SignalGen.m_Translation[1] = m_Controls->m_MaxTranslationBoxY->value();
     parameters.m_SignalGen.m_Translation[2] = m_Controls->m_MaxTranslationBoxZ->value();
     parameters.m_SignalGen.m_Rotation[0] = m_Controls->m_MaxRotationBoxX->value();
     parameters.m_SignalGen.m_Rotation[1] = m_Controls->m_MaxRotationBoxY->value();
     parameters.m_SignalGen.m_Rotation[2] = m_Controls->m_MaxRotationBoxZ->value();
     if ( m_Controls->m_AddMotion->isChecked() && m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNotNull() )
     {
         parameters.m_Misc.m_ArtifactModelString += "_MOTION";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Random", BoolProperty::New(parameters.m_SignalGen.m_DoRandomizeMotion));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Translation-x", DoubleProperty::New(parameters.m_SignalGen.m_Translation[0]));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Translation-y", DoubleProperty::New(parameters.m_SignalGen.m_Translation[1]));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Translation-z", DoubleProperty::New(parameters.m_SignalGen.m_Translation[2]));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Rotation-x", DoubleProperty::New(parameters.m_SignalGen.m_Rotation[0]));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Rotation-y", DoubleProperty::New(parameters.m_SignalGen.m_Rotation[1]));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Rotation-z", DoubleProperty::New(parameters.m_SignalGen.m_Rotation[2]));
     }
 
     // other imaging parameters
     parameters.m_SignalGen.m_tLine = m_Controls->m_LineReadoutTimeBox->value();
     parameters.m_SignalGen.m_tInhom = m_Controls->m_T2starBox->value();
     parameters.m_SignalGen.m_tEcho = m_Controls->m_TEbox->value();
     parameters.m_SignalGen.m_DoDisablePartialVolume = m_Controls->m_EnforcePureFiberVoxelsBox->isChecked();
     parameters.m_SignalGen.m_AxonRadius = m_Controls->m_FiberRadius->value();
     parameters.m_SignalGen.m_SignalScale = m_Controls->m_SignalScaleBox->value();
 
     // adjust echo time if needed
     if ( parameters.m_SignalGen.m_tEcho < parameters.m_SignalGen.m_ImageRegion.GetSize(1)*parameters.m_SignalGen.m_tLine )
     {
         this->m_Controls->m_TEbox->setValue( parameters.m_SignalGen.m_ImageRegion.GetSize(1)*parameters.m_SignalGen.m_tLine );
         parameters.m_SignalGen.m_tEcho = m_Controls->m_TEbox->value();
         QMessageBox::information( NULL, "Warning", "Echo time is too short! Time not sufficient to read slice. Automaticall adjusted to "+QString::number(parameters.m_SignalGen.m_tEcho)+" ms");
     }
 
     // Noise
     parameters.m_Misc.m_CheckAddNoiseBox = m_Controls->m_AddNoise->isChecked();
     if (m_Controls->m_AddNoise->isChecked())
     {
         double noiseVariance = m_Controls->m_NoiseLevel->value();
         {
             switch (m_Controls->m_NoiseDistributionBox->currentIndex())
             {
             case 0:
             {
                 parameters.m_NoiseModel = new mitk::RicianNoiseModel<ScalarType>();
                 parameters.m_Misc.m_ArtifactModelString += "_RICIAN-";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Rician"));
                 break;
             }
             case 1:
             {
                 parameters.m_NoiseModel = new mitk::ChiSquareNoiseModel<ScalarType>();
                 parameters.m_Misc.m_ArtifactModelString += "_CHISQUARED-";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Chi-squared"));
                 break;
             }
             default:
             {
                 parameters.m_NoiseModel = new mitk::RicianNoiseModel<ScalarType>();
                 parameters.m_Misc.m_ArtifactModelString += "_RICIAN-";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Rician"));
             }
             }
         }
         parameters.m_NoiseModel->SetNoiseVariance(noiseVariance);
         parameters.m_Misc.m_ArtifactModelString += QString::number(noiseVariance).toStdString();
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Variance", DoubleProperty::New(noiseVariance));
     }
 
     // adjusting line readout time to the adapted image size needed for the DFT
     unsigned int y = parameters.m_SignalGen.m_ImageRegion.GetSize(1);
     y += y%2;
     if ( y>parameters.m_SignalGen.m_ImageRegion.GetSize(1) )
         parameters.m_SignalGen.m_tLine *= (double)parameters.m_SignalGen.m_ImageRegion.GetSize(1)/y;
 
     // signal models
     {
         // compartment 1
         switch (m_Controls->m_Compartment1Box->currentIndex())
         {
         case 0:
         {
             mitk::StickModel<ScalarType>* model = new mitk::StickModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity(m_Controls->m_StickWidget1->GetD());
             model->SetT2(m_Controls->m_StickWidget1->GetT2());
             model->m_CompartmentId = 1;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Stick";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Stick") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D", DoubleProperty::New(m_Controls->m_StickWidget1->GetD()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 1:
         {
             mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity1(m_Controls->m_ZeppelinWidget1->GetD1());
             model->SetDiffusivity2(m_Controls->m_ZeppelinWidget1->GetD2());
             model->SetDiffusivity3(m_Controls->m_ZeppelinWidget1->GetD2());
             model->SetT2(m_Controls->m_ZeppelinWidget1->GetT2());
             model->m_CompartmentId = 1;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Zeppelin";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Zeppelin") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD1()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD2()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 2:
         {
             mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity1(m_Controls->m_TensorWidget1->GetD1());
             model->SetDiffusivity2(m_Controls->m_TensorWidget1->GetD2());
             model->SetDiffusivity3(m_Controls->m_TensorWidget1->GetD3());
             model->SetT2(m_Controls->m_TensorWidget1->GetT2());
             model->m_CompartmentId = 1;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Tensor";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Tensor") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD1()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD2()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D3", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD3()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 3:
         {
             mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
             parameters.m_SignalGen.m_DoSimulateRelaxation = false;
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetMaxNumKernels(m_Controls->m_PrototypeWidget1->GetNumberOfSamples());
             model->SetFaRange(m_Controls->m_PrototypeWidget1->GetMinFa(), m_Controls->m_PrototypeWidget1->GetMaxFa());
             model->SetAdcRange(m_Controls->m_PrototypeWidget1->GetMinAdc(), m_Controls->m_PrototypeWidget1->GetMaxAdc());
             model->m_CompartmentId = 1;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Prototype";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Prototype") );
             break;
         }
         }
 
         // compartment 2
         switch (m_Controls->m_Compartment2Box->currentIndex())
         {
         case 0:
             break;
         case 1:
         {
             mitk::StickModel<ScalarType>* model = new mitk::StickModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity(m_Controls->m_StickWidget2->GetD());
             model->SetT2(m_Controls->m_StickWidget2->GetT2());
             model->m_CompartmentId = 2;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Stick";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Stick") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D", DoubleProperty::New(m_Controls->m_StickWidget2->GetD()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 2:
         {
             mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity1(m_Controls->m_ZeppelinWidget2->GetD1());
             model->SetDiffusivity2(m_Controls->m_ZeppelinWidget2->GetD2());
             model->SetDiffusivity3(m_Controls->m_ZeppelinWidget2->GetD2());
             model->SetT2(m_Controls->m_ZeppelinWidget2->GetT2());
             model->m_CompartmentId = 2;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Zeppelin";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Zeppelin") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD1()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD2()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 3:
         {
             mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity1(m_Controls->m_TensorWidget2->GetD1());
             model->SetDiffusivity2(m_Controls->m_TensorWidget2->GetD2());
             model->SetDiffusivity3(m_Controls->m_TensorWidget2->GetD3());
             model->SetT2(m_Controls->m_TensorWidget2->GetT2());
             model->m_CompartmentId = 2;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Tensor";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Tensor") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD1()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD2()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D3", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD3()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         }
 
         // compartment 3
         switch (m_Controls->m_Compartment3Box->currentIndex())
         {
         case 0:
         {
             mitk::BallModel<ScalarType>* model = new mitk::BallModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity(m_Controls->m_BallWidget1->GetD());
             model->SetT2(m_Controls->m_BallWidget1->GetT2());
             model->m_CompartmentId = 3;
             parameters.m_NonFiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Ball";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Ball") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_BallWidget1->GetD()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 1:
         {
             mitk::AstroStickModel<ScalarType>* model = new mitk::AstroStickModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity(m_Controls->m_AstrosticksWidget1->GetD());
             model->SetT2(m_Controls->m_AstrosticksWidget1->GetT2());
             model->SetRandomizeSticks(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks());
             model->m_CompartmentId = 3;
             parameters.m_NonFiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Astrosticks";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Astrosticks") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget1->GetD()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(model->GetT2()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks()) );
             break;
         }
         case 2:
         {
             mitk::DotModel<ScalarType>* model = new mitk::DotModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetT2(m_Controls->m_DotWidget1->GetT2());
             model->m_CompartmentId = 3;
             parameters.m_NonFiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Dot";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Dot") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 3:
         {
             mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
             parameters.m_SignalGen.m_DoSimulateRelaxation = false;
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetMaxNumKernels(m_Controls->m_PrototypeWidget3->GetNumberOfSamples());
             model->SetFaRange(m_Controls->m_PrototypeWidget3->GetMinFa(), m_Controls->m_PrototypeWidget3->GetMaxFa());
             model->SetAdcRange(m_Controls->m_PrototypeWidget3->GetMinAdc(), m_Controls->m_PrototypeWidget3->GetMaxAdc());
             model->m_CompartmentId = 3;
             parameters.m_NonFiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Prototype";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Prototype") );
             break;
         }
         }
 
         // compartment 4
         ItkDoubleImgType::Pointer comp4VolumeImage = NULL;
         ItkDoubleImgType::Pointer comp3VolumeImage = NULL;
         if (m_Controls->m_Compartment4Box->currentIndex()>0)
         {
             mitk::DataNode::Pointer volumeNode = m_Controls->m_Comp4VolumeFraction->GetSelectedNode();
             if (volumeNode.IsNull())
             {
                 QMessageBox::information( NULL, "Information", "No volume fraction image selected! Second extra-axonal compartment has been disabled for this simultation.");
                 MITK_WARN << "No volume fraction image selected! Second extra-axonal compartment has been disabled.";
             }
             else
             {
                 MITK_INFO << "Rescaling volume fraction image...";
                 comp4VolumeImage = ItkDoubleImgType::New();
                 mitk::Image* img = dynamic_cast<mitk::Image*>(volumeNode->GetData());
                 CastToItkImage< ItkDoubleImgType >(img, comp4VolumeImage);
 
                 double max = itk::NumericTraits<double>::min();
                 double min = itk::NumericTraits<double>::max();
 
                 itk::ImageRegionIterator< ItkDoubleImgType > it(comp4VolumeImage, comp4VolumeImage->GetLargestPossibleRegion());
                 while(!it.IsAtEnd())
                 {
                     if (parameters.m_SignalGen.m_MaskImage.IsNotNull() && parameters.m_SignalGen.m_MaskImage->GetPixel(it.GetIndex())<=0)
                     {
                         it.Set(0.0);
                         ++it;
                         continue;
                     }
                     if (it.Get()>900)
                         it.Set(900);
 
                     if (it.Get()>max)
                         max = it.Get();
                     if (it.Get()<min)
                         min = it.Get();
                     ++it;
                 }
                 itk::ShiftScaleImageFilter< ItkDoubleImgType, ItkDoubleImgType >::Pointer scaler = itk::ShiftScaleImageFilter< ItkDoubleImgType, ItkDoubleImgType >::New();
                 scaler->SetInput(comp4VolumeImage);
                 scaler->SetShift(-min);
                 scaler->SetScale(1.0/(max-min));
                 scaler->Update();
                 comp4VolumeImage = scaler->GetOutput();
 
 //                itk::ImageFileWriter< ItkDoubleImgType >::Pointer wr = itk::ImageFileWriter< ItkDoubleImgType >::New();
 //                wr->SetInput(comp4VolumeImage);
 //                wr->SetFileName("/local/comp4.nrrd");
 //                wr->Update();
 
                 //            if (max>1 || min<0) // are volume fractions between 0 and 1?
                 //            {
                 //                itk::RescaleIntensityImageFilter<ItkDoubleImgType,ItkDoubleImgType>::Pointer rescaler = itk::RescaleIntensityImageFilter<ItkDoubleImgType,ItkDoubleImgType>::New();
                 //                rescaler->SetInput(0, comp4VolumeImage);
                 //                rescaler->SetOutputMaximum(1);
                 //                rescaler->SetOutputMinimum(0);
                 //                rescaler->Update();
                 //                comp4VolumeImage = rescaler->GetOutput();
                 //            }
 
                 itk::InvertIntensityImageFilter< ItkDoubleImgType, ItkDoubleImgType >::Pointer inverter = itk::InvertIntensityImageFilter< ItkDoubleImgType, ItkDoubleImgType >::New();
                 inverter->SetMaximum(1.0);
                 inverter->SetInput(comp4VolumeImage);
                 inverter->Update();
                 comp3VolumeImage = inverter->GetOutput();
             }
         }
 
         if (comp4VolumeImage.IsNotNull())
         {
             switch (m_Controls->m_Compartment4Box->currentIndex())
             {
             case 0:
                 break;
             case 1:
             {
                 mitk::BallModel<ScalarType>* model = new mitk::BallModel<ScalarType>();
                 model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
                 model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
                 model->SetDiffusivity(m_Controls->m_BallWidget2->GetD());
                 model->SetT2(m_Controls->m_BallWidget2->GetT2());
                 model->SetVolumeFractionImage(comp4VolumeImage);
                 model->m_CompartmentId = 4;
                 parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(comp3VolumeImage);
                 parameters.m_NonFiberModelList.push_back(model);
                 parameters.m_Misc.m_SignalModelString += "Ball";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Ball") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_BallWidget2->GetD()) );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(model->GetT2()) );
                 break;
             }
             case 2:
             {
                 mitk::AstroStickModel<ScalarType>* model = new mitk::AstroStickModel<ScalarType>();
                 model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
                 model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
                 model->SetDiffusivity(m_Controls->m_AstrosticksWidget2->GetD());
                 model->SetT2(m_Controls->m_AstrosticksWidget2->GetT2());
                 model->SetRandomizeSticks(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks());
                 parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(comp3VolumeImage);
                 model->SetVolumeFractionImage(comp4VolumeImage);
                 model->m_CompartmentId = 4;
                 parameters.m_NonFiberModelList.push_back(model);
                 parameters.m_Misc.m_SignalModelString += "Astrosticks";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Astrosticks") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget2->GetD()) );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(model->GetT2()) );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks()) );
                 break;
             }
             case 3:
             {
                 mitk::DotModel<ScalarType>* model = new mitk::DotModel<ScalarType>();
                 model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
                 model->SetT2(m_Controls->m_DotWidget2->GetT2());
                 model->SetVolumeFractionImage(comp4VolumeImage);
                 model->m_CompartmentId = 4;
                 parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(comp3VolumeImage);
                 parameters.m_NonFiberModelList.push_back(model);
                 parameters.m_Misc.m_SignalModelString += "Dot";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Dot") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(model->GetT2()) );
                 break;
             }
             case 4:
             {
                 mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
                 parameters.m_SignalGen.m_DoSimulateRelaxation = false;
                 model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
                 model->SetMaxNumKernels(m_Controls->m_PrototypeWidget4->GetNumberOfSamples());
                 model->SetFaRange(m_Controls->m_PrototypeWidget4->GetMinFa(), m_Controls->m_PrototypeWidget4->GetMaxFa());
                 model->SetAdcRange(m_Controls->m_PrototypeWidget4->GetMinAdc(), m_Controls->m_PrototypeWidget4->GetMaxAdc());
                 model->SetVolumeFractionImage(comp4VolumeImage);
                 model->m_CompartmentId = 4;
                 parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(comp3VolumeImage);
                 parameters.m_NonFiberModelList.push_back(model);
                 parameters.m_Misc.m_SignalModelString += "Prototype";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Prototype") );
                 break;
             }
             }
         }
     }
 
     parameters.m_SignalGen.m_FiberSeparationThreshold = m_Controls->m_SeparationAngleBox->value();
     switch (m_Controls->m_DiffusionDirectionBox->currentIndex())
     {
     case 0:
         parameters.m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS;
         break;
     case 1:
         parameters.m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::MAIN_FIBER_DIRECTIONS;
         break;
     case 2:
         parameters.m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::RANDOM_DIRECTIONS;
         parameters.m_SignalGen.m_DoAddMotion = false;
         parameters.m_SignalGen.m_DoAddGibbsRinging = false;
         parameters.m_SignalGen.m_KspaceLineOffset = 0.0;
         parameters.m_SignalGen.m_FrequencyMap = NULL;
         parameters.m_SignalGen.m_CroppingFactor = 1.0;
         parameters.m_SignalGen.m_EddyStrength = 0;
         break;
     default:
         parameters.m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS;
     }
 
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.SignalScale", IntProperty::New(parameters.m_SignalGen.m_SignalScale));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.FiberRadius", IntProperty::New(parameters.m_SignalGen.m_AxonRadius));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Tinhom", DoubleProperty::New(parameters.m_SignalGen.m_tInhom));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Tline", DoubleProperty::New(parameters.m_SignalGen.m_tLine));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.TE", DoubleProperty::New(parameters.m_SignalGen.m_tEcho));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.b-value", DoubleProperty::New(parameters.m_SignalGen.m_Bvalue));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.NoPartialVolume", BoolProperty::New(parameters.m_SignalGen.m_DoDisablePartialVolume));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Relaxation", BoolProperty::New(parameters.m_SignalGen.m_DoSimulateRelaxation));
     parameters.m_Misc.m_ResultNode->AddProperty("binary", BoolProperty::New(false));
 
     parameters.m_Misc.m_CheckRealTimeFibersBox = m_Controls->m_RealTimeFibers->isChecked();
     parameters.m_Misc.m_CheckAdvancedFiberOptionsBox = m_Controls->m_AdvancedOptionsBox->isChecked();
     parameters.m_Misc.m_CheckIncludeFiducialsBox = m_Controls->m_IncludeFiducials->isChecked();
     parameters.m_Misc.m_CheckConstantRadiusBox = m_Controls->m_ConstantRadiusBox->isChecked();
 
     switch(m_Controls->m_DistributionBox->currentIndex())
     {
     case 0:
         parameters.m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
         break;
     case 1:
         parameters.m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_GAUSSIAN;
         break;
     default:
         parameters.m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
     }
     parameters.m_FiberGen.m_Variance = m_Controls->m_VarianceBox->value();
     parameters.m_FiberGen.m_Density = m_Controls->m_FiberDensityBox->value();
     parameters.m_FiberGen.m_Sampling = m_Controls->m_FiberSamplingBox->value();
     parameters.m_FiberGen.m_Tension = m_Controls->m_TensionBox->value();
     parameters.m_FiberGen.m_Continuity = m_Controls->m_ContinuityBox->value();
     parameters.m_FiberGen.m_Bias = m_Controls->m_BiasBox->value();
     parameters.m_FiberGen.m_Rotation[0] = m_Controls->m_XrotBox->value();
     parameters.m_FiberGen.m_Rotation[1] = m_Controls->m_YrotBox->value();
     parameters.m_FiberGen.m_Rotation[2] = m_Controls->m_ZrotBox->value();
     parameters.m_FiberGen.m_Translation[0] = m_Controls->m_XtransBox->value();
     parameters.m_FiberGen.m_Translation[1] = m_Controls->m_YtransBox->value();
     parameters.m_FiberGen.m_Translation[2] = m_Controls->m_ZtransBox->value();
     parameters.m_FiberGen.m_Scale[0] = m_Controls->m_XscaleBox->value();
     parameters.m_FiberGen.m_Scale[1] = m_Controls->m_YscaleBox->value();
     parameters.m_FiberGen.m_Scale[2] = m_Controls->m_ZscaleBox->value();
 
     return parameters;
 }
 
 void QmitkFiberfoxView::SaveParameters()
 {
     FiberfoxParameters<> ffParamaters = UpdateImageParameters<double>();
 
     QString filename = QFileDialog::getSaveFileName(
                 0,
                 tr("Save Parameters"),
                 m_ParameterFile,
                 tr("Fiberfox Parameters (*.ffp)") );
 
     bool ok = true;
     bool first = true;
     bool dosampling = false;
     mitk::Image::Pointer diffImg = NULL;
     itk::Image< itk::DiffusionTensor3D< double >, 3 >::Pointer tensorImage = NULL;
     const int shOrder = 2;
     typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,shOrder,QBALL_ODFSIZE> QballFilterType;
     QballFilterType::CoefficientImageType::Pointer itkFeatureImage = NULL;
     ItkDoubleImgType::Pointer adcImage = NULL;
 
     for (unsigned int i=0; i<ffParamaters.m_FiberModelList.size()+ffParamaters.m_NonFiberModelList.size(); i++)
     {
         mitk::RawShModel<>* model = NULL;
         if (i<ffParamaters.m_FiberModelList.size())
             model = dynamic_cast<  mitk::RawShModel<>* >(ffParamaters.m_FiberModelList.at(i));
         else
             model = dynamic_cast<  mitk::RawShModel<>* >(ffParamaters.m_NonFiberModelList.at(i-ffParamaters.m_FiberModelList.size()));
 
         if (model!=0 && model->GetNumberOfKernels()<=0)
         {
             if (first==true)
             {
                 if (QMessageBox::question(NULL, "Prototype signal sampling", "Do you want to sample prototype signals from the selected diffusion-weighted imag and save them?",QMessageBox::Yes,QMessageBox::No)==QMessageBox::Yes)
                     dosampling = true;
 
                 first = false;
                 if (dosampling && (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNull() || !mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData()))))
                 {
                     QMessageBox::information(NULL, "Parameter file not saved", "No diffusion-weighted image selected to sample signal from.");
                     return;
                 }
                 else if (dosampling)
                 {
                   diffImg = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
 
                   typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
                   TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
                   ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
                   mitk::CastToItkImage(diffImg, itkVectorImagePointer);
                   filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
                   filter->SetBValue( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
 
                   filter->Update();
                   tensorImage = filter->GetOutput();
 
                   const int NumCoeffs = (shOrder*shOrder + shOrder + 2)/2 + shOrder;
                   QballFilterType::Pointer qballfilter = QballFilterType::New();
                   qballfilter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
                   qballfilter->SetBValue( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
                   qballfilter->SetLambda(0.006);
                   qballfilter->SetNormalizationMethod(QballFilterType::QBAR_RAW_SIGNAL);
                   qballfilter->Update();
                   itkFeatureImage = qballfilter->GetCoefficientImage();
 
                   itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
                   adcFilter->SetInput( itkVectorImagePointer );
                   adcFilter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
                   adcFilter->SetB_value( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
                   adcFilter->Update();
                   adcImage = adcFilter->GetOutput();
                 }
             }
 
             if (dosampling && diffImg.IsNotNull())
             {
                 ok = model->SampleKernels(diffImg, ffParamaters.m_SignalGen.m_MaskImage, tensorImage, itkFeatureImage, adcImage);
                 if (!ok)
                 {
                     QMessageBox::information( NULL, "Parameter file not saved", "No valid prototype signals could be sampled.");
                     return;
                 }
             }
         }
     }
 
     ffParamaters.SaveParameters(filename.toStdString());
     m_ParameterFile = filename;
 }
 
 void QmitkFiberfoxView::LoadParameters()
 {
     QString filename = QFileDialog::getOpenFileName(0, tr("Load Parameters"), QString(itksys::SystemTools::GetFilenamePath(m_ParameterFile.toStdString()).c_str()), tr("Fiberfox Parameters (*.ffp)") );
     if(filename.isEmpty() || filename.isNull())
         return;
 
     m_ParameterFile = filename;
 
     FiberfoxParameters<> parameters;
     parameters.LoadParameters(filename.toStdString());
 
     m_Controls->m_RealTimeFibers->setChecked(parameters.m_Misc.m_CheckRealTimeFibersBox);
     m_Controls->m_AdvancedOptionsBox->setChecked(parameters.m_Misc.m_CheckAdvancedFiberOptionsBox);
     m_Controls->m_IncludeFiducials->setChecked(parameters.m_Misc.m_CheckIncludeFiducialsBox);
     m_Controls->m_ConstantRadiusBox->setChecked(parameters.m_Misc.m_CheckConstantRadiusBox);
 
     m_Controls->m_DistributionBox->setCurrentIndex(parameters.m_FiberGen.m_Distribution);
     m_Controls->m_VarianceBox->setValue(parameters.m_FiberGen.m_Variance);
     m_Controls->m_FiberDensityBox->setValue(parameters.m_FiberGen.m_Density);
     m_Controls->m_FiberSamplingBox->setValue(parameters.m_FiberGen.m_Sampling);
     m_Controls->m_TensionBox->setValue(parameters.m_FiberGen.m_Tension);
     m_Controls->m_ContinuityBox->setValue(parameters.m_FiberGen.m_Continuity);
     m_Controls->m_BiasBox->setValue(parameters.m_FiberGen.m_Bias);
     m_Controls->m_XrotBox->setValue(parameters.m_FiberGen.m_Rotation[0]);
     m_Controls->m_YrotBox->setValue(parameters.m_FiberGen.m_Rotation[1]);
     m_Controls->m_ZrotBox->setValue(parameters.m_FiberGen.m_Rotation[2]);
     m_Controls->m_XtransBox->setValue(parameters.m_FiberGen.m_Translation[0]);
     m_Controls->m_YtransBox->setValue(parameters.m_FiberGen.m_Translation[1]);
     m_Controls->m_ZtransBox->setValue(parameters.m_FiberGen.m_Translation[2]);
     m_Controls->m_XscaleBox->setValue(parameters.m_FiberGen.m_Scale[0]);
     m_Controls->m_YscaleBox->setValue(parameters.m_FiberGen.m_Scale[1]);
     m_Controls->m_ZscaleBox->setValue(parameters.m_FiberGen.m_Scale[2]);
 
     // image generation parameters
     m_Controls->m_SizeX->setValue(parameters.m_SignalGen.m_ImageRegion.GetSize(0));
     m_Controls->m_SizeY->setValue(parameters.m_SignalGen.m_ImageRegion.GetSize(1));
     m_Controls->m_SizeZ->setValue(parameters.m_SignalGen.m_ImageRegion.GetSize(2));
     m_Controls->m_SpacingX->setValue(parameters.m_SignalGen.m_ImageSpacing[0]);
     m_Controls->m_SpacingY->setValue(parameters.m_SignalGen.m_ImageSpacing[1]);
     m_Controls->m_SpacingZ->setValue(parameters.m_SignalGen.m_ImageSpacing[2]);
     m_Controls->m_NumGradientsBox->setValue(parameters.m_SignalGen.GetNumWeightedVolumes());
     m_Controls->m_BvalueBox->setValue(parameters.m_SignalGen.m_Bvalue);
     m_Controls->m_SignalScaleBox->setValue(parameters.m_SignalGen.m_SignalScale);
     m_Controls->m_TEbox->setValue(parameters.m_SignalGen.m_tEcho);
     m_Controls->m_LineReadoutTimeBox->setValue(parameters.m_SignalGen.m_tLine);
     m_Controls->m_T2starBox->setValue(parameters.m_SignalGen.m_tInhom);
     m_Controls->m_FiberRadius->setValue(parameters.m_SignalGen.m_AxonRadius);
     m_Controls->m_RelaxationBox->setChecked(parameters.m_SignalGen.m_DoSimulateRelaxation);
     m_Controls->m_EnforcePureFiberVoxelsBox->setChecked(parameters.m_SignalGen.m_DoDisablePartialVolume);
 
     if (parameters.m_NoiseModel!=NULL)
     {
         m_Controls->m_AddNoise->setChecked(parameters.m_Misc.m_CheckAddNoiseBox);
         if (dynamic_cast<mitk::RicianNoiseModel<double>*>(parameters.m_NoiseModel))
             m_Controls->m_NoiseDistributionBox->setCurrentIndex(0);
         else if (dynamic_cast<mitk::ChiSquareNoiseModel<double>*>(parameters.m_NoiseModel))
             m_Controls->m_NoiseDistributionBox->setCurrentIndex(1);
         m_Controls->m_NoiseLevel->setValue(parameters.m_NoiseModel->GetNoiseVariance());
     }
     else
         m_Controls->m_AddNoise->setChecked(false);
 
     m_Controls->m_VolumeFractionsBox->setChecked(parameters.m_Misc.m_CheckOutputVolumeFractionsBox);
     m_Controls->m_AdvancedOptionsBox_2->setChecked(parameters.m_Misc.m_CheckAdvancedSignalOptionsBox);
     m_Controls->m_AddGhosts->setChecked(parameters.m_Misc.m_CheckAddGhostsBox);
     m_Controls->m_AddAliasing->setChecked(parameters.m_Misc.m_CheckAddAliasingBox);
     m_Controls->m_AddDistortions->setChecked(parameters.m_Misc.m_CheckAddDistortionsBox);
     m_Controls->m_AddSpikes->setChecked(parameters.m_Misc.m_CheckAddSpikesBox);
     m_Controls->m_AddEddy->setChecked(parameters.m_Misc.m_CheckAddEddyCurrentsBox);
 
     m_Controls->m_kOffsetBox->setValue(parameters.m_SignalGen.m_KspaceLineOffset);
     m_Controls->m_WrapBox->setValue(100*(1-parameters.m_SignalGen.m_CroppingFactor));
     m_Controls->m_SpikeNumBox->setValue(parameters.m_SignalGen.m_Spikes);
     m_Controls->m_SpikeScaleBox->setValue(parameters.m_SignalGen.m_SpikeAmplitude);
     m_Controls->m_EddyGradientStrength->setValue(parameters.m_SignalGen.m_EddyStrength);
     m_Controls->m_AddGibbsRinging->setChecked(parameters.m_SignalGen.m_DoAddGibbsRinging);
     m_Controls->m_AddMotion->setChecked(parameters.m_SignalGen.m_DoAddMotion);
     m_Controls->m_RandomMotion->setChecked(parameters.m_SignalGen.m_DoRandomizeMotion);
     m_Controls->m_MaxTranslationBoxX->setValue(parameters.m_SignalGen.m_Translation[0]);
     m_Controls->m_MaxTranslationBoxY->setValue(parameters.m_SignalGen.m_Translation[1]);
     m_Controls->m_MaxTranslationBoxZ->setValue(parameters.m_SignalGen.m_Translation[2]);
     m_Controls->m_MaxRotationBoxX->setValue(parameters.m_SignalGen.m_Rotation[0]);
     m_Controls->m_MaxRotationBoxY->setValue(parameters.m_SignalGen.m_Rotation[1]);
     m_Controls->m_MaxRotationBoxZ->setValue(parameters.m_SignalGen.m_Rotation[2]);
     m_Controls->m_DiffusionDirectionBox->setCurrentIndex(parameters.m_SignalGen.m_DiffusionDirectionMode);
     m_Controls->m_SeparationAngleBox->setValue(parameters.m_SignalGen.m_FiberSeparationThreshold);
 
     m_Controls->m_Compartment1Box->setCurrentIndex(0);
     m_Controls->m_Compartment2Box->setCurrentIndex(0);
     m_Controls->m_Compartment3Box->setCurrentIndex(0);
     m_Controls->m_Compartment4Box->setCurrentIndex(0);
 
     for (unsigned int i=0; i<parameters.m_FiberModelList.size()+parameters.m_NonFiberModelList.size(); i++)
     {
         mitk::DiffusionSignalModel<ScalarType>* signalModel = NULL;
         if (i<parameters.m_FiberModelList.size())
             signalModel = parameters.m_FiberModelList.at(i);
         else
             signalModel = parameters.m_NonFiberModelList.at(i-parameters.m_FiberModelList.size());
 
         switch (signalModel->m_CompartmentId)
         {
         case 1:
         {
             if (dynamic_cast<mitk::StickModel<>*>(signalModel))
             {
                 mitk::StickModel<>* model = dynamic_cast<mitk::StickModel<>*>(signalModel);
                 m_Controls->m_StickWidget1->SetT2(model->GetT2());
                 m_Controls->m_StickWidget1->SetD(model->GetDiffusivity());
                 m_Controls->m_Compartment1Box->setCurrentIndex(0);
                 break;
             }
             else if (dynamic_cast<mitk::TensorModel<>*>(signalModel))
             {
                 mitk::TensorModel<>* model = dynamic_cast<mitk::TensorModel<>*>(signalModel);
                 m_Controls->m_TensorWidget1->SetT2(model->GetT2());
                 m_Controls->m_TensorWidget1->SetD1(model->GetDiffusivity1());
                 m_Controls->m_TensorWidget1->SetD2(model->GetDiffusivity2());
                 m_Controls->m_TensorWidget1->SetD3(model->GetDiffusivity3());
                 m_Controls->m_Compartment1Box->setCurrentIndex(2);
                 break;
             }
             else if (dynamic_cast<mitk::RawShModel<>*>(signalModel))
             {
                 mitk::RawShModel<>* model = dynamic_cast<mitk::RawShModel<>*>(signalModel);
                 m_Controls->m_PrototypeWidget1->SetNumberOfSamples(model->GetMaxNumKernels());
                 m_Controls->m_PrototypeWidget1->SetMinFa(model->GetFaRange().first);
                 m_Controls->m_PrototypeWidget1->SetMaxFa(model->GetFaRange().second);
                 m_Controls->m_PrototypeWidget1->SetMinAdc(model->GetAdcRange().first);
                 m_Controls->m_PrototypeWidget1->SetMaxAdc(model->GetAdcRange().second);
                 m_Controls->m_Compartment1Box->setCurrentIndex(3);
                 break;
             }
             break;
         }
         case 2:
         {
             if (dynamic_cast<mitk::StickModel<>*>(signalModel))
             {
                 mitk::StickModel<>* model = dynamic_cast<mitk::StickModel<>*>(signalModel);
                 m_Controls->m_StickWidget2->SetT2(model->GetT2());
                 m_Controls->m_StickWidget2->SetD(model->GetDiffusivity());
                 m_Controls->m_Compartment2Box->setCurrentIndex(1);
                 break;
             }
             else if (dynamic_cast<mitk::TensorModel<>*>(signalModel))
             {
                 mitk::TensorModel<>* model = dynamic_cast<mitk::TensorModel<>*>(signalModel);
                 m_Controls->m_TensorWidget2->SetT2(model->GetT2());
                 m_Controls->m_TensorWidget2->SetD1(model->GetDiffusivity1());
                 m_Controls->m_TensorWidget2->SetD2(model->GetDiffusivity2());
                 m_Controls->m_TensorWidget2->SetD3(model->GetDiffusivity3());
                 m_Controls->m_Compartment2Box->setCurrentIndex(3);
                 break;
             }
             break;
         }
         case 3:
         {
             if (dynamic_cast<mitk::BallModel<>*>(signalModel))
             {
                 mitk::BallModel<>* model = dynamic_cast<mitk::BallModel<>*>(signalModel);
                 m_Controls->m_BallWidget1->SetT2(model->GetT2());
                 m_Controls->m_BallWidget1->SetD(model->GetDiffusivity());
                 m_Controls->m_Compartment3Box->setCurrentIndex(0);
                 break;
             }
             else if (dynamic_cast<mitk::AstroStickModel<>*>(signalModel))
             {
                 mitk::AstroStickModel<>* model = dynamic_cast<mitk::AstroStickModel<>*>(signalModel);
                 m_Controls->m_AstrosticksWidget1->SetT2(model->GetT2());
                 m_Controls->m_AstrosticksWidget1->SetD(model->GetDiffusivity());
                 m_Controls->m_AstrosticksWidget1->SetRandomizeSticks(model->GetRandomizeSticks());
                 m_Controls->m_Compartment3Box->setCurrentIndex(1);
                 break;
             }
             else if (dynamic_cast<mitk::DotModel<>*>(signalModel))
             {
                 mitk::DotModel<>* model = dynamic_cast<mitk::DotModel<>*>(signalModel);
                 m_Controls->m_DotWidget1->SetT2(model->GetT2());
                 m_Controls->m_Compartment3Box->setCurrentIndex(2);
                 break;
             }
             else if (dynamic_cast<mitk::RawShModel<>*>(signalModel))
             {
                 mitk::RawShModel<>* model = dynamic_cast<mitk::RawShModel<>*>(signalModel);
                 m_Controls->m_PrototypeWidget3->SetNumberOfSamples(model->GetMaxNumKernels());
                 m_Controls->m_PrototypeWidget3->SetMinFa(model->GetFaRange().first);
                 m_Controls->m_PrototypeWidget3->SetMaxFa(model->GetFaRange().second);
                 m_Controls->m_PrototypeWidget3->SetMinAdc(model->GetAdcRange().first);
                 m_Controls->m_PrototypeWidget3->SetMaxAdc(model->GetAdcRange().second);
                 m_Controls->m_Compartment3Box->setCurrentIndex(3);
                 break;
             }
             break;
         }
         case 4:
         {
             if (dynamic_cast<mitk::BallModel<>*>(signalModel))
             {
                 mitk::BallModel<>* model = dynamic_cast<mitk::BallModel<>*>(signalModel);
                 m_Controls->m_BallWidget2->SetT2(model->GetT2());
                 m_Controls->m_BallWidget2->SetD(model->GetDiffusivity());
                 m_Controls->m_Compartment4Box->setCurrentIndex(1);
                 break;
             }
             else if (dynamic_cast<mitk::AstroStickModel<>*>(signalModel))
             {
                 mitk::AstroStickModel<>* model = dynamic_cast<mitk::AstroStickModel<>*>(signalModel);
                 m_Controls->m_AstrosticksWidget2->SetT2(model->GetT2());
                 m_Controls->m_AstrosticksWidget2->SetD(model->GetDiffusivity());
                 m_Controls->m_AstrosticksWidget2->SetRandomizeSticks(model->GetRandomizeSticks());
                 m_Controls->m_Compartment4Box->setCurrentIndex(2);
                 break;
             }
             else if (dynamic_cast<mitk::DotModel<>*>(signalModel))
             {
                 mitk::DotModel<>* model = dynamic_cast<mitk::DotModel<>*>(signalModel);
                 m_Controls->m_DotWidget2->SetT2(model->GetT2());
                 m_Controls->m_Compartment4Box->setCurrentIndex(3);
                 break;
             }
             else if (dynamic_cast<mitk::RawShModel<>*>(signalModel))
             {
                 mitk::RawShModel<>* model = dynamic_cast<mitk::RawShModel<>*>(signalModel);
                 m_Controls->m_PrototypeWidget4->SetNumberOfSamples(model->GetMaxNumKernels());
                 m_Controls->m_PrototypeWidget4->SetMinFa(model->GetFaRange().first);
                 m_Controls->m_PrototypeWidget4->SetMaxFa(model->GetFaRange().second);
                 m_Controls->m_PrototypeWidget4->SetMinAdc(model->GetAdcRange().first);
                 m_Controls->m_PrototypeWidget4->SetMaxAdc(model->GetAdcRange().second);
                 m_Controls->m_Compartment4Box->setCurrentIndex(4);
                 break;
             }
             break;
         }
         }
     }
 }
 
 void QmitkFiberfoxView::ShowAdvancedOptions(int state)
 {
     if (state)
     {
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(true);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(true);
         m_Controls->m_AdvancedOptionsBox->setChecked(true);
         m_Controls->m_AdvancedOptionsBox_2->setChecked(true);
     }
     else
     {
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedOptionsBox->setChecked(false);
         m_Controls->m_AdvancedOptionsBox_2->setChecked(false);
     }
 }
 
 void QmitkFiberfoxView::Comp1ModelFrameVisibility(int index)
 {
     m_Controls->m_StickWidget1->setVisible(false);
     m_Controls->m_ZeppelinWidget1->setVisible(false);
     m_Controls->m_TensorWidget1->setVisible(false);
     m_Controls->m_PrototypeWidget1->setVisible(false);
 
     switch (index)
     {
     case 0:
         m_Controls->m_StickWidget1->setVisible(true);
         break;
     case 1:
         m_Controls->m_ZeppelinWidget1->setVisible(true);
         break;
     case 2:
         m_Controls->m_TensorWidget1->setVisible(true);
         break;
     case 3:
         m_Controls->m_PrototypeWidget1->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp2ModelFrameVisibility(int index)
 {
     m_Controls->m_StickWidget2->setVisible(false);
     m_Controls->m_ZeppelinWidget2->setVisible(false);
     m_Controls->m_TensorWidget2->setVisible(false);
 
     switch (index)
     {
     case 0:
         break;
     case 1:
         m_Controls->m_StickWidget2->setVisible(true);
         break;
     case 2:
         m_Controls->m_ZeppelinWidget2->setVisible(true);
         break;
     case 3:
         m_Controls->m_TensorWidget2->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp3ModelFrameVisibility(int index)
 {
     m_Controls->m_BallWidget1->setVisible(false);
     m_Controls->m_AstrosticksWidget1->setVisible(false);
     m_Controls->m_DotWidget1->setVisible(false);
     m_Controls->m_PrototypeWidget3->setVisible(false);
 
     switch (index)
     {
     case 0:
         m_Controls->m_BallWidget1->setVisible(true);
         break;
     case 1:
         m_Controls->m_AstrosticksWidget1->setVisible(true);
         break;
     case 2:
         m_Controls->m_DotWidget1->setVisible(true);
         break;
     case 3:
         m_Controls->m_PrototypeWidget3->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp4ModelFrameVisibility(int index)
 {
     m_Controls->m_BallWidget2->setVisible(false);
     m_Controls->m_AstrosticksWidget2->setVisible(false);
     m_Controls->m_DotWidget2->setVisible(false);
     m_Controls->m_PrototypeWidget4->setVisible(false);
     m_Controls->m_Comp4FractionFrame->setVisible(false);
 
     switch (index)
     {
     case 0:
         break;
     case 1:
         m_Controls->m_BallWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     case 2:
         m_Controls->m_AstrosticksWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     case 3:
         m_Controls->m_DotWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     case 4:
         m_Controls->m_PrototypeWidget4->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::OnConstantRadius(int value)
 {
     if (value>0 && m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnAddMotion(int value)
 {
     if (value>0)
         m_Controls->m_MotionArtifactFrame->setVisible(true);
     else
         m_Controls->m_MotionArtifactFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddAliasing(int value)
 {
     if (value>0)
         m_Controls->m_AliasingFrame->setVisible(true);
     else
         m_Controls->m_AliasingFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddSpikes(int value)
 {
     if (value>0)
         m_Controls->m_SpikeFrame->setVisible(true);
     else
         m_Controls->m_SpikeFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddEddy(int value)
 {
     if (value>0)
         m_Controls->m_EddyFrame->setVisible(true);
     else
         m_Controls->m_EddyFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddDistortions(int value)
 {
     if (value>0)
         m_Controls->m_DistortionsFrame->setVisible(true);
     else
         m_Controls->m_DistortionsFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddGhosts(int value)
 {
     if (value>0)
         m_Controls->m_GhostFrame->setVisible(true);
     else
         m_Controls->m_GhostFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddNoise(int value)
 {
     if (value>0)
         m_Controls->m_NoiseFrame->setVisible(true);
     else
         m_Controls->m_NoiseFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnDistributionChanged(int value)
 {
     if (value==1)
         m_Controls->m_VarianceBox->setVisible(true);
     else
         m_Controls->m_VarianceBox->setVisible(false);
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnVarianceChanged(double)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFiberDensityChanged(int)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFiberSamplingChanged(double)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnTensionChanged(double)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnContinuityChanged(double)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnBiasChanged(double)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::AlignOnGrid()
 {
     for (unsigned int i=0; i<m_SelectedFiducials.size(); i++)
     {
         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
         mitk::DataStorage::SetOfObjects::ConstPointer parentFibs = GetDataStorage()->GetSources(m_SelectedFiducials.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = parentFibs->begin(); it != parentFibs->end(); ++it )
         {
             mitk::DataNode::Pointer pFibNode = *it;
-            if ( pFibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pFibNode->GetData()) )
+            if ( pFibNode.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(pFibNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(pFibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer pImgNode = *it2;
                     if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
                     {
                         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(pImgNode->GetData());
                         mitk::BaseGeometry::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
 
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
 
                         break;
                     }
                 }
                 break;
             }
         }
     }
 
     for(unsigned int i=0; i<m_SelectedBundles2.size(); i++ )
     {
         mitk::DataNode::Pointer fibNode = m_SelectedBundles2.at(i);
 
         mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(fibNode);
         for( mitk::DataStorage::SetOfObjects::const_iterator it = sources->begin(); it != sources->end(); ++it )
         {
             mitk::DataNode::Pointer imgNode = *it;
             if ( imgNode.IsNotNull() && dynamic_cast<mitk::Image*>(imgNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(fibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
                         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(imgNode->GetData());
                         mitk::BaseGeometry::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
                     }
                 }
 
                 break;
             }
         }
     }
 
     for(unsigned int i=0; i<m_SelectedImages.size(); i++ )
     {
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_SelectedImages.at(i)->GetData());
 
         mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
         {
             mitk::DataNode::Pointer fibNode = *it;
-            if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
+            if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(fibNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations2 = GetDataStorage()->GetDerivations(fibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations2->begin(); it2 != derivations2->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
                         mitk::BaseGeometry::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
                     }
                 }
             }
         }
     }
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFlipButton()
 {
     if (m_SelectedFiducial.IsNull())
         return;
 
     std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(m_SelectedFiducial.GetPointer());
     if( it != m_DataNodeToPlanarFigureData.end() )
     {
         QmitkPlanarFigureData& data = it->second;
         data.m_Flipped += 1;
         data.m_Flipped %= 2;
     }
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 QmitkFiberfoxView::GradientListType QmitkFiberfoxView::GenerateHalfShell(int NPoints)
 {
     NPoints *= 2;
     GradientListType pointshell;
 
     int numB0 = NPoints/20;
     if (numB0==0)
         numB0=1;
     GradientType g;
     g.Fill(0.0);
     for (int i=0; i<numB0; i++)
         pointshell.push_back(g);
 
     if (NPoints==0)
         return pointshell;
 
     vnl_vector<double> theta; theta.set_size(NPoints);
     vnl_vector<double> phi; phi.set_size(NPoints);
     double C = sqrt(4*M_PI);
     phi(0) = 0.0;
     phi(NPoints-1) = 0.0;
     for(int i=0; i<NPoints; i++)
     {
         theta(i) = acos(-1.0+2.0*i/(NPoints-1.0)) - M_PI / 2.0;
         if( i>0 && i<NPoints-1)
         {
             phi(i) = (phi(i-1) + C /
                       sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
             // % (2*DIST_POINTSHELL_PI);
         }
     }
 
     for(int i=0; i<NPoints; i++)
     {
         g[2] = sin(theta(i));
         if (g[2]<0)
             continue;
         g[0] = cos(theta(i)) * cos(phi(i));
         g[1] = cos(theta(i)) * sin(phi(i));
         pointshell.push_back(g);
     }
 
     return pointshell;
 }
 
 template<int ndirs>
 std::vector<itk::Vector<double,3> > QmitkFiberfoxView::MakeGradientList()
 {
     std::vector<itk::Vector<double,3> > retval;
     vnl_matrix_fixed<double, 3, ndirs>* U =
             itk::PointShell<ndirs, vnl_matrix_fixed<double, 3, ndirs> >::DistributePointShell();
 
 
     // Add 0 vector for B0
     int numB0 = ndirs/10;
     if (numB0==0)
         numB0=1;
     itk::Vector<double,3> v;
     v.Fill(0.0);
     for (int i=0; i<numB0; i++)
     {
         retval.push_back(v);
     }
 
     for(int i=0; i<ndirs;i++)
     {
         itk::Vector<double,3> v;
         v[0] = U->get(0,i); v[1] = U->get(1,i); v[2] = U->get(2,i);
         retval.push_back(v);
     }
 
     return retval;
 }
 
 void QmitkFiberfoxView::OnAddBundle()
 {
     if (m_SelectedImage.IsNull())
         return;
 
     mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedImage);
 
-    mitk::FiberBundleX::Pointer bundle = mitk::FiberBundleX::New();
+    mitk::FiberBundle::Pointer bundle = mitk::FiberBundle::New();
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( bundle );
     QString name = QString("Bundle_%1").arg(children->size());
     node->SetName(name.toStdString());
     m_SelectedBundles.push_back(node);
     UpdateGui();
 
     GetDataStorage()->Add(node, m_SelectedImage);
 }
 
 void QmitkFiberfoxView::OnDrawROI()
 {
     if (m_SelectedBundles.empty())
         OnAddBundle();
     if (m_SelectedBundles.empty())
         return;
 
     mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(0));
 
     mitk::PlanarEllipse::Pointer figure = mitk::PlanarEllipse::New();
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( figure );
     node->SetBoolProperty("planarfigure.3drendering", true);
 
     QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
     for( int i=0; i<nodes.size(); i++)
         nodes.at(i)->SetSelected(false);
 
     m_SelectedFiducial = node;
 
     QString name = QString("Fiducial_%1").arg(children->size());
     node->SetName(name.toStdString());
     node->SetSelected(true);
 
     this->DisableCrosshairNavigation();
 
     mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
     if(figureInteractor.IsNull())
     {
         figureInteractor = mitk::PlanarFigureInteractor::New();
         us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
         figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
         figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
         figureInteractor->SetDataNode( node );
     }
 
     UpdateGui();
     GetDataStorage()->Add(node, m_SelectedBundles.at(0));
 }
 
 bool CompareLayer(mitk::DataNode::Pointer i,mitk::DataNode::Pointer j)
 {
     int li = -1;
     i->GetPropertyValue("layer", li);
     int lj = -1;
     j->GetPropertyValue("layer", lj);
     return li<lj;
 }
 
 void QmitkFiberfoxView::GenerateFibers()
 {
     if (m_SelectedBundles.empty())
     {
         if (m_SelectedFiducial.IsNull())
             return;
 
         mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(m_SelectedFiducial);
         for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
-            if(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()))
+            if(dynamic_cast<mitk::FiberBundle*>((*it)->GetData()))
                 m_SelectedBundles.push_back(*it);
 
         if (m_SelectedBundles.empty())
             return;
     }
 
     FiberfoxParameters<double> parameters = UpdateImageParameters<double>();
 
     for (unsigned int i=0; i<m_SelectedBundles.size(); i++)
     {
         mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(i));
         std::vector< mitk::DataNode::Pointer > childVector;
         for( mitk::DataStorage::SetOfObjects::const_iterator it = children->begin(); it != children->end(); ++it )
             childVector.push_back(*it);
         sort(childVector.begin(), childVector.end(), CompareLayer);
 
         vector< mitk::PlanarEllipse::Pointer > fib;
         vector< unsigned int > flip;
         float radius = 1;
         int count = 0;
         for( std::vector< mitk::DataNode::Pointer >::const_iterator it = childVector.begin(); it != childVector.end(); ++it )
         {
             mitk::DataNode::Pointer node = *it;
 
             if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
             {
                 mitk::PlanarEllipse* ellipse = dynamic_cast<mitk::PlanarEllipse*>(node->GetData());
                 if (m_Controls->m_ConstantRadiusBox->isChecked())
                 {
                     ellipse->SetTreatAsCircle(true);
                     mitk::Point2D c = ellipse->GetControlPoint(0);
                     mitk::Point2D p = ellipse->GetControlPoint(1);
                     mitk::Vector2D v = p-c;
                     if (count==0)
                     {
                         radius = v.GetVnlVector().magnitude();
                         ellipse->SetControlPoint(1, p);
                         ellipse->Modified();
                     }
                     else
                     {
                         v.Normalize();
                         v *= radius;
                         ellipse->SetControlPoint(1, c+v);
                         ellipse->Modified();
                     }
                 }
                 fib.push_back(ellipse);
 
                 std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(node.GetPointer());
                 if( it != m_DataNodeToPlanarFigureData.end() )
                 {
                     QmitkPlanarFigureData& data = it->second;
                     flip.push_back(data.m_Flipped);
                 }
                 else
                     flip.push_back(0);
             }
             count++;
         }
         if (fib.size()>1)
         {
             parameters.m_FiberGen.m_Fiducials.push_back(fib);
             parameters.m_FiberGen.m_FlipList.push_back(flip);
         }
         else if (fib.size()>0)
-            m_SelectedBundles.at(i)->SetData( mitk::FiberBundleX::New() );
+            m_SelectedBundles.at(i)->SetData( mitk::FiberBundle::New() );
 
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     itk::FibersFromPlanarFiguresFilter::Pointer filter = itk::FibersFromPlanarFiguresFilter::New();
     filter->SetParameters(parameters.m_FiberGen);
     filter->Update();
-    vector< mitk::FiberBundleX::Pointer > fiberBundles = filter->GetFiberBundles();
+    vector< mitk::FiberBundle::Pointer > fiberBundles = filter->GetFiberBundles();
 
     for (unsigned int i=0; i<fiberBundles.size(); i++)
     {
         m_SelectedBundles.at(i)->SetData( fiberBundles.at(i) );
         if (fiberBundles.at(i)->GetNumFibers()>50000)
             m_SelectedBundles.at(i)->SetVisibility(false);
     }
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::GenerateImage()
 {
     if (m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNull() && m_Controls->m_TemplateComboBox->GetSelectedNode().IsNull())
     {
         mitk::Image::Pointer image = mitk::ImageGenerator::GenerateGradientImage<unsigned int>(
                     m_Controls->m_SizeX->value(),
                     m_Controls->m_SizeY->value(),
                     m_Controls->m_SizeZ->value(),
                     m_Controls->m_SpacingX->value(),
                     m_Controls->m_SpacingY->value(),
                     m_Controls->m_SpacingZ->value());
 
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData( image );
         node->SetName("Dummy");
         unsigned int window = m_Controls->m_SizeX->value()*m_Controls->m_SizeY->value()*m_Controls->m_SizeZ->value();
         unsigned int level = window/2;
         mitk::LevelWindow lw; lw.SetLevelWindow(level, window);
         node->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( lw ) );
         GetDataStorage()->Add(node);
         m_SelectedImage = node;
 
         mitk::BaseData::Pointer basedata = node->GetData();
         if (basedata.IsNotNull())
         {
             mitk::RenderingManager::GetInstance()->InitializeViews( basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
             mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
         UpdateGui();
     }
     else if (m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNotNull())
         SimulateImageFromFibers(m_Controls->m_FiberBundleComboBox->GetSelectedNode());
     else if ( m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() )
         SimulateForExistingDwi(m_Controls->m_TemplateComboBox->GetSelectedNode());
 }
 
 void QmitkFiberfoxView::SimulateForExistingDwi(mitk::DataNode* imageNode)
 {
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(imageNode->GetData())) );
   if ( !isDiffusionImage )
   {
     return;
   }
 
     FiberfoxParameters<short> parameters = UpdateImageParameters<short>();
 
     if (parameters.m_NoiseModel==NULL &&
             parameters.m_SignalGen.m_Spikes==0 &&
             parameters.m_SignalGen.m_FrequencyMap.IsNull() &&
             parameters.m_SignalGen.m_KspaceLineOffset<=0.000001 &&
             !parameters.m_SignalGen.m_DoAddGibbsRinging &&
             !(parameters.m_SignalGen.m_EddyStrength>0) &&
             parameters.m_SignalGen.m_CroppingFactor>0.999)
     {
         QMessageBox::information( NULL, "Simulation cancelled", "No valid artifact enabled! Motion artifacts and relaxation effects can NOT be added to an existing diffusion weighted image.");
         return;
     }
 
     mitk::Image::Pointer diffImg = dynamic_cast<mitk::Image*>(imageNode->GetData());
 
     ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
     mitk::CastToItkImage(diffImg, itkVectorImagePointer);
 
     m_ArtifactsToDwiFilter = itk::AddArtifactsToDwiImageFilter< short >::New();
     m_ArtifactsToDwiFilter->SetInput(itkVectorImagePointer);
     parameters.m_Misc.m_ParentNode = imageNode;
     m_ArtifactsToDwiFilter->SetParameters(parameters);
     m_Worker.m_FilterType = 1;
     m_Thread.start(QThread::LowestPriority);
 }
 
 void QmitkFiberfoxView::SimulateImageFromFibers(mitk::DataNode* fiberNode)
 {
-    mitk::FiberBundleX::Pointer fiberBundle = dynamic_cast<mitk::FiberBundleX*>(fiberNode->GetData());
+    mitk::FiberBundle::Pointer fiberBundle = dynamic_cast<mitk::FiberBundle*>(fiberNode->GetData());
     if (fiberBundle->GetNumFibers()<=0)
         return;
 
     FiberfoxParameters<double> parameters = UpdateImageParameters<double>();
 
     m_TractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
     parameters.m_Misc.m_ParentNode = fiberNode;
     if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData())))
     {
         bool first = true;
         bool ok = true;
         mitk::Image::Pointer diffImg = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
         itk::Image< itk::DiffusionTensor3D< double >, 3 >::Pointer tensorImage = NULL;
         const int shOrder = 2;
         typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,shOrder,QBALL_ODFSIZE> QballFilterType;
         QballFilterType::CoefficientImageType::Pointer itkFeatureImage = NULL;
         ItkDoubleImgType::Pointer adcImage = NULL;
 
         for (unsigned int i=0; i<parameters.m_FiberModelList.size()+parameters.m_NonFiberModelList.size(); i++)
         {
             mitk::RawShModel<>* model = NULL;
             if (i<parameters.m_FiberModelList.size())
                 model = dynamic_cast<  mitk::RawShModel<>* >(parameters.m_FiberModelList.at(i));
             else
                 model = dynamic_cast<  mitk::RawShModel<>* >(parameters.m_NonFiberModelList.at(i-parameters.m_FiberModelList.size()));
 
             if (model!=0 && model->GetNumberOfKernels()<=0)
             {
                 if (first==true)
                 {
                   ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
                   mitk::CastToItkImage(diffImg, itkVectorImagePointer);
 
                     typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
                     TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
                     filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
                     filter->SetBValue( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
                     filter->Update();
                     tensorImage = filter->GetOutput();
 
                     const int NumCoeffs = (shOrder*shOrder + shOrder + 2)/2 + shOrder;
                     QballFilterType::Pointer qballfilter = QballFilterType::New();
                     qballfilter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
                     qballfilter->SetBValue( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
                     qballfilter->SetLambda(0.006);
                     qballfilter->SetNormalizationMethod(QballFilterType::QBAR_RAW_SIGNAL);
                     qballfilter->Update();
                     itkFeatureImage = qballfilter->GetCoefficientImage();
 
                     itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
                     adcFilter->SetInput( itkVectorImagePointer );
                     adcFilter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
                     adcFilter->SetB_value( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
                     adcFilter->Update();
                     adcImage = adcFilter->GetOutput();
                 }
                 ok = model->SampleKernels(diffImg, parameters.m_SignalGen.m_MaskImage, tensorImage, itkFeatureImage, adcImage);
                 if (!ok)
                     break;
             }
         }
 
         if (!ok)
         {
             QMessageBox::information( NULL, "Simulation cancelled", "No valid prototype signals could be sampled.");
             return;
         }
     }
     else if ( m_Controls->m_Compartment1Box->currentIndex()==3 || m_Controls->m_Compartment3Box->currentIndex()==3 || m_Controls->m_Compartment4Box->currentIndex()==4 )
     {
         QMessageBox::information( NULL, "Simulation cancelled", "Prototype signal but no diffusion-weighted image selected to sample signal from.");
         return;
     }
 
     m_TractsToDwiFilter->SetParameters(parameters);
     m_TractsToDwiFilter->SetFiberBundle(fiberBundle);
     m_Worker.m_FilterType = 0;
     m_Thread.start(QThread::LowestPriority);
 }
 
 void QmitkFiberfoxView::ApplyTransform()
 {
     vector< mitk::DataNode::Pointer > selectedBundles;
     for(unsigned int i=0; i<m_SelectedImages.size(); i++ )
     {
         mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
         {
             mitk::DataNode::Pointer fibNode = *it;
-            if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
+            if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(fibNode->GetData()) )
                 selectedBundles.push_back(fibNode);
         }
     }
     if (selectedBundles.empty())
         selectedBundles = m_SelectedBundles2;
 
     if (!selectedBundles.empty())
     {
         for (std::vector<mitk::DataNode::Pointer>::const_iterator it = selectedBundles.begin(); it!=selectedBundles.end(); ++it)
         {
-            mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
+            mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>((*it)->GetData());
             fib->RotateAroundAxis(m_Controls->m_XrotBox->value(), m_Controls->m_YrotBox->value(), m_Controls->m_ZrotBox->value());
             fib->TranslateFibers(m_Controls->m_XtransBox->value(), m_Controls->m_YtransBox->value(), m_Controls->m_ZtransBox->value());
             fib->ScaleFibers(m_Controls->m_XscaleBox->value(), m_Controls->m_YscaleBox->value(), m_Controls->m_ZscaleBox->value());
 
             // handle child fiducials
             if (m_Controls->m_IncludeFiducials->isChecked())
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::BaseGeometry* geom = pe->GetGeometry();
 
                         // translate
                         mitk::Vector3D world;
                         world[0] = m_Controls->m_XtransBox->value();
                         world[1] = m_Controls->m_YtransBox->value();
                         world[2] = m_Controls->m_ZtransBox->value();
                         geom->Translate(world);
 
                         // calculate rotation matrix
                         double x = m_Controls->m_XrotBox->value()*M_PI/180;
                         double y = m_Controls->m_YrotBox->value()*M_PI/180;
                         double z = m_Controls->m_ZrotBox->value()*M_PI/180;
 
                         itk::Matrix< double, 3, 3 > rotX; rotX.SetIdentity();
                         rotX[1][1] = cos(x);
                         rotX[2][2] = rotX[1][1];
                         rotX[1][2] = -sin(x);
                         rotX[2][1] = -rotX[1][2];
 
                         itk::Matrix< double, 3, 3 > rotY; rotY.SetIdentity();
                         rotY[0][0] = cos(y);
                         rotY[2][2] = rotY[0][0];
                         rotY[0][2] = sin(y);
                         rotY[2][0] = -rotY[0][2];
 
                         itk::Matrix< double, 3, 3 > rotZ; rotZ.SetIdentity();
                         rotZ[0][0] = cos(z);
                         rotZ[1][1] = rotZ[0][0];
                         rotZ[0][1] = -sin(z);
                         rotZ[1][0] = -rotZ[0][1];
 
                         itk::Matrix< double, 3, 3 > rot = rotZ*rotY*rotX;
 
                         // transform control point coordinate into geometry translation
                         geom->SetOrigin(pe->GetWorldControlPoint(0));
                         mitk::Point2D cp; cp.Fill(0.0);
                         pe->SetControlPoint(0, cp);
 
                         // rotate fiducial
                         geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
 
                         // implicit translation
                         mitk::Vector3D trans;
                         trans[0] = geom->GetOrigin()[0]-fib->GetGeometry()->GetCenter()[0];
                         trans[1] = geom->GetOrigin()[1]-fib->GetGeometry()->GetCenter()[1];
                         trans[2] = geom->GetOrigin()[2]-fib->GetGeometry()->GetCenter()[2];
                         mitk::Vector3D newWc = rot*trans;
                         newWc = newWc-trans;
                         geom->Translate(newWc);
 
                         pe->Modified();
                     }
                 }
             }
         }
     }
     else
     {
         for (unsigned int i=0; i<m_SelectedFiducials.size(); i++)
         {
             mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
             mitk::BaseGeometry* geom = pe->GetGeometry();
 
             // translate
             mitk::Vector3D world;
             world[0] = m_Controls->m_XtransBox->value();
             world[1] = m_Controls->m_YtransBox->value();
             world[2] = m_Controls->m_ZtransBox->value();
             geom->Translate(world);
 
             // calculate rotation matrix
             double x = m_Controls->m_XrotBox->value()*M_PI/180;
             double y = m_Controls->m_YrotBox->value()*M_PI/180;
             double z = m_Controls->m_ZrotBox->value()*M_PI/180;
             itk::Matrix< double, 3, 3 > rotX; rotX.SetIdentity();
             rotX[1][1] = cos(x);
             rotX[2][2] = rotX[1][1];
             rotX[1][2] = -sin(x);
             rotX[2][1] = -rotX[1][2];
             itk::Matrix< double, 3, 3 > rotY; rotY.SetIdentity();
             rotY[0][0] = cos(y);
             rotY[2][2] = rotY[0][0];
             rotY[0][2] = sin(y);
             rotY[2][0] = -rotY[0][2];
             itk::Matrix< double, 3, 3 > rotZ; rotZ.SetIdentity();
             rotZ[0][0] = cos(z);
             rotZ[1][1] = rotZ[0][0];
             rotZ[0][1] = -sin(z);
             rotZ[1][0] = -rotZ[0][1];
             itk::Matrix< double, 3, 3 > rot = rotZ*rotY*rotX;
 
             // transform control point coordinate into geometry translation
             geom->SetOrigin(pe->GetWorldControlPoint(0));
             mitk::Point2D cp; cp.Fill(0.0);
             pe->SetControlPoint(0, cp);
 
             // rotate fiducial
             geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
             pe->Modified();
         }
         if (m_Controls->m_RealTimeFibers->isChecked())
             GenerateFibers();
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::CopyBundles()
 {
     if ( m_SelectedBundles.size()<1 ){
         QMessageBox::information( NULL, "Warning", "Select at least one fiber bundle!");
         MITK_WARN("QmitkFiberFoxView") << "Select at least one fiber bundle!";
         return;
     }
 
     for (std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin(); it!=m_SelectedBundles.end(); ++it)
     {
         // find parent image
         mitk::DataNode::Pointer parentNode;
         mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(*it);
         for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
         {
             mitk::DataNode::Pointer pImgNode = *it2;
             if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
             {
                 parentNode = pImgNode;
                 break;
             }
         }
 
-        mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
-        mitk::FiberBundleX::Pointer newBundle = fib->GetDeepCopy();
+        mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>((*it)->GetData());
+        mitk::FiberBundle::Pointer newBundle = fib->GetDeepCopy();
         QString name((*it)->GetName().c_str());
         name += "_copy";
 
         mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
         fbNode->SetData(newBundle);
         fbNode->SetName(name.toStdString());
         fbNode->SetVisibility(true);
         if (parentNode.IsNotNull())
             GetDataStorage()->Add(fbNode, parentNode);
         else
             GetDataStorage()->Add(fbNode);
 
         // copy child fiducials
         if (m_Controls->m_IncludeFiducials->isChecked())
         {
             mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
             for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
             {
                 mitk::DataNode::Pointer fiducialNode = *it2;
                 if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                 {
                     mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData())->Clone();
                     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
                     newNode->SetData(pe);
                     newNode->SetName(fiducialNode->GetName());
                     newNode->SetBoolProperty("planarfigure.3drendering", true);
                     GetDataStorage()->Add(newNode, fbNode);
 
                 }
             }
         }
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::JoinBundles()
 {
     if ( m_SelectedBundles.size()<2 ){
         QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
         MITK_WARN("QmitkFiberFoxView") << "Select at least two fiber bundles!";
         return;
     }
 
     std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin();
-    mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
+    mitk::FiberBundle::Pointer newBundle = dynamic_cast<mitk::FiberBundle*>((*it)->GetData());
     QString name("");
     name += QString((*it)->GetName().c_str());
     ++it;
     for (; it!=m_SelectedBundles.end(); ++it)
     {
-        newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()));
+        newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundle*>((*it)->GetData()));
         name += "+"+QString((*it)->GetName().c_str());
     }
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newBundle);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::UpdateGui()
 {
     m_Controls->m_GeometryFrame->setEnabled(true);
     m_Controls->m_GeometryMessage->setVisible(false);
     m_Controls->m_DiffusionPropsMessage->setVisible(false);
     m_Controls->m_FiberGenMessage->setVisible(true);
 
     m_Controls->m_TransformBundlesButton->setEnabled(false);
     m_Controls->m_CopyBundlesButton->setEnabled(false);
     m_Controls->m_GenerateFibersButton->setEnabled(false);
     m_Controls->m_FlipButton->setEnabled(false);
     m_Controls->m_CircleButton->setEnabled(false);
     m_Controls->m_BvalueBox->setEnabled(true);
     m_Controls->m_NumGradientsBox->setEnabled(true);
     m_Controls->m_JoinBundlesButton->setEnabled(false);
     m_Controls->m_AlignOnGrid->setEnabled(false);
 
     // Fiber generation gui
     if (m_SelectedFiducial.IsNotNull())
     {
         m_Controls->m_TransformBundlesButton->setEnabled(true);
         m_Controls->m_FlipButton->setEnabled(true);
         m_Controls->m_AlignOnGrid->setEnabled(true);
     }
 
     if (m_SelectedImage.IsNotNull() || !m_SelectedBundles.empty())
     {
         m_Controls->m_CircleButton->setEnabled(true);
         m_Controls->m_FiberGenMessage->setVisible(false);
     }
     if (m_SelectedImage.IsNotNull() && !m_SelectedBundles.empty())
         m_Controls->m_AlignOnGrid->setEnabled(true);
 
     if (!m_SelectedBundles.empty())
     {
         m_Controls->m_TransformBundlesButton->setEnabled(true);
         m_Controls->m_CopyBundlesButton->setEnabled(true);
         m_Controls->m_GenerateFibersButton->setEnabled(true);
 
         if (m_SelectedBundles.size()>1)
             m_Controls->m_JoinBundlesButton->setEnabled(true);
     }
 
     // Signal generation gui
     if (m_Controls->m_MaskComboBox->GetSelectedNode().IsNotNull() || m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull())
     {
         m_Controls->m_GeometryMessage->setVisible(true);
         m_Controls->m_GeometryFrame->setEnabled(false);
     }
 
     if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData())))
     {
         m_Controls->m_DiffusionPropsMessage->setVisible(true);
         m_Controls->m_BvalueBox->setEnabled(false);
         m_Controls->m_NumGradientsBox->setEnabled(false);
         m_Controls->m_GeometryMessage->setVisible(true);
         m_Controls->m_GeometryFrame->setEnabled(false);
     }
 }
 
 void QmitkFiberfoxView::OnSelectionChanged( berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes )
 {
     m_SelectedBundles2.clear();
     m_SelectedImages.clear();
     m_SelectedFiducials.clear();
     m_SelectedFiducial = NULL;
     m_SelectedBundles.clear();
     m_SelectedImage = NULL;
 
     // iterate all selected objects, adjust warning visibility
     for( int i=0; i<nodes.size(); i++)
     {
         mitk::DataNode::Pointer node = nodes.at(i);
 
 //        bool isDiffusionImage(false);
 //        if ( node.IsNotNull() )
 //        {
 //          isDiffusionImage = mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData()));
 //        }
 
 //        if ( node.IsNotNull() && isDiffusionImage )
 //        {
 //            m_SelectedDWI = node;
 //            m_SelectedImage = node;
 //            m_SelectedImages.push_back(node);
 //        }
 
         if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             m_SelectedImages.push_back(node);
             m_SelectedImage = node;
         }
-        else if ( node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
+        else if ( node.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
         {
             m_SelectedBundles2.push_back(node);
             if (m_Controls->m_RealTimeFibers->isChecked())
             {
                 m_SelectedBundles.push_back(node);
-                mitk::FiberBundleX::Pointer newFib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
+                mitk::FiberBundle::Pointer newFib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
                 if (newFib->GetNumFibers()!=m_Controls->m_FiberDensityBox->value())
                     GenerateFibers();
             }
             else
                 m_SelectedBundles.push_back(node);
         }
         else if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
         {
             m_SelectedFiducials.push_back(node);
             m_SelectedFiducial = node;
             m_SelectedBundles.clear();
             mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(node);
             for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
             {
                 mitk::DataNode::Pointer pNode = *it;
-                if ( pNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pNode->GetData()) )
+                if ( pNode.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(pNode->GetData()) )
                     m_SelectedBundles.push_back(pNode);
             }
         }
     }
     UpdateGui();
 }
 
 
 void QmitkFiberfoxView::EnableCrosshairNavigation()
 {
     MITK_DEBUG << "EnableCrosshairNavigation";
 
     // enable the crosshair navigation
     if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
             dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
     {
         MITK_DEBUG << "enabling linked navigation";
         linkedRenderWindow->EnableLinkedNavigation(true);
         //        linkedRenderWindow->EnableSlicingPlanes(true);
     }
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::DisableCrosshairNavigation()
 {
     MITK_DEBUG << "DisableCrosshairNavigation";
 
     // disable the crosshair navigation during the drawing
     if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
             dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
     {
         MITK_DEBUG << "disabling linked navigation";
         linkedRenderWindow->EnableLinkedNavigation(false);
         //        linkedRenderWindow->EnableSlicingPlanes(false);
     }
 }
 
 void QmitkFiberfoxView::NodeRemoved(const mitk::DataNode* node)
 {
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
     std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(nonConstNode);
 
-    if (dynamic_cast<FiberBundleX*>(node->GetData()))
+    if (dynamic_cast<FiberBundle*>(node->GetData()))
     {
         m_SelectedBundles.clear();
         m_SelectedBundles2.clear();
     }
     else if (dynamic_cast<Image*>(node->GetData()))
         m_SelectedImages.clear();
 
     if( it != m_DataNodeToPlanarFigureData.end() )
     {
         QmitkPlanarFigureData& data = it->second;
 
         // remove observers
         data.m_Figure->RemoveObserver( data.m_EndPlacementObserverTag );
         data.m_Figure->RemoveObserver( data.m_SelectObserverTag );
         data.m_Figure->RemoveObserver( data.m_StartInteractionObserverTag );
         data.m_Figure->RemoveObserver( data.m_EndInteractionObserverTag );
 
         m_DataNodeToPlanarFigureData.erase( it );
     }
 }
 
 void QmitkFiberfoxView::NodeAdded( const mitk::DataNode* node )
 {
     // add observer for selection in renderwindow
     mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
     bool isPositionMarker (false);
     node->GetBoolProperty("isContourMarker", isPositionMarker);
     if( figure && !isPositionMarker )
     {
         MITK_DEBUG << "figure added. will add interactor if needed.";
         mitk::PlanarFigureInteractor::Pointer figureInteractor
                 = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
         mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>( node );
         if(figureInteractor.IsNull())
         {
             figureInteractor = mitk::PlanarFigureInteractor::New();
             us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
             figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
             figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
             figureInteractor->SetDataNode( nonConstNode );
         }
 
         MITK_DEBUG << "will now add observers for planarfigure";
         QmitkPlanarFigureData data;
         data.m_Figure = figure;
 
         //        // add observer for event when figure has been placed
         typedef itk::SimpleMemberCommand< QmitkFiberfoxView > SimpleCommandType;
         //        SimpleCommandType::Pointer initializationCommand = SimpleCommandType::New();
         //        initializationCommand->SetCallbackFunction( this, &QmitkFiberfoxView::PlanarFigureInitialized );
         //        data.m_EndPlacementObserverTag = figure->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
 
         // add observer for event when figure is picked (selected)
         typedef itk::MemberCommand< QmitkFiberfoxView > MemberCommandType;
         MemberCommandType::Pointer selectCommand = MemberCommandType::New();
         selectCommand->SetCallbackFunction( this, &QmitkFiberfoxView::PlanarFigureSelected );
         data.m_SelectObserverTag = figure->AddObserver( mitk::SelectPlanarFigureEvent(), selectCommand );
 
         // add observer for event when interaction with figure starts
         SimpleCommandType::Pointer startInteractionCommand = SimpleCommandType::New();
         startInteractionCommand->SetCallbackFunction( this, &QmitkFiberfoxView::DisableCrosshairNavigation);
         data.m_StartInteractionObserverTag = figure->AddObserver( mitk::StartInteractionPlanarFigureEvent(), startInteractionCommand );
 
         // add observer for event when interaction with figure starts
         SimpleCommandType::Pointer endInteractionCommand = SimpleCommandType::New();
         endInteractionCommand->SetCallbackFunction( this, &QmitkFiberfoxView::EnableCrosshairNavigation);
         data.m_EndInteractionObserverTag = figure->AddObserver( mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand );
 
         m_DataNodeToPlanarFigureData[nonConstNode] = data;
     }
 }
 
 void QmitkFiberfoxView::PlanarFigureSelected( itk::Object* object, const itk::EventObject& )
 {
     mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPf = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
 
     mitk::DataStorage::SetOfObjects::ConstPointer allPfs = this->GetDataStorage()->GetSubset( isPf );
     for ( mitk::DataStorage::SetOfObjects::const_iterator it = allPfs->begin(); it!=allPfs->end(); ++it)
     {
         mitk::DataNode* node = *it;
 
         if( node->GetData() == object )
         {
             node->SetSelected(true);
             m_SelectedFiducial = node;
         }
         else
             node->SetSelected(false);
     }
     UpdateGui();
     this->RequestRenderWindowUpdate();
 }
 
 void QmitkFiberfoxView::SetFocus()
 {
     m_Controls->m_CircleButton->setFocus();
 }
 
 
 void QmitkFiberfoxView::SetOutputPath()
 {
     // SELECT FOLDER DIALOG
 
     string outputPath = QFileDialog::getExistingDirectory(NULL, "Save images to...", QString(outputPath.c_str())).toStdString();
 
     if (outputPath.empty())
         m_Controls->m_SavePathEdit->setText("-");
     else
     {
         outputPath += "/";
         m_Controls->m_SavePathEdit->setText(QString(outputPath.c_str()));
     }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
index edff70dd72..4e08a03627 100755
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
@@ -1,214 +1,214 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 
 #include <berryISelectionListener.h>
 #include <berryIStructuredSelection.h>
 
 #include <QmitkAbstractView.h>
 #include "ui_QmitkFiberfoxViewControls.h"
 #include <itkVectorImage.h>
 #include <itkVectorContainer.h>
 #include <itkOrientationDistributionFunction.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <mitkPlanarEllipse.h>
 #include <mitkDiffusionNoiseModel.h>
 #include <mitkDiffusionSignalModel.h>
 #include <mitkRicianNoiseModel.h>
 #include <itkTractsToDWIImageFilter.h>
 #include <itkAddArtifactsToDwiImageFilter.h>
 #include <mitkTensorModel.h>
 #include <mitkBallModel.h>
 #include <mitkStickModel.h>
 #include <mitkAstroStickModel.h>
 #include <mitkDotModel.h>
 #include <QThread>
 #include <QObject>
 #include <QTimer>
 #include <QTime>
 #include <mitkFiberfoxParameters.h>
 #include <itkStatisticsImageFilter.h>
 #include <mitkDiffusionPropertyHelper.h>
 
 /*!
 \brief View for fiber based diffusion software phantoms (Fiberfox). See "Fiberfox: Facilitating the creation of realistic white matter software phantoms" (DOI: 10.1002/mrm.25045) for details.
 \sa QmitkFunctionality
 \ingroup Functionalities
 */
 
 // Forward Qt class declarations
 
 using namespace std;
 
 class QmitkFiberfoxView;
 
 class QmitkFiberfoxWorker : public QObject
 {
     Q_OBJECT
 
 public:
 
     QmitkFiberfoxWorker(QmitkFiberfoxView* view);
     int m_FilterType;
 
 public slots:
 
     void run();
 
 private:
 
     QmitkFiberfoxView*                  m_View;
 };
 
 class QmitkFiberfoxView : public QmitkAbstractView
 {
 
     // this is needed for all Qt objects that should have a Qt meta-object
     // (everything that derives from QObject and wants to have signal/slots)
     Q_OBJECT
 
 public:
 
     static const string VIEW_ID;
 
     QmitkFiberfoxView();
     virtual ~QmitkFiberfoxView();
 
     virtual void CreateQtPartControl(QWidget *parent);
     void SetFocus();
 
     typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
     typedef itk::Vector<double,3>           GradientType;
     typedef vector<GradientType>            GradientListType;
     typedef itk::VectorImage< short, 3 >                                    ItkDwiType;
     typedef itk::Image<double, 3>           ItkDoubleImgType;
     typedef itk::Image<unsigned char, 3>    ItkUcharImgType;
 
     template<int ndirs> vector<itk::Vector<double,3> > MakeGradientList();
 
 protected slots:
 
     void SetOutputPath();           ///< path where image is automatically saved to after the simulation is finished
     void LoadParameters();          ///< load fiberfox parameters
     void SaveParameters();          ///< save fiberfox parameters
 
     void BeforeThread();
     void AfterThread();
     void KillThread();              ///< abort simulation
     void UpdateSimulationStatus();  ///< print simulation progress and satus messages
 
     void OnDrawROI();               ///< adds new ROI, handles interactors etc.
     void OnAddBundle();             ///< adds new fiber bundle to datastorage
     void OnFlipButton();            ///< negate one coordinate of the fiber waypoints in the selcted planar figure. needed in case of unresolvable twists
     void GenerateFibers();          ///< generate fibers from the selected ROIs
     void GenerateImage();           ///< start image simulation
     void JoinBundles();             ///< merges selcted fiber bundles into one
     void CopyBundles();             ///< add copy of the selected bundle to the datamanager
     void ApplyTransform();          ///< rotate and shift selected bundles
     void AlignOnGrid();             ///< shift selected fiducials to nearest voxel center
     void Comp1ModelFrameVisibility(int index);  ///< only show parameters of selected signal model for compartment 1
     void Comp2ModelFrameVisibility(int index);  ///< only show parameters of selected signal model for compartment 2
     void Comp3ModelFrameVisibility(int index);  ///< only show parameters of selected signal model for compartment 3
     void Comp4ModelFrameVisibility(int index);  ///< only show parameters of selected signal model for compartment 4
     void ShowAdvancedOptions(int state);
 
     /** update fibers if any parameter changes */
     void OnFiberDensityChanged(int value);
     void OnFiberSamplingChanged(double value);
     void OnTensionChanged(double value);
     void OnContinuityChanged(double value);
     void OnBiasChanged(double value);
     void OnVarianceChanged(double value);
     void OnDistributionChanged(int value);
     void OnConstantRadius(int value);
 
     /** update GUI elements */
     void OnAddNoise(int value);
     void OnAddGhosts(int value);
     void OnAddDistortions(int value);
     void OnAddEddy(int value);
     void OnAddSpikes(int value);
     void OnAddAliasing(int value);
     void OnAddMotion(int value);
     void OnMaskSelected(int value);
     void OnFibSelected(int value);
     void OnTemplateSelected(int value);
 
 protected:
 
     /// \brief called by QmitkFunctionality when DataManager's selection has changed
     virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>&);
 
     GradientListType GenerateHalfShell(int NPoints);    ///< generate vectors distributed over the halfsphere
 
     Ui::QmitkFiberfoxViewControls* m_Controls;
 
     void SimulateForExistingDwi(mitk::DataNode* imageNode);     ///< add artifacts to existing diffusion weighted image
     void SimulateImageFromFibers(mitk::DataNode* fiberNode);    ///< simulate new diffusion weighted image
     template< class ScalarType > FiberfoxParameters< ScalarType > UpdateImageParameters();  ///< update fiberfox paramater object (template parameter defines noise model type)
     void UpdateGui();                                           ///< enable/disbale buttons etc. according to current datamanager selection
     void PlanarFigureSelected( itk::Object* object, const itk::EventObject& );
     void EnableCrosshairNavigation();               ///< enable crosshair navigation if planar figure interaction ends
     void DisableCrosshairNavigation();              ///< disable crosshair navigation if planar figure interaction starts
     void NodeAdded( const mitk::DataNode* node );   ///< add observers
     void NodeRemoved(const mitk::DataNode* node);   ///< remove observers
 
     /** structure to keep track of planar figures and observers */
     struct QmitkPlanarFigureData
     {
         QmitkPlanarFigureData()
             : m_Figure(0)
             , m_EndPlacementObserverTag(0)
             , m_SelectObserverTag(0)
             , m_StartInteractionObserverTag(0)
             , m_EndInteractionObserverTag(0)
             , m_Flipped(0)
         {
         }
         mitk::PlanarFigure* m_Figure;
         unsigned int m_EndPlacementObserverTag;
         unsigned int m_SelectObserverTag;
         unsigned int m_StartInteractionObserverTag;
         unsigned int m_EndInteractionObserverTag;
         unsigned int m_Flipped;
     };
 
     std::map<mitk::DataNode*, QmitkPlanarFigureData>    m_DataNodeToPlanarFigureData;   ///< map each planar figure uniquely to a QmitkPlanarFigureData
     mitk::DataNode::Pointer                             m_SelectedFiducial;             ///< selected planar ellipse
     mitk::DataNode::Pointer                             m_SelectedImage;
     vector< mitk::DataNode::Pointer >                   m_SelectedBundles;
     vector< mitk::DataNode::Pointer >                   m_SelectedBundles2;
     vector< mitk::DataNode::Pointer >                   m_SelectedFiducials;
     vector< mitk::DataNode::Pointer >                   m_SelectedImages;
 
     QString m_ParameterFile;    ///< parameter file name
 
     // GUI thread
     QmitkFiberfoxWorker     m_Worker;   ///< runs filter
     QThread                 m_Thread;   ///< worker thread
     bool                    m_ThreadIsRunning;
     QTimer*                 m_SimulationTimer;
     QTime                   m_SimulationTime;
     QString                 m_SimulationStatusText;
 
     /** Image filters that do all the simulations. */
     itk::TractsToDWIImageFilter< short >::Pointer           m_TractsToDwiFilter;
     itk::AddArtifactsToDwiImageFilter< short >::Pointer     m_ArtifactsToDwiFilter;
 
     friend class QmitkFiberfoxWorker;
 };
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp
index 5de6996c71..b131d32f75 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp
@@ -1,768 +1,768 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkGibbsTrackingView.h"
 #include <QmitkStdMultiWidget.h>
 
 // Qt
 #include <QMessageBox>
 #include <QFileDialog>
 #include <QDir>
 
 // MITK
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkProgressBar.h>
 #include <mitkIOUtil.h>
 
 // ITK
 #include <itkGibbsTrackingFilter.h>
 #include <itkResampleImageFilter.h>
 #include <itksys/SystemTools.hxx>
 
 // MISC
 #include <tinyxml.h>
 
 
 
 
 QmitkTrackingWorker::QmitkTrackingWorker(QmitkGibbsTrackingView* view)
     : m_View(view)
 {
 }
 
 void QmitkTrackingWorker::run()
 {
     m_View->m_GlobalTracker = QmitkGibbsTrackingView::GibbsTrackingFilterType::New();
 
     m_View->m_GlobalTracker->SetQBallImage(m_View->m_ItkQBallImage);
     m_View->m_GlobalTracker->SetTensorImage(m_View->m_ItkTensorImage);
     m_View->m_GlobalTracker->SetMaskImage(m_View->m_MaskImage);
     m_View->m_GlobalTracker->SetStartTemperature((float)m_View->m_Controls->m_StartTempSlider->value()/100);
     m_View->m_GlobalTracker->SetEndTemperature((float)m_View->m_Controls->m_EndTempSlider->value()/10000);
     m_View->m_GlobalTracker->SetIterations(m_View->m_Iterations);
     m_View->m_GlobalTracker->SetParticleWeight((float)m_View->m_Controls->m_ParticleWeightSlider->value()/10000);
     m_View->m_GlobalTracker->SetParticleWidth((float)(m_View->m_Controls->m_ParticleWidthSlider->value())/10);
     m_View->m_GlobalTracker->SetParticleLength((float)(m_View->m_Controls->m_ParticleLengthSlider->value())/10);
     m_View->m_GlobalTracker->SetInexBalance((float)m_View->m_Controls->m_InExBalanceSlider->value()/10);
     m_View->m_GlobalTracker->SetMinFiberLength(m_View->m_Controls->m_FiberLengthSlider->value());
     m_View->m_GlobalTracker->SetCurvatureThreshold(cos((float)m_View->m_Controls->m_CurvatureThresholdSlider->value()*M_PI/180));
     m_View->m_GlobalTracker->SetRandomSeed(m_View->m_Controls->m_RandomSeedSlider->value());
     try{
         m_View->m_GlobalTracker->Update();
     }
     catch( mitk::Exception e )
     {
         MITK_ERROR << "Internal error occured: " <<  e.what() << "\nAborting";
     }
     m_View->m_TrackingThread.quit();
 }
 
 const std::string QmitkGibbsTrackingView::VIEW_ID = "org.mitk.views.gibbstracking";
 
 QmitkGibbsTrackingView::QmitkGibbsTrackingView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget(NULL)
     , m_FiberBundle(NULL)
     , m_MaskImage(NULL)
     , m_TensorImage(NULL)
     , m_QBallImage(NULL)
     , m_ItkQBallImage(NULL)
     , m_ItkTensorImage(NULL)
     , m_ImageNode(NULL)
     , m_MaskImageNode(NULL)
     , m_FiberBundleNode(NULL)
     , m_ThreadIsRunning(false)
     , m_ElapsedTime(0)
     , m_Iterations(10000000)
     , m_LastStep(0)
     , m_GlobalTracker(NULL)
     , m_TrackingWorker(this)
     , m_TrackingNode(NULL)
 {
     m_TrackingWorker.moveToThread(&m_TrackingThread);
     connect(&m_TrackingThread, SIGNAL(started()), this, SLOT(BeforeThread()));
     connect(&m_TrackingThread, SIGNAL(started()), &m_TrackingWorker, SLOT(run()));
     connect(&m_TrackingThread, SIGNAL(finished()), this, SLOT(AfterThread()));
     connect(&m_TrackingThread, SIGNAL(terminated()), this, SLOT(AfterThread()));
     m_TrackingTimer = new QTimer(this);
 }
 
 QmitkGibbsTrackingView::~QmitkGibbsTrackingView()
 {
   if (m_GlobalTracker.IsNull())
       return;
 
   m_GlobalTracker->SetAbortTracking(true);
   m_TrackingThread.wait();
 }
 
 // update tracking status and generate fiber bundle
 void QmitkGibbsTrackingView::TimerUpdate()
 {
     int currentStep = m_GlobalTracker->GetCurrentStep();
 
     mitk::ProgressBar::GetInstance()->Progress(currentStep-m_LastStep);
     UpdateTrackingStatus();
     GenerateFiberBundle();
     m_LastStep = currentStep;
 }
 
 // tell global tractography filter to stop after current step
 void QmitkGibbsTrackingView::StopGibbsTracking()
 {
     if (m_GlobalTracker.IsNull())
         return;
 
     //mitk::ProgressBar::GetInstance()->Progress(m_GlobalTracker->GetSteps()-m_LastStep+1);
     m_GlobalTracker->SetAbortTracking(true);
     m_Controls->m_TrackingStop->setEnabled(false);
     m_Controls->m_TrackingStop->setText("Stopping Tractography ...");
     m_TrackingNode = NULL;
 }
 
 // update gui elements and generate fiber bundle after tracking is finished
 void QmitkGibbsTrackingView::AfterThread()
 {
     m_ThreadIsRunning = false;
     m_TrackingTimer->stop();
 
     mitk::ProgressBar::GetInstance()->Progress(m_GlobalTracker->GetSteps()-m_LastStep+1);
     UpdateGUI();
 
     if( !m_GlobalTracker->GetIsInValidState() )
     {
         QMessageBox::critical( NULL, "Gibbs Tracking", "An internal error occured. Tracking aborted.\n Please check the log for details." );
         m_FiberBundleNode = NULL;
         return;
     }
     UpdateTrackingStatus();
 
     if(m_Controls->m_ParticleWeightSlider->value()==0)
     {
         m_Controls->m_ParticleWeightLabel->setText(QString::number(m_GlobalTracker->GetParticleWeight()));
         m_Controls->m_ParticleWeightSlider->setValue(m_GlobalTracker->GetParticleWeight()*10000);
     }
     if(m_Controls->m_ParticleWidthSlider->value()==0)
     {
         m_Controls->m_ParticleWidthLabel->setText(QString::number(m_GlobalTracker->GetParticleWidth()));
         m_Controls->m_ParticleWidthSlider->setValue(m_GlobalTracker->GetParticleWidth()*10);
     }
     if(m_Controls->m_ParticleLengthSlider->value()==0)
     {
         m_Controls->m_ParticleLengthLabel->setText(QString::number(m_GlobalTracker->GetParticleLength()));
         m_Controls->m_ParticleLengthSlider->setValue(m_GlobalTracker->GetParticleLength()*10);
     }
 
     GenerateFiberBundle();
     m_FiberBundleNode = 0;
     m_GlobalTracker = 0;
 
     // images not needed anymore ( relevant only for computation )
     // we need to release them to remove the memory access block created through CastToItk<> calls
     this->m_ItkQBallImage = 0;
     this->m_ItkTensorImage = 0;
 }
 
 // start tracking timer and update gui elements before tracking is started
 void QmitkGibbsTrackingView::BeforeThread()
 {
     m_ThreadIsRunning = true;
     m_TrackingTime = QTime::currentTime();
     m_ElapsedTime = 0;
     m_TrackingTimer->start(1000);
     m_LastStep = 0;
 
     UpdateGUI();
 }
 
 // setup gui elements and signal/slot connections
 void QmitkGibbsTrackingView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkGibbsTrackingViewControls;
         m_Controls->setupUi( parent );
 
         AdvancedSettings();
 
         connect( m_TrackingTimer, SIGNAL(timeout()), this, SLOT(TimerUpdate()) );
         connect( m_Controls->m_TrackingStop, SIGNAL(clicked()), this, SLOT(StopGibbsTracking()) );
         connect( m_Controls->m_TrackingStart, SIGNAL(clicked()), this, SLOT(StartGibbsTracking()) );
         connect( m_Controls->m_AdvancedSettingsCheckbox, SIGNAL(clicked()), this, SLOT(AdvancedSettings()) );
         connect( m_Controls->m_SaveTrackingParameters, SIGNAL(clicked()), this, SLOT(SaveTrackingParameters()) );
         connect( m_Controls->m_LoadTrackingParameters, SIGNAL(clicked()), this, SLOT(LoadTrackingParameters()) );
         connect( m_Controls->m_IterationsSlider, SIGNAL(valueChanged(int)), this, SLOT(SetIterations(int)) );
         connect( m_Controls->m_ParticleWidthSlider, SIGNAL(valueChanged(int)), this, SLOT(SetParticleWidth(int)) );
         connect( m_Controls->m_ParticleLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(SetParticleLength(int)) );
         connect( m_Controls->m_InExBalanceSlider, SIGNAL(valueChanged(int)), this, SLOT(SetInExBalance(int)) );
         connect( m_Controls->m_FiberLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(SetFiberLength(int)) );
         connect( m_Controls->m_ParticleWeightSlider, SIGNAL(valueChanged(int)), this, SLOT(SetParticleWeight(int)) );
         connect( m_Controls->m_StartTempSlider, SIGNAL(valueChanged(int)), this, SLOT(SetStartTemp(int)) );
         connect( m_Controls->m_EndTempSlider, SIGNAL(valueChanged(int)), this, SLOT(SetEndTemp(int)) );
         connect( m_Controls->m_CurvatureThresholdSlider, SIGNAL(valueChanged(int)), this, SLOT(SetCurvatureThreshold(int)) );
         connect( m_Controls->m_RandomSeedSlider, SIGNAL(valueChanged(int)), this, SLOT(SetRandomSeed(int)) );
         connect( m_Controls->m_OutputFileButton, SIGNAL(clicked()), this, SLOT(SetOutputFile()) );
     }
 }
 
 void QmitkGibbsTrackingView::SetInExBalance(int value)
 {
     m_Controls->m_InExBalanceLabel->setText(QString::number((float)value/10));
 }
 
 void QmitkGibbsTrackingView::SetFiberLength(int value)
 {
     m_Controls->m_FiberLengthLabel->setText(QString::number(value)+"mm");
 }
 
 void QmitkGibbsTrackingView::SetRandomSeed(int value)
 {
     if (value>=0)
         m_Controls->m_RandomSeedLabel->setText(QString::number(value));
     else
         m_Controls->m_RandomSeedLabel->setText("auto");
 }
 
 void QmitkGibbsTrackingView::SetParticleWeight(int value)
 {
     if (value>0)
         m_Controls->m_ParticleWeightLabel->setText(QString::number((float)value/10000));
     else
         m_Controls->m_ParticleWeightLabel->setText("auto");
 }
 
 void QmitkGibbsTrackingView::SetStartTemp(int value)
 {
     m_Controls->m_StartTempLabel->setText(QString::number((float)value/100));
 }
 
 void QmitkGibbsTrackingView::SetEndTemp(int value)
 {
     m_Controls->m_EndTempLabel->setText(QString::number((float)value/10000));
 }
 
 void QmitkGibbsTrackingView::SetParticleWidth(int value)
 {
     if (value>0)
         m_Controls->m_ParticleWidthLabel->setText(QString::number((float)value/10)+" mm");
     else
         m_Controls->m_ParticleWidthLabel->setText("auto");
 }
 
 void QmitkGibbsTrackingView::SetParticleLength(int value)
 {
     if (value>0)
         m_Controls->m_ParticleLengthLabel->setText(QString::number((float)value/10)+" mm");
     else
         m_Controls->m_ParticleLengthLabel->setText("auto");
 }
 
 void QmitkGibbsTrackingView::SetCurvatureThreshold(int value)
 {
     m_Controls->m_CurvatureThresholdLabel->setText(QString::number(value)+"°");
 }
 
 void QmitkGibbsTrackingView::SetIterations(int value)
 {
     switch(value)
     {
     case 0:
         m_Controls->m_IterationsLabel->setText("Iterations: 1x10^4");
         m_Iterations = 10000;
         break;
     case 1:
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^4");
         m_Iterations = 50000;
         break;
     case 2:
         m_Controls->m_IterationsLabel->setText("Iterations: 1x10^5");
         m_Iterations = 100000;
         break;
     case 3:
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^5");
         m_Iterations = 500000;
         break;
     case 4:
         m_Controls->m_IterationsLabel->setText("Iterations: 1x10^6");
         m_Iterations = 1000000;
         break;
     case 5:
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^6");
         m_Iterations = 5000000;
         break;
     case 6:
         m_Controls->m_IterationsLabel->setText("Iterations: 1x10^7");
         m_Iterations = 10000000;
         break;
     case 7:
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^7");
         m_Iterations = 50000000;
         break;
     case 8:
         m_Controls->m_IterationsLabel->setText("Iterations: 1x10^8");
         m_Iterations = 100000000;
         break;
     case 9:
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^8");
         m_Iterations = 500000000;
         break;
     }
 }
 
 void QmitkGibbsTrackingView::StdMultiWidgetAvailable(QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkGibbsTrackingView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 // called if datamanager selection changes
 void QmitkGibbsTrackingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     if (m_ThreadIsRunning)
         return;
 
     m_ImageNode = NULL;
     m_MaskImageNode = NULL;
 
     // iterate all selected objects
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if( node.IsNotNull() && dynamic_cast<mitk::QBallImage*>(node->GetData()) )
             m_ImageNode = node;
         else if( node.IsNotNull() && dynamic_cast<mitk::TensorImage*>(node->GetData()) )
             m_ImageNode = node;
         else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(node->GetData());
             if (img->GetPixelType().GetPixelType()==itk::ImageIOBase::SCALAR)
                 m_MaskImageNode = node;
         }
     }
 
     UpdateGUI();
 }
 
 
 void QmitkGibbsTrackingView::NodeRemoved(const mitk::DataNode * node)
 {
   if (m_ThreadIsRunning)
   {
     if (node==m_TrackingNode.GetPointer())
     {
       StopGibbsTracking();
     }
   }
 }
 
 // update gui elements displaying trackings status
 void QmitkGibbsTrackingView::UpdateTrackingStatus()
 {
     if (m_GlobalTracker.IsNull())
         return;
 
     m_ElapsedTime += m_TrackingTime.elapsed()/1000;
     m_TrackingTime.restart();
     unsigned long hours = m_ElapsedTime/3600;
     unsigned long minutes = (m_ElapsedTime%3600)/60;
     unsigned long seconds = m_ElapsedTime%60;
 
     m_Controls->m_ProposalAcceptance->setText(QString::number(m_GlobalTracker->GetProposalAcceptance()*100)+"%");
 
     m_Controls->m_TrackingTimeLabel->setText( QString::number(hours)+QString("h ")+QString::number(minutes)+QString("m ")+QString::number(seconds)+QString("s") );
     m_Controls->m_NumConnectionsLabel->setText( QString::number(m_GlobalTracker->GetNumConnections()) );
     m_Controls->m_NumParticlesLabel->setText( QString::number(m_GlobalTracker->GetNumParticles()) );
     m_Controls->m_CurrentStepLabel->setText( QString::number(100*(float)(m_GlobalTracker->GetCurrentStep()-1)/m_GlobalTracker->GetSteps())+"%" );
     m_Controls->m_AcceptedFibersLabel->setText( QString::number(m_GlobalTracker->GetNumAcceptedFibers()) );
 }
 
 // update gui elements (enable/disable elements and set tooltips)
 void QmitkGibbsTrackingView::UpdateGUI()
 {
     if (m_ImageNode.IsNotNull())
     {
         m_Controls->m_QballImageLabel->setText(m_ImageNode->GetName().c_str());
         m_Controls->m_DataFrame->setTitle("Input Data");
     }
     else
     {
         m_Controls->m_QballImageLabel->setText("<font color='red'>mandatory</font>");
         m_Controls->m_DataFrame->setTitle("Please Select Input Data");
     }
     if (m_MaskImageNode.IsNotNull())
         m_Controls->m_MaskImageLabel->setText(m_MaskImageNode->GetName().c_str());
     else
         m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</font>");
 
     if (!m_ThreadIsRunning && m_ImageNode.IsNotNull())
     {
         m_Controls->m_TrackingStop->setEnabled(false);
         m_Controls->m_TrackingStart->setEnabled(true);
         m_Controls->m_LoadTrackingParameters->setEnabled(true);
         m_Controls->m_IterationsSlider->setEnabled(true);
         m_Controls->m_AdvancedFrame->setEnabled(true);
         m_Controls->m_TrackingStop->setText("Stop Tractography");
         m_Controls->m_TrackingStart->setToolTip("Start tractography. No further change of parameters possible.");
         m_Controls->m_TrackingStop->setToolTip("");
     }
     else if (!m_ThreadIsRunning)
     {
         m_Controls->m_TrackingStop->setEnabled(false);
         m_Controls->m_TrackingStart->setEnabled(false);
         m_Controls->m_LoadTrackingParameters->setEnabled(true);
         m_Controls->m_IterationsSlider->setEnabled(true);
         m_Controls->m_AdvancedFrame->setEnabled(true);
         m_Controls->m_TrackingStop->setText("Stop Tractography");
         m_Controls->m_TrackingStart->setToolTip("No Q-Ball image selected.");
         m_Controls->m_TrackingStop->setToolTip("");
     }
     else
     {
         m_Controls->m_TrackingStop->setEnabled(true);
         m_Controls->m_TrackingStart->setEnabled(false);
         m_Controls->m_LoadTrackingParameters->setEnabled(false);
         m_Controls->m_IterationsSlider->setEnabled(false);
         m_Controls->m_AdvancedFrame->setEnabled(false);
         m_Controls->m_AdvancedFrame->setVisible(false);
         m_Controls->m_AdvancedSettingsCheckbox->setChecked(false);
         m_Controls->m_TrackingStart->setToolTip("Tracking in progress.");
         m_Controls->m_TrackingStop->setToolTip("Stop tracking and display results.");
     }
 }
 
 // show/hide advanced settings frame
 void QmitkGibbsTrackingView::AdvancedSettings()
 {
     m_Controls->m_AdvancedFrame->setVisible(m_Controls->m_AdvancedSettingsCheckbox->isChecked());
 }
 
 // set mask image data node
 void QmitkGibbsTrackingView::SetMask()
 {
     std::vector<mitk::DataNode*> nodes = GetDataManagerSelection();
     if (nodes.empty())
     {
         m_MaskImageNode = NULL;
         m_Controls->m_MaskImageLabel->setText("-");
         return;
     }
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
          it != nodes.end();
          ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if (node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()))
         {
             m_MaskImageNode = node;
             m_Controls->m_MaskImageLabel->setText(node->GetName().c_str());
             return;
         }
     }
 }
 
 // check for mask and qbi and start tracking thread
 void QmitkGibbsTrackingView::StartGibbsTracking()
 {
     if(m_ThreadIsRunning)
     {
         MITK_WARN("QmitkGibbsTrackingView")<<"Thread already running!";
         return;
     }
     m_GlobalTracker = NULL;
 
     if (m_ImageNode.IsNull())
     {
         QMessageBox::information( NULL, "Warning", "Please load and select a qball image before starting image processing.");
         return;
     }
 
     if (dynamic_cast<mitk::QBallImage*>(m_ImageNode->GetData()))
         m_QBallImage = dynamic_cast<mitk::QBallImage*>(m_ImageNode->GetData());
     else if (dynamic_cast<mitk::TensorImage*>(m_ImageNode->GetData()))
         m_TensorImage = dynamic_cast<mitk::TensorImage*>(m_ImageNode->GetData());
 
     if (m_QBallImage.IsNull() && m_TensorImage.IsNull())
         return;
 
     // cast qbi to itk
     m_TrackingNode = m_ImageNode;
     m_ItkTensorImage = NULL;
     m_ItkQBallImage = NULL;
     m_MaskImage = NULL;
 
     if (m_QBallImage.IsNotNull())
     {
         m_ItkQBallImage = ItkQBallImgType::New();
         mitk::CastToItkImage(m_QBallImage, m_ItkQBallImage);
     }
     else
     {
         m_ItkTensorImage = ItkTensorImage::New();
         mitk::CastToItkImage(m_TensorImage, m_ItkTensorImage);
     }
 
     // mask image found?
     // catch exceptions thrown by the itkAccess macros
     try{
         if(m_MaskImageNode.IsNotNull())
         {
             if (dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData()))
                 mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData()), m_MaskImage);
         }
     }
     catch(...){};
 
     unsigned int steps = m_Iterations/10000;
     if (steps<10)
         steps = 10;
 
     m_LastStep = 1;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(steps);
 
     // start worker thread
     m_TrackingThread.start(QThread::LowestPriority);
 }
 
 // generate mitkFiberBundle from tracking filter output
 void QmitkGibbsTrackingView::GenerateFiberBundle()
 {
     if (m_GlobalTracker.IsNull() || (!(m_Controls->m_VisualizationCheckbox->isChecked() || m_Controls->m_VisualizeOnceButton->isChecked()) && m_ThreadIsRunning))
         return;
 
     if (m_Controls->m_VisualizeOnceButton->isChecked())
         m_Controls->m_VisualizeOnceButton->setChecked(false);
 
     vtkSmartPointer<vtkPolyData> fiberBundle = m_GlobalTracker->GetFiberBundle();
     if ( m_GlobalTracker->GetNumAcceptedFibers()==0 )
         return;
-    m_FiberBundle = mitk::FiberBundleX::New(fiberBundle);
+    m_FiberBundle = mitk::FiberBundle::New(fiberBundle);
     m_FiberBundle->SetReferenceGeometry(dynamic_cast<mitk::Image*>(m_ImageNode->GetData())->GetGeometry());
 
     if (m_FiberBundleNode.IsNotNull()){
         GetDefaultDataStorage()->Remove(m_FiberBundleNode);
         m_FiberBundleNode = 0;
     }
     m_FiberBundleNode = mitk::DataNode::New();
     m_FiberBundleNode->SetData(m_FiberBundle);
 
     QString name("FiberBundle_");
     name += m_ImageNode->GetName().c_str();
     name += "_Gibbs";
     m_FiberBundleNode->SetName(name.toStdString());
     m_FiberBundleNode->SetVisibility(true);
 
 
     if (!m_OutputFileName.isEmpty() && !m_ThreadIsRunning)
     {
         try
         {
           mitk::IOUtil::Save(m_FiberBundle.GetPointer(),m_OutputFileName.toStdString());
           QMessageBox::information(NULL, "Fiber bundle saved to", m_OutputFileName);
         }
         catch (itk::ExceptionObject &ex)
         {
             QMessageBox::information(NULL, "Fiber bundle could not be saved", QString("%1\n%2\n%3\n%4\n%5\n%6").arg(ex.GetNameOfClass()).arg(ex.GetFile()).arg(ex.GetLine()).arg(ex.GetLocation()).arg(ex.what()).arg(ex.GetDescription()));
         }
     }
     if(m_ImageNode.IsNull())
         GetDataStorage()->Add(m_FiberBundleNode);
     else
         GetDataStorage()->Add(m_FiberBundleNode, m_ImageNode);
 }
 
 void QmitkGibbsTrackingView::SetOutputFile()
 {
     // SELECT FOLDER DIALOG
     m_OutputFileName = QFileDialog::getSaveFileName(0,
                                                     tr("Set file name"),
                                                     QDir::currentPath()+"/FiberBundle.fib",
                                                     tr("Fiber Bundle (*.fib)") );
     if (m_OutputFileName.isEmpty())
         m_Controls->m_OutputFileLabel->setText("N/A");
     else
         m_Controls->m_OutputFileLabel->setText(m_OutputFileName);
 }
 
 // save current tracking paramters as xml file (.gtp)
 void QmitkGibbsTrackingView::SaveTrackingParameters()
 {
     TiXmlDocument documentXML;
     TiXmlDeclaration* declXML = new TiXmlDeclaration( "1.0", "", "" );
     documentXML.LinkEndChild( declXML );
 
     TiXmlElement* mainXML = new TiXmlElement("global_tracking_parameter_file");
     mainXML->SetAttribute("file_version",  "0.1");
     documentXML.LinkEndChild(mainXML);
 
     TiXmlElement* paramXML = new TiXmlElement("parameter_set");
     paramXML->SetAttribute("iterations", QString::number(m_Iterations).toStdString());
     paramXML->SetAttribute("particle_length", QString::number((float)m_Controls->m_ParticleLengthSlider->value()/10).toStdString());
     paramXML->SetAttribute("particle_width", QString::number((float)m_Controls->m_ParticleWidthSlider->value()/10).toStdString());
     paramXML->SetAttribute("particle_weight", QString::number((float)m_Controls->m_ParticleWeightSlider->value()/10000).toStdString());
     paramXML->SetAttribute("temp_start", QString::number((float)m_Controls->m_StartTempSlider->value()/100).toStdString());
     paramXML->SetAttribute("temp_end", QString::number((float)m_Controls->m_EndTempSlider->value()/10000).toStdString());
     paramXML->SetAttribute("inexbalance", QString::number((float)m_Controls->m_InExBalanceSlider->value()/10).toStdString());
     paramXML->SetAttribute("fiber_length", QString::number(m_Controls->m_FiberLengthSlider->value()).toStdString());
     paramXML->SetAttribute("curvature_threshold", QString::number(m_Controls->m_CurvatureThresholdSlider->value()).toStdString());
     mainXML->LinkEndChild(paramXML);
     QString filename = QFileDialog::getSaveFileName(
                 0,
                 tr("Save Parameters"),
                 QDir::currentPath()+"/param.gtp",
                 tr("Global Tracking Parameters (*.gtp)") );
 
     if(filename.isEmpty() || filename.isNull())
         return;
     if(!filename.endsWith(".gtp"))
         filename += ".gtp";
     documentXML.SaveFile( filename.toStdString() );
 }
 
 void QmitkGibbsTrackingView::UpdateIteraionsGUI(unsigned long iterations)
 {
     switch(iterations)
     {
     case 10000:
         m_Controls->m_IterationsSlider->setValue(0);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^4");
         break;
     case 50000:
         m_Controls->m_IterationsSlider->setValue(1);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^4");
         break;
     case 100000:
         m_Controls->m_IterationsSlider->setValue(2);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^5");
         break;
     case 500000:
         m_Controls->m_IterationsSlider->setValue(3);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^5");
         break;
     case 1000000:
         m_Controls->m_IterationsSlider->setValue(4);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^6");
         break;
     case 5000000:
         m_Controls->m_IterationsSlider->setValue(5);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^6");
         break;
     case 10000000:
         m_Controls->m_IterationsSlider->setValue(6);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^7");
         break;
     case 50000000:
         m_Controls->m_IterationsSlider->setValue(7);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^7");
         break;
     case 100000000:
         m_Controls->m_IterationsSlider->setValue(8);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^8");
         break;
     case 500000000:
         m_Controls->m_IterationsSlider->setValue(9);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^8");
         break;
     case 1000000000:
         m_Controls->m_IterationsSlider->setValue(10);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^9");
         break;
     case 5000000000:
         m_Controls->m_IterationsSlider->setValue(11);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^9");
         break;
     }
 }
 
 // load current tracking paramters from xml file (.gtp)
 void QmitkGibbsTrackingView::LoadTrackingParameters()
 {
     QString filename = QFileDialog::getOpenFileName(0, tr("Load Parameters"), QDir::currentPath(), tr("Global Tracking Parameters (*.gtp)") );
     if(filename.isEmpty() || filename.isNull())
         return;
 
     TiXmlDocument doc( filename.toStdString() );
     doc.LoadFile();
 
     TiXmlHandle hDoc(&doc);
     TiXmlElement* pElem;
     TiXmlHandle hRoot(0);
 
     pElem = hDoc.FirstChildElement().Element();
     hRoot = TiXmlHandle(pElem);
     pElem = hRoot.FirstChildElement("parameter_set").Element();
 
     QString iterations(pElem->Attribute("iterations"));
     m_Iterations = iterations.toULong();
     UpdateIteraionsGUI(m_Iterations);
 
     QString particleLength(pElem->Attribute("particle_length"));
     float pLength = particleLength.toFloat();
     QString particleWidth(pElem->Attribute("particle_width"));
     float pWidth = particleWidth.toFloat();
 
     if (pLength==0)
         m_Controls->m_ParticleLengthLabel->setText("auto");
     else
         m_Controls->m_ParticleLengthLabel->setText(particleLength+" mm");
     if (pWidth==0)
         m_Controls->m_ParticleWidthLabel->setText("auto");
     else
         m_Controls->m_ParticleWidthLabel->setText(particleWidth+" mm");
 
     m_Controls->m_ParticleWidthSlider->setValue(pWidth*10);
     m_Controls->m_ParticleLengthSlider->setValue(pLength*10);
 
     QString partWeight(pElem->Attribute("particle_weight"));
     m_Controls->m_ParticleWeightSlider->setValue(partWeight.toFloat()*10000);
     m_Controls->m_ParticleWeightLabel->setText(partWeight);
 
     QString startTemp(pElem->Attribute("temp_start"));
     m_Controls->m_StartTempSlider->setValue(startTemp.toFloat()*100);
     m_Controls->m_StartTempLabel->setText(startTemp);
 
     QString endTemp(pElem->Attribute("temp_end"));
     m_Controls->m_EndTempSlider->setValue(endTemp.toFloat()*10000);
     m_Controls->m_EndTempLabel->setText(endTemp);
 
     QString inExBalance(pElem->Attribute("inexbalance"));
     m_Controls->m_InExBalanceSlider->setValue(inExBalance.toFloat()*10);
     m_Controls->m_InExBalanceLabel->setText(inExBalance);
 
     QString fiberLength(pElem->Attribute("fiber_length"));
     m_Controls->m_FiberLengthSlider->setValue(fiberLength.toInt());
     m_Controls->m_FiberLengthLabel->setText(fiberLength+"mm");
 
     QString curvThres(pElem->Attribute("curvature_threshold"));
     m_Controls->m_CurvatureThresholdSlider->setValue(curvThres.toInt());
     m_Controls->m_CurvatureThresholdLabel->setText(curvThres+"°");
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.h
index 5cebd39bb4..a9294e9ca7 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.h
@@ -1,167 +1,167 @@
 /*===================================================================
 
 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 QmitkGibbsTrackingView_h
 #define QmitkGibbsTrackingView_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkFunctionality.h>
 
 #include "ui_QmitkGibbsTrackingViewControls.h"
 
 #include <mitkQBallImage.h>
 #include <QThread>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <QTime>
 #include <itkImage.h>
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <itkDiffusionTensor3D.h>
 #include <mitkTensorImage.h>
 
 class QmitkGibbsTrackingView;
 
 class QmitkTrackingWorker : public QObject
 {
   Q_OBJECT
 
 public:
 
   QmitkTrackingWorker(QmitkGibbsTrackingView* view);
 
 public slots:
 
   void run();
 
 private:
 
   QmitkGibbsTrackingView* m_View;
 };
 
 /*!
   \brief View for global fiber tracking (Gibbs tracking)
 
   \sa QmitkFunctionality
   \ingroup Functionalities
 */
 typedef itk::Image< float, 3 >            FloatImageType;
 
 namespace itk
 {
 template<class X>
 class GibbsTrackingFilter;
 }
 
 class QmitkGibbsTrackingView : public QmitkFunctionality
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   typedef itk::Image<float,3>                               ItkFloatImageType;
   typedef itk::Vector<float, QBALL_ODFSIZE>                 OdfVectorType;
   typedef itk::Image<OdfVectorType, 3>                      ItkQBallImgType;
   typedef itk::Image< itk::DiffusionTensor3D<float>, 3 >    ItkTensorImage;
   typedef itk::GibbsTrackingFilter< ItkQBallImgType >       GibbsTrackingFilterType;
 
   static const std::string VIEW_ID;
 
   QmitkGibbsTrackingView();
   virtual ~QmitkGibbsTrackingView();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
 
 signals:
 
 protected slots:
 
   void StartGibbsTracking();
   void StopGibbsTracking();
   void AfterThread();                       ///< update gui etc. after tracking has finished
   void BeforeThread();                      ///< start timer etc.
   void TimerUpdate();
   void SetMask();
   void AdvancedSettings();                  ///< show/hide advanced tracking options
   void SaveTrackingParameters();            ///< save tracking parameters to xml file
   void LoadTrackingParameters();            ///< load tracking parameters from xml file
 
   /** update labels if parameters have changed */
   void SetIterations(int value);
   void SetParticleWidth(int value);
   void SetParticleLength(int value);
   void SetInExBalance(int value);
   void SetFiberLength(int value);
   void SetParticleWeight(int value);
   void SetStartTemp(int value);
   void SetEndTemp(int value);
   void SetCurvatureThreshold(int value);
   void SetRandomSeed(int value);
   void SetOutputFile();
 
 private:
 
   // Visualization & GUI
   void GenerateFiberBundle();   ///< generate fiber bundle from tracking output and add to datanode
   void UpdateGUI();             ///< update button activity etc. dpending on current datamanager selection
   void UpdateTrackingStatus();  ///< update textual status display of the tracking process
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
   /// \brief called when DataNode is removed to stop gibbs tracking after node is removed
   virtual void NodeRemoved(const mitk::DataNode * node);
 
   void UpdateIteraionsGUI(unsigned long iterations);    ///< update iterations label text
 
   Ui::QmitkGibbsTrackingViewControls* m_Controls;
   QmitkStdMultiWidget* m_MultiWidget;
 
   /** data objects */
   mitk::DataNode::Pointer       m_TrackingNode;     ///< actual node that is tracked
-  mitk::FiberBundleX::Pointer   m_FiberBundle;      ///< tracking output
+  mitk::FiberBundle::Pointer   m_FiberBundle;      ///< tracking output
   ItkFloatImageType::Pointer    m_MaskImage;        ///< used to reduce the algorithms search space. tracking only inside of the mask.
   mitk::TensorImage::Pointer    m_TensorImage;      ///< actual image that is tracked
   mitk::QBallImage::Pointer     m_QBallImage;       ///< actual image that is tracked
   ItkQBallImgType::Pointer      m_ItkQBallImage;    ///< actual image that is tracked
   ItkTensorImage::Pointer       m_ItkTensorImage;   ///< actual image that is tracked
 
   /** data nodes */
   mitk::DataNode::Pointer m_ImageNode;
   mitk::DataNode::Pointer m_MaskImageNode;
   mitk::DataNode::Pointer m_FiberBundleNode;
 
   /** flags etc. */
   bool            m_ThreadIsRunning;
   QTimer*         m_TrackingTimer;
   QTime           m_TrackingTime;
   unsigned long   m_ElapsedTime;
   unsigned long   m_Iterations;
   int             m_LastStep;
   QString         m_OutputFileName;
 
   /** global tracker and friends */
   itk::SmartPointer<GibbsTrackingFilterType> m_GlobalTracker;
   QmitkTrackingWorker m_TrackingWorker;
   QThread m_TrackingThread;
   friend class QmitkTrackingWorker;
 };
 
 #endif // _QMITKGibbsTrackingVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp
index c928cfe266..15fd3e614c 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp
@@ -1,778 +1,778 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 //misc
 #define _USE_MATH_DEFINES
 #include <math.h>
 #include <QFileDialog>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkOdfMaximaExtractionView.h"
 
 // MITK
 #include <mitkImageCast.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <mitkImage.h>
 #include <mitkImageToItk.h>
 #include <mitkTensorImage.h>
 
 // ITK
 #include <itkVectorImage.h>
 #include <itkOdfMaximaExtractionFilter.h>
 #include <itkFiniteDiffOdfMaximaExtractionFilter.h>
 #include <itkMrtrixPeakImageConverter.h>
 #include <itkFslPeakImageConverter.h>
 #include <itkShCoefficientImageImporter.h>
 #include <itkDiffusionTensorPrincipalDirectionImageFilter.h>
 
 // Qt
 #include <QMessageBox>
 
 const std::string QmitkOdfMaximaExtractionView::VIEW_ID = "org.mitk.views.odfmaximaextractionview";
 using namespace mitk;
 
 QmitkOdfMaximaExtractionView::QmitkOdfMaximaExtractionView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
 {
 
 }
 
 // Destructor
 QmitkOdfMaximaExtractionView::~QmitkOdfMaximaExtractionView()
 {
 
 }
 
 
 void QmitkOdfMaximaExtractionView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkOdfMaximaExtractionViewControls;
         m_Controls->setupUi( parent );
 
         connect((QObject*) m_Controls->m_StartTensor, SIGNAL(clicked()), (QObject*) this, SLOT(StartTensor()));
         connect((QObject*) m_Controls->m_StartFiniteDiff, SIGNAL(clicked()), (QObject*) this, SLOT(StartFiniteDiff()));
         connect((QObject*) m_Controls->m_GenerateImageButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateImage()));
         connect((QObject*) m_Controls->m_ImportPeaks, SIGNAL(clicked()), (QObject*) this, SLOT(ConvertPeaks()));
         connect((QObject*) m_Controls->m_ImportShCoeffs, SIGNAL(clicked()), (QObject*) this, SLOT(ConvertShCoeffs()));
     }
 }
 
 void QmitkOdfMaximaExtractionView::UpdateGui()
 {
     m_Controls->m_GenerateImageButton->setEnabled(false);
     m_Controls->m_StartFiniteDiff->setEnabled(false);
     m_Controls->m_StartTensor->setEnabled(false);
     m_Controls->m_CoeffImageFrame->setEnabled(false);
 
     if (!m_ImageNodes.empty() || !m_TensorImageNodes.empty())
     {
         m_Controls->m_InputData->setTitle("Input Data");
 
         if (!m_TensorImageNodes.empty())
         {
             m_Controls->m_DwiFibLabel->setText(m_TensorImageNodes.front()->GetName().c_str());
             m_Controls->m_StartTensor->setEnabled(true);
         }
         else
         {
             m_Controls->m_DwiFibLabel->setText(m_ImageNodes.front()->GetName().c_str());
             m_Controls->m_StartFiniteDiff->setEnabled(true);
             m_Controls->m_GenerateImageButton->setEnabled(true);
             m_Controls->m_CoeffImageFrame->setEnabled(true);
             m_Controls->m_ShOrderBox->setEnabled(true);
             m_Controls->m_MaxNumPeaksBox->setEnabled(true);
             m_Controls->m_PeakThresholdBox->setEnabled(true);
             m_Controls->m_AbsoluteThresholdBox->setEnabled(true);
         }
     }
     else
         m_Controls->m_DwiFibLabel->setText("<font color='red'>mandatory</font>");
 
 
     if (m_ImageNodes.empty())
     {
         m_Controls->m_ImportPeaks->setEnabled(false);
         m_Controls->m_ImportShCoeffs->setEnabled(false);
     }
     else
     {
         m_Controls->m_ImportPeaks->setEnabled(true);
         m_Controls->m_ImportShCoeffs->setEnabled(true);
     }
 
     if (!m_BinaryImageNodes.empty())
     {
         m_Controls->m_MaskLabel->setText(m_BinaryImageNodes.front()->GetName().c_str());
     }
     else
     {
         m_Controls->m_MaskLabel->setText("<font color='grey'>optional</font>");
     }
 }
 
 template<int shOrder>
 void QmitkOdfMaximaExtractionView::TemplatedConvertShCoeffs(mitk::Image* mitkImg)
 {
     typedef itk::ShCoefficientImageImporter< float, shOrder > FilterType;
     typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
     CasterType::Pointer caster = CasterType::New();
     caster->SetInput(mitkImg);
     caster->Update();
 
     typename FilterType::Pointer filter = FilterType::New();
 
     switch (m_Controls->m_ToolkitBox->currentIndex())
     {
     case 0:
         filter->SetToolkit(FilterType::FSL);
         break;
     case 1:
         filter->SetToolkit(FilterType::MRTRIX);
         break;
     default:
         filter->SetToolkit(FilterType::FSL);
     }
 
     filter->SetInputImage(caster->GetOutput());
     filter->GenerateData();
     typename FilterType::QballImageType::Pointer itkQbi = filter->GetQballImage();
     typename FilterType::CoefficientImageType::Pointer itkCi = filter->GetCoefficientImage();
 
     {
         mitk::Image::Pointer img = mitk::Image::New();
         img->InitializeByItk( itkCi.GetPointer() );
         img->SetVolume( itkCi->GetBufferPointer() );
         DataNode::Pointer node = DataNode::New();
         node->SetData(img);
         node->SetName("_ShCoefficientImage");
         node->SetVisibility(false);
         GetDataStorage()->Add(node);
     }
 
     {
         mitk::QBallImage::Pointer img = mitk::QBallImage::New();
         img->InitializeByItk( itkQbi.GetPointer() );
         img->SetVolume( itkQbi->GetBufferPointer() );
         DataNode::Pointer node = DataNode::New();
         node->SetData(img);
         node->SetName("_QballImage");
         GetDataStorage()->Add(node);
     }
 }
 
 void QmitkOdfMaximaExtractionView::ConvertShCoeffs()
 {
     if (m_ImageNodes.empty())
         return;
     mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_ImageNodes.at(0)->GetData());
     if (mitkImg->GetDimension()!=4)
     {
         MITK_INFO << "wrong image type (need 4 dimensions)";
         return;
     }
 
     int nrCoeffs = mitkImg->GetLargestPossibleRegion().GetSize()[3];
     // solve bx² + cx + d = 0 = shOrder² + 2*shOrder + 2-2*neededCoeffs;
     int c=3, d=2-2*nrCoeffs;
     double D = c*c-4*d;
     int shOrder;
     if (D>0)
     {
         shOrder = (-c+sqrt(D))/2.0;
         if (shOrder<0)
             shOrder = (-c-sqrt(D))/2.0;
     }
     else if (D==0)
         shOrder = -c/2.0;
 
     MITK_INFO << "using SH-order " << shOrder;
 
     switch (shOrder)
     {
     case 2:
         TemplatedConvertShCoeffs<2>(mitkImg);
         break;
     case 4:
         TemplatedConvertShCoeffs<4>(mitkImg);
         break;
     case 6:
         TemplatedConvertShCoeffs<6>(mitkImg);
         break;
     case 8:
         TemplatedConvertShCoeffs<8>(mitkImg);
         break;
     case 10:
         TemplatedConvertShCoeffs<10>(mitkImg);
         break;
     case 12:
         TemplatedConvertShCoeffs<12>(mitkImg);
         break;
     default:
         MITK_INFO << "SH-order " << shOrder << " not supported";
     }
 }
 
 void QmitkOdfMaximaExtractionView::ConvertPeaks()
 {
     if (m_ImageNodes.empty())
         return;
 
     switch (m_Controls->m_ToolkitBox->currentIndex())
     {
     case 0:
     {
         typedef itk::Image< float, 4 > ItkImageType;
         typedef itk::FslPeakImageConverter< float > FilterType;
         FilterType::Pointer filter = FilterType::New();
         FilterType::InputType::Pointer inputVec = FilterType::InputType::New();
         mitk::BaseGeometry::Pointer geom;
 
         for (int i=0; i<m_ImageNodes.size(); i++)
         {
             mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_ImageNodes.at(i)->GetData());
             geom = mitkImg->GetGeometry();
             typedef mitk::ImageToItk< FilterType::InputImageType > CasterType;
             CasterType::Pointer caster = CasterType::New();
             caster->SetInput(mitkImg);
             caster->Update();
             FilterType::InputImageType::Pointer itkImg = caster->GetOutput();
             inputVec->InsertElement(inputVec->Size(), itkImg);
         }
 
         filter->SetInputImages(inputVec);
         filter->GenerateData();
 
         mitk::Vector3D outImageSpacing = geom->GetSpacing();
         float maxSpacing = 1;
         if(outImageSpacing[0]>outImageSpacing[1] && outImageSpacing[0]>outImageSpacing[2])
             maxSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] > outImageSpacing[2])
             maxSpacing = outImageSpacing[1];
         else
             maxSpacing = outImageSpacing[2];
 
-        mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
+        mitk::FiberBundle::Pointer directions = filter->GetOutputFiberBundle();
         // directions->SetGeometry(geom);
         DataNode::Pointer node = DataNode::New();
         node->SetData(directions);
         node->SetName("_VectorField");
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(maxSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
 
         typedef FilterType::DirectionImageContainerType DirectionImageContainerType;
         DirectionImageContainerType::Pointer container = filter->GetDirectionImageContainer();
         for (int i=0; i<container->Size(); i++)
         {
             ItkDirectionImage3DType::Pointer itkImg = container->GetElement(i);
             mitk::Image::Pointer img = mitk::Image::New();
             img->InitializeByItk( itkImg.GetPointer() );
             img->SetVolume( itkImg->GetBufferPointer() );
             DataNode::Pointer node = DataNode::New();
             node->SetData(img);
             QString name(m_ImageNodes.at(i)->GetName().c_str());
             name += "_Direction";
             name += QString::number(i+1);
             node->SetName(name.toStdString().c_str());
             node->SetVisibility(false);
             GetDataStorage()->Add(node);
         }
         break;
     }
     case 1:
     {
         typedef itk::Image< float, 4 > ItkImageType;
         typedef itk::MrtrixPeakImageConverter< float > FilterType;
         FilterType::Pointer filter = FilterType::New();
 
         // cast to itk
         mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_ImageNodes.at(0)->GetData());
         mitk::BaseGeometry::Pointer geom = mitkImg->GetGeometry();
         typedef mitk::ImageToItk< FilterType::InputImageType > CasterType;
         CasterType::Pointer caster = CasterType::New();
         caster->SetInput(mitkImg);
         caster->Update();
         FilterType::InputImageType::Pointer itkImg = caster->GetOutput();
 
         filter->SetInputImage(itkImg);
         filter->GenerateData();
 
         mitk::Vector3D outImageSpacing = geom->GetSpacing();
         float maxSpacing = 1;
         if(outImageSpacing[0]>outImageSpacing[1] && outImageSpacing[0]>outImageSpacing[2])
             maxSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] > outImageSpacing[2])
             maxSpacing = outImageSpacing[1];
         else
             maxSpacing = outImageSpacing[2];
 
-        mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
+        mitk::FiberBundle::Pointer directions = filter->GetOutputFiberBundle();
         //directions->SetGeometry(geom);
         DataNode::Pointer node = DataNode::New();
         node->SetData(directions);
         QString name(m_ImageNodes.at(0)->GetName().c_str());
         name += "_VectorField";
         node->SetName(name.toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(maxSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
 
         {
             ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
             mitk::Image::Pointer image2 = mitk::Image::New();
             image2->InitializeByItk( numDirImage.GetPointer() );
             image2->SetVolume( numDirImage->GetBufferPointer() );
             DataNode::Pointer node2 = DataNode::New();
             node2->SetData(image2);
             QString name(m_ImageNodes.at(0)->GetName().c_str());
             name += "_NumDirections";
             node2->SetName(name.toStdString().c_str());
             GetDataStorage()->Add(node2);
         }
 
         typedef FilterType::DirectionImageContainerType DirectionImageContainerType;
         DirectionImageContainerType::Pointer container = filter->GetDirectionImageContainer();
         for (int i=0; i<container->Size(); i++)
         {
             ItkDirectionImage3DType::Pointer itkImg = container->GetElement(i);
             mitk::Image::Pointer img = mitk::Image::New();
             img->InitializeByItk( itkImg.GetPointer() );
             img->SetVolume( itkImg->GetBufferPointer() );
             DataNode::Pointer node = DataNode::New();
             node->SetData(img);
             QString name(m_ImageNodes.at(0)->GetName().c_str());
             name += "_Direction";
             name += QString::number(i+1);
             node->SetName(name.toStdString().c_str());
             node->SetVisibility(false);
             GetDataStorage()->Add(node);
         }
         break;
     }
     }
 }
 
 void QmitkOdfMaximaExtractionView::GenerateImage()
 {
     if (!m_ImageNodes.empty())
         GenerateDataFromDwi();
 }
 
 void QmitkOdfMaximaExtractionView::StartTensor()
 {
     if (m_TensorImageNodes.empty())
         return;
 
     typedef itk::DiffusionTensorPrincipalDirectionImageFilter< float, float > MaximaExtractionFilterType;
     MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
 
     mitk::BaseGeometry::Pointer geometry;
     try{
         TensorImage::Pointer img = dynamic_cast<TensorImage*>(m_TensorImageNodes.at(0)->GetData());
         ItkTensorImage::Pointer itkImage = ItkTensorImage::New();
         CastToItkImage(img, itkImage);
         filter->SetInput(itkImage);
         geometry = img->GetGeometry();
     }
     catch(itk::ExceptionObject &e)
     {
         MITK_INFO << "wrong image type: " << e.what();
         QMessageBox::warning( NULL, "Wrong pixel type", "Could not perform Tensor Principal Direction Extraction due to Image has wrong pixel type.", QMessageBox::Ok );
         return;
         //throw e;
     }
 
     if (!m_BinaryImageNodes.empty())
     {
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_BinaryImageNodes.at(0)->GetData());
         CastToItkImage(mitkMaskImg, itkMaskImage);
         filter->SetMaskImage(itkMaskImage);
     }
 
     if (m_Controls->m_NormalizationBox->currentIndex()==0)
         filter->SetNormalizeVectors(false);
 
     filter->Update();
 
     if (m_Controls->m_OutputDirectionImagesBox->isChecked())
     {
         MaximaExtractionFilterType::OutputImageType::Pointer itkImg = filter->GetOutput();
         mitk::Image::Pointer img = mitk::Image::New();
         img->InitializeByItk( itkImg.GetPointer() );
         img->SetVolume( itkImg->GetBufferPointer() );
         DataNode::Pointer node = DataNode::New();
         node->SetData(img);
         QString name(m_TensorImageNodes.at(0)->GetName().c_str());
         name += "_PrincipalDirection";
         node->SetName(name.toStdString().c_str());
         node->SetVisibility(false);
         GetDataStorage()->Add(node);
     }
 
     if (m_Controls->m_OutputNumDirectionsBox->isChecked())
     {
         ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
         mitk::Image::Pointer image2 = mitk::Image::New();
         image2->InitializeByItk( numDirImage.GetPointer() );
         image2->SetVolume( numDirImage->GetBufferPointer() );
         DataNode::Pointer node2 = DataNode::New();
         node2->SetData(image2);
         QString name(m_TensorImageNodes.at(0)->GetName().c_str());
         name += "_NumDirections";
         node2->SetName(name.toStdString().c_str());
         GetDataStorage()->Add(node2);
     }
 
     if (m_Controls->m_OutputVectorFieldBox->isChecked())
     {
         mitk::Vector3D outImageSpacing = geometry->GetSpacing();
         float minSpacing = 1;
         if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
             minSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] < outImageSpacing[2])
             minSpacing = outImageSpacing[1];
         else
             minSpacing = outImageSpacing[2];
 
-        mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
+        mitk::FiberBundle::Pointer directions = filter->GetOutputFiberBundle();
         // directions->SetGeometry(geometry);
         DataNode::Pointer node = DataNode::New();
         node->SetData(directions);
         QString name(m_TensorImageNodes.at(0)->GetName().c_str());
         name += "_VectorField";
         node->SetName(name.toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
     }
 }
 
 template<int shOrder>
 void QmitkOdfMaximaExtractionView::StartMaximaExtraction()
 {
     typedef itk::FiniteDiffOdfMaximaExtractionFilter< float, shOrder, 20242 > MaximaExtractionFilterType;
     typename MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
 
     switch (m_Controls->m_ToolkitBox->currentIndex())
     {
     case 0:
         filter->SetToolkit(MaximaExtractionFilterType::FSL);
         break;
     case 1:
         filter->SetToolkit(MaximaExtractionFilterType::MRTRIX);
         break;
     default:
         filter->SetToolkit(MaximaExtractionFilterType::FSL);
     }
 
     mitk::BaseGeometry::Pointer geometry;
     try{
         Image::Pointer img = dynamic_cast<Image*>(m_ImageNodes.at(0)->GetData());
         typedef ImageToItk< typename MaximaExtractionFilterType::CoefficientImageType > CasterType;
         typename CasterType::Pointer caster = CasterType::New();
         caster->SetInput(img);
         caster->Update();
         filter->SetInput(caster->GetOutput());
         geometry = img->GetGeometry();
     }
     catch(itk::ExceptionObject &e)
     {
         MITK_INFO << "wrong image type: " << e.what();
         QMessageBox::warning( NULL, "Wrong pixel type", "Could not perform Finite Differences Extraction due to Image has wrong pixel type.", QMessageBox::Ok );
         return;
         //throw;
     }
 
     filter->SetAngularThreshold(cos((float)m_Controls->m_AngularThreshold->value()*M_PI/180));
     filter->SetClusteringThreshold(cos((float)m_Controls->m_ClusteringAngleBox->value()*M_PI/180));
     filter->SetMaxNumPeaks(m_Controls->m_MaxNumPeaksBox->value());
     filter->SetPeakThreshold(m_Controls->m_PeakThresholdBox->value());
     filter->SetAbsolutePeakThreshold(m_Controls->m_AbsoluteThresholdBox->value());
 
     if (!m_BinaryImageNodes.empty())
     {
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_BinaryImageNodes.at(0)->GetData());
         CastToItkImage(mitkMaskImg, itkMaskImage);
         filter->SetMaskImage(itkMaskImage);
     }
 
     switch (m_Controls->m_NormalizationBox->currentIndex())
     {
     case 0:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
         break;
     case 1:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
         break;
     case 2:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
         break;
     }
 
     filter->Update();
 
     if (m_Controls->m_OutputDirectionImagesBox->isChecked())
     {
         typedef typename MaximaExtractionFilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
         typename ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
         for (int i=0; i<container->Size(); i++)
         {
             typename MaximaExtractionFilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
             mitk::Image::Pointer img = mitk::Image::New();
             img->InitializeByItk( itkImg.GetPointer() );
             img->SetVolume( itkImg->GetBufferPointer() );
             DataNode::Pointer node = DataNode::New();
             node->SetData(img);
             QString name(m_ImageNodes.at(0)->GetName().c_str());
             name += "_Direction";
             name += QString::number(i+1);
             node->SetName(name.toStdString().c_str());
             node->SetVisibility(false);
             GetDataStorage()->Add(node);
         }
     }
 
     if (m_Controls->m_OutputNumDirectionsBox->isChecked())
     {
         ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
         mitk::Image::Pointer image2 = mitk::Image::New();
         image2->InitializeByItk( numDirImage.GetPointer() );
         image2->SetVolume( numDirImage->GetBufferPointer() );
         DataNode::Pointer node2 = DataNode::New();
         node2->SetData(image2);
         QString name(m_ImageNodes.at(0)->GetName().c_str());
         name += "_NumDirections";
         node2->SetName(name.toStdString().c_str());
         GetDataStorage()->Add(node2);
     }
 
     if (m_Controls->m_OutputVectorFieldBox->isChecked())
     {
         mitk::Vector3D outImageSpacing = geometry->GetSpacing();
         float minSpacing = 1;
         if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
             minSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] < outImageSpacing[2])
             minSpacing = outImageSpacing[1];
         else
             minSpacing = outImageSpacing[2];
 
-        mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
+        mitk::FiberBundle::Pointer directions = filter->GetOutputFiberBundle();
         // directions->SetGeometry(geometry);
         DataNode::Pointer node = DataNode::New();
         node->SetData(directions);
         QString name(m_ImageNodes.at(0)->GetName().c_str());
         name += "_VectorField";
         node->SetName(name.toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
     }
 }
 
 void QmitkOdfMaximaExtractionView::StartFiniteDiff()
 {
     if (m_ImageNodes.empty())
         return;
 
     switch (m_Controls->m_ShOrderBox->currentIndex())
     {
     case 0:
         StartMaximaExtraction<2>();
         break;
     case 1:
         StartMaximaExtraction<4>();
         break;
     case 2:
         StartMaximaExtraction<6>();
         break;
     case 3:
         StartMaximaExtraction<8>();
         break;
     case 4:
         StartMaximaExtraction<10>();
         break;
     case 5:
         StartMaximaExtraction<12>();
         break;
     }
 }
 
 void QmitkOdfMaximaExtractionView::GenerateDataFromDwi()
 {
     typedef itk::OdfMaximaExtractionFilter< float > MaximaExtractionFilterType;
     MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
 
     mitk::BaseGeometry::Pointer geometry;
     if (!m_ImageNodes.empty())
     {
         try{
             Image::Pointer img = dynamic_cast<Image*>(m_ImageNodes.at(0)->GetData());
             typedef ImageToItk< MaximaExtractionFilterType::CoefficientImageType > CasterType;
             CasterType::Pointer caster = CasterType::New();
             caster->SetInput(img);
             caster->Update();
             filter->SetShCoeffImage(caster->GetOutput());
             geometry = img->GetGeometry();
         }
         catch(itk::ExceptionObject &e)
         {
             MITK_INFO << "wrong image type: " << e.what();
             return;
         }
     }
     else
         return;
 
     filter->SetMaxNumPeaks(m_Controls->m_MaxNumPeaksBox->value());
     filter->SetPeakThreshold(m_Controls->m_PeakThresholdBox->value());
 
     if (!m_BinaryImageNodes.empty())
     {
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_BinaryImageNodes.at(0)->GetData());
         CastToItkImage(mitkMaskImg, itkMaskImage);
         filter->SetMaskImage(itkMaskImage);
     }
 
     switch (m_Controls->m_NormalizationBox->currentIndex())
     {
     case 0:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
         break;
     case 1:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
         break;
     case 2:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
         break;
     }
 
     filter->GenerateData();
 
     ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
 
     if (m_Controls->m_OutputDirectionImagesBox->isChecked())
     {
         typedef MaximaExtractionFilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
         ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
         for (int i=0; i<container->Size(); i++)
         {
             MaximaExtractionFilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
             mitk::Image::Pointer img = mitk::Image::New();
             img->InitializeByItk( itkImg.GetPointer() );
             img->SetVolume( itkImg->GetBufferPointer() );
             DataNode::Pointer node = DataNode::New();
             node->SetData(img);
             QString name(m_ImageNodes.at(0)->GetName().c_str());
             name += "_Direction";
             name += QString::number(i+1);
             node->SetName(name.toStdString().c_str());
             GetDataStorage()->Add(node);
         }
     }
 
     if (m_Controls->m_OutputNumDirectionsBox->isChecked())
     {
         mitk::Image::Pointer image2 = mitk::Image::New();
         image2->InitializeByItk( numDirImage.GetPointer() );
         image2->SetVolume( numDirImage->GetBufferPointer() );
         DataNode::Pointer node = DataNode::New();
         node->SetData(image2);
         QString name(m_ImageNodes.at(0)->GetName().c_str());
         name += "_NumDirections";
         node->SetName(name.toStdString().c_str());
         GetDataStorage()->Add(node);
     }
 
     if (m_Controls->m_OutputVectorFieldBox->isChecked())
     {
         mitk::Vector3D outImageSpacing = geometry->GetSpacing();
         float minSpacing = 1;
         if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
             minSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] < outImageSpacing[2])
             minSpacing = outImageSpacing[1];
         else
             minSpacing = outImageSpacing[2];
 
-        mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
+        mitk::FiberBundle::Pointer directions = filter->GetOutputFiberBundle();
         // directions->SetGeometry(geometry);
         DataNode::Pointer node = DataNode::New();
         node->SetData(directions);
         QString name(m_ImageNodes.at(0)->GetName().c_str());
         name += "_VectorField";
         node->SetName(name.toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
     }
 }
 
 void QmitkOdfMaximaExtractionView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkOdfMaximaExtractionView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 void QmitkOdfMaximaExtractionView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     m_Controls->m_InputData->setTitle("Please Select Input Data");
     m_Controls->m_DwiFibLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_MaskLabel->setText("<font color='grey'>optional</font>");
 
     m_BinaryImageNodes.clear();
     m_ImageNodes.clear();
     m_TensorImageNodes.clear();
 
     // iterate all selected objects, adjust warning visibility
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if ( node.IsNotNull() && dynamic_cast<mitk::TensorImage*>(node->GetData()) )
         {
             m_TensorImageNodes.push_back(node);
         }
         else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             bool isBinary = false;
             node->GetPropertyValue<bool>("binary", isBinary);
             if (isBinary)
                 m_BinaryImageNodes.push_back(node);
             else
                 m_ImageNodes.push_back(node);
         }
     }
 
     UpdateGui();
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
index a5ccce623d..738e29bf18 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
@@ -1,295 +1,295 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIStructuredSelection.h>
 
 // Qmitk
 #include "QmitkStochasticFiberTrackingView.h"
 #include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkImageToItk.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <mitkImageCast.h>
 
 // VTK
 #include <vtkPolyData.h>
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkSmartPointer.h>
 #include <vtkPolyLine.h>
 #include <vtkCellData.h>
 
 
 const std::string QmitkStochasticFiberTrackingView::VIEW_ID = "org.mitk.views.stochasticfibertracking";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace berry;
 
 QmitkStochasticFiberTrackingView::QmitkStochasticFiberTrackingView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
     , m_SeedRoi( NULL )
     , m_DiffusionImage( NULL )
 {
 }
 
 // Destructor
 QmitkStochasticFiberTrackingView::~QmitkStochasticFiberTrackingView()
 {
 
 }
 
 void QmitkStochasticFiberTrackingView::CreateQtPartControl( QWidget *parent )
 {
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkStochasticFiberTrackingViewControls;
         m_Controls->setupUi( parent );
 
         connect( m_Controls->commandLinkButton, SIGNAL(clicked()), this, SLOT(DoFiberTracking()) );
         connect( m_Controls->m_SeedsPerVoxelSlider, SIGNAL(valueChanged(int)), this, SLOT(OnSeedsPerVoxelChanged(int)) );
         connect( m_Controls->m_MaxCacheSizeSlider, SIGNAL(valueChanged(int)), this, SLOT(OnMaxCacheSizeChanged(int)) );
         connect( m_Controls->m_MaxTractLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(OnMaxTractLengthChanged(int)) );
     }
 }
 
 void QmitkStochasticFiberTrackingView::OnSeedsPerVoxelChanged(int value)
 {
     m_Controls->m_SeedsPerVoxelLabel->setText(QString("Seeds per Voxel: ")+QString::number(value));
 }
 
 void QmitkStochasticFiberTrackingView::OnMaxTractLengthChanged(int value)
 {
     m_Controls->m_MaxTractLengthLabel->setText(QString("Max. Tract Length: ")+QString::number(value));
 }
 
 void QmitkStochasticFiberTrackingView::OnMaxCacheSizeChanged(int value)
 {
     m_Controls->m_MaxCacheSizeLabel->setText(QString("Max. Cache Size: ")+QString::number(value)+"GB");
 }
 
 void QmitkStochasticFiberTrackingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkStochasticFiberTrackingView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 void QmitkStochasticFiberTrackingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     m_DiffusionImageNode = NULL;
     m_DiffusionImage = NULL;
     m_SeedRoi = NULL;
     m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_RoiImageLabel->setText("<font color='red'>mandatory</font>");
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
           bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
           if ( isDiffusionImage )
             {
                 m_DiffusionImageNode = node;
                 m_DiffusionImage = dynamic_cast<mitk::Image*>(node->GetData());
                 m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
             }
             else
             {
                 bool isBinary = false;
                 node->GetPropertyValue<bool>("binary", isBinary);
                 if (isBinary)
                 {
                     m_SeedRoi = dynamic_cast<mitk::Image*>(node->GetData());
                     m_Controls->m_RoiImageLabel->setText(node->GetName().c_str());
                 }
             }
         }
     }
 
     if(m_DiffusionImage.IsNotNull() && m_SeedRoi.IsNotNull())
     {
         m_Controls->m_InputData->setTitle("Input Data");
         m_Controls->commandLinkButton->setEnabled(true);
     }
     else
     {
         m_Controls->m_InputData->setTitle("Please Select Input Data");
         m_Controls->commandLinkButton->setEnabled(false);
     }
 }
 
 
 
 void QmitkStochasticFiberTrackingView::DoFiberTracking()
 {
     typedef itk::VectorImage< short int, 3 >    DWIVectorImageType;
     typedef itk::Image< float, 3 >              FloatImageType;
     typedef itk::Image< unsigned int, 3 >       CImageType;
     typedef itk::StochasticTractographyFilter< DWIVectorImageType, FloatImageType, CImageType > TrackingFilterType;
     typedef itk::DTITubeSpatialObject<3>        DTITubeType;
     typedef itk::DTITubeSpatialObjectPoint<3>   DTITubePointType;
     typedef itk::SceneSpatialObject<3>          SceneSpatialObjectType;
 
     /* get Gradients/Direction of dwi */
     GradientDirectionContainerType::Pointer Pdir = static_cast<mitk::GradientDirectionsProperty*>( m_DiffusionImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
 
     /* bValueContainer, Container includes b-values according to corresponding gradient-direction*/
     TrackingFilterType::bValueContainerType::Pointer vecCont = TrackingFilterType::bValueContainerType::New();
 
     /* for each gradient set b-Value; for 0-gradient set b-value eq. 0 */
     for ( int i=0; i<(int)Pdir->size(); ++i)
     {
         vnl_vector_fixed<double,3> valsGrad = Pdir->at(i);
         if (valsGrad.get(0) == 0 && valsGrad.get(1) == 0 && valsGrad.get(2) == 0)
         {  //set 0-Gradient to bValue 0
             vecCont->InsertElement(i,0);
         }else{
             vecCont->InsertElement(i, static_cast<mitk::FloatProperty*>(m_DiffusionImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue());
         }
     }
 
     /* define measurement frame (identity-matrix 3x3) */
     TrackingFilterType::MeasurementFrameType measurement_frame =  static_cast<mitk::MeasurementFrameProperty*>(m_DiffusionImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame();
 
     /* generate white matterImage (dummy?)*/
     ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
   mitk::CastToItkImage(m_DiffusionImage, itkVectorImagePointer);
 
     FloatImageType::Pointer wmImage = FloatImageType::New();
     wmImage->SetSpacing( itkVectorImagePointer->GetSpacing() );
     wmImage->SetOrigin( itkVectorImagePointer->GetOrigin() );
     wmImage->SetDirection( itkVectorImagePointer->GetDirection() );
     wmImage->SetLargestPossibleRegion( itkVectorImagePointer->GetLargestPossibleRegion() );
     wmImage->SetBufferedRegion( wmImage->GetLargestPossibleRegion() );
     wmImage->SetRequestedRegion( wmImage->GetLargestPossibleRegion() );
     wmImage->Allocate();
 
     itk::ImageRegionIterator<FloatImageType> ot(wmImage, wmImage->GetLargestPossibleRegion() );
     while (!ot.IsAtEnd())
     {
         ot.Set(1);
         ++ot;
     }
 
     /* init TractographyFilter */
     TrackingFilterType::Pointer trackingFilter = TrackingFilterType::New();
     trackingFilter->SetPrimaryInput(itkVectorImagePointer.GetPointer());
     trackingFilter->SetbValues(vecCont);
     trackingFilter->SetGradients(Pdir);
     trackingFilter->SetMeasurementFrame(measurement_frame);
     trackingFilter->SetWhiteMatterProbabilityImage(wmImage);
     trackingFilter->SetTotalTracts(m_Controls->m_SeedsPerVoxelSlider->value());
     trackingFilter->SetMaxLikelihoodCacheSize(m_Controls->m_MaxCacheSizeSlider->value()*1000);
     trackingFilter->SetMaxTractLength(m_Controls->m_MaxTractLengthSlider->value());
 
     //itk::Image< char, 3 >
     mitk::ImageToItk< itk::Image< unsigned char, 3 > >::Pointer binaryImageToItk1 = mitk::ImageToItk< itk::Image< unsigned char, 3 > >::New();
     binaryImageToItk1->SetInput( m_SeedRoi );
     binaryImageToItk1->Update();
 
     vtkSmartPointer<vtkPoints> vPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vCellArray = vtkSmartPointer<vtkCellArray>::New();
 
     itk::ImageRegionConstIterator< BinaryImageType > it(binaryImageToItk1->GetOutput(), binaryImageToItk1->GetOutput()->GetRequestedRegion());
     it.GoToBegin();
     mitk::BaseGeometry* geom = m_DiffusionImage->GetGeometry();
 
     while(!it.IsAtEnd())
     {
         itk::ImageConstIterator<BinaryImageType>::PixelType tmpPxValue = it.Get();
 
         if(tmpPxValue != 0){
             mitk::Point3D point;
             itk::ImageRegionConstIterator< BinaryImageType >::IndexType seedIdx = it.GetIndex();
             trackingFilter->SetSeedIndex(seedIdx);
             trackingFilter->Update();
 
 
             /* get results from Filter */
             /* write each single tract into member container */
             TrackingFilterType::TractContainerType::Pointer container_tmp = trackingFilter->GetOutputTractContainer();
             TrackingFilterType::TractContainerType::Iterator elIt = container_tmp->Begin();
             TrackingFilterType::TractContainerType::Iterator end = container_tmp->End();
             bool addTract = true;
 
             while( elIt != end ){
                 TrackingFilterType::TractContainerType::Element tract = elIt.Value();
                 TrackingFilterType::TractContainerType::Element::ObjectType::VertexListType::ConstPointer vertexlist = tract->GetVertexList();
 
                 vtkSmartPointer<vtkPolyLine> vPolyLine = vtkSmartPointer<vtkPolyLine>::New();
                 for( int j=0; j<(int)vertexlist->Size(); j++)
                 {
                     TrackingFilterType::TractContainerType::Element::ObjectType::VertexListType::Element vertex = vertexlist->GetElement(j);
                     mitk::Point3D index;
                     index[0] = (float)vertex[0];
                     index[1] = (float)vertex[1];
                     index[2] = (float)vertex[2];
 
                     if (geom->IsIndexInside(index))
                     {
                         geom->IndexToWorld(index, point);
                         vtkIdType id = vPoints->InsertNextPoint(point.GetDataPointer());
                         vPolyLine->GetPointIds()->InsertNextId(id);
                     }
                     else
                     {
                         addTract = false;
                         break;
                     }
                 }
 
                 if (addTract)
                     vCellArray->InsertNextCell(vPolyLine);
 
                 ++elIt;
             }
         }
         ++it;
     }
 
     vtkSmartPointer<vtkPolyData> fiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     fiberPolyData->SetPoints(vPoints);
     fiberPolyData->SetLines(vCellArray);
 
-    mitk::FiberBundleX::Pointer fib = mitk::FiberBundleX::New(fiberPolyData);
+    mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(fiberPolyData);
     fib->SetReferenceGeometry(dynamic_cast<mitk::Image*>(m_DiffusionImageNode->GetData())->GetGeometry());
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(fib);
     QString name("FiberBundle_");
     name += m_DiffusionImageNode->GetName().c_str();
     name += "_Probabilistic";
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode, m_DiffusionImageNode);
 }
 
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStreamlineTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStreamlineTrackingView.cpp
index 6c60f8db19..da8fb53113 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStreamlineTrackingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStreamlineTrackingView.cpp
@@ -1,286 +1,286 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIStructuredSelection.h>
 
 // Qmitk
 #include "QmitkStreamlineTrackingView.h"
 #include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkImageToItk.h>
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 #include <mitkImageCast.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateDimension.h>
 
 // VTK
 #include <vtkPolyData.h>
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkSmartPointer.h>
 #include <vtkPolyLine.h>
 #include <vtkCellData.h>
 
 
 const std::string QmitkStreamlineTrackingView::VIEW_ID = "org.mitk.views.streamlinetracking";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace berry;
 
 QmitkStreamlineTrackingView::QmitkStreamlineTrackingView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
     , m_MaskImage( NULL )
     , m_SeedRoi( NULL )
 {
 }
 
 // Destructor
 QmitkStreamlineTrackingView::~QmitkStreamlineTrackingView()
 {
 
 }
 
 void QmitkStreamlineTrackingView::CreateQtPartControl( QWidget *parent )
 {
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkStreamlineTrackingViewControls;
         m_Controls->setupUi( parent );
         m_Controls->m_FaImageBox->SetDataStorage(this->GetDataStorage());
 
         mitk::TNodePredicateDataType<mitk::Image>::Pointer isImagePredicate = mitk::TNodePredicateDataType<mitk::Image>::New();
 
         mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
         mitk::NodePredicateNot::Pointer isNotBinaryPredicate = mitk::NodePredicateNot::New( isBinaryPredicate );
         mitk::NodePredicateAnd::Pointer isNotABinaryImagePredicate = mitk::NodePredicateAnd::New( isImagePredicate, isNotBinaryPredicate );
         mitk::NodePredicateDimension::Pointer dimensionPredicate = mitk::NodePredicateDimension::New(3);
 
         m_Controls->m_FaImageBox->SetPredicate( mitk::NodePredicateAnd::New(isNotABinaryImagePredicate, dimensionPredicate) );
 
         connect( m_Controls->commandLinkButton, SIGNAL(clicked()), this, SLOT(DoFiberTracking()) );
         connect( m_Controls->m_SeedsPerVoxelSlider, SIGNAL(valueChanged(int)), this, SLOT(OnSeedsPerVoxelChanged(int)) );
         connect( m_Controls->m_MinTractLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(OnMinTractLengthChanged(int)) );
         connect( m_Controls->m_FaThresholdSlider, SIGNAL(valueChanged(int)), this, SLOT(OnFaThresholdChanged(int)) );
         connect( m_Controls->m_AngularThresholdSlider, SIGNAL(valueChanged(int)), this, SLOT(OnAngularThresholdChanged(int)) );
         connect( m_Controls->m_StepsizeSlider, SIGNAL(valueChanged(int)), this, SLOT(OnStepsizeChanged(int)) );
         connect( m_Controls->m_fSlider, SIGNAL(valueChanged(int)), this, SLOT(OnfChanged(int)) );
         connect( m_Controls->m_gSlider, SIGNAL(valueChanged(int)), this, SLOT(OngChanged(int)) );
     }
 }
 
 void QmitkStreamlineTrackingView::OnfChanged(int value)
 {
     m_Controls->m_fLabel->setText(QString("f: ")+QString::number((float)value/100));
 }
 
 void QmitkStreamlineTrackingView::OngChanged(int value)
 {
     m_Controls->m_gLabel->setText(QString("g: ")+QString::number((float)value/100));
 }
 
 void QmitkStreamlineTrackingView::OnAngularThresholdChanged(int value)
 {
     if (value<0)
         m_Controls->m_AngularThresholdLabel->setText(QString("Min. Curvature Radius: auto"));
     else
         m_Controls->m_AngularThresholdLabel->setText(QString("Min. Curvature Radius: ")+QString::number((float)value/10)+QString("mm"));
 }
 
 void QmitkStreamlineTrackingView::OnSeedsPerVoxelChanged(int value)
 {
     m_Controls->m_SeedsPerVoxelLabel->setText(QString("Seeds per Voxel: ")+QString::number(value));
 }
 
 void QmitkStreamlineTrackingView::OnMinTractLengthChanged(int value)
 {
     m_Controls->m_MinTractLengthLabel->setText(QString("Min. Tract Length: ")+QString::number(value)+QString("mm"));
 }
 
 void QmitkStreamlineTrackingView::OnFaThresholdChanged(int value)
 {
     m_Controls->m_FaThresholdLabel->setText(QString("FA Threshold: ")+QString::number((float)value/100));
 }
 
 void QmitkStreamlineTrackingView::OnStepsizeChanged(int value)
 {
     if (value==0)
         m_Controls->m_StepsizeLabel->setText(QString("Stepsize: auto"));
     else
         m_Controls->m_StepsizeLabel->setText(QString("Stepsize: ")+QString::number((float)value/10)+QString("mm"));
 }
 
 void QmitkStreamlineTrackingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkStreamlineTrackingView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 void QmitkStreamlineTrackingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     m_TensorImageNodes.clear();
     m_TensorImages.clear();
     m_SeedRoi = NULL;
     m_MaskImage = NULL;
     m_Controls->m_TensorImageLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_RoiImageLabel->setText("<font color='grey'>optional</font>");
     m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</font>");
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             if( dynamic_cast<mitk::TensorImage*>(node->GetData()) )
             {
                 m_TensorImageNodes.push_back(node);
                 m_TensorImages.push_back(dynamic_cast<mitk::TensorImage*>(node->GetData()));
             }
             else
             {
                 bool isBinary = false;
                 node->GetPropertyValue<bool>("binary", isBinary);
                 if (isBinary && m_SeedRoi.IsNull())
                 {
                     m_SeedRoi = dynamic_cast<mitk::Image*>(node->GetData());
                     m_Controls->m_RoiImageLabel->setText(node->GetName().c_str());
                 }
                 else if (isBinary)
                 {
                     m_MaskImage = dynamic_cast<mitk::Image*>(node->GetData());
                     m_Controls->m_MaskImageLabel->setText(node->GetName().c_str());
                 }
             }
         }
     }
 
     if(!m_TensorImageNodes.empty())
     {
         if (m_TensorImageNodes.size()>1)
             m_Controls->m_TensorImageLabel->setText(m_TensorImageNodes.size()+" tensor images selected");
         else
             m_Controls->m_TensorImageLabel->setText(m_TensorImageNodes.at(0)->GetName().c_str());
         m_Controls->m_InputData->setTitle("Input Data");
         m_Controls->commandLinkButton->setEnabled(true);
     }
     else
     {
         m_Controls->m_InputData->setTitle("Please Select Input Data");
         m_Controls->commandLinkButton->setEnabled(false);
     }
 }
 
 
 
 void QmitkStreamlineTrackingView::DoFiberTracking()
 {
     if (m_TensorImages.empty())
         return;
 
     typedef itk::Image< itk::DiffusionTensor3D<float>, 3> TensorImageType;
     typedef mitk::ImageToItk<TensorImageType> CastType;
     typedef mitk::ImageToItk<ItkUCharImageType> CastType2;
 
     typedef itk::StreamlineTrackingFilter< float > FilterType;
     FilterType::Pointer filter = FilterType::New();
 
     for (int i=0; i<(int)m_TensorImages.size(); i++)
     {
         CastType::Pointer caster = CastType::New();
         caster->SetInput(m_TensorImages.at(i));
         caster->Update();
         filter->SetInput(i, caster->GetOutput());
     }
 
     if (m_Controls->m_UseFaImage->isChecked())
     {
         mitk::ImageToItk<ItkFloatImageType>::Pointer floatCast = mitk::ImageToItk<ItkFloatImageType>::New();
         floatCast->SetInput(dynamic_cast<mitk::Image*>(m_Controls->m_FaImageBox->GetSelectedNode()->GetData()));
         floatCast->Update();
         filter->SetFaImage(floatCast->GetOutput());
     }
 
     //filter->SetNumberOfThreads(1);
     filter->SetSeedsPerVoxel(m_Controls->m_SeedsPerVoxelSlider->value());
     filter->SetFaThreshold((float)m_Controls->m_FaThresholdSlider->value()/100);
     filter->SetMinCurvatureRadius((float)m_Controls->m_AngularThresholdSlider->value()/10);
     filter->SetStepSize((float)m_Controls->m_StepsizeSlider->value()/10);
     filter->SetF((float)m_Controls->m_fSlider->value()/100);
     filter->SetG((float)m_Controls->m_gSlider->value()/100);
     filter->SetInterpolate(m_Controls->m_InterpolationBox->isChecked());
     filter->SetMinTractLength(m_Controls->m_MinTractLengthSlider->value());
 
     if (m_SeedRoi.IsNotNull())
     {
         ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
         mitk::CastToItkImage(m_SeedRoi, mask);
         filter->SetSeedImage(mask);
     }
 
     if (m_MaskImage.IsNotNull())
     {
         ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
         mitk::CastToItkImage(m_MaskImage, mask);
         filter->SetMaskImage(mask);
     }
 
     filter->Update();
 
     vtkSmartPointer<vtkPolyData> fiberBundle = filter->GetFiberPolyData();
     if ( fiberBundle->GetNumberOfLines()==0 )
     {
         QMessageBox warnBox;
         warnBox.setWindowTitle("Warning");
         warnBox.setText("No fiberbundle was generated!");
         warnBox.setDetailedText("No fibers were generated using the parameters: \n\n" + m_Controls->m_FaThresholdLabel->text() + "\n" + m_Controls->m_AngularThresholdLabel->text() + "\n" + m_Controls->m_fLabel->text() + "\n" + m_Controls->m_gLabel->text() + "\n" + m_Controls->m_StepsizeLabel->text() + "\n" + m_Controls->m_MinTractLengthLabel->text() + "\n" + m_Controls->m_SeedsPerVoxelLabel->text() + "\n\nPlease check your parametersettings.");
         warnBox.setIcon(QMessageBox::Warning);
         warnBox.exec();
         return;
     }
-    mitk::FiberBundleX::Pointer fib = mitk::FiberBundleX::New(fiberBundle);
+    mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(fiberBundle);
     fib->SetReferenceGeometry(dynamic_cast<mitk::Image*>(m_TensorImageNodes.at(0)->GetData())->GetGeometry());
     if (m_Controls->m_ResampleFibersBox->isChecked())
         fib->Compress(m_Controls->m_FiberErrorBox->value());
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(fib);
     QString name("FiberBundle_");
     name += m_TensorImageNodes.at(0)->GetName().c_str();
     name += "_Streamline";
     node->SetName(name.toStdString());
     node->SetVisibility(true);
     GetDataStorage()->Add(node, m_TensorImageNodes.at(0));
 }
 
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp
index 7de3c7fdef..efc75ed8e0 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp
@@ -1,1137 +1,1137 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Qmitk
 #include "QmitkTractbasedSpatialStatisticsView.h"
 #include "QmitkStdMultiWidget.h"
 
 #include "mitkDataNodeObject.h"
 #include <itkCastImageFilter.h>
 
 // Qt
 #include <QMessageBox>
 #include <QInputDialog>
 #include <QClipboard>
 
 #include <qwt_plot_picker.h>
 
 #include <mitkTractAnalyzer.h>
 #include <mitkTbssImporter.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarFigureInteractor.h>
 
 
 #include "vtkPoints.h"
 #include <vtkCellArray.h>
 #include <vtkPolyLine.h>
 
 
 const std::string QmitkTractbasedSpatialStatisticsView::VIEW_ID = "org.mitk.views.tractbasedspatialstatistics";
 
 using namespace berry;
 
 
 QmitkTractbasedSpatialStatisticsView::QmitkTractbasedSpatialStatisticsView()
 : QmitkFunctionality()
 , m_Controls( 0 )
 , m_MultiWidget( NULL )
 {
 
 }
 
 QmitkTractbasedSpatialStatisticsView::~QmitkTractbasedSpatialStatisticsView()
 {
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::PerformChange()
 {
   m_Controls->m_RoiPlotWidget->ModifyPlot(m_Controls->m_Segments->value(), m_Controls->m_Average->isChecked());
 }
 
 void QmitkTractbasedSpatialStatisticsView::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
 {
   //datamanager selection changed
   if (!this->IsActivated())
     return;
 
 
   // Check which datatypes are selected in the datamanager and enable/disable widgets accordingly
 
   bool foundTbssRoi = false;
   bool foundTbss = false;
   bool found3dImage = false;
   bool found4dImage = false;
   bool foundFiberBundle = false;
   bool foundStartRoi = false;
   bool foundEndRoi = false;
 
   mitk::TbssRoiImage* roiImage;
   mitk::TbssImage* image;
   mitk::Image* img;
-  mitk::FiberBundleX* fib;
+  mitk::FiberBundle* fib;
   mitk::PlanarFigure* start;
   mitk::PlanarFigure* end;
 
   m_CurrentStartRoi = NULL;
   m_CurrentEndRoi = NULL;
 
 
 
   for ( int i=0; i<nodes.size(); i++ )
   {
 
     // only look at interesting types
     // check for valid data
     mitk::BaseData* nodeData = nodes[i]->GetData();
     if( nodeData )
     {
       if(QString("TbssRoiImage").compare(nodeData->GetNameOfClass())==0)
       {
         foundTbssRoi = true;
         roiImage = static_cast<mitk::TbssRoiImage*>(nodeData);
       }
       else if (QString("TbssImage").compare(nodeData->GetNameOfClass())==0)
       {
         foundTbss = true;
         image = static_cast<mitk::TbssImage*>(nodeData);
       }
       else if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
         img = static_cast<mitk::Image*>(nodeData);
         if(img->GetDimension() == 3)
         {
           found3dImage = true;
         }
         else if(img->GetDimension() == 4)
         {
           found4dImage = true;
         }
       }
 
-      else if (QString("FiberBundleX").compare(nodeData->GetNameOfClass())==0)
+      else if (QString("FiberBundle").compare(nodeData->GetNameOfClass())==0)
       {
         foundFiberBundle = true;
-        fib = static_cast<mitk::FiberBundleX*>(nodeData);
+        fib = static_cast<mitk::FiberBundle*>(nodeData);
         this->m_CurrentFiberNode = nodes[i];
       }
 
 
       if(QString("PlanarCircle").compare(nodeData->GetNameOfClass())==0)
       {
         if(!foundStartRoi)
         {
           start = dynamic_cast<mitk::PlanarFigure*>(nodeData);
           this->m_CurrentStartRoi = nodes[i];
           foundStartRoi =  true;
         }
         else
         {
           end = dynamic_cast<mitk::PlanarFigure*>(nodeData);
           this->m_CurrentEndRoi = nodes[i];
           foundEndRoi = true;
         }
       }
     }
   }
 
 
   this->m_Controls->m_CreateRoi->setEnabled(found3dImage);
   this->m_Controls->m_ImportFsl->setEnabled(found4dImage);
 
 
 
   if(foundTbss && foundTbssRoi)
   {
     this->Plot(image, roiImage);
   }
 
   else if(found3dImage && foundFiberBundle && foundStartRoi && foundEndRoi)
   {
     this->PlotFiberBundle(fib, img, start, end);
   }
 
   else if(found3dImage && foundFiberBundle)
   {
     this->PlotFiberBundle(fib, img);
   }
 
   else if(foundTbss && foundStartRoi && foundEndRoi && foundFiberBundle)
   {
     this->PlotFiber4D(image, fib, start, end);
   }
 
   if(found3dImage)
   {
     this->InitPointsets();
   }
 
   this->m_Controls->m_Cut->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi);
   this->m_Controls->m_SegmentLabel->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && (found3dImage || foundTbss));
   this->m_Controls->m_Segments->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && (found3dImage || foundTbss));
   this->m_Controls->m_Average->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && found3dImage);
 
 }
 
 void QmitkTractbasedSpatialStatisticsView::InitPointsets()
 {
   // Check if PointSetStart exsits, if not create it.
   m_P1 = this->GetDefaultDataStorage()->GetNamedNode("PointSetNode");
 
   if (m_PointSetNode)
   {
     //m_PointSetNode = dynamic_cast<mitk::PointSet*>(m_P1->GetData());
     return;
   }
 
   if ((!m_P1) || (!m_PointSetNode))
   {
     // create new ones
     m_PointSetNode = mitk::PointSet::New();
     m_P1 = mitk::DataNode::New();
     m_P1->SetData( m_PointSetNode );
     m_P1->SetProperty( "name", mitk::StringProperty::New( "PointSet" ) );
     m_P1->SetProperty( "opacity", mitk::FloatProperty::New( 1 ) );
     m_P1->SetProperty( "helper object", mitk::BoolProperty::New(true) ); // CHANGE if wanted
     m_P1->SetProperty( "pointsize", mitk::FloatProperty::New( 0.1 ) );
     m_P1->SetColor( 1.0, 0.0, 0.0 );
     this->GetDefaultDataStorage()->Add(m_P1);
     m_Controls->m_PointWidget->SetPointSetNode(m_P1);
     m_Controls->m_PointWidget->SetMultiWidget(GetActiveStdMultiWidget());
   }
 }
 
 void QmitkTractbasedSpatialStatisticsView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkTractbasedSpatialStatisticsViewControls;
     m_Controls->setupUi( parent );
     this->CreateConnections();
   }
 
 
   // Table for the FSL TBSS import
   m_GroupModel = new QmitkTbssTableModel();
   m_Controls->m_GroupInfo->setModel(m_GroupModel);
 
 
 }
 
 void QmitkTractbasedSpatialStatisticsView::Activated()
 {
   QmitkFunctionality::Activated();
 
 }
 
 void QmitkTractbasedSpatialStatisticsView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 void QmitkTractbasedSpatialStatisticsView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_CreateRoi), SIGNAL(clicked()), this, SLOT(CreateRoi()) );
     connect( (QObject*)(m_Controls->m_ImportFsl), SIGNAL(clicked()), this, SLOT(TbssImport()) );
     connect( (QObject*)(m_Controls->m_AddGroup), SIGNAL(clicked()), this, SLOT(AddGroup()) );
     connect( (QObject*)(m_Controls->m_RemoveGroup), SIGNAL(clicked()), this, SLOT(RemoveGroup()) );
     connect( (QObject*)(m_Controls->m_Clipboard), SIGNAL(clicked()), this, SLOT(CopyToClipboard()) );
     connect( m_Controls->m_RoiPlotWidget->m_PlotPicker, SIGNAL(selected(const QPointF&)), SLOT(Clicked(const QPointF&) ) );
     connect( m_Controls->m_RoiPlotWidget->m_PlotPicker, SIGNAL(moved(const QPointF&)), SLOT(Clicked(const QPointF&) ) );
     connect( (QObject*)(m_Controls->m_Cut), SIGNAL(clicked()), this, SLOT(Cut()) );
     connect( (QObject*)(m_Controls->m_Average), SIGNAL(stateChanged(int)), this, SLOT(PerformChange()) );
     connect( (QObject*)(m_Controls->m_Segments), SIGNAL(valueChanged(int)), this, SLOT(PerformChange()) );
 
   }
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::CopyToClipboard()
 {
 
 
 
   if(m_Controls->m_RoiPlotWidget->IsPlottingFiber())
   {
     // Working with fiber bundles
     std::vector <std::vector<double> > profiles = m_Controls->m_RoiPlotWidget->GetIndividualProfiles();
 
     QString clipboardText;
     for (std::vector<std::vector<double> >::iterator it = profiles.begin(); it
                                                            != profiles.end(); ++it)
     {
       for (std::vector<double>::iterator it2 = (*it).begin(); it2 !=
             (*it).end(); ++it2)
       {
         clipboardText.append(QString("%1 \t").arg(*it2));
       }
       clipboardText.append(QString("\n"));
     }
 
 
 
     if(m_Controls->m_Average->isChecked())
     {
       std::vector<double> averages = m_Controls->m_RoiPlotWidget->GetAverageProfile();
       clipboardText.append(QString("\nAverage\n"));
 
       for (std::vector<double>::iterator it2 = averages.begin(); it2 !=
             averages.end(); ++it2)
       {
         clipboardText.append(QString("%1 \t").arg(*it2));
 
       }
     }
 
     QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 
   }
 
   else{
 
     // Working with TBSS Data
     if(m_Controls->m_Average->isChecked())
     {
       std::vector<std::vector<double> > vals = m_Controls->m_RoiPlotWidget->GetVals();
       QString clipboardText;
       for (std::vector<std::vector<double> >::iterator it = vals.begin(); it
                                                              != vals.end(); ++it)
       {
         for (std::vector<double>::iterator it2 = (*it).begin(); it2 !=
               (*it).end(); ++it2)
         {
           clipboardText.append(QString("%1 \t").arg(*it2));
 
           double d = *it2;
           std::cout << d <<std::endl;
         }
         clipboardText.append(QString("\n"));
       }
 
       QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
     }
     else
     {
       std::vector<std::vector<double> > vals = m_Controls->m_RoiPlotWidget->GetIndividualProfiles();
       QString clipboardText;
       for (std::vector<std::vector<double> >::iterator it = vals.begin(); it
                                                              != vals.end(); ++it)
       {
         for (std::vector<double>::iterator it2 = (*it).begin(); it2 !=
               (*it).end(); ++it2)
         {
           clipboardText.append(QString("%1 \t").arg(*it2));
 
           double d = *it2;
           std::cout << d <<std::endl;
         }
         clipboardText.append(QString("\n"));
       }
       QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
     }
 
   }
 
 
 }
 
 void QmitkTractbasedSpatialStatisticsView::RemoveGroup()
 {
 
   QTableView *temp = static_cast<QTableView*>(m_Controls->m_GroupInfo);
 
   QItemSelectionModel *selectionModel = temp->selectionModel();
 
   QModelIndexList indices = selectionModel->selectedRows();
 
   QModelIndex index;
 
   foreach(index, indices)
   {
     int row = index.row();
     m_GroupModel->removeRows(row, 1, QModelIndex());
   }
 
 }
 
 
 
 void QmitkTractbasedSpatialStatisticsView::AddGroup()
 {
   QString group("Group");
   int number = 0;
   QPair<QString, int> pair(group, number);
   QList< QPair<QString, int> >list = m_GroupModel->getList();
 
 
   if(!list.contains(pair))
   {
     m_GroupModel->insertRows(0, 1, QModelIndex());
 
     QModelIndex index = m_GroupModel->index(0, 0, QModelIndex());
     m_GroupModel->setData(index, group, Qt::EditRole);
     index = m_GroupModel->index(0, 1, QModelIndex());
     m_GroupModel->setData(index, number, Qt::EditRole);
 
   }
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::TbssImport()
 {
 
   // Read groups from the interface
   mitk::TbssImporter::Pointer importer = mitk::TbssImporter::New();
 
   QList< QPair<QString, int> >list = m_GroupModel->getList();
 
 
   if(list.size() == 0)
   {
     QMessageBox msgBox;
     msgBox.setText("No study group information has been set yet.");
     msgBox.exec();
     return;
   }
 
 
   std::vector < std::pair<std::string, int> > groups;
   for(int i=0; i<list.size(); i++)
   {
     QPair<QString, int> pair = list.at(i);
     std::string s = pair.first.toStdString();
     int n = pair.second;
 
     std::pair<std::string, int> p;
     p.first = s;
     p.second = n;
     groups.push_back(p);
   }
 
   importer->SetGroupInfo(groups);
 
   std::string minfo = m_Controls->m_MeasurementInfo->text().toStdString();
   importer->SetMeasurementInfo(minfo);
 
 
   std::string name = "";
 
   std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
 
   for ( int i=0; i<nodes.size(); i++ )
   {
     if(QString("Image").compare(nodes[i]->GetData()->GetNameOfClass())==0)
     {
       mitk::Image* img = static_cast<mitk::Image*>(nodes[i]->GetData());
       if(img->GetDimension() == 4)
       {
         importer->SetImportVolume(img);
         name = nodes[i]->GetName();
       }
     }
   }
 
 
   mitk::TbssImage::Pointer tbssImage;
 
   tbssImage = importer->Import();
   name += "_tbss";
   AddTbssToDataStorage(tbssImage, name);
 
 
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::AddTbssToDataStorage(mitk::Image* image, std::string name)
 {
   mitk::LevelWindow levelwindow;
   levelwindow.SetAuto( image );
   mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
   levWinProp->SetLevelWindow( levelwindow );
 
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty( "name", mitk::StringProperty::New(name) );
   result->SetData( image );
   result->SetProperty( "levelwindow", levWinProp );
 
 
   // add new image to data storage and set as active to ease further processing
   GetDefaultDataStorage()->Add( result );
 
   // show the results
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::Clicked(const QPointF& pos)
 {
   int index = (int)pos.x();
 
   if(m_Roi.size() > 0 && m_CurrentGeometry != NULL && !m_Controls->m_RoiPlotWidget->IsPlottingFiber() )
   {
 
     index = std::min( (int)m_Roi.size()-1, std::max(0, index) );
     itk::Index<3> ix = m_Roi.at(index);
 
     mitk::Vector3D i;
     i[0] = ix[0];
     i[1] = ix[1];
     i[2] = ix[2];
 
     mitk::Vector3D w;
 
     m_CurrentGeometry->IndexToWorld(i, w);
 
     mitk::Point3D origin = m_CurrentGeometry->GetOrigin();
 
     mitk::Point3D p;
     p[0] = w[0] + origin[0];
     p[1] = w[1] + origin[1];
     p[2] = w[2] + origin[2];
 
     m_MultiWidget->MoveCrossToPosition(p);
     m_Controls->m_RoiPlotWidget->drawBar(index);
   }
 
   else if(m_Controls->m_RoiPlotWidget->IsPlottingFiber() )
   {
 
     mitk::Point3D point = m_Controls->m_RoiPlotWidget->GetPositionInWorld(index);
     m_MultiWidget->MoveCrossToPosition(point);
 
 
   }
 
 
 }
 
 void QmitkTractbasedSpatialStatisticsView::Cut()
 {
   mitk::BaseData* fibData = m_CurrentFiberNode->GetData();
-  mitk::FiberBundleX* fib = static_cast<mitk::FiberBundleX*>(fibData);
+  mitk::FiberBundle* fib = static_cast<mitk::FiberBundle*>(fibData);
 
   mitk::BaseData* startData = m_CurrentStartRoi->GetData();
   mitk::PlanarFigure* startRoi = static_cast<mitk::PlanarFigure*>(startData);
   mitk::PlaneGeometry* startGeometry2D = const_cast<mitk::PlaneGeometry*>(startRoi->GetPlaneGeometry());
 
   mitk::BaseData* endData = m_CurrentEndRoi->GetData();
   mitk::PlanarFigure* endRoi = static_cast<mitk::PlanarFigure*>(endData);
   mitk::PlaneGeometry* endGeometry2D = const_cast<mitk::PlaneGeometry*>(endRoi->GetPlaneGeometry());
 
   mitk::Point3D startCenter = startRoi->GetWorldControlPoint(0); //center Point of start roi
   mitk::Point3D endCenter = endRoi->GetWorldControlPoint(0); //center Point of end roi
 
-  mitk::FiberBundleX::Pointer inStart = fib->ExtractFiberSubset(startRoi);
-  mitk::FiberBundleX::Pointer inBoth = inStart->ExtractFiberSubset(endRoi);
+  mitk::FiberBundle::Pointer inStart = fib->ExtractFiberSubset(startRoi);
+  mitk::FiberBundle::Pointer inBoth = inStart->ExtractFiberSubset(endRoi);
 
   int num = inBoth->GetNumFibers();
 
   vtkSmartPointer<vtkPolyData> fiberPolyData = inBoth->GetFiberPolyData();
   vtkCellArray* lines = fiberPolyData->GetLines();
   lines->InitTraversal();
 
 
   // initialize new vtk polydata
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
 
   int pointIndex=0;
 
 
   // find start and endpoint
   for( int fiberID( 0 ); fiberID < num; fiberID++ )
   {
     vtkIdType   numPointsInCell(0);
     vtkIdType*  pointsInCell(NULL);
     lines->GetNextCell ( numPointsInCell, pointsInCell );
 
     int startId = 0;
     int endId = 0;
 
     float minDistStart = std::numeric_limits<float>::max();
     float minDistEnd = std::numeric_limits<float>::max();
 
 
     vtkSmartPointer<vtkPolyLine> polyLine = vtkSmartPointer<vtkPolyLine>::New();
     int lineIndex=0;
 
 
     for( int pointInCellID( 0 ); pointInCellID < numPointsInCell ; pointInCellID++)
     {
       double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
 
       mitk::Point3D point;
       point[0] = p[0];
       point[1] = p[1];
       point[2] = p[2];
 
       float distanceToStart = point.EuclideanDistanceTo(startCenter);
       float distanceToEnd = point.EuclideanDistanceTo(endCenter);
 
       if(distanceToStart < minDistStart)
       {
         minDistStart = distanceToStart;
         startId = pointInCellID;
       }
 
       if(distanceToEnd < minDistEnd)
       {
         minDistEnd = distanceToEnd;
         endId = pointInCellID;
       }
 
 
 
     }
 
 
 
     /* We found the start and end points of of the part that should be plottet for
        the current fiber. now we need to plot them. If the endId is smaller than the startId the plot order
        must be reversed*/
 
     if(startId < endId)
     {
 
       double *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
 
       mitk::Vector3D p0;
       p0[0] = p[0];
       p0[1] = p[1];
       p0[2] = p[2];
 
       p = fiberPolyData->GetPoint( pointsInCell[ startId+1 ] );
 
       mitk::Vector3D p1;
       p1[0] = p[0];
       p1[1] = p[1];
       p1[2] = p[2];
 
 
       // Check if p and p2 are both on the same side of the plane
       mitk::Vector3D normal = startGeometry2D->GetNormal();
 
       mitk::Point3D pStart;
       pStart[0] = p0[0];
       pStart[1] = p0[1];
       pStart[2] = p0[2];
 
       bool startOnPositive = startGeometry2D->IsAbove(pStart);
 
       mitk::Point3D pSecond;
       pSecond[0] = p1[0];
       pSecond[1] = p1[1];
       pSecond[2] = p1[2];
 
       bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
 
 
       // Calculate intersection with the plane
 
       mitk::Vector3D onPlane;
       onPlane[0] = startCenter[0];
       onPlane[1] = startCenter[1];
       onPlane[2] = startCenter[2];
 
 
       if(! (secondOnPositive ^ startOnPositive) )
       {
         /* startId and startId+1 lie on the same side of the plane, so we need
            need startId-1 to calculate the intersection with the planar figure*/
         p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
         p1[0] = p[0];
         p1[1] = p[1];
         p1[2] = p[2];
       }
 
 
       double d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
 
       mitk::Vector3D newPoint = (p0-p1);
 
       newPoint[0] = d*newPoint[0] + p0[0];
       newPoint[1] = d*newPoint[1] + p0[1];
       newPoint[2] = d*newPoint[2] + p0[2];
 
 
       double insertPoint[3];
       insertPoint[0] = newPoint[0];
       insertPoint[1] = newPoint[1];
       insertPoint[2] = newPoint[2];
 
 
       // First insert the intersection with the start roi
       points->InsertNextPoint(insertPoint);
       polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
       lineIndex++;
       pointIndex++;
 
       if(! (secondOnPositive ^ startOnPositive) )
       {
         /* StartId and startId+1 lie on the same side of the plane
            so startId is also part of the ROI*/
 
         double *start = fiberPolyData->GetPoint( pointsInCell[startId] );
         points->InsertNextPoint(start);
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
 
 
       }
 
       // Insert the rest up and to including endId-1
       for( int pointInCellID( startId+1 ); pointInCellID < endId ; pointInCellID++)
       {
         // create new polyline for new polydata
         double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
         points->InsertNextPoint(p);
 
 
         // add point to line
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
 
       }
 
 
 
       /* endId must be included if endId and endId-1 lie on the same side of the
          plane defined by endRoi*/
 
 
       p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
       p0[0] = p[0];      p0[1] = p[1];      p0[2] = p[2];
 
 
       p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
       p1[0] = p[0];      p1[1] = p[1];      p1[2] = p[2];
 
 
       mitk::Point3D pLast;
       pLast[0] = p0[0];      pLast[1] = p0[1];      pLast[2] = p0[2];
 
       mitk::Point3D pBeforeLast;
       pBeforeLast[0] = p1[0];      pBeforeLast[1] = p1[1];      pBeforeLast[2] = p1[2];
 
       bool lastOnPositive = endGeometry2D->IsAbove(pLast);
       bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
       normal = endGeometry2D->GetNormal();
 
 
       onPlane[0] = endCenter[0];
       onPlane[1] = endCenter[1];
       onPlane[2] = endCenter[2];
 
 
 
       if(! (lastOnPositive ^ secondLastOnPositive) )
       {
         /* endId and endId-1 lie on the same side of the plane, so we need
            need endId+1 to calculate the intersection with the planar figure.
            this should exist since we know that the fiber crosses the planar figure
            endId is part of the roi so can also be included here*/
         p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
         p1[0] = p[0];
         p1[1] = p[1];
         p1[2] = p[2];
 
 
         double *end = fiberPolyData->GetPoint( pointsInCell[endId] );
         points->InsertNextPoint(end);
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
       }
 
       d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
 
       newPoint = (p0-p1);
 
       newPoint[0] = d*newPoint[0] + p0[0];
       newPoint[1] = d*newPoint[1] + p0[1];
       newPoint[2] = d*newPoint[2] + p0[2];
 
       insertPoint[0] = newPoint[0];
       insertPoint[1] = newPoint[1];
       insertPoint[2] = newPoint[2];
 
       //Insert the Last Point (intersection with the end roi)
 
       points->InsertNextPoint(insertPoint);
       polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
       lineIndex++;
       pointIndex++;
 
 
     }
 
     // Need to reverse walking order
     else{
       double *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
 
       mitk::Vector3D p0;
       p0[0] = p[0];
       p0[1] = p[1];
       p0[2] = p[2];
 
       p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
 
       mitk::Vector3D p1;
       p1[0] = p[0];
       p1[1] = p[1];
       p1[2] = p[2];
 
 
       // Check if p and p2 are both on the same side of the plane
       mitk::Vector3D normal = startGeometry2D->GetNormal();
 
       mitk::Point3D pStart;
       pStart[0] = p0[0];
       pStart[1] = p0[1];
       pStart[2] = p0[2];
 
       bool startOnPositive = startGeometry2D->IsAbove(pStart);
 
       mitk::Point3D pSecond;
       pSecond[0] = p1[0];
       pSecond[1] = p1[1];
       pSecond[2] = p1[2];
 
       bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
 
 
       // Calculate intersection with the plane
 
       mitk::Vector3D onPlane;
       onPlane[0] = startCenter[0];
       onPlane[1] = startCenter[1];
       onPlane[2] = startCenter[2];
 
 
       if(! (secondOnPositive ^ startOnPositive) )
       {
         /* startId and startId-1 lie on the same side of the plane, so we need
            need startId+1 to calculate the intersection with the planar figure*/
         p = fiberPolyData->GetPoint( pointsInCell[ startId+1 ] );
         p1[0] = p[0];
         p1[1] = p[1];
         p1[2] = p[2];
       }
 
 
       double d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
 
       mitk::Vector3D newPoint = (p0-p1);
 
       newPoint[0] = d*newPoint[0] + p0[0];
       newPoint[1] = d*newPoint[1] + p0[1];
       newPoint[2] = d*newPoint[2] + p0[2];
 
 
       double insertPoint[3];
       insertPoint[0] = newPoint[0];
       insertPoint[1] = newPoint[1];
       insertPoint[2] = newPoint[2];
 
 
       // First insert the intersection with the start roi
       points->InsertNextPoint(insertPoint);
       polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
       lineIndex++;
       pointIndex++;
 
       if(! (secondOnPositive ^ startOnPositive) )
       {
         /* startId and startId-1 lie on the same side of the plane
            so endId is also part of the ROI*/
 
         double *start = fiberPolyData->GetPoint( pointsInCell[startId] );
         points->InsertNextPoint(start);
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
 
 
       }
 
       // Insert the rest up and to including endId-1
       for( int pointInCellID( startId-1 ); pointInCellID > endId ; pointInCellID--)
       {
         // create new polyline for new polydata
         double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
         points->InsertNextPoint(p);
 
 
         // add point to line
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
 
       }
 
 
 
       /* startId must be included if startId and startId+ lie on the same side of the
          plane defined by endRoi*/
 
 
       p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
       p0[0] = p[0];
       p0[1] = p[1];
       p0[2] = p[2];
 
 
       p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
       p1[0] = p[0];
       p1[1] = p[1];
       p1[2] = p[2];
 
 
       mitk::Point3D pLast;
       pLast[0] = p0[0];
       pLast[1] = p0[1];
       pLast[2] = p0[2];
 
       bool lastOnPositive = endGeometry2D->IsAbove(pLast);
 
       mitk::Point3D pBeforeLast;
       pBeforeLast[0] = p1[0];
       pBeforeLast[1] = p1[1];
       pBeforeLast[2] = p1[2];
 
       bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
 
       onPlane[0] = endCenter[0];
       onPlane[1] = endCenter[1];
       onPlane[2] = endCenter[2];
 
 
 
       if(! (lastOnPositive ^ secondLastOnPositive) )
       {
         /* endId and endId+1 lie on the same side of the plane, so we need
            need endId-1 to calculate the intersection with the planar figure.
            this should exist since we know that the fiber crosses the planar figure*/
         p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
         p1[0] = p[0];
         p1[1] = p[1];
         p1[2] = p[2];
 
 
         /* endId and endId+1 lie on the same side of the plane
            so startId is also part of the ROI*/
 
         double *end = fiberPolyData->GetPoint( pointsInCell[endId] );
         points->InsertNextPoint(end);
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
       }
 
       d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
 
       newPoint = (p0-p1);
 
       newPoint[0] = d*newPoint[0] + p0[0];
       newPoint[1] = d*newPoint[1] + p0[1];
       newPoint[2] = d*newPoint[2] + p0[2];
 
 
       insertPoint[0] = newPoint[0];
       insertPoint[1] = newPoint[1];
       insertPoint[2] = newPoint[2];
 
 
 
       //Insert the Last Point (intersection with the end roi)
       points->InsertNextPoint(insertPoint);
       polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
       lineIndex++;
       pointIndex++;
 
 
 
     }
 
 
     // add polyline to vtk cell array
      cells->InsertNextCell(polyLine);
 
   }
 
 
   // Add the points to the dataset
   polyData->SetPoints(points);
 
   // Add the lines to the dataset
   polyData->SetLines(cells);
 
-  mitk::FiberBundleX::Pointer cutBundle = mitk::FiberBundleX::New(polyData);
+  mitk::FiberBundle::Pointer cutBundle = mitk::FiberBundle::New(polyData);
 
 
   mitk::DataNode::Pointer cutNode = mitk::DataNode::New();
   cutNode->SetData(cutBundle);
   std::string name = "fiberCut";
   cutNode->SetName(name);
   GetDataStorage()->Add(cutNode);
 
 
 
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::CreateRoi()
 {
   bool ok;
   double threshold = QInputDialog::getDouble(m_Controls->m_CreateRoi, tr("Set an FA threshold"),
                                                       tr("Threshold:"), 0.2, 0.0, 1.0, 2, &ok);
 
   if(!ok)
     return;
 
   mitk::Image::Pointer image;
 
   std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
 
   for ( int i=0; i<nodes.size(); i++ )
   {
     if(QString("Image").compare(nodes[i]->GetData()->GetNameOfClass())==0)
     {
         mitk::Image* img = static_cast<mitk::Image*>(nodes[i]->GetData());
         if(img->GetDimension() == 3)
         {
           image = img;
         }
     }
   }
 
   if(image.IsNull())
   {
     return;
   }
 
   mitk::TractAnalyzer analyzer;
   analyzer.SetInputImage(image);
   analyzer.SetThreshold(threshold);
 
   m_PointSetNode = this->m_Controls->m_PointWidget->GetPointSet();
 
   // Set Pointset to analyzer
   analyzer.SetPointSet(m_PointSetNode);
 
   // Run Analyzer
   try
   {
     analyzer.MakeRoi();
   }
   catch (const mitk::Exception& e)
   {
     QMessageBox msgBox;
     msgBox.setText(QString::fromStdString(e.what()));
     msgBox.exec();
   }
 
   // Obtain tbss roi image from analyzer
   mitk::TbssRoiImage::Pointer tbssRoi = analyzer.GetRoiImage();
 
   tbssRoi->SetStructure(m_Controls->m_Structure->text().toStdString());
 
   // get path description and set to interface
   std::string pathDescription = analyzer.GetPathDescription();
   m_Controls->m_PathTextEdit->setPlainText(QString(pathDescription.c_str()));
 
 
   // Add roi image to datastorage
   AddTbssToDataStorage(tbssRoi, m_Controls->m_RoiName->text().toStdString());
 
 
 
 
 }
 
 void QmitkTractbasedSpatialStatisticsView::PlotFiber4D(mitk::TbssImage* image,
-                                                            mitk::FiberBundleX* fib,
+                                                            mitk::FiberBundle* fib,
                                                             mitk::PlanarFigure* startRoi,
                                                             mitk::PlanarFigure* endRoi)
 {
 
 
   if(m_Controls->m_TabWidget->currentWidget() == m_Controls->m_MeasureTAB)
   {
     m_CurrentGeometry = image->GetGeometry();
 
     m_Controls->m_RoiPlotWidget->SetGroups(image->GetGroupInfo());
     m_Controls->m_RoiPlotWidget->SetProjections(image->GetImage());
     m_Controls->m_RoiPlotWidget->SetMeasure( image->GetMeasurementInfo() );
     m_Controls->m_RoiPlotWidget->PlotFiber4D(image, fib, startRoi, endRoi, m_Controls->m_Segments->value());
   }
 
 
 }
 
-void QmitkTractbasedSpatialStatisticsView:: PlotFiberBundle(mitk::FiberBundleX *fib, mitk::Image* img,
+void QmitkTractbasedSpatialStatisticsView:: PlotFiberBundle(mitk::FiberBundle *fib, mitk::Image* img,
                                                            mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi)
 {
   bool avg = m_Controls->m_Average->isChecked();
   int segments = m_Controls->m_Segments->value();
   m_Controls->m_RoiPlotWidget->PlotFiberBetweenRois(fib, img, startRoi ,endRoi, avg, segments);
   m_Controls->m_RoiPlotWidget->SetPlottingFiber(true);
   mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::Plot(mitk::TbssImage* image, mitk::TbssRoiImage* roiImage)
 {
   if(m_Controls->m_TabWidget->currentWidget() == m_Controls->m_MeasureTAB)
   {
 
     std::vector< itk::Index<3> > roi = roiImage->GetRoi();
     m_Roi = roi;
     m_CurrentGeometry = image->GetGeometry();
 
 
     std::string structure = roiImage->GetStructure();
 
     m_Controls->m_RoiPlotWidget->SetGroups(image->GetGroupInfo());
     m_Controls->m_RoiPlotWidget->SetProjections(image->GetImage());
     m_Controls->m_RoiPlotWidget->SetRoi(roi);
     m_Controls->m_RoiPlotWidget->SetStructure(structure);
     m_Controls->m_RoiPlotWidget->SetMeasure( image->GetMeasurementInfo() );
     m_Controls->m_RoiPlotWidget->DrawProfiles();
   }
 
   m_Controls->m_RoiPlotWidget->SetPlottingFiber(false);
 
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.h
index ff17a225a3..bd78730a44 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.h
@@ -1,177 +1,177 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QmitkTractbasedSpatialStatisticsView_h
 #define QmitkTractbasedSpatialStatisticsView_h
 
 
 #include <QmitkFunctionality.h>
 
 #include "ui_QmitkTractbasedSpatialStatisticsViewControls.h"
 #include <QListWidgetItem>
 
 #include <itkImageFileReader.h>
 #include <itkImageFileWriter.h>
 
 #include <itkDiffusionTensor3D.h>
 
 #include <mitkTbssImage.h>
 #include <mitkTbssRoiImage.h>
 
 #include "QmitkTbssTableModel.h"
 #include "QmitkTbssMetaTableModel.h"
 
-#include <mitkFiberBundleX.h>
+#include <mitkFiberBundle.h>
 
 
 // Image types
 typedef short DiffusionPixelType;
 typedef itk::Image<char, 3> CharImageType;
 typedef itk::Image<unsigned char, 3> UCharImageType;
 typedef itk::Image<float, 4> Float4DImageType;
 typedef itk::Image<float, 3> FloatImageType;
 typedef itk::VectorImage<float, 3> VectorImageType;
 
 // Readers/Writers
 typedef itk::ImageFileReader< CharImageType > CharReaderType;
 typedef itk::ImageFileReader< UCharImageType > UCharReaderType;
 typedef itk::ImageFileWriter< CharImageType > CharWriterType;
 typedef itk::ImageFileReader< FloatImageType > FloatReaderType;
 typedef itk::ImageFileWriter< FloatImageType > FloatWriterType;
 typedef itk::ImageFileReader< Float4DImageType > Float4DReaderType;
 typedef itk::ImageFileWriter< Float4DImageType > Float4DWriterType;
 
 
 
 /*!
   * \brief This plugin provides an extension for Tract-based spatial statistics (see Smith et al., 2009. http://dx.doi.org/10.1016/j.neuroimage.2006.02.024)
   * TBSS enables analyzing the brain by a pipeline of registration, skeletonization, and projection that results in a white matter skeleton
   * for all subjects that are analyzed statistically in a whole-brain manner.
   * This plugin provides functionality to select single tracts and analyze them separately.
   *
   * Prerequisites: the mean_FA_skeleton and all_FA_skeletonised datasets produced by the FSL TBSS pipeline: http://fsl.fmrib.ox.ac.uk/fsl/fsl4.0/tbss/index
 */
 
 class QmitkTractbasedSpatialStatisticsView : public QmitkFunctionality
 {
 
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkTractbasedSpatialStatisticsView();
     virtual ~QmitkTractbasedSpatialStatisticsView();
 
     virtual void CreateQtPartControl(QWidget *parent);
 
     /// \brief Creation of the connections of main and control widget
     virtual void CreateConnections();
 
     virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
     virtual void StdMultiWidgetNotAvailable();
 
     /// \brief Called when the functionality is activated
     virtual void Activated();
 
     virtual void Deactivated();
 
 
   protected slots:
 
     // Creates Roi
     void CreateRoi();
 
     void Clicked(const QPointF& pos);
 
     // Import of FSL TBSS data
     void TbssImport();
 
     // Add a group as metadata. This metadata is required by the plotting functionality
     void AddGroup();
 
     // Remove a group
     void RemoveGroup();
 
     // Copies the values displayed in the plot widget to clipboard, i.e. exports the data
     void CopyToClipboard();
 
     // Method to cut away parts of fiber bundles that should not be plotted.
     void Cut();
 
     // Adjust plot widget
     void PerformChange();
 
 
   protected:
 
 
     /// \brief called by QmitkFunctionality when DataManager's selection has changed
     virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
 
     // Creates a plot using a 4D image containing the projections of all subjects and a region of interest
     void Plot(mitk::TbssImage*, mitk::TbssRoiImage*);
 
 
-    void PlotFiberBundle(mitk::FiberBundleX* fib, mitk::Image* img, mitk::PlanarFigure* startRoi=NULL, mitk::PlanarFigure* endRoi=NULL);
+    void PlotFiberBundle(mitk::FiberBundle* fib, mitk::Image* img, mitk::PlanarFigure* startRoi=NULL, mitk::PlanarFigure* endRoi=NULL);
 
 
-    void PlotFiber4D(mitk::TbssImage*, mitk::FiberBundleX* fib, mitk::PlanarFigure* startRoi=NULL, mitk::PlanarFigure* endRoi=NULL);
+    void PlotFiber4D(mitk::TbssImage*, mitk::FiberBundle* fib, mitk::PlanarFigure* startRoi=NULL, mitk::PlanarFigure* endRoi=NULL);
 
     // Create a point set. This point set defines the points through which a region of interest should go
     void InitPointsets();
 
     // Pointset and DataNode to contain the PointSet used in ROI creation
     mitk::PointSet::Pointer m_PointSetNode;
     mitk::DataNode::Pointer m_P1;
 
     // GUI widgets
     Ui::QmitkTractbasedSpatialStatisticsViewControls* m_Controls;
 
     /* A pointer to the QmitkStdMultiWidget. Used for interaction with the plot widget
     (clicking in the plot widget makes the image cross jump to the corresponding location
     on the skeleton).*/
     QmitkStdMultiWidget* m_MultiWidget;
 
     // Used to save the region of interest in a vector of itk::index.
     std::vector< itk::Index<3> > m_Roi;
 
-    mitk::FiberBundleX* m_Fib;
+    mitk::FiberBundle* m_Fib;
 
     mitk::BaseGeometry* m_CurrentGeometry;
 
     // A table model for saving group information in a name,number pair.
     QmitkTbssTableModel* m_GroupModel;
 
     // Convenience function for adding a new image to the datastorage and giving it a name.
     void AddTbssToDataStorage(mitk::Image* image, std::string name);
 
     mitk::DataNode::Pointer m_CurrentFiberNode; // needed for the index property when interacting with the plot widget
 
     // needed when a plot should only show values between a start end end roi
     mitk::DataNode::Pointer m_CurrentStartRoi;
     mitk::DataNode::Pointer m_CurrentEndRoi;
 
 
 
 
 };
 
 
 
 #endif // _QMITKTRACTBASEDSPATIALSTATISTICSVIEW_H_INCLUDED