diff --git a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.cpp b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.cpp
old mode 100644
new mode 100755
index bfa02769d7..9644bd7aa9
--- a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.cpp
+++ b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.cpp
@@ -1,860 +1,860 @@
 /*===================================================================
 
 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 )
+, allowLoops( true )
+, m_UseCoMCoordinates( true )
 , m_LabelsToCoordinatesMap()
 , m_MappingStrategy( EndElementPosition )
 , m_EndPointSearchRadius( 10.0 )
 {
 }
 
 mitk::ConnectomicsNetworkCreator::ConnectomicsNetworkCreator( mitk::Image::Pointer segmentation, mitk::FiberBundleX::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( EndElementPosition )
 , m_EndPointSearchRadius( 10.0 )
 {
 }
 
 mitk::ConnectomicsNetworkCreator::~ConnectomicsNetworkCreator()
 {
 }
 
 void mitk::ConnectomicsNetworkCreator::SetFiberBundle(mitk::FiberBundleX::Pointer fiberBundle)
 {
   m_FiberBundle = fiberBundle;
 }
 
 void mitk::ConnectomicsNetworkCreator::SetSegmentation(mitk::Image::Pointer segmentation)
 {
   m_Segmentation = segmentation;
 }
 
 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->clear();
   m_LabelToVertexMap.clear();
   m_LabelToNodePropertyMap.clear();
   {
       CalculateCenterOfMass();
   }
 
   std::cout << m_ConNetwork->GetNumberOfVertices() << std::endl;
 
   vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
 
   int numFibers = m_FiberBundle->GetNumFibers();
   for( int fiberID( 0 ); fiberID < numFibers; fiberID++ )
   {
     vtkCell* cell = fiberPolyData->GetCell(fiberID);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     TractType::Pointer singleTract = TractType::New();
     for( int pointInCellID( 0 ); pointInCellID < numPoints ; pointInCellID++)
     {
       // push back point
       PointType point = GetItkPoint( points->GetPoint( pointInCellID ) );
       singleTract->InsertElement( singleTract->Size(), point );
     }
 
     if ( singleTract && ( singleTract->Size() > 0 ) )
     {
       AddConnectionToNetwork(
         ReturnAssociatedVertexPairForLabelPair(
         ReturnLabelForFiberTract( singleTract, m_MappingStrategy )
         )
         );
     }
   }
 
   // Prune unconnected nodes
   //m_ConNetwork->PruneUnconnectedSingleNodes();
 
   // provide network with geometry
   m_ConNetwork->SetGeometry( dynamic_cast<mitk::Geometry3D*>(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)
 {
   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 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 PrecomputeAndDistance:
     {
       return PrecomputeVertexLocationsBySegmentation( singleTract );
     }
   case JustEndPointVerticesNoLabel:
     {
       return JustEndPointVerticesNoLabelTest( singleTract );
     }
   case EndElementPositionAvoidingWhiteMatter:
     {
       return EndElementPositionLabelAvoidingWhiteMatter( singleTract );
     }
   }
 
   // To remove warnings, this code should never be reached
   MBI_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_INVALID_MAPPING;
   ImageLabelPairType nullPair( NULL, NULL );
   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;
     mitk::Index3D firstElementSegIndex, lastElementSegIndex;
 
     if( singleTract->front().Size() != 3 )
     {
       MBI_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_INVALID_DIMENSION_NEED_3;
     }
     for( 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_Segmentation->GetPixelValueByIndex( firstElementSegIndex );
     int lastLabel = m_Segmentation->GetPixelValueByIndex( 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;
     mitk::Index3D firstElementSegIndex, lastElementSegIndex;
 
     if( singleTract->front().Size() != 3 )
     {
       MBI_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_INVALID_DIMENSION_NEED_3;
     }
     for( 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_Segmentation->GetPixelValueByIndex( firstElementSegIndex );
     int lastLabel = m_Segmentation->GetPixelValueByIndex( 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 );
       mitk::Index3D 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 );
       mitk::Index3D tempIndex = lastElementSegIndex;
 
       LinearExtensionUntilGreyMatter( indexVectorOfPointsToUse, singleTract, tempLabel, tempIndex );
 
       lastLabel = tempLabel;
       lastElementSegIndex = tempIndex;
     }
         if ( retractFront )
     {
       // label and coordinate temp storage
       int tempLabel( firstLabel );
       mitk::Index3D tempIndex = firstElementSegIndex;
 
       RetractionUntilBrainMatter( true, singleTract, tempLabel, tempIndex );
 
       firstLabel = tempLabel;
       firstElementSegIndex = tempIndex;
 
     }
 
     if ( retractEnd )
     {
       // label and coordinate temp storage
       int tempLabel( lastLabel );
       mitk::Index3D 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;
     mitk::Index3D firstElementSegIndex, lastElementSegIndex;
 
     if( singleTract->front().Size() != 3 )
     {
       MBI_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_INVALID_DIMENSION_NEED_3;
     }
     for( 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,
   mitk::Index3D & 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( int index( 0 ); index < indexVectorOfPointsToUse.size(); index++ )
   {
     if( indexVectorOfPointsToUse[ index ] > singleTract->Size() )
     {
       MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_ESTIMATING_BEYOND_END;
       return;
     }
     if( indexVectorOfPointsToUse[ index ] < 0 )
     {
       MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_ESTIMATING_BEYOND_START;
       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( 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( 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( int index = 0; index < differenceVector.size() ; index++ )
     {
       sum = sum + differenceVector[ index ] * differenceVector[ index ];
     }
 
     length = std::sqrt( sum );
 
     for( int index = 0; index < differenceVector.size() ; index++ )
     {
       differenceVector[ index ] = differenceVector[ index ] / length;
     }
 
     // follow line until first non white matter label
     mitk::Index3D tempIndex;
     int tempLabel( label );
 
     bool keepOn( true );
 
     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 ] );
       }
 
       tempLabel = m_Segmentation->GetPixelValueByIndex( tempIndex );
 
       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, mitk::Index3D & 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( 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( 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( int index = 0; index < differenceVector.size() ; index++ )
     {
       sum = sum + differenceVector[ index ] * differenceVector[ index ];
     }
 
     length = std::sqrt( sum );
 
     if( length < mitk::eps )
     {
         continue;
     }
 
     // retract
     mitk::Index3D 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_Segmentation->GetPixelValueByIndex( tempIndex );
 
       if( !IsBackgroundLabel( tempLabel ) )
       {
         // check whether result is within the search space
         {
           mitk::Point3D endPoint, foundPointSegmentation, foundPointFiber;
           for( 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( 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( 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 ) || ( currentRetractionIndex > ( singleTract->Size() - 2 ) ) )
       {
         keepRetracting = false;
       }
     }
   }
 }
 
 void mitk::ConnectomicsNetworkCreator::CalculateCenterOfMass()
 {
   const int dimensions = 3;
   typedef itk::Image<int, dimensions > ITKImageType;
 
   ITKImageType::Pointer itkImage = ITKImageType::New();
   mitk::CastToItkImage( m_Segmentation, itkImage );
 
   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( itkImage, itkImage->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 ) );
 
     // Peter Hack
     {
     CreateNewNode( currentLabel, mitk::Index3D(), true );
     if( ! ( m_LabelToVertexMap.count( currentLabel ) > 0 ) )
     {
       VertexType newVertex = m_ConNetwork->AddVertex( idCounter );
       idCounter++;
       SupplyVertexWithInformation(currentLabel, newVertex);
       m_LabelToVertexMap.insert( std::pair< ImageLabelType, VertexType >( currentLabel, newVertex ) );
     }
     }
   }
 
   //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, mitk::Index3D 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/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
old mode 100644
new mode 100755
index 46fc032ff7..3c7ec39bc5
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
@@ -1,708 +1,702 @@
 /*===================================================================
 
 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 "itkTractsToDWIImageFilter.h"
 #include <boost/progress.hpp>
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <mitkGibbsRingingArtifact.h>
 #include <itkResampleImageFilter.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 #include <itkBSplineInterpolateImageFunction.h>
 #include <itkCastImageFilter.h>
 #include <itkImageFileWriter.h>
 #include <itkRescaleIntensityImageFilter.h>
 #include <itkWindowedSincInterpolateImageFunction.h>
 #include <itkResampleDwiImageFilter.h>
 #include <itkKspaceImageFilter.h>
 #include <itkDftImageFilter.h>
 #include <itkAddImageFilter.h>
 
 namespace itk
 {
 TractsToDWIImageFilter::TractsToDWIImageFilter()
     : m_CircleDummy(false)
     , m_VolumeAccuracy(10)
     , m_Upsampling(1)
     , m_NumberOfRepetitions(1)
     , m_EnforcePureFiberVoxels(false)
     , m_InterpolationShrink(1000)
     , m_FiberRadius(0)
     , m_SignalScale(25)
     , m_kOffset(0)
     , m_tLine(1)
     , m_UseInterpolation(false)
     , m_SimulateRelaxation(true)
     , m_tInhom(50)
     , m_TE(100)
     , m_FrequencyMap(NULL)
     , m_EddyGradientStrength(0.001)
     , m_SimulateEddyCurrents(false)
 {
     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);
 }
 
 TractsToDWIImageFilter::~TractsToDWIImageFilter()
 {
 
 }
 
 TractsToDWIImageFilter::DoubleDwiType::Pointer TractsToDWIImageFilter::DoKspaceStuff( std::vector< DoubleDwiType::Pointer >& images )
 {
     // create slice object
     ImageRegion<2> sliceRegion;
     sliceRegion.SetSize(0, m_UpsampledImageRegion.GetSize()[0]);
     sliceRegion.SetSize(1, m_UpsampledImageRegion.GetSize()[1]);
 
     // frequency map slice
     SliceType::Pointer fMap = NULL;
     if (m_FrequencyMap.IsNotNull())
     {
         fMap = SliceType::New();
         ImageRegion<2> region;
         region.SetSize(0, m_UpsampledImageRegion.GetSize()[0]);
         region.SetSize(1, m_UpsampledImageRegion.GetSize()[1]);
         fMap->SetLargestPossibleRegion( region );
         fMap->SetBufferedRegion( region );
         fMap->SetRequestedRegion( region );
         fMap->Allocate();
     }
 
     DoubleDwiType::Pointer newImage = DoubleDwiType::New();
     newImage->SetSpacing( m_Spacing );
     newImage->SetOrigin( m_Origin );
     newImage->SetDirection( m_DirectionMatrix );
     newImage->SetLargestPossibleRegion( m_ImageRegion );
     newImage->SetBufferedRegion( m_ImageRegion );
     newImage->SetRequestedRegion( m_ImageRegion );
     newImage->SetVectorLength( images.at(0)->GetVectorLength() );
     newImage->Allocate();
 
     MatrixType transform = m_DirectionMatrix;
     for (int i=0; i<3; i++)
         for (int j=0; j<3; j++)
         {
             if (j<2)
                 transform[i][j] *= m_UpsampledSpacing[j];
             else
                 transform[i][j] *= m_Spacing[j];
         }
 
     boost::progress_display disp(images.at(0)->GetVectorLength()*images.at(0)->GetLargestPossibleRegion().GetSize(2));
     for (int g=0; g<images.at(0)->GetVectorLength(); g++)
         for (int z=0; z<images.at(0)->GetLargestPossibleRegion().GetSize(2); z++)
         {
             ++disp;
             std::vector< SliceType::Pointer > compartmentSlices;
             std::vector< double > t2Vector;
 
             for (int i=0; i<images.size(); i++)
             {
                 DiffusionSignalModel<double>* signalModel;
                 if (i<m_FiberModels.size())
                     signalModel = m_FiberModels.at(i);
                 else
                     signalModel = m_NonFiberModels.at(i-m_FiberModels.size());
 
                 SliceType::Pointer slice = SliceType::New();
                 slice->SetLargestPossibleRegion( sliceRegion );
                 slice->SetBufferedRegion( sliceRegion );
                 slice->SetRequestedRegion( sliceRegion );
                 slice->Allocate();
                 slice->FillBuffer(0.0);
 
                 // extract slice from channel g
                 for (int y=0; y<images.at(0)->GetLargestPossibleRegion().GetSize(1); y++)
                     for (int x=0; x<images.at(0)->GetLargestPossibleRegion().GetSize(0); x++)
                     {
                         SliceType::IndexType index2D; index2D[0]=x; index2D[1]=y;
                         DoubleDwiType::IndexType index3D; index3D[0]=x; index3D[1]=y; index3D[2]=z;
 
                         slice->SetPixel(index2D, images.at(i)->GetPixel(index3D)[g]);
 
                         if (fMap.IsNotNull() && i==0)
                             fMap->SetPixel(index2D, m_FrequencyMap->GetPixel(index3D));
                     }
 
                 compartmentSlices.push_back(slice);
                 t2Vector.push_back(signalModel->GetT2());
             }
 
             // create k-sapce (inverse fourier transform slices)
             itk::KspaceImageFilter< SliceType::PixelType >::Pointer idft = itk::KspaceImageFilter< SliceType::PixelType >::New();
             idft->SetCompartmentImages(compartmentSlices);
             idft->SetT2(t2Vector);
             idft->SetkOffset(m_kOffset);
             idft->SettLine(m_tLine);
             idft->SetTE(m_TE);
             idft->SetTinhom(m_tInhom);
             idft->SetSimulateRelaxation(m_SimulateRelaxation);
             idft->SetSimulateEddyCurrents(m_SimulateEddyCurrents);
             idft->SetEddyGradientMagnitude(m_EddyGradientStrength);
             idft->SetZ((double)z-(double)images.at(0)->GetLargestPossibleRegion().GetSize(2)/2.0);
             idft->SetDirectionMatrix(transform);
             idft->SetDiffusionGradientDirection(m_FiberModels.at(0)->GetGradientDirection(g));
             idft->SetFrequencyMap(fMap);
             idft->SetSignalScale(m_SignalScale);
             idft->Update();
 
             ComplexSliceType::Pointer fSlice;
             fSlice = idft->GetOutput();
             fSlice = RearrangeSlice(fSlice);
 
             // add artifacts
             for (int a=0; a<m_KspaceArtifacts.size(); a++)
                 fSlice = m_KspaceArtifacts.at(a)->AddArtifact(fSlice);
 
             // fourier transform slice
             SliceType::Pointer newSlice;
             itk::DftImageFilter< SliceType::PixelType >::Pointer dft = itk::DftImageFilter< SliceType::PixelType >::New();
             dft->SetInput(fSlice);
             dft->Update();
             newSlice = dft->GetOutput();
 
             // put slice back into channel g
             for (int y=0; y<fSlice->GetLargestPossibleRegion().GetSize(1); y++)
                 for (int x=0; x<fSlice->GetLargestPossibleRegion().GetSize(0); x++)
                 {
                     DoubleDwiType::IndexType index3D; index3D[0]=x; index3D[1]=y; index3D[2]=z;
                     SliceType::IndexType index2D; index2D[0]=x; index2D[1]=y;
 
                     DoubleDwiType::PixelType pix3D = newImage->GetPixel(index3D);
                     pix3D[g] = newSlice->GetPixel(index2D);
                     newImage->SetPixel(index3D, pix3D);
                 }
 
         }
     return newImage;
 }
 
 TractsToDWIImageFilter::ComplexSliceType::Pointer TractsToDWIImageFilter::RearrangeSlice(ComplexSliceType::Pointer slice)
 {
     ImageRegion<2> region = slice->GetLargestPossibleRegion();
     ComplexSliceType::Pointer rearrangedSlice = ComplexSliceType::New();
     rearrangedSlice->SetLargestPossibleRegion( region );
     rearrangedSlice->SetBufferedRegion( region );
     rearrangedSlice->SetRequestedRegion( region );
     rearrangedSlice->Allocate();
 
     int xHalf = region.GetSize(0)/2;
     int yHalf = region.GetSize(1)/2;
 
     for (int y=0; y<region.GetSize(1); y++)
         for (int x=0; x<region.GetSize(0); x++)
         {
             SliceType::IndexType idx;
             idx[0]=x; idx[1]=y;
             vcl_complex< double > pix = slice->GetPixel(idx);
 
             if( idx[0] <  xHalf )
                 idx[0] = idx[0] + xHalf;
             else
                 idx[0] = idx[0] - xHalf;
 
             if( idx[1] <  yHalf )
                 idx[1] = idx[1] + yHalf;
             else
                 idx[1] = idx[1] - yHalf;
 
             rearrangedSlice->SetPixel(idx, pix);
         }
 
     return rearrangedSlice;
 }
 
 void TractsToDWIImageFilter::GenerateData()
 {
     // check input data
     if (m_FiberBundle.IsNull())
         itkExceptionMacro("Input fiber bundle is NULL!");
 
     int numFibers = m_FiberBundle->GetNumFibers();
     if (numFibers<=0)
         itkExceptionMacro("Input fiber bundle contains no fibers!");
 
     if (m_FiberModels.empty())
         itkExceptionMacro("No diffusion model for fiber compartments defined!");
 
     if (m_NonFiberModels.empty())
         itkExceptionMacro("No diffusion model for non-fiber compartments defined!");
 
     int baselineIndex = m_FiberModels[0]->GetFirstBaselineIndex();
     if (baselineIndex<0)
         itkExceptionMacro("No baseline index found!");
 
     // determine k-space undersampling
     for (int i=0; i<m_KspaceArtifacts.size(); i++)
         if ( dynamic_cast<mitk::GibbsRingingArtifact<double>*>(m_KspaceArtifacts.at(i)) )
             m_Upsampling = dynamic_cast<mitk::GibbsRingingArtifact<double>*>(m_KspaceArtifacts.at(i))->GetKspaceCropping();
     if (m_Upsampling<1)
         m_Upsampling = 1;
 
     if (m_TissueMask.IsNotNull())
     {
         // use input tissue mask
         m_Spacing = m_TissueMask->GetSpacing();
         m_Origin = m_TissueMask->GetOrigin();
         m_DirectionMatrix = m_TissueMask->GetDirection();
         m_ImageRegion = m_TissueMask->GetLargestPossibleRegion();
 
-        if (m_Upsampling>1)
+        if (m_Upsampling>1.00001)
         {
             ImageRegion<3> region = m_ImageRegion;
             region.SetSize(0, m_ImageRegion.GetSize(0)*m_Upsampling);
             region.SetSize(1, m_ImageRegion.GetSize(1)*m_Upsampling);
             itk::Vector<double> spacing = m_Spacing;
             spacing[0] /= m_Upsampling;
             spacing[1] /= m_Upsampling;
             itk::RescaleIntensityImageFilter<ItkUcharImgType,ItkUcharImgType>::Pointer rescaler = itk::RescaleIntensityImageFilter<ItkUcharImgType,ItkUcharImgType>::New();
             rescaler->SetInput(0,m_TissueMask);
             rescaler->SetOutputMaximum(100);
             rescaler->SetOutputMinimum(0);
             rescaler->Update();
 
             itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::Pointer resampler = itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::New();
             resampler->SetInput(rescaler->GetOutput());
             resampler->SetOutputParametersFromImage(m_TissueMask);
             resampler->SetSize(region.GetSize());
             resampler->SetOutputSpacing(spacing);
             resampler->Update();
             m_TissueMask = resampler->GetOutput();
         }
         MITK_INFO << "Using tissue mask";
     }
 
     // initialize output dwi image
     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_FiberModels[0]->GetNumGradients() );
     outImage->Allocate();
     OutputImageType::PixelType temp;
     temp.SetSize(m_FiberModels[0]->GetNumGradients());
     temp.Fill(0.0);
     outImage->FillBuffer(temp);
 
     // is input slize size a power of two?
     int x=m_ImageRegion.GetSize(0); int y=m_ImageRegion.GetSize(1);
     if ( x%2 == 1 )
         x += 1;
     if ( y%2 == 1 )
         y += 1;
 
     // if not, adjust size and dimension (needed for FFT); zero-padding
     if (x!=m_ImageRegion.GetSize(0))
-    {
-        MITK_INFO << "Adjusting image width: " << m_ImageRegion.GetSize(0) << " --> " << x << " --> " << x*m_Upsampling;
         m_ImageRegion.SetSize(0, x);
-    }
     if (y!=m_ImageRegion.GetSize(1))
-    {
-        MITK_INFO << "Adjusting image height: " << m_ImageRegion.GetSize(1) << " --> " << y << " --> " << y*m_Upsampling;
         m_ImageRegion.SetSize(1, y);
-    }
 
     // apply undersampling to image parameters
     m_UpsampledSpacing = m_Spacing;
     m_UpsampledImageRegion = m_ImageRegion;
     m_UpsampledSpacing[0] /= m_Upsampling;
     m_UpsampledSpacing[1] /= m_Upsampling;
     m_UpsampledImageRegion.SetSize(0, m_ImageRegion.GetSize()[0]*m_Upsampling);
     m_UpsampledImageRegion.SetSize(1, m_ImageRegion.GetSize()[1]*m_Upsampling);
 
     // everything from here on is using the upsampled image parameters!!!
     if (m_TissueMask.IsNull())
     {
         m_TissueMask = ItkUcharImgType::New();
         m_TissueMask->SetSpacing( m_UpsampledSpacing );
         m_TissueMask->SetOrigin( m_Origin );
         m_TissueMask->SetDirection( m_DirectionMatrix );
         m_TissueMask->SetLargestPossibleRegion( m_UpsampledImageRegion );
         m_TissueMask->SetBufferedRegion( m_UpsampledImageRegion );
         m_TissueMask->SetRequestedRegion( m_UpsampledImageRegion );
         m_TissueMask->Allocate();
         m_TissueMask->FillBuffer(1);
     }
 
     // resample frequency map
     if (m_FrequencyMap.IsNotNull())
     {
         itk::ResampleImageFilter<ItkDoubleImgType, ItkDoubleImgType>::Pointer resampler = itk::ResampleImageFilter<ItkDoubleImgType, ItkDoubleImgType>::New();
         resampler->SetInput(m_FrequencyMap);
         resampler->SetOutputParametersFromImage(m_FrequencyMap);
         resampler->SetSize(m_UpsampledImageRegion.GetSize());
         resampler->SetOutputSpacing(m_UpsampledSpacing);
         resampler->Update();
         m_FrequencyMap = resampler->GetOutput();
     }
 
     // initialize volume fraction images
     m_VolumeFractions.clear();
     for (int i=0; i<m_FiberModels.size()+m_NonFiberModels.size(); i++)
     {
         ItkDoubleImgType::Pointer tempimg = ItkDoubleImgType::New();
         tempimg->SetSpacing( m_UpsampledSpacing );
         tempimg->SetOrigin( m_Origin );
         tempimg->SetDirection( m_DirectionMatrix );
         tempimg->SetLargestPossibleRegion( m_UpsampledImageRegion );
         tempimg->SetBufferedRegion( m_UpsampledImageRegion );
         tempimg->SetRequestedRegion( m_UpsampledImageRegion );
         tempimg->Allocate();
         tempimg->FillBuffer(0);
         m_VolumeFractions.push_back(tempimg);
     }
 
     // resample fiber bundle for sufficient voxel coverage
     double segmentVolume = 0.0001;
     float minSpacing = 1;
     if(m_UpsampledSpacing[0]<m_UpsampledSpacing[1] && m_UpsampledSpacing[0]<m_UpsampledSpacing[2])
         minSpacing = m_UpsampledSpacing[0];
     else if (m_UpsampledSpacing[1] < m_UpsampledSpacing[2])
         minSpacing = m_UpsampledSpacing[1];
     else
         minSpacing = m_UpsampledSpacing[2];
     FiberBundleType fiberBundle = m_FiberBundle->GetDeepCopy();
     fiberBundle->ResampleFibers(minSpacing/m_VolumeAccuracy);
     double mmRadius = m_FiberRadius/1000;
     if (mmRadius>0)
         segmentVolume = M_PI*mmRadius*mmRadius*minSpacing/m_VolumeAccuracy;
 
     // generate double images to work with because we don't want to lose precision
     // we use a separate image for each compartment model
     std::vector< DoubleDwiType::Pointer > compartments;
     for (int i=0; i<m_FiberModels.size()+m_NonFiberModels.size(); i++)
     {
         DoubleDwiType::Pointer doubleDwi = DoubleDwiType::New();
         doubleDwi->SetSpacing( m_UpsampledSpacing );
         doubleDwi->SetOrigin( m_Origin );
         doubleDwi->SetDirection( m_DirectionMatrix );
         doubleDwi->SetLargestPossibleRegion( m_UpsampledImageRegion );
         doubleDwi->SetBufferedRegion( m_UpsampledImageRegion );
         doubleDwi->SetRequestedRegion( m_UpsampledImageRegion );
         doubleDwi->SetVectorLength( m_FiberModels[0]->GetNumGradients() );
         doubleDwi->Allocate();
         DoubleDwiType::PixelType pix;
         pix.SetSize(m_FiberModels[0]->GetNumGradients());
         pix.Fill(0.0);
         doubleDwi->FillBuffer(pix);
         compartments.push_back(doubleDwi);
     }
 
     double interpFact = 2*atan(-0.5*m_InterpolationShrink);
     double maxVolume = 0;
 
     MITK_INFO << "Generating signal of " << m_FiberModels.size() << " fiber compartments";
     vtkSmartPointer<vtkPolyData> fiberPolyData = fiberBundle->GetFiberPolyData();
     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;
 
         for( int j=0; j<numPoints; j++)
         {
             double* temp = points->GetPoint(j);
             itk::Point<float, 3> vertex = GetItkPoint(temp);
             itk::Vector<double> v = GetItkVector(temp);
 
             itk::Vector<double, 3> dir(3);
             if (j<numPoints-1)
                 dir = GetItkVector(points->GetPoint(j+1))-v;
             else
                 dir = v-GetItkVector(points->GetPoint(j-1));
 
             itk::Index<3> idx;
             itk::ContinuousIndex<float, 3> contIndex;
             m_TissueMask->TransformPhysicalPointToIndex(vertex, idx);
             m_TissueMask->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
 
             if (!m_UseInterpolation)    // use nearest neighbour interpolation
             {
                 if (!m_TissueMask->GetLargestPossibleRegion().IsInside(idx) || m_TissueMask->GetPixel(idx)<=0)
                     continue;
 
                 // generate signal for each fiber compartment
                 for (int k=0; k<m_FiberModels.size(); k++)
                 {
                     DoubleDwiType::Pointer doubleDwi = compartments.at(k);
                     m_FiberModels[k]->SetFiberDirection(dir);
                     DoubleDwiType::PixelType pix = doubleDwi->GetPixel(idx);
                     pix += segmentVolume*m_FiberModels[k]->SimulateMeasurement();
                     doubleDwi->SetPixel(idx, pix );
                     if (pix[baselineIndex]>maxVolume)
                         maxVolume = pix[baselineIndex];
                 }
 
                 continue;
             }
 
             double frac_x = contIndex[0] - idx[0];
             double frac_y = contIndex[1] - idx[1];
             double frac_z = contIndex[2] - idx[2];
             if (frac_x<0)
             {
                 idx[0] -= 1;
                 frac_x += 1;
             }
             if (frac_y<0)
             {
                 idx[1] -= 1;
                 frac_y += 1;
             }
             if (frac_z<0)
             {
                 idx[2] -= 1;
                 frac_z += 1;
             }
 
             frac_x = atan((0.5-frac_x)*m_InterpolationShrink)/interpFact + 0.5;
             frac_y = atan((0.5-frac_y)*m_InterpolationShrink)/interpFact + 0.5;
             frac_z = atan((0.5-frac_z)*m_InterpolationShrink)/interpFact + 0.5;
 
             // use trilinear interpolation
             itk::Index<3> newIdx;
             for (int x=0; x<2; x++)
             {
                 frac_x = 1-frac_x;
                 for (int y=0; y<2; y++)
                 {
                     frac_y = 1-frac_y;
                     for (int z=0; z<2; z++)
                     {
                         frac_z = 1-frac_z;
 
                         newIdx[0] = idx[0]+x;
                         newIdx[1] = idx[1]+y;
                         newIdx[2] = idx[2]+z;
 
                         double frac = frac_x*frac_y*frac_z;
 
                         // is position valid?
                         if (!m_TissueMask->GetLargestPossibleRegion().IsInside(newIdx) || m_TissueMask->GetPixel(newIdx)<=0)
                             continue;
 
                         // generate signal for each fiber compartment
                         for (int k=0; k<m_FiberModels.size(); k++)
                         {
                             DoubleDwiType::Pointer doubleDwi = compartments.at(k);
                             m_FiberModels[k]->SetFiberDirection(dir);
                             DoubleDwiType::PixelType pix = doubleDwi->GetPixel(newIdx);
                             pix += segmentVolume*frac*m_FiberModels[k]->SimulateMeasurement();
                             doubleDwi->SetPixel(newIdx, pix );
                             if (pix[baselineIndex]>maxVolume)
                                 maxVolume = pix[baselineIndex];
                         }
                     }
                 }
             }
         }
     }
 
     MITK_INFO << "Generating signal of " << m_NonFiberModels.size() << " non-fiber compartments";
     ImageRegionIterator<ItkUcharImgType> it3(m_TissueMask, m_TissueMask->GetLargestPossibleRegion());
     boost::progress_display disp3(m_TissueMask->GetLargestPossibleRegion().GetNumberOfPixels());
     double voxelVolume = m_UpsampledSpacing[0]*m_UpsampledSpacing[1]*m_UpsampledSpacing[2];
 
     double fact = 1;
     if (m_FiberRadius<0.0001)
         fact = voxelVolume/maxVolume;
 
     while(!it3.IsAtEnd())
     {
         ++disp3;
         DoubleDwiType::IndexType index = it3.GetIndex();
 
         if (it3.Get()>0)
         {
             // get fiber volume fraction
             DoubleDwiType::Pointer fiberDwi = compartments.at(0);
             DoubleDwiType::PixelType fiberPix = fiberDwi->GetPixel(index); // intra axonal compartment
             if (fact>1) // auto scale intra-axonal if no fiber radius is specified
             {
                 fiberPix *= fact;
                 fiberDwi->SetPixel(index, fiberPix);
             }
             double f = fiberPix[baselineIndex];
 
             if (f>voxelVolume || f>0 && m_EnforcePureFiberVoxels)  // more fiber than space in voxel?
             {
                 fiberDwi->SetPixel(index, fiberPix*voxelVolume/f);
 
                 for (int i=1; i<m_FiberModels.size(); i++)
                 {
                     DoubleDwiType::PixelType pix; pix.Fill(0.0);
                     compartments.at(i)->SetPixel(index, pix);
                     m_VolumeFractions.at(i)->SetPixel(index, 1);
                 }
             }
             else
             {
                 m_VolumeFractions.at(0)->SetPixel(index, f);
 
                 double nonf = voxelVolume-f;    // non-fiber volume
                 double inter = 0;
                 if (m_FiberModels.size()>1)
                     inter = nonf * f/voxelVolume;   // intra-axonal fraction of non fiber compartment scales linearly with f
                 double other = nonf - inter;        // rest of compartment
                 double singleinter = inter/(m_FiberModels.size()-1);
 
                 // adjust non-fiber and intra-axonal signal
                 for (int i=1; i<m_FiberModels.size(); i++)
                 {
                     DoubleDwiType::Pointer doubleDwi = compartments.at(i);
                     DoubleDwiType::PixelType pix = doubleDwi->GetPixel(index);
                     if (pix[baselineIndex]>0)
                         pix /= pix[baselineIndex];
                     pix *= singleinter;
                     doubleDwi->SetPixel(index, pix);
                     m_VolumeFractions.at(i)->SetPixel(index, singleinter/voxelVolume);
                 }
                 for (int i=0; i<m_NonFiberModels.size(); i++)
                 {
                     DoubleDwiType::Pointer doubleDwi = compartments.at(i+m_FiberModels.size());
                     DoubleDwiType::PixelType pix = doubleDwi->GetPixel(index) + m_NonFiberModels[i]->SimulateMeasurement()*other*m_NonFiberModels[i]->GetWeight();
                     doubleDwi->SetPixel(index, pix);
                     m_VolumeFractions.at(i+m_FiberModels.size())->SetPixel(index, other/voxelVolume*m_NonFiberModels[i]->GetWeight());
                 }
             }
         }
         ++it3;
     }
 
     // do k-space stuff
     DoubleDwiType::Pointer doubleOutImage;
     if (m_FrequencyMap.IsNotNull() || !m_KspaceArtifacts.empty() || m_kOffset>0 || m_SimulateRelaxation || m_SimulateEddyCurrents)
     {
         MITK_INFO << "Adjusting complex signal";
         doubleOutImage = DoKspaceStuff(compartments);
         m_SignalScale = 1;
     }
     else
     {
         MITK_INFO << "Summing compartments";
         doubleOutImage = compartments.at(0);
 
         for (int i=1; i<compartments.size(); i++)
         {
             itk::AddImageFilter< DoubleDwiType, DoubleDwiType, DoubleDwiType>::Pointer adder = itk::AddImageFilter< DoubleDwiType, DoubleDwiType, DoubleDwiType>::New();
             adder->SetInput1(doubleOutImage);
             adder->SetInput2(compartments.at(i));
             adder->Update();
             doubleOutImage = adder->GetOutput();
         }
     }
 
     MITK_INFO << "Finalizing image";
     unsigned int window = 0;
     unsigned int min = itk::NumericTraits<unsigned int>::max();
     ImageRegionIterator<DWIImageType> it4 (outImage, outImage->GetLargestPossibleRegion());
     DoubleDwiType::PixelType signal; signal.SetSize(m_FiberModels[0]->GetNumGradients());
     boost::progress_display disp4(outImage->GetLargestPossibleRegion().GetNumberOfPixels());
     while(!it4.IsAtEnd())
     {
         ++disp4;
         DWIImageType::IndexType index = it4.GetIndex();
         signal = doubleOutImage->GetPixel(index)*m_SignalScale;
 
         if (m_NoiseModel->GetNoiseVariance() > 0)
         {
             DoubleDwiType::PixelType accu = signal; accu.Fill(0.0);
             for (int i=0; i<m_NumberOfRepetitions; i++)
             {
                 DoubleDwiType::PixelType temp = signal;
                 m_NoiseModel->AddNoise(temp);
                 accu += temp;
             }
             signal = accu/m_NumberOfRepetitions;
         }
 
         for (int i=0; i<signal.Size(); i++)
         {
             if (signal[i]>0)
                 signal[i] = floor(signal[i]+0.5);
             else
                 signal[i] = ceil(signal[i]-0.5);
 
             if (!m_FiberModels.at(0)->IsBaselineIndex(i) && signal[i]>window)
                 window = signal[i];
             if (!m_FiberModels.at(0)->IsBaselineIndex(i) && signal[i]<min)
                 min = signal[i];
         }
         it4.Set(signal);
         ++it4;
     }
     window -= min;
     unsigned int level = window/2 + min;
     m_LevelWindow.SetLevelWindow(level, window);
     this->SetNthOutput(0, outImage);
 }
 
 itk::Point<float, 3> TractsToDWIImageFilter::GetItkPoint(double point[3])
 {
     itk::Point<float, 3> itkPoint;
     itkPoint[0] = point[0];
     itkPoint[1] = point[1];
     itkPoint[2] = point[2];
     return itkPoint;
 }
 
 itk::Vector<double, 3> TractsToDWIImageFilter::GetItkVector(double point[3])
 {
     itk::Vector<double, 3> itkVector;
     itkVector[0] = point[0];
     itkVector[1] = point[1];
     itkVector[2] = point[2];
     return itkVector;
 }
 
 vnl_vector_fixed<double, 3> TractsToDWIImageFilter::GetVnlVector(double point[3])
 {
     vnl_vector_fixed<double, 3> vnlVector;
     vnlVector[0] = point[0];
     vnlVector[1] = point[1];
     vnlVector[2] = point[2];
     return vnlVector;
 }
 
 
 vnl_vector_fixed<double, 3> TractsToDWIImageFilter::GetVnlVector(Vector<float,3>& vector)
 {
     vnl_vector_fixed<double, 3> vnlVector;
     vnlVector[0] = vector[0];
     vnlVector[1] = vector[1];
     vnlVector[2] = vector[2];
     return vnlVector;
 }
 
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
old mode 100644
new mode 100755
index d63ea9f277..18dbccc23b
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
@@ -1,151 +1,151 @@
 /*===================================================================
 
 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__
 
 // MITK
 #include <mitkFiberBundleX.h>
 #include <mitkDiffusionSignalModel.h>
 #include <mitkDiffusionNoiseModel.h>
 #include <mitkKspaceArtifact.h>
 #include <mitkGibbsRingingArtifact.h>
 
 // ITK
 #include <itkImage.h>
 #include <itkVectorImage.h>
 #include <itkImageSource.h>
 #include <itkVnlForwardFFTImageFilter.h>
 #include <itkVnlInverseFFTImageFilter.h>
 
 #include <cmath>
 
 typedef itk::VectorImage< short, 3 > DWIImageType;
 
 namespace itk
 {
 
 /**
 * \brief Generates artificial diffusion weighted image volume from the input fiberbundle using a generic multicompartment model.   */
 
 class TractsToDWIImageFilter : public ImageSource< DWIImageType >
 {
 
 public:
     typedef TractsToDWIImageFilter      Self;
     typedef ImageSource< DWIImageType > Superclass;
     typedef SmartPointer< Self >        Pointer;
     typedef SmartPointer< const Self >  ConstPointer;
 
     typedef itk::Image<double, 3>                           ItkDoubleImgType;
     typedef itk::Image<float, 3>                            ItkFloatImgType;
     typedef itk::Image<unsigned char, 3>                    ItkUcharImgType;
     typedef mitk::FiberBundleX::Pointer                     FiberBundleType;
     typedef itk::VectorImage< double, 3 >                   DoubleDwiType;
     typedef std::vector< mitk::KspaceArtifact<double>* >    KspaceArtifactList;
     typedef std::vector< mitk::DiffusionSignalModel<double>* >    DiffusionModelList;
     typedef itk::Matrix<double, 3, 3>                       MatrixType;
     typedef mitk::DiffusionNoiseModel<double>               NoiseModelType;
     typedef itk::Image< double, 2 >                         SliceType;
     typedef itk::VnlForwardFFTImageFilter<SliceType>::OutputImageType ComplexSliceType;
 
     itkNewMacro(Self)
     itkTypeMacro( TractsToDWIImageFilter, ImageToImageFilter )
 
     // input
     itkSetMacro( SignalScale, double )
     itkSetMacro( FiberRadius, double )
     itkSetMacro( InterpolationShrink, double )          ///< large values shrink (towards nearest neighbour interpolation), small values strech interpolation function (towards linear interpolation)
     itkSetMacro( VolumeAccuracy, unsigned int )         ///< determines fiber sampling density and thereby the accuracy of the fiber volume fraction
     itkSetMacro( FiberBundle, FiberBundleType )         ///< input fiber bundle
     itkSetMacro( Spacing, mitk::Vector3D )              ///< output image spacing
     itkSetMacro( Origin, mitk::Point3D )                ///< output image origin
     itkSetMacro( DirectionMatrix, MatrixType )          ///< output image rotation
     itkSetMacro( EnforcePureFiberVoxels, bool )         ///< treat all voxels containing at least one fiber as fiber-only (actually disable non-fiber compartments for this voxel).
     itkSetMacro( ImageRegion, ImageRegion<3> )          ///< output image size
     itkSetMacro( NumberOfRepetitions, unsigned int )    ///< number of acquisition repetitions to reduce noise (default is no additional repetition)
     itkSetMacro( TissueMask, ItkUcharImgType::Pointer ) ///< voxels outside of this binary mask contain only noise (are treated as air)
     void SetNoiseModel(NoiseModelType* noiseModel){ m_NoiseModel = noiseModel; }            ///< generates the noise added to the image values
     void SetFiberModels(DiffusionModelList modelList){ m_FiberModels = modelList; }         ///< generate signal of fiber compartments
     void SetNonFiberModels(DiffusionModelList modelList){ m_NonFiberModels = modelList; }   ///< generate signal of non-fiber compartments
     void SetKspaceArtifacts(KspaceArtifactList artifactList){ m_KspaceArtifacts = artifactList; }
     mitk::LevelWindow GetLevelWindow(){ return m_LevelWindow; }
     itkSetMacro( FrequencyMap, ItkDoubleImgType::Pointer )
     itkSetMacro( kOffset, double )
     itkSetMacro( tLine, double )
     itkSetMacro( tInhom, double )
     itkSetMacro( TE, double )
     itkSetMacro( UseInterpolation, bool )
     itkSetMacro( SimulateEddyCurrents, bool )
     itkSetMacro( SimulateRelaxation, bool )
     itkSetMacro( EddyGradientStrength, double )
 
     // output
     std::vector< ItkDoubleImgType::Pointer > GetVolumeFractions(){ return m_VolumeFractions; }
 
     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);
 
     /** Transform generated image compartment by compartment, channel by channel and slice by slice using FFT and add k-space artifacts. */
     DoubleDwiType::Pointer DoKspaceStuff(std::vector< DoubleDwiType::Pointer >& images);
 
     /** Rearrange FFT output to shift low frequencies to the iamge center (correct itk). */
     TractsToDWIImageFilter::ComplexSliceType::Pointer RearrangeSlice(ComplexSliceType::Pointer slice);
 
     itk::Vector<double>                 m_Spacing;              ///< output image spacing
     itk::Vector<double>                 m_UpsampledSpacing;
     mitk::Point3D                       m_Origin;               ///< output image origin
     MatrixType                          m_DirectionMatrix;      ///< output image rotation
     ImageRegion<3>                      m_ImageRegion;          ///< output image size
     ImageRegion<3>                      m_UpsampledImageRegion;
     ItkUcharImgType::Pointer            m_TissueMask;           ///< voxels outside of this binary mask contain only noise (are treated as air)
     ItkDoubleImgType::Pointer           m_FrequencyMap;         ///< map of the B0 inhomogeneities
     double                              m_kOffset;
     double                              m_tLine;
     double                              m_TE;
     double                              m_tInhom;
     FiberBundleType                     m_FiberBundle;          ///< input fiber bundle
     DiffusionModelList                  m_FiberModels;          ///< generate signal of fiber compartments
     DiffusionModelList                  m_NonFiberModels;       ///< generate signal of non-fiber compartments
     KspaceArtifactList                  m_KspaceArtifacts;
     NoiseModelType*                     m_NoiseModel;           ///< generates the noise added to the image values
     bool                                m_CircleDummy;
     unsigned int                        m_VolumeAccuracy;
-    unsigned int                        m_Upsampling;
+    double                              m_Upsampling;
     unsigned int                        m_NumberOfRepetitions;
     bool                                m_EnforcePureFiberVoxels;
     double                              m_InterpolationShrink;
     double                              m_FiberRadius;
     double                              m_SignalScale;
     mitk::LevelWindow                   m_LevelWindow;
     bool                                m_UseInterpolation;
     std::vector< ItkDoubleImgType::Pointer >    m_VolumeFractions;  ///< one double image for each compartment containing the corresponding volume fraction per voxel
     bool                                m_SimulateRelaxation;
     bool                                m_SimulateEddyCurrents;
     double                              m_EddyGradientStrength;
 };
 }
 
 #include "itkTractsToDWIImageFilter.cpp"
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
old mode 100644
new mode 100755
index e721cc1645..6eea24cc6b
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
@@ -1,1703 +1,1703 @@
 /*===================================================================
 
 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 <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarFigureComposite.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>
 
 const char* mitk::FiberBundleX::COLORCODING_ORIENTATION_BASED = "Color_Orient";
 //const char* mitk::FiberBundleX::COLORCODING_FA_AS_OPACITY = "Color_Orient_FA_Opacity";
 const char* mitk::FiberBundleX::COLORCODING_FA_BASED = "FA_Values";
 const char* mitk::FiberBundleX::COLORCODING_CUSTOM = "custom";
 const char* mitk::FiberBundleX::FIBER_ID_ARRAY = "Fiber_IDs";
 
 using namespace std;
 
 mitk::FiberBundleX::FiberBundleX( vtkPolyData* fiberPolyData )
     : m_CurrentColorCoding(NULL)
     , m_NumFibers(0)
     , m_FiberSampling(0)
 {
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     if (fiberPolyData != NULL)
     {
         m_FiberPolyData = fiberPolyData;
         //m_FiberPolyData->DeepCopy(fiberPolyData);
         this->DoColorCodingOrientationBased();
     }
 
     this->UpdateFiberGeometry();
     this->SetColorCoding(COLORCODING_ORIENTATION_BASED);
     this->GenerateFiberIds();
 }
 
 mitk::FiberBundleX::~FiberBundleX()
 {
 
 }
 
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::GetDeepCopy()
 {
     mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(m_FiberPolyData);
     newFib->SetColorCoding(m_CurrentColorCoding);
     return newFib;
 }
 
 vtkSmartPointer<vtkPolyData> mitk::FiberBundleX::GeneratePolyDataByIds(std::vector<long> fiberIds)
 {
     MITK_DEBUG << "\n=====FINAL RESULT: fib_id ======\n";
     MITK_DEBUG << "Number of new Fibers: " << fiberIds.size();
     // iterate through the vectorcontainer hosting all desired fiber Ids
 
     vtkSmartPointer<vtkPolyData> newFiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> newLineSet = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> newPointSet = vtkSmartPointer<vtkPoints>::New();
 
     // if FA array available, initialize fa double array
     // if color orient array is available init color array
     vtkSmartPointer<vtkDoubleArray> faValueArray;
     vtkSmartPointer<vtkUnsignedCharArray> colorsT;
     //colors and alpha value for each single point, RGBA = 4 components
     unsigned char rgba[4] = {0,0,0,0};
     int componentSize = sizeof(rgba);
 
     if (m_FiberIdDataSet->GetPointData()->HasArray(COLORCODING_FA_BASED)){
         MITK_DEBUG << "FA VALUES AVAILABLE, init array for new fiberbundle";
         faValueArray = vtkSmartPointer<vtkDoubleArray>::New();
     }
 
     if (m_FiberIdDataSet->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED)){
         MITK_DEBUG << "colorValues available, init array for new fiberbundle";
         colorsT = vtkUnsignedCharArray::New();
         colorsT->SetNumberOfComponents(componentSize);
         colorsT->SetName(COLORCODING_ORIENTATION_BASED);
     }
 
 
 
     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++)
         {
             //            MITK_DEBUG << "id: " << fiber->GetPointId(i);
             //            MITK_DEBUG << fibPoints->GetPoint(i)[0] << " | " << fibPoints->GetPoint(i)[1] << " | " << fibPoints->GetPoint(i)[2];
             newFiber->GetPointIds()->SetId(i, newPointSet->GetNumberOfPoints());
             newPointSet->InsertNextPoint(fibPoints->GetPoint(i)[0], fibPoints->GetPoint(i)[1], fibPoints->GetPoint(i)[2]);
 
 
             if (m_FiberIdDataSet->GetPointData()->HasArray(COLORCODING_FA_BASED)){
                 //                MITK_DEBUG << m_FiberIdDataSet->GetPointData()->GetArray(FA_VALUE_ARRAY)->GetTuple(fiber->GetPointId(i));
             }
 
             if (m_FiberIdDataSet->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED)){
                 //                MITK_DEBUG << "ColorValue: " << m_FiberIdDataSet->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED)->GetTuple(fiber->GetPointId(i))[0];
             }
         }
 
         newLineSet->InsertNextCell(newFiber);
         ++finIt;
     }
 
     newFiberPolyData->SetPoints(newPointSet);
     newFiberPolyData->SetLines(newLineSet);
     MITK_DEBUG << "new fiberbundle polydata points: " << newFiberPolyData->GetNumberOfPoints();
     MITK_DEBUG << "new fiberbundle polydata lines: " << newFiberPolyData->GetNumberOfLines();
     MITK_DEBUG << "=====================\n";
 
     //    mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(newFiberPolyData);
     return newFiberPolyData;
 }
 
 // merge two fiber bundles
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::AddBundle(mitk::FiberBundleX* 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
     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);
         }
         vNewLines->InsertNextCell(container);
     }
 
     // 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);
         }
         vNewLines->InsertNextCell(container);
     }
 
     // initialize polydata
     vNewPolyData->SetPoints(vNewPoints);
     vNewPolyData->SetLines(vNewLines);
 
     // initialize fiber bundle
     mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(vNewPolyData);
     return newFib;
 }
 
 // subtract two fiber bundles
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::SubtractBundle(mitk::FiberBundleX* 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
     int numFibers = GetNumFibers();
     boost::progress_display disp(numFibers);
     for( int i=0; i<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(i);
             int numPoints2 = cell2->GetNumberOfPoints();
             vtkPoints* points2 = cell2->GetPoints();
 
             if (points2==NULL || numPoints2<=0)
                 continue;
 
             // check endpoints
             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 ???
                 if (numPoints2==numPoints)
                     contained = true;
             }
         }
 
         // 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
     mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(vNewPolyData);
     return newFib;
 }
 
 itk::Point<float, 3> mitk::FiberBundleX::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)
 {
     if (fiberPD == NULL)
         this->m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     else
     {
         m_FiberPolyData->DeepCopy(fiberPD);
         DoColorCodingOrientationBased();
     }
 
     m_NumFibers = m_FiberPolyData->GetNumberOfLines();
 
     if (updateGeometry)
         UpdateFiberGeometry();
     SetColorCoding(COLORCODING_ORIENTATION_BASED);
     GenerateFiberIds();
 }
 
 /*
  * return vtkPolyData
  */
 vtkSmartPointer<vtkPolyData> mitk::FiberBundleX::GetFiberPolyData()
 {
     return m_FiberPolyData;
 }
 
 void mitk::FiberBundleX::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
     //=================================================
 
 
     /*  make sure that processing colorcoding is only called when necessary */
     if ( m_FiberPolyData->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED) &&
          m_FiberPolyData->GetNumberOfPoints() ==
          m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED)->GetNumberOfTuples() )
     {
         // fiberstructure is already colorcoded
         MITK_DEBUG << " NO NEED TO REGENERATE COLORCODING! " ;
         this->ResetFiberOpacity();
         this->SetColorCoding(COLORCODING_ORIENTATION_BASED);
         return;
     }
 
     /* Finally, execute color calculation */
     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 = sizeof(rgba);
     int componentSize = 4;
 
     vtkSmartPointer<vtkUnsignedCharArray> colorsT = vtkSmartPointer<vtkUnsignedCharArray>::New();
     colorsT->Allocate(numOfPoints * componentSize);
     colorsT->SetNumberOfComponents(componentSize);
     colorsT->SetName(COLORCODING_ORIENTATION_BASED);
 
 
 
     /* checkpoint: does polydata contain any fibers */
     int numOfFibers = m_FiberPolyData->GetNumberOfLines();
     if (numOfFibers < 1) {
         MITK_DEBUG << "\n ========= Number of Fibers is 0 and below ========= \n";
         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);
 
         //    MITK_DEBUG << "Fib#: " << fi << " of " << numOfFibers << " pnts in fiber: " << pointsPerFiber ;
 
         /* 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);
 
                 }
 
                 colorsT->InsertTupleValue(idList[i], rgba);
 
             } //end for loop
 
         } else if (pointsPerFiber == 1) {
             /* a single point does not define a fiber (use vertex mechanisms instead */
             continue;
             //      colorsT->InsertTupleValue(0, rgba);
 
         } else {
             MITK_DEBUG << "Fiber with 0 points detected... please check your tractography algorithm!" ;
             continue;
 
         }
 
 
     }//end for loop
 
     m_FiberPolyData->GetPointData()->AddArray(colorsT);
 
     /*=========================
       - this is more relevant for renderer than for fiberbundleX datastructure
       - think about sourcing this to a explicit method which coordinates colorcoding */
     this->SetColorCoding(COLORCODING_ORIENTATION_BASED);
     //  ===========================
 
     //mini test, shall be ported to MITK TESTINGS!
     if (colorsT->GetSize() != numOfPoints*componentSize)
         MITK_DEBUG << "ALLOCATION ERROR IN INITIATING COLOR ARRAY";
 
 
 }
 
 void mitk::FiberBundleX::DoColorCodingFaBased()
 {
     if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_FA_BASED) != 1 )
         return;
 
     this->SetColorCoding(COLORCODING_FA_BASED);
     MITK_DEBUG << "FBX: done CC FA based";
     this->GenerateFiberIds();
 }
 
 void mitk::FiberBundleX::DoUseFaFiberOpacity()
 {
     if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_FA_BASED) != 1 )
         return;
 
     if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED) != 1 )
         return;
 
     vtkDoubleArray* FAValArray = (vtkDoubleArray*) m_FiberPolyData->GetPointData()->GetArray(COLORCODING_FA_BASED);
     vtkUnsignedCharArray* ColorArray = dynamic_cast<vtkUnsignedCharArray*>  (m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED));
 
     for(long i=0; i<ColorArray->GetNumberOfTuples(); i++) {
         double faValue = FAValArray->GetValue(i);
         faValue = faValue * 255.0;
         ColorArray->SetComponent(i,3, (unsigned char) faValue );
     }
 
     this->SetColorCoding(COLORCODING_ORIENTATION_BASED);
     MITK_DEBUG << "FBX: done CC OPACITY";
     this->GenerateFiberIds();
 }
 
 void mitk::FiberBundleX::ResetFiberOpacity() {
     vtkUnsignedCharArray* ColorArray = dynamic_cast<vtkUnsignedCharArray*>  (m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED));
     if (ColorArray==NULL)
         return;
     for(long i=0; i<ColorArray->GetNumberOfTuples(); i++)
         ColorArray->SetComponent(i,3, 255.0 );
 }
 
 void mitk::FiberBundleX::SetFAMap(mitk::Image::Pointer FAimage)
 {
     MITK_DEBUG << "SetFAMap";
     vtkSmartPointer<vtkDoubleArray> faValues = vtkSmartPointer<vtkDoubleArray>::New();
     faValues->SetName(COLORCODING_FA_BASED);
     faValues->Allocate(m_FiberPolyData->GetNumberOfPoints());
     faValues->SetNumberOfValues(m_FiberPolyData->GetNumberOfPoints());
 
     vtkPoints* pointSet = m_FiberPolyData->GetPoints();
     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 faPixelValue = 1-FAimage->GetPixelValueByWorldCoordinate(px);
         faValues->InsertValue(i, faPixelValue);
     }
 
     m_FiberPolyData->GetPointData()->AddArray(faValues);
     this->GenerateFiberIds();
 
     if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_FA_BASED))
         MITK_DEBUG << "FA VALUE ARRAY SET";
 }
 
 void mitk::FiberBundleX::GenerateFiberIds()
 {
     if (m_FiberPolyData == NULL)
         return;
 
     vtkSmartPointer<vtkIdFilter> idFiberFilter = vtkSmartPointer<vtkIdFilter>::New();
     idFiberFilter->SetInput(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_DEBUG << "Generating Fiber Ids...[done] | " << m_FiberIdDataSet->GetNumberOfCells();
 
 }
 
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::ExtractFiberSubset(ItkUcharImgType* mask, bool anyPoint)
 {
     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();
         fibCopy->ResampleFibers(minSpacing/10);
         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 = cell->GetNumberOfPoints();
-        vtkPoints* pointsOriginal = cell->GetPoints();
+        int numPointsOriginal = cellOriginal->GetNumberOfPoints();
+        vtkPoints* pointsOriginal = cellOriginal->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
 
-        if (numPoints>1)
+        if (numPoints>1 && numPointsOriginal)
         {
             if (anyPoint)
             {
                 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 )
+                    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
             {
-                double* start = points->GetPoint(0);
+                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 = points->GetPoint(numPoints-1);
+                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 )
+                if ( mask->GetPixel(idxStart)>0 && mask->GetPixel(idxEnd)>0 && mask->GetLargestPossibleRegion().IsInside(idxStart) && mask->GetLargestPossibleRegion().IsInside(idxEnd) )
                 {
-                    for (int j=0; j<numPoints; j++)
+                    for (int j=0; j<numPointsOriginal; j++)
                     {
-                        double* p = points->GetPoint(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);
 }
 
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::ExtractFiberSubset(mitk::PlanarFigure* pf)
 {
     if (pf==NULL)
         return NULL;
 
     std::vector<long> tmp = ExtractFiberIdSubset(pf);
 
     if (tmp.size()<=0)
         return mitk::FiberBundleX::New();
     vtkSmartPointer<vtkPolyData> pTmp = GeneratePolyDataByIds(tmp);
     return mitk::FiberBundleX::New(pTmp);
 }
 
 std::vector<long> mitk::FiberBundleX::ExtractFiberIdSubset(mitk::PlanarFigure* pf)
 {
     MITK_DEBUG << "Extracting fibers!";
     // vector which is returned, contains all extracted FiberIds
     std::vector<long> FibersInROI;
 
     if (pf==NULL)
         return FibersInROI;
 
     /* Handle type of planarfigure */
     // if incoming pf is a pfc
     mitk::PlanarFigureComposite::Pointer pfcomp= dynamic_cast<mitk::PlanarFigureComposite*>(pf);
     if (!pfcomp.IsNull()) {
         // process requested boolean operation of PFC
         switch (pfcomp->getOperationType()) {
         case 0:
         {
             MITK_DEBUG << "AND PROCESSING";
             //AND
             //temporarly store results of the child in this vector, we need that to accumulate the
             std::vector<long> childResults = this->ExtractFiberIdSubset(pfcomp->getChildAt(0));
             MITK_DEBUG << "first roi got fibers in ROI: " << childResults.size();
             MITK_DEBUG << "sorting...";
             std::sort(childResults.begin(), childResults.end());
             MITK_DEBUG << "sorting done";
             std::vector<long> AND_Assamblage(childResults.size());
             //std::vector<unsigned long> AND_Assamblage;
             fill(AND_Assamblage.begin(), AND_Assamblage.end(), -1);
             //AND_Assamblage.reserve(childResults.size()); //max size AND can reach anyway
 
             std::vector<long>::iterator it;
             for (int i=1; i<pfcomp->getNumberOfChildren(); ++i)
             {
                 std::vector<long> tmpChild = this->ExtractFiberIdSubset(pfcomp->getChildAt(i));
                 MITK_DEBUG << "ROI " << i << " has fibers in ROI: " << tmpChild.size();
                 sort(tmpChild.begin(), tmpChild.end());
 
                 it = std::set_intersection(childResults.begin(), childResults.end(),
                                            tmpChild.begin(), tmpChild.end(),
                                            AND_Assamblage.begin() );
             }
 
             MITK_DEBUG << "resize Vector";
             long i=0;
             while (i < AND_Assamblage.size() && AND_Assamblage[i] != -1){ //-1 represents a placeholder in the array
                 ++i;
             }
             AND_Assamblage.resize(i);
 
             MITK_DEBUG << "returning AND vector, size: " << AND_Assamblage.size();
             return AND_Assamblage;
             //            break;
 
         }
         case 1:
         {
             //OR
             std::vector<long> OR_Assamblage = this->ExtractFiberIdSubset(pfcomp->getChildAt(0));
             std::vector<long>::iterator it;
             MITK_DEBUG << OR_Assamblage.size();
 
             for (int i=1; i<pfcomp->getNumberOfChildren(); ++i) {
                 it = OR_Assamblage.end();
                 std::vector<long> tmpChild = this->ExtractFiberIdSubset(pfcomp->getChildAt(i));
                 OR_Assamblage.insert(it, tmpChild.begin(), tmpChild.end());
                 MITK_DEBUG << "ROI " << i << " has fibers in ROI: " << tmpChild.size() << " OR Assamblage: " << OR_Assamblage.size();
             }
 
             sort(OR_Assamblage.begin(), OR_Assamblage.end());
             it = unique(OR_Assamblage.begin(), OR_Assamblage.end());
             OR_Assamblage.resize( it - OR_Assamblage.begin() );
             MITK_DEBUG << "returning OR vector, size: " << OR_Assamblage.size();
 
             return OR_Assamblage;
         }
         case 2:
         {
             //NOT
             //get IDs of all fibers
             std::vector<long> childResults;
             childResults.reserve(this->GetNumFibers());
             vtkSmartPointer<vtkDataArray> idSet = m_FiberIdDataSet->GetCellData()->GetArray(FIBER_ID_ARRAY);
             MITK_DEBUG << "m_NumOfFib: " << this->GetNumFibers() << " cellIdNum: " << idSet->GetNumberOfTuples();
             for(long i=0; i<this->GetNumFibers(); i++)
             {
                 MITK_DEBUG << "i: " << i << " idset: " << idSet->GetTuple(i)[0];
                 childResults.push_back(idSet->GetTuple(i)[0]);
             }
 
             std::sort(childResults.begin(), childResults.end());
             std::vector<long> NOT_Assamblage(childResults.size());
             //fill it with -1, otherwise 0 will be stored and 0 can also be an ID of fiber!
             fill(NOT_Assamblage.begin(), NOT_Assamblage.end(), -1);
             std::vector<long>::iterator it;
 
             for (long i=0; i<pfcomp->getNumberOfChildren(); ++i)
             {
                 std::vector<long> tmpChild = ExtractFiberIdSubset(pfcomp->getChildAt(i));
                 sort(tmpChild.begin(), tmpChild.end());
 
                 it = std::set_difference(childResults.begin(), childResults.end(),
                                          tmpChild.begin(), tmpChild.end(),
                                          NOT_Assamblage.begin() );
 
             }
 
             MITK_DEBUG << "resize Vector";
             long i=0;
             while (NOT_Assamblage[i] != -1){ //-1 represents a placeholder in the array
                 ++i;
             }
             NOT_Assamblage.resize(i);
 
             return NOT_Assamblage;
         }
         default:
             MITK_DEBUG << "we have an UNDEFINED composition... ERROR" ;
             break;
 
         }
     }
     else
     {
         mitk::Geometry2D::ConstPointer pfgeometry = pf->GetGeometry2D();
         const mitk::PlaneGeometry* planeGeometry = dynamic_cast<const mitk::PlaneGeometry*> (pfgeometry.GetPointer());
         Vector3D planeNormal = planeGeometry->GetNormal();
         planeNormal.Normalize();
         Point3D planeOrigin = planeGeometry->GetOrigin();
 
         MITK_DEBUG << "planeOrigin: " << planeOrigin[0] << " | " << planeOrigin[1] << " | " << planeOrigin[2] << endl;
         MITK_DEBUG << "planeNormal: " << planeNormal[0] << " | " << planeNormal[1] << " | " << planeNormal[2] << endl;
 
         std::vector<int> PointsOnPlane; // contains all pointIds which are crossing the cutting plane
         std::vector<int> PointsInROI; // based on PointsOnPlane, all ROI relevant point IDs are stored here
 
         /* Define cutting plane by ROI (PlanarFigure) */
         vtkSmartPointer<vtkPlane> plane = vtkSmartPointer<vtkPlane>::New();
         plane->SetOrigin(planeOrigin[0],planeOrigin[1],planeOrigin[2]);
         plane->SetNormal(planeNormal[0],planeNormal[1],planeNormal[2]);
 
         /* get all points/fibers cutting the plane */
         MITK_DEBUG << "start clipping";
         vtkSmartPointer<vtkClipPolyData> clipper = vtkSmartPointer<vtkClipPolyData>::New();
         clipper->SetInput(m_FiberIdDataSet);
         clipper->SetClipFunction(plane);
         clipper->GenerateClipScalarsOn();
         clipper->GenerateClippedOutputOn();
         vtkSmartPointer<vtkPolyData> clipperout = clipper->GetClippedOutput();
         MITK_DEBUG << "end clipping";
 
         MITK_DEBUG << "init and update clipperoutput";
         clipperout->GetPointData()->Initialize();
         clipperout->Update();
         MITK_DEBUG << "init and update clipperoutput completed";
 
         MITK_DEBUG << "STEP 1: find all points which have distance 0 to the given plane";
         /*======STEP 1======
       * extract all points, which are crossing the plane */
         // Scalar values describe the distance between each remaining point to the given plane. Values sorted by point index
         vtkSmartPointer<vtkDataArray> distanceList = clipperout->GetPointData()->GetScalars();
         vtkIdType sizeOfList =  distanceList->GetNumberOfTuples();
         PointsOnPlane.reserve(sizeOfList); /* use reserve for high-performant push_back, no hidden copy procedures are processed then!
                                          * size of list can be optimized by reducing allocation, but be aware of iterator and vector size*/
 
         for (int i=0; i<sizeOfList; ++i) {
             double *distance = distanceList->GetTuple(i);
 
             // check if point is on plane.
             // 0.01 due to some approximation errors when calculating distance
             if (distance[0] >= -0.01 && distance[0] <= 0.01)
                 PointsOnPlane.push_back(i);
         }
 
 
         MITK_DEBUG << "Num Of points on plane: " <<  PointsOnPlane.size();
 
         MITK_DEBUG << "Step 2: extract Interesting points with respect to given extraction planarFigure";
 
         PointsInROI.reserve(PointsOnPlane.size());
         /*=======STEP 2=====
      * extract ROI relevant pointIds */
 
         mitk::PlanarCircle::Pointer circleName = mitk::PlanarCircle::New();
         mitk::PlanarPolygon::Pointer polyName = mitk::PlanarPolygon::New();
         if ( pf->GetNameOfClass() == circleName->GetNameOfClass() )
         {
             //calculate circle radius
             mitk::Point3D V1w = pf->GetWorldControlPoint(0); //centerPoint
             mitk::Point3D V2w  = pf->GetWorldControlPoint(1); //radiusPoint
 
             double distPF = V1w.EuclideanDistanceTo(V2w);
 
             for (int i=0; i<PointsOnPlane.size(); i++)
             {
                 //distance between circle radius and given point
                 double XdistPnt =  sqrt((double) (clipperout->GetPoint(PointsOnPlane[i])[0] - V1w[0]) * (clipperout->GetPoint(PointsOnPlane[i])[0] - V1w[0]) +
                                         (clipperout->GetPoint(PointsOnPlane[i])[1] - V1w[1]) * (clipperout->GetPoint(PointsOnPlane[i])[1] - V1w[1]) +
                                         (clipperout->GetPoint(PointsOnPlane[i])[2] - V1w[2]) * (clipperout->GetPoint(PointsOnPlane[i])[2] - V1w[2])) ;
 
                 if( XdistPnt <= distPF)
                     PointsInROI.push_back(PointsOnPlane[i]);
             }
         }
         else if ( pf->GetNameOfClass() == polyName->GetNameOfClass() )
         {
             //create vtkPolygon using controlpoints from planarFigure polygon
             vtkSmartPointer<vtkPolygon> polygonVtk = vtkSmartPointer<vtkPolygon>::New();
 
             //get the control points from pf and insert them to vtkPolygon
             unsigned int nrCtrlPnts = pf->GetNumberOfControlPoints();
 
             for (int i=0; i<nrCtrlPnts; ++i)
             {
                 polygonVtk->GetPoints()->InsertNextPoint((double)pf->GetWorldControlPoint(i)[0], (double)pf->GetWorldControlPoint(i)[1], (double)pf->GetWorldControlPoint(i)[2] );
             }
 
             //prepare everything for using pointInPolygon function
             double n[3];
             polygonVtk->ComputeNormal(polygonVtk->GetPoints()->GetNumberOfPoints(),
                                       static_cast<double*>(polygonVtk->GetPoints()->GetData()->GetVoidPointer(0)), n);
 
             double bounds[6];
             polygonVtk->GetPoints()->GetBounds(bounds);
 
             for (int i=0; i<PointsOnPlane.size(); i++)
             {
                 double checkIn[3] = {clipperout->GetPoint(PointsOnPlane[i])[0], clipperout->GetPoint(PointsOnPlane[i])[1], clipperout->GetPoint(PointsOnPlane[i])[2]};
                 int isInPolygon = polygonVtk->PointInPolygon(checkIn, polygonVtk->GetPoints()->GetNumberOfPoints()
                                                              , static_cast<double*>(polygonVtk->GetPoints()->GetData()->GetVoidPointer(0)), bounds, n);
                 if( isInPolygon )
                     PointsInROI.push_back(PointsOnPlane[i]);
             }
         }
 
         MITK_DEBUG << "Step3: Identify fibers";
         // we need to access the fiberId Array, so make sure that this array is available
         if (!clipperout->GetCellData()->HasArray(FIBER_ID_ARRAY))
         {
             MITK_DEBUG << "ERROR: FiberID array does not exist, no correlation between points and fiberIds possible! Make sure calling GenerateFiberIds()";
             return FibersInROI; // FibersInRoi is empty then
         }
         if (PointsInROI.size()<=0)
             return FibersInROI;
 
         // prepare a structure where each point id is represented as an indexId.
         // vector looks like: | pntId | fiberIdx |
         std::vector< long > pointindexFiberMap;
 
         // walk through the whole subline section and create an vector sorted by point index
         vtkCellArray *clipperlines = clipperout->GetLines();
         clipperlines->InitTraversal();
         long numOfLineCells = clipperlines->GetNumberOfCells();
         long numofClippedPoints = clipperout->GetNumberOfPoints();
         pointindexFiberMap.resize(numofClippedPoints);
 
 
         //prepare resulting vector
         FibersInROI.reserve(PointsInROI.size());
 
         MITK_DEBUG << "\n===== Pointindex based structure initialized ======\n";
 
         // go through resulting "sub"lines which are stored as cells, "i" corresponds to current line id.
         for (int i=0, ic=0 ; i<numOfLineCells; i++, ic+=3)
         { //ic is the index counter for the cells hosting the desired information, eg. 2 | 45 | 46. each cell consits of 3 items.
 
             vtkIdType npts;
             vtkIdType *pts;
             clipperlines->GetCell(ic, npts, pts);
 
             // go through point ids in hosting subline, "j" corresponds to current pointindex in current line i. eg. idx[0]=45; idx[1]=46
             for (long j=0; j<npts; j++)
             {
                 // MITK_DEBUG << "writing fiber id: " << clipperout->GetCellData()->GetArray(FIBER_ID_ARRAY)->GetTuple(i)[0] << " to pointId: " << pts[j];
                 pointindexFiberMap[ pts[j] ] = clipperout->GetCellData()->GetArray(FIBER_ID_ARRAY)->GetTuple(i)[0];
                 // MITK_DEBUG << "in array: " << pointindexFiberMap[ pts[j] ];
             }
 
         }
 
         MITK_DEBUG << "\n===== Pointindex based structure finalized ======\n";
 
         // get all Points in ROI with according fiberID
         for (long k = 0; k < PointsInROI.size(); k++)
         {
             //MITK_DEBUG << "point " << PointsInROI[k] << " belongs to fiber " << pointindexFiberMap[ PointsInROI[k] ];
             if (pointindexFiberMap[ PointsInROI[k] ]<=GetNumFibers() && pointindexFiberMap[ PointsInROI[k] ]>=0)
                 FibersInROI.push_back(pointindexFiberMap[ PointsInROI[k] ]);
             else
                 MITK_INFO << "ERROR in ExtractFiberIdSubset; impossible fiber id detected";
         }
 
         m_PointsRoi = PointsInROI;
 
     }
 
     //  detecting fiberId duplicates
     MITK_DEBUG << "check for duplicates";
 
     sort(FibersInROI.begin(), FibersInROI.end());
     bool hasDuplicats = false;
     for(long i=0; i<FibersInROI.size()-1; ++i)
     {
         if(FibersInROI[i] == FibersInROI[i+1])
             hasDuplicats = true;
     }
 
     if(hasDuplicats)
     {
         std::vector<long>::iterator it;
         it = unique (FibersInROI.begin(), FibersInROI.end());
         FibersInROI.resize( it - FibersInROI.begin() );
     }
 
     return FibersInROI;
 }
 
 void mitk::FiberBundleX::UpdateFiberGeometry()
 {
     vtkSmartPointer<vtkCleanPolyData> cleaner = vtkSmartPointer<vtkCleanPolyData>::New();
     cleaner->SetInput(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_NumFibers<=0) // no fibers present; apply default geometry
     {
         m_MinFiberLength = 0;
         m_MaxFiberLength = 0;
         mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
         geometry->SetImageGeometry(true);
         float b[] = {0, 1, 0, 1, 0, 1};
         geometry->SetFloatBounds(b);
         SetGeometry(geometry);
         return;
     }
     float min = itk::NumericTraits<float>::NonpositiveMin();
     float max = itk::NumericTraits<float>::max();
     float b[] = {max, min, max, min, max, min};
 
     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; j++)
         {
             // calculate bounding box
             double p1[3];
             points->GetPoint(j, p1);
 
             if (p1[0]<b[0])
                 b[0]=p1[0];
             if (p1[0]>b[1])
                 b[1]=p1[0];
 
             if (p1[1]<b[2])
                 b[2]=p1[1];
             if (p1[1]>b[3])
                 b[3]=p1[1];
 
             if (p1[2]<b[4])
                 b[4]=p1[2];
             if (p1[2]>b[5])
                 b[5]=p1[2];
 
             // calculate statistics
             if (j<p-1)
             {
                 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);
 
     // provide some border margin
     for(int i=0; i<=4; i+=2)
         b[i] -=10;
     for(int i=1; i<=5; i+=2)
         b[i] +=10;
 
     mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
     geometry->SetFloatBounds(b);
     this->SetGeometry(geometry);
 }
 
 QStringList mitk::FiberBundleX::GetAvailableColorCodings()
 {
     QStringList availableColorCodings;
     int numColors = m_FiberPolyData->GetPointData()->GetNumberOfArrays();
     for(int i=0; i<numColors; i++)
     {
         availableColorCodings.append(m_FiberPolyData->GetPointData()->GetArrayName(i));
     }
 
     //this controlstructure shall be implemented by the calling method
     if (availableColorCodings.isEmpty())
         MITK_DEBUG << "no colorcodings available in fiberbundleX";
 
     return availableColorCodings;
 }
 
 
 char* mitk::FiberBundleX::GetCurrentColorCoding()
 {
     return m_CurrentColorCoding;
 }
 
 void mitk::FiberBundleX::SetColorCoding(const char* requestedColorCoding)
 {
 
     if (requestedColorCoding==NULL)
         return;
     MITK_DEBUG << "SetColorCoding:" << requestedColorCoding;
 
     if( strcmp (COLORCODING_ORIENTATION_BASED,requestedColorCoding) == 0 )    {
         this->m_CurrentColorCoding = (char*) COLORCODING_ORIENTATION_BASED;
 
     } else if( strcmp (COLORCODING_FA_BASED,requestedColorCoding) == 0 ) {
         this->m_CurrentColorCoding = (char*) COLORCODING_FA_BASED;
 
     } else if( strcmp (COLORCODING_CUSTOM,requestedColorCoding) == 0 ) {
         this->m_CurrentColorCoding = (char*) COLORCODING_CUSTOM;
 
     } else {
         MITK_DEBUG << "FIBERBUNDLE X: UNKNOWN COLORCODING in FIBERBUNDLEX Datastructure";
         this->m_CurrentColorCoding = (char*) COLORCODING_CUSTOM; //will cause blank colorcoding of fibers
     }
 }
 
 void mitk::FiberBundleX::RotateAroundAxis(double x, double y, double z)
 {
     MITK_INFO << "Rotating fibers";
     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::Geometry3D::Pointer geom = this->GetGeometry();
     mitk::Point3D center = geom->GetCenter();
 
     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);
             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);
     UpdateColorCoding();
     UpdateFiberGeometry();
 }
 
 void mitk::FiberBundleX::ScaleFibers(double x, double y, double z)
 {
     MITK_INFO << "Scaling fibers";
     boost::progress_display disp(m_NumFibers);
 
     mitk::Geometry3D* 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);
             p[0] -= c[0]; p[1] -= c[1]; p[2] -= c[2];
             p[0] *= x;
             p[1] *= y;
             p[2] *= z;
             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);
     UpdateColorCoding();
     UpdateFiberGeometry();
 }
 
 void mitk::FiberBundleX::TranslateFibers(double x, double y, double z)
 {
     MITK_INFO << "Translating 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[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);
     UpdateColorCoding();
     UpdateFiberGeometry();
 }
 
 void mitk::FiberBundleX::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);
     UpdateColorCoding();
     UpdateFiberGeometry();
 }
 
 bool mitk::FiberBundleX::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);
 
     UpdateColorCoding();
     UpdateFiberGeometry();
     return true;
 }
 
 bool mitk::FiberBundleX::RemoveShortFibers(float lengthInMM)
 {
     if (lengthInMM<=0 || lengthInMM<m_MinFiberLength)
         return true;
 
     if (lengthInMM>m_MaxFiberLength)    // can't remove all fibers
         return false;
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
     float min = m_MaxFiberLength;
 
     MITK_INFO << "Removing short 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 (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);
 
     UpdateColorCoding();
     UpdateFiberGeometry();
     return true;
 }
 
 bool mitk::FiberBundleX::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);
     UpdateColorCoding();
     UpdateFiberGeometry();
     return true;
 }
 
 void mitk::FiberBundleX::DoFiberSmoothing(int pointsPerCm, double tension, double continuity, double bias )
 {
     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 << "Resampling 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);
         length /=10;
         int sampling = pointsPerCm*length;
 
         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);
     UpdateColorCoding();
     UpdateFiberGeometry();
     m_FiberSampling = pointsPerCm;
 }
 
 void mitk::FiberBundleX::DoFiberSmoothing(int pointsPerCm)
 {
     DoFiberSmoothing(pointsPerCm, 0, 0, 0 );
 }
 
 // Resample fiber to get equidistant points
 void mitk::FiberBundleX::ResampleFibers(float pointDistance)
 {
     if (pointDistance<=0.00001)
         return;
 
     vtkSmartPointer<vtkPolyData> newPoly = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> newCellArray = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints>    newPoints = vtkSmartPointer<vtkPoints>::New();
 
     int numberOfLines = m_NumFibers;
 
     MITK_INFO << "Resampling fibers";
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<numberOfLines; i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
 
         double* point = points->GetPoint(0);
         vtkIdType pointId = newPoints->InsertNextPoint(point);
         container->GetPointIds()->InsertNextId(pointId);
 
         float dtau = 0;
         int cur_p = 1;
         itk::Vector<float,3> dR;
         float normdR = 0;
 
         for (;;)
         {
             while (dtau <= pointDistance && cur_p < numPoints)
             {
                 itk::Vector<float,3> v1;
                 point = points->GetPoint(cur_p-1);
                 v1[0] = point[0];
                 v1[1] = point[1];
                 v1[2] = point[2];
                 itk::Vector<float,3> v2;
                 point = points->GetPoint(cur_p);
                 v2[0] = point[0];
                 v2[1] = point[1];
                 v2[2] = point[2];
 
                 dR  = v2 - v1;
                 normdR = std::sqrt(dR.GetSquaredNorm());
                 dtau += normdR;
                 cur_p++;
             }
 
             if (dtau >= pointDistance)
             {
                 itk::Vector<float,3> v1;
                 point = points->GetPoint(cur_p-1);
                 v1[0] = point[0];
                 v1[1] = point[1];
                 v1[2] = point[2];
 
                 itk::Vector<float,3> v2 = v1 - dR*( (dtau-pointDistance)/normdR );
                 pointId = newPoints->InsertNextPoint(v2.GetDataPointer());
                 container->GetPointIds()->InsertNextId(pointId);
             }
             else
             {
                 point = points->GetPoint(numPoints-1);
                 pointId = newPoints->InsertNextPoint(point);
                 container->GetPointIds()->InsertNextId(pointId);
                 break;
             }
             dtau = dtau-pointDistance;
         }
 
         newCellArray->InsertNextCell(container);
     }
 
     newPoly->SetPoints(newPoints);
     newPoly->SetLines(newCellArray);
     m_FiberPolyData = newPoly;
     UpdateFiberGeometry();
     UpdateColorCoding();
     m_FiberSampling = 10/pointDistance;
 }
 
 // reapply selected colorcoding in case polydata structure has changed
 void mitk::FiberBundleX::UpdateColorCoding()
 {
     char* cc = GetCurrentColorCoding();
 
     if( strcmp (COLORCODING_ORIENTATION_BASED,cc) == 0 )
         DoColorCodingOrientationBased();
     else if( strcmp (COLORCODING_FA_BASED,cc) == 0 )
         DoColorCodingFaBased();
 }
 
 // reapply selected colorcoding in case polydata structure has changed
 bool mitk::FiberBundleX::Equals(mitk::FiberBundleX* fib)
 {
     if (fib==NULL)
         return false;
 
     mitk::FiberBundleX::Pointer tempFib = this->SubtractBundle(fib);
     mitk::FiberBundleX::Pointer tempFib2 = fib->SubtractBundle(this);
 
     if (tempFib.IsNull() && tempFib2.IsNull())
         return true;
 
     return false;
 }
 
 /* ESSENTIAL IMPLEMENTATION OF SUPERCLASS METHODS */
 void mitk::FiberBundleX::UpdateOutputInformation()
 {
 
 }
 void mitk::FiberBundleX::SetRequestedRegionToLargestPossibleRegion()
 {
 
 }
 bool mitk::FiberBundleX::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
     return false;
 }
 bool mitk::FiberBundleX::VerifyRequestedRegion()
 {
     return true;
 }
 void mitk::FiberBundleX::SetRequestedRegion(const itk::DataObject *data )
 {
 
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkGibbsRingingArtifact.cpp b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkGibbsRingingArtifact.cpp
old mode 100644
new mode 100755
index fc094304c2..b9f16f14ce
--- a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkGibbsRingingArtifact.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkGibbsRingingArtifact.cpp
@@ -1,62 +1,62 @@
 /*===================================================================
 
 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 <math.h>
 
 template< class ScalarType >
 GibbsRingingArtifact< ScalarType >::GibbsRingingArtifact()
-    : m_KspaceCropping(0.1)
+    : m_KspaceCropping(1.1)
 {
 
 }
 
 template< class ScalarType >
 GibbsRingingArtifact< ScalarType >::~GibbsRingingArtifact()
 {
 
 }
 
 template< class ScalarType >
 typename GibbsRingingArtifact< ScalarType >::ComplexSliceType::Pointer GibbsRingingArtifact< ScalarType >::AddArtifact(typename ComplexSliceType::Pointer slice)
 {
     itk::ImageRegion<2> region = slice->GetLargestPossibleRegion();
 
     int x = region.GetSize()[0]/m_KspaceCropping;
     int y = region.GetSize()[1]/m_KspaceCropping;
 
     typename ComplexSliceType::Pointer newSlice = ComplexSliceType::New();
     itk::ImageRegion<2> newRegion;
     newRegion.SetSize(0, x);
     newRegion.SetSize(1, y);
 
     newSlice->SetLargestPossibleRegion( newRegion );
     newSlice->SetBufferedRegion( newRegion );
     newSlice->SetRequestedRegion( newRegion );
     newSlice->Allocate();
 
     itk::ImageRegionIterator<ComplexSliceType> it(newSlice, newRegion);
     while(!it.IsAtEnd())
     {
         typename ComplexSliceType::IndexType idx;
         idx[0] = region.GetSize()[0]/2-x/2+it.GetIndex()[0];
         idx[1] = region.GetSize()[1]/2-y/2+it.GetIndex()[1];
 
         it.Set(slice->GetPixel(idx));
 
         ++it;
     }
     return newSlice;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkGibbsRingingArtifact.h b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkGibbsRingingArtifact.h
old mode 100644
new mode 100755
index 9115346e66..f418a9d16a
--- a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkGibbsRingingArtifact.h
+++ b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkGibbsRingingArtifact.h
@@ -1,58 +1,58 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef _MITK_GibbsRingingArtifact_H
 #define _MITK_GibbsRingingArtifact_H
 
 #include <FiberTrackingExports.h>
 #include <mitkKspaceArtifact.h>
 #include <itkImageRegion.h>
 #include <itkImageRegionIterator.h>
 
 namespace mitk {
 
 /**
   * \brief Class to add gibbs ringing artifact to input complex slice
   *
   */
 template< class ScalarType >
 class GibbsRingingArtifact : public KspaceArtifact< ScalarType >
 {
 public:
 
     GibbsRingingArtifact();
     ~GibbsRingingArtifact();
 
     typedef typename KspaceArtifact< ScalarType >::ComplexSliceType ComplexSliceType;
 
     /** Adds Gibbs ringing to the input slice (by zero padding). **/
     typename ComplexSliceType::Pointer AddArtifact(typename ComplexSliceType::Pointer slice);
 
-    void SetKspaceCropping(int factor){ m_KspaceCropping=factor; }
-    int GetKspaceCropping(){ return m_KspaceCropping; }
+    void SetKspaceCropping(double factor){ m_KspaceCropping=factor; }
+    double GetKspaceCropping(){ return m_KspaceCropping; }
 
 protected:
 
-    int  m_KspaceCropping;
+    double  m_KspaceCropping;
 
 };
 
 #include "mitkGibbsRingingArtifact.cpp"
 
 }
 
 #endif