diff --git a/Modules/DiffusionImaging/Algorithms/Connectomics/mitkConnectomicsNetworkCreator.cpp b/Modules/DiffusionImaging/Algorithms/Connectomics/mitkConnectomicsNetworkCreator.cpp
index 12317bfb1a..dbbf1cf2df 100644
--- a/Modules/DiffusionImaging/Algorithms/Connectomics/mitkConnectomicsNetworkCreator.cpp
+++ b/Modules/DiffusionImaging/Algorithms/Connectomics/mitkConnectomicsNetworkCreator.cpp
@@ -1,758 +1,759 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$ 
  
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkConnectomicsNetworkCreator.h"
 
 #include <sstream>
 #include <vector>
 
 #include "mitkConnectomicsConstantsManager.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 )
 {
 }
 
 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 )
 {
 }
 
 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();
 
   vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
   vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
   vLines->InitTraversal();
 
   //int numFibers = m_FiberBundle->GetNumFibers();
   int numFibers= 10;
   for( int fiberID( 0 ); fiberID < numFibers; fiberID++ )
   {
     vtkIdType   numPointsInCell(0);
     vtkIdType*  pointsInCell(NULL);
     vLines->GetNextCell ( numPointsInCell, pointsInCell );
 
     TractType::Pointer singleTract = TractType::New();
     for( int pointInCellID( 0 ); pointInCellID < numPointsInCell ; pointInCellID++)
     {
       // push back point
       PointType point = GetItkPoint( fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] ) );
       singleTract->InsertElement( singleTract->Size(), point );
     }
 
     //MappingStrategy strategy = EndElementPosition;
     //MappingStrategy strategy = JustEndPointVerticesNoLabel;
     MappingStrategy strategy = EndElementPositionAvoidingWhiteMatter;
     if ( singleTract && ( singleTract->Size() > 0 ) )
     {
       AddConnectionToNetwork( 
         ReturnAssociatedVertexPairForLabelPair( 
         ReturnLabelForFiberTract( singleTract, strategy ) 
         ) 
         );
     }
   }
 
   // provide network with geometry
   m_ConNetwork->SetGeometry( m_Segmentation->GetGeometry() );
+  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;
 
   // if vertices A and B exist
   if( vertexA && vertexB)
   {
     // 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
     if( ! ( m_LabelToNodePropertyMap.count( firstLabel ) > 0 ) )
     {
       NetworkNode firstNode;
 
       firstNode.coordinates.resize( 3 );
       for( unsigned int index = 0; index < firstNode.coordinates.size() ; index++ )
       {
         firstNode.coordinates[ index ] = firstElementSegIndex[ index ] ;
       }
 
       firstNode.label = LabelToString( firstLabel );
 
       m_LabelToNodePropertyMap.insert( std::pair< ImageLabelType, NetworkNode >( firstLabel, firstNode ) );
     }
 
     if( ! ( m_LabelToNodePropertyMap.count( lastLabel ) > 0 ) )
     {
       NetworkNode lastNode;
 
       lastNode.coordinates.resize( 3 );
       for( unsigned int index = 0; index < lastNode.coordinates.size() ; index++ )
       {
         lastNode.coordinates[ index ] = lastElementSegIndex[ index ] ; 
       }
 
       lastNode.label = LabelToString( lastLabel );
 
       m_LabelToNodePropertyMap.insert( std::pair< ImageLabelType, NetworkNode >( lastLabel, lastNode ) );
     }
   }
     
   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
     if( ! ( m_LabelToNodePropertyMap.count( firstLabel ) > 0 ) )
     {
       NetworkNode firstNode;
 
       firstNode.coordinates.resize( 3 );
       for( unsigned int index = 0; index < firstNode.coordinates.size() ; index++ )
       {
         firstNode.coordinates[ index ] = firstElementSegIndex[ index ] ;
       }
 
       firstNode.label = LabelToString( firstLabel );
 
       m_LabelToNodePropertyMap.insert( std::pair< ImageLabelType, NetworkNode >( firstLabel, firstNode ) );
     }
 
     if( ! ( m_LabelToNodePropertyMap.count( lastLabel ) > 0 ) )
     {
       NetworkNode lastNode;
 
       lastNode.coordinates.resize( 3 );
       for( unsigned int index = 0; index < lastNode.coordinates.size() ; index++ )
       {
         lastNode.coordinates[ index ] = lastElementSegIndex[ index ] ; 
       }
 
       lastNode.label = LabelToString( lastLabel );
 
       m_LabelToNodePropertyMap.insert( std::pair< ImageLabelType, NetworkNode >( lastLabel, lastNode ) );
     }
   }
 
   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
     if( ! ( m_LabelToNodePropertyMap.count( firstLabel ) > 0 ) )
     {
       NetworkNode firstNode;
 
       firstNode.coordinates.resize( 3 );
       for( unsigned int index = 0; index < firstNode.coordinates.size() ; index++ )
       {
         firstNode.coordinates[ index ] = firstElementSegIndex[ index ] ;
       }
 
       firstNode.label = LabelToString( firstLabel );
 
       m_LabelToNodePropertyMap.insert( std::pair< ImageLabelType, NetworkNode >( firstLabel, firstNode ) );
     }
 
     if( ! ( m_LabelToNodePropertyMap.count( lastLabel ) > 0 ) )
     {
       NetworkNode lastNode;
 
       lastNode.coordinates.resize( 3 );
       for( unsigned int index = 0; index < lastNode.coordinates.size() ; index++ )
       {
         lastNode.coordinates[ index ] = lastElementSegIndex[ index ] ; 
       }
 
       lastNode.label = LabelToString( lastLabel );
 
       m_LabelToNodePropertyMap.insert( std::pair< ImageLabelType, NetworkNode >( lastLabel, lastNode ) );
     }
   }
 
   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 )  
     );
 
   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 );
 
     // 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 ) )
       {
         label = tempLabel;
         mitkIndex = tempIndex;
         return;
       }
       // hit next point without finding brain matter
       currentRetractionIndex = currentRetractionIndex + retractionStepIndexSize;
       if( ( currentRetractionIndex < 1 ) || ( currentRetractionIndex > ( singleTract->Size() - 2 ) ) )
       {
         keepRetracting = false;
       }
     }
   }
 }
diff --git a/Modules/DiffusionImaging/Algorithms/Connectomics/mitkConnectomicsSyntheticNetworkGenerator.cpp b/Modules/DiffusionImaging/Algorithms/Connectomics/mitkConnectomicsSyntheticNetworkGenerator.cpp
index 927ae173c6..d71742d711 100644
--- a/Modules/DiffusionImaging/Algorithms/Connectomics/mitkConnectomicsSyntheticNetworkGenerator.cpp
+++ b/Modules/DiffusionImaging/Algorithms/Connectomics/mitkConnectomicsSyntheticNetworkGenerator.cpp
@@ -1,350 +1,352 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$ 
  
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkConnectomicsSyntheticNetworkGenerator.h"
 
 #include <sstream>
 #include <vector>
 
 #include "mitkConnectomicsConstantsManager.h"
 
 #include <vtkMatrix4x4.h>
 
 //for random number generation
 #include "vxl/core/vnl/vnl_random.h"
 #include "vxl/core/vnl/vnl_math.h"
 
 mitk::ConnectomicsSyntheticNetworkGenerator::ConnectomicsSyntheticNetworkGenerator()
 {
 }
 
 mitk::ConnectomicsSyntheticNetworkGenerator::~ConnectomicsSyntheticNetworkGenerator()
 {
 }
 
 mitk::ConnectomicsNetwork::Pointer mitk::ConnectomicsSyntheticNetworkGenerator::CreateSyntheticNetwork(int networkTypeId, int paramterOne, double parameterTwo)
 {
   mitk::ConnectomicsNetwork::Pointer network = mitk::ConnectomicsNetwork::New();
 
   // give the network an artificial geometry
   network->SetGeometry( this->GenerateDefaultGeometry() );
 
   switch (networkTypeId) {
   case 0:
     GenerateSyntheticCubeNetwork( network, paramterOne, parameterTwo );
     break;
   case 1:
     GenerateSyntheticCenterToSurfaceNetwork( network, paramterOne, parameterTwo );
     break;
   case 2:
     GenerateSyntheticRandomNetwork( network, paramterOne, parameterTwo );
     break;
   case 3:
     //GenerateSyntheticScaleFreeNetwork( network, 1000 );
     break;
   case 4:
     //GenerateSyntheticSmallWorldNetwork( network, 1000 );
     break;
   default:
     MBI_ERROR << "Unrecognized Network ID";
   }
 
+  network->UpdateBounds();
+
   return network;
 
 }
 
 mitk::Geometry3D::Pointer mitk::ConnectomicsSyntheticNetworkGenerator::GenerateDefaultGeometry()
 {
   mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
 
   double zero( 0.0 );
   double one( 1.0 );
   // origin = {0,0,0}
   mitk::Point3D origin;
 
   origin[0] = zero;
   origin[1] = zero;
   origin[2] = zero;
   geometry->SetOrigin(origin);
 
   // spacing = {1,1,1}
   float spacing[3];
   spacing[0] = one;
   spacing[1] = one;
   spacing[2] = one;
   geometry->SetSpacing(spacing);
 
   // transform 
   vtkMatrix4x4* transformMatrix = vtkMatrix4x4::New();
   transformMatrix->SetElement(0,0,one);
   transformMatrix->SetElement(1,0,zero);
   transformMatrix->SetElement(2,0,zero);
   transformMatrix->SetElement(0,1,zero);
   transformMatrix->SetElement(1,1,one);
   transformMatrix->SetElement(2,1,zero);
   transformMatrix->SetElement(0,2,zero);
   transformMatrix->SetElement(1,2,zero);
   transformMatrix->SetElement(2,2,one);
 
   transformMatrix->SetElement(0,3,origin[0]);
   transformMatrix->SetElement(1,3,origin[1]);
   transformMatrix->SetElement(2,3,origin[2]);
   transformMatrix->SetElement(3,3,1);
   geometry->SetIndexToWorldTransformByVtkMatrix( transformMatrix );
 
   geometry->SetImageGeometry(true);
 
   return geometry;
 }
 
 void mitk::ConnectomicsSyntheticNetworkGenerator::GenerateSyntheticCubeNetwork( 
   mitk::ConnectomicsNetwork::Pointer network, int cubeExtent, double distance )
 {
   // map for storing the conversion from indices to vertex descriptor
   std::map< int, mitk::ConnectomicsNetwork::VertexDescriptorType > idToVertexMap;
 
   int vertexID(0);
   for( int loopX( 0 ); loopX < cubeExtent; loopX++  )
   {
     for( int loopY( 0 ); loopY < cubeExtent; loopY++  )
     {
       for( int loopZ( 0 ); loopZ < cubeExtent; loopZ++  )
       {
         std::vector< float > position;
         std::string label;
         std::stringstream labelStream;
         labelStream << vertexID;
         label = labelStream.str();
 
         position.push_back( loopX * distance );
         position.push_back( loopY * distance );
         position.push_back( loopZ * distance );
 
         mitk::ConnectomicsNetwork::VertexDescriptorType newVertex = network->AddVertex( vertexID );
         network->SetLabel( newVertex, label );
         network->SetCoordinates( newVertex, position );
 
         if ( idToVertexMap.count( vertexID ) > 0 )
         {
           MITK_ERROR << "Aborting network creation, duplicate vertex ID generated.";
           return;
         }
         idToVertexMap.insert( std::pair< int, mitk::ConnectomicsNetwork::VertexDescriptorType >( vertexID, newVertex) );
 
         vertexID++;
       }
     }
   }
 
   int edgeID(0), edgeSourceID(0), edgeTargetID(0); 
   // uniform weight of one
   int edgeWeight(1);
 
   mitk::ConnectomicsNetwork::VertexDescriptorType source;
   mitk::ConnectomicsNetwork::VertexDescriptorType target;
 
   for( int loopX( 0 ); loopX < cubeExtent; loopX++  )
   {
     for( int loopY( 0 ); loopY < cubeExtent; loopY++  )
     {
       for( int loopZ( 0 ); loopZ < cubeExtent; loopZ++  )
       {
         // to avoid creating an edge twice (this being an undirected graph) we only generate
         // edges in three directions, the others will be supplied by the corresponding nodes
         if( loopX != 0 )
         {
           edgeTargetID = edgeSourceID - cubeExtent * cubeExtent;
 
           source = idToVertexMap.find( edgeSourceID )->second;
           target = idToVertexMap.find( edgeTargetID )->second;
           network->AddEdge( source, target, edgeSourceID, edgeTargetID, edgeWeight);
 
           edgeID++;
         }
         if( loopY != 0 )
         {
           edgeTargetID = edgeSourceID - cubeExtent;
 
           source = idToVertexMap.find( edgeSourceID )->second;
           target = idToVertexMap.find( edgeTargetID )->second;
           network->AddEdge( source, target, edgeSourceID, edgeTargetID, edgeWeight);
 
           edgeID++;
         }
         if( loopZ != 0 )
         {
           edgeTargetID = edgeSourceID - 1;
 
           source = idToVertexMap.find( edgeSourceID )->second;
           target = idToVertexMap.find( edgeTargetID )->second;
           network->AddEdge( source, target, edgeSourceID, edgeTargetID, edgeWeight);
 
           edgeID++;
         }
 
         edgeSourceID++;
       } // end for( int loopZ( 0 ); loopZ < cubeExtent; loopZ++  )
     } // end for( int loopY( 0 ); loopY < cubeExtent; loopY++  )
   } // end for( int loopX( 0 ); loopX < cubeExtent; loopX++  )
 }
 
 void mitk::ConnectomicsSyntheticNetworkGenerator::GenerateSyntheticCenterToSurfaceNetwork( 
   mitk::ConnectomicsNetwork::Pointer network, int numberOfPoints, double radius )
 {
   //the random number generators
   unsigned int randomOne = (unsigned int) rand();
   unsigned int randomTwo = (unsigned int) rand();
 
   vnl_random rng( (unsigned int) rand() );
   vnl_random rng2( (unsigned int) rand() );
 
   mitk::ConnectomicsNetwork::VertexDescriptorType centerVertex;
   int vertexID(0);
   { //add center vertex
     std::vector< float > position;
     std::string label;
     std::stringstream labelStream;
     labelStream << vertexID;
     label = labelStream.str();
 
     position.push_back( 0 );
     position.push_back( 0 );
     position.push_back( 0 );
 
     centerVertex = network->AddVertex( vertexID );
     network->SetLabel( centerVertex, label );
     network->SetCoordinates( centerVertex, position );
   }//end add center vertex
 
   // uniform weight of one
   int edgeWeight(1);
 
   mitk::ConnectomicsNetwork::VertexDescriptorType source;
   mitk::ConnectomicsNetwork::VertexDescriptorType target;
 
   //add vertices on sphere surface
   for( int loopID( 1 ); loopID < numberOfPoints; loopID++  )
   {
 
     std::vector< float > position;
     std::string label;
     std::stringstream labelStream;
     labelStream << loopID;
     label = labelStream.str();
 
     //generate random, uniformly distributed points on a sphere surface
     const double uVariable = rng.drand64( 0.0 , 1.0);
     const double vVariable = rng.drand64( 0.0 , 1.0);
     const double phi = 2 * vnl_math::pi * uVariable;
     const double theta = std::acos( 2 * vVariable - 1 );
 
     double xpos = radius * std::cos( phi ) * std::sin( theta );
     double ypos = radius * std::sin( phi ) * std::sin( theta );
     double zpos = radius * std::cos( theta );
 
     position.push_back( xpos );
     position.push_back( ypos );
     position.push_back( zpos );
 
     mitk::ConnectomicsNetwork::VertexDescriptorType newVertex = network->AddVertex( loopID );
     network->SetLabel( newVertex, label );
     network->SetCoordinates( newVertex, position );
 
     network->AddEdge( newVertex, centerVertex, loopID, 0, edgeWeight);
   }
 }
 
 void mitk::ConnectomicsSyntheticNetworkGenerator::GenerateSyntheticRandomNetwork(
   mitk::ConnectomicsNetwork::Pointer network, int numberOfPoints, double threshold )
 {
   // as the surface is proportional to the square of the radius the density stays the same
   double radius = 5 * std::sqrt( (float) numberOfPoints );
 
   //the random number generators
   unsigned int randomOne = (unsigned int) rand();
   unsigned int randomTwo = (unsigned int) rand();
 
   vnl_random rng( (unsigned int) rand() );
   vnl_random rng2( (unsigned int) rand() );
 
   // map for storing the conversion from indices to vertex descriptor
   std::map< int, mitk::ConnectomicsNetwork::VertexDescriptorType > idToVertexMap;
 
   //add vertices on sphere surface
   for( int loopID( 0 ); loopID < numberOfPoints; loopID++  )
   {
 
     std::vector< float > position;
     std::string label;
     std::stringstream labelStream;
     labelStream << loopID;
     label = labelStream.str();
 
     //generate random, uniformly distributed points on a sphere surface
     const double uVariable = rng.drand64( 0.0 , 1.0);
     const double vVariable = rng.drand64( 0.0 , 1.0);
     const double phi = 2 * vnl_math::pi * uVariable;
     const double theta = std::acos( 2 * vVariable - 1 );
 
     double xpos = radius * std::cos( phi ) * std::sin( theta );
     double ypos = radius * std::sin( phi ) * std::sin( theta );
     double zpos = radius * std::cos( theta );
 
     position.push_back( xpos );
     position.push_back( ypos );
     position.push_back( zpos );
 
     mitk::ConnectomicsNetwork::VertexDescriptorType newVertex = network->AddVertex( loopID );
     network->SetLabel( newVertex, label );
     network->SetCoordinates( newVertex, position );
 
     if ( idToVertexMap.count( loopID ) > 0 )
     {
       MITK_ERROR << "Aborting network creation, duplicate vertex ID generated.";
       return;
     }
     idToVertexMap.insert( std::pair< int, mitk::ConnectomicsNetwork::VertexDescriptorType >( loopID, newVertex) );
   }
 
   int edgeID(0); 
   // uniform weight of one
   int edgeWeight(1);
 
   mitk::ConnectomicsNetwork::VertexDescriptorType source;
   mitk::ConnectomicsNetwork::VertexDescriptorType target;
 
   for( int loopID( 0 ); loopID < numberOfPoints; loopID++  )
   {
     // to avoid creating an edge twice (this being an undirected graph) we only 
     // potentially generate edges with all nodes with a bigger ID
     for( int innerLoopID( loopID ); innerLoopID < numberOfPoints; innerLoopID++  )
     {
       if( rng.drand64( 0.0 , 1.0) > threshold)
       {
         // do nothing
       } 
       else 
       {
         source = idToVertexMap.find( loopID )->second;
         target = idToVertexMap.find( innerLoopID )->second;
         network->AddEdge( source, target, loopID, innerLoopID, edgeWeight);
 
         edgeID++;
       }
     } // end for( int innerLoopID( loopID ); innerLoopID < numberOfPoints; innerLoopID++  )
   } // end for( int loopID( 0 ); loopID < numberOfPoints; loopID++  )
 }
\ No newline at end of file
diff --git a/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetwork.cpp b/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetwork.cpp
index 144e4227c5..b93ae625d4 100644
--- a/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetwork.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetwork.cpp
@@ -1,454 +1,505 @@
 
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date$
 Version:   $Revision: 11989 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkConnectomicsNetwork.h"
 #include <boost/graph/clustering_coefficient.hpp>
 
 /* Constructor and Destructor */
 mitk::ConnectomicsNetwork::ConnectomicsNetwork()
 : m_IsModified( false )
 {
 }
 
 mitk::ConnectomicsNetwork::~ConnectomicsNetwork()
 {
 }
 
 /* Wrapper methods */
 
 bool mitk::ConnectomicsNetwork::EdgeExists( 
   mitk::ConnectomicsNetwork::VertexDescriptorType vertexA, mitk::ConnectomicsNetwork::VertexDescriptorType vertexB ) const
 {
   return boost::edge(vertexA, vertexB, m_Network ).second;
 }
 
 void mitk::ConnectomicsNetwork::IncreaseEdgeWeight( 
   mitk::ConnectomicsNetwork::VertexDescriptorType vertexA, mitk::ConnectomicsNetwork::VertexDescriptorType vertexB )
 {
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].weight++;
 
   SetIsModified( true );
 }
 
 void mitk::ConnectomicsNetwork::AddEdge( 
                                         mitk::ConnectomicsNetwork::VertexDescriptorType vertexA, 
                                         mitk::ConnectomicsNetwork::VertexDescriptorType vertexB
                                         )
 {
   AddEdge(vertexA, vertexB, m_Network[ vertexA ].id, m_Network[ vertexB ].id );
 }
 
 void mitk::ConnectomicsNetwork::AddEdge( 
                                         mitk::ConnectomicsNetwork::VertexDescriptorType vertexA, 
                                         mitk::ConnectomicsNetwork::VertexDescriptorType vertexB, 
                                         int sourceID, int targetID, int weight )
 {
   boost::add_edge( vertexA, vertexB, m_Network );
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].sourceId = sourceID;
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].targetId = targetID;
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].weight = weight;
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].edge_weight = 1.0;
 
   SetIsModified( true );
 }
 
 mitk::ConnectomicsNetwork::VertexDescriptorType mitk::ConnectomicsNetwork::AddVertex( int id )
 {
   VertexDescriptorType vertex = boost::add_vertex( m_Network );
   m_Network[vertex].id = id;
 
   SetIsModified( true );
 
   return vertex;
 }
 
 void mitk::ConnectomicsNetwork::SetLabel( 
   mitk::ConnectomicsNetwork::VertexDescriptorType vertex, std::string inLabel )
 {
   m_Network[vertex].label = inLabel;
 
   SetIsModified( true );
 }
 
 void mitk::ConnectomicsNetwork::SetCoordinates( 
   mitk::ConnectomicsNetwork::VertexDescriptorType vertex, std::vector< float > inCoordinates )
 {
   m_Network[vertex].coordinates = inCoordinates;
 
   SetIsModified( true );
 }
 
 void mitk::ConnectomicsNetwork::clear()
 {
   m_Network.clear();
 
   SetIsModified( true );
 }
 
 /* Superclass methods, that need to be implemented */
 void mitk::ConnectomicsNetwork::UpdateOutputInformation()
 {
 
 }
 void mitk::ConnectomicsNetwork::SetRequestedRegionToLargestPossibleRegion()
 {
 
 }
 bool mitk::ConnectomicsNetwork::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   return false;
 }
 bool mitk::ConnectomicsNetwork::VerifyRequestedRegion()
 {
   return true;
 }
 void mitk::ConnectomicsNetwork::SetRequestedRegion( itk::DataObject *data )
 {
 
 }
 
 
 
 std::vector< mitk::ConnectomicsNetwork::NetworkNode > 
 mitk::ConnectomicsNetwork::GetVectorOfAllNodes() const
 {
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::vertices( m_Network );
 
   std::vector< NetworkNode > vectorOfNodes;
 
   for ( ; iterator != end; ++iterator)
   {
     NetworkNode tempNode;
 
     // the value of an iterator is a descriptor
     tempNode = m_Network[ *iterator ];
 
     vectorOfNodes.push_back( tempNode );
   }
 
   return vectorOfNodes;
 }
 
 std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType > 
 mitk::ConnectomicsNetwork::GetVectorOfAllVertexDescriptors() const
 {
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::vertices( m_Network );
 
   std::vector< VertexDescriptorType > vectorOfDescriptors;
 
   for ( ; iterator != end; ++iterator)
   {
     vectorOfDescriptors.push_back( *iterator );
   }
 
   return vectorOfDescriptors;
 }
 
 std::vector< std::pair< 
 std::pair< mitk::ConnectomicsNetwork::NetworkNode, mitk::ConnectomicsNetwork::NetworkNode > 
 , mitk::ConnectomicsNetwork::NetworkEdge > > 
 mitk::ConnectomicsNetwork::GetVectorOfAllEdges() const
 {
   boost::graph_traits<NetworkType>::edge_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::edges( m_Network );
 
   std::vector< 
     std::pair< 
     std::pair< NetworkNode, NetworkNode > 
     , NetworkEdge 
     > 
   > vectorOfEdges;
 
   for ( ; iterator != end; ++iterator)
   {
     NetworkNode sourceNode, targetNode;
     NetworkEdge tempEdge;
 
     // the value of an iterator is a descriptor
     tempEdge = m_Network[ *iterator ];
     sourceNode = m_Network[ boost::source( *iterator, m_Network ) ];
     targetNode = m_Network[ boost::target( *iterator, m_Network ) ];
 
     std::pair< NetworkNode, NetworkNode > nodePair( sourceNode, targetNode );
     std::pair< std::pair< NetworkNode, NetworkNode > , NetworkEdge > edgePair( nodePair, tempEdge);
     vectorOfEdges.push_back( edgePair );
   }
 
   return vectorOfEdges;
 }
 
 int mitk::ConnectomicsNetwork::GetNumberOfVertices() const
 {
   return boost::num_vertices( m_Network );
 }
 
 int mitk::ConnectomicsNetwork::GetNumberOfEdges()
 {
   return boost::num_edges( m_Network );
 }
 
 int mitk::ConnectomicsNetwork::GetMaximumWeight() const
 {
   int maxWeight( 0 );
 
   boost::graph_traits<NetworkType>::edge_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::edges( m_Network );
 
   for ( ; iterator != end; ++iterator)
   {
     int tempWeight;
 
     // the value of an iterator is a descriptor
     tempWeight = m_Network[ *iterator ].weight;
 
     if( tempWeight > maxWeight )
     {
       maxWeight = tempWeight;
     }
   }
 
   return maxWeight;
 }
 
 int mitk::ConnectomicsNetwork::GetNumberOfSelfLoops()
 {
   int noOfSelfLoops( 0 );
 
   std::vector< std::pair< std::pair< NetworkNode, NetworkNode > , NetworkEdge > > 
     edgeVector =  GetVectorOfAllEdges();
 
   for( int index = 0; index < edgeVector.size() ; index++ )
   {
     double sourceX, sourceY, sourceZ, targetX, targetY, targetZ;
 
     sourceX = edgeVector[ index ].first.first.coordinates[0] ;
     sourceY = edgeVector[ index ].first.first.coordinates[1] ;
     sourceZ = edgeVector[ index ].first.first.coordinates[2] ;
     targetX = edgeVector[ index ].first.second.coordinates[0] ;
     targetY = edgeVector[ index ].first.second.coordinates[1] ;
     targetZ = edgeVector[ index ].first.second.coordinates[2] ;
 
     // if the coordinates are the same
     if(
       sourceX > ( targetX - 0.01 ) && 
       sourceX < ( targetX + 0.01 ) &&
       sourceY > ( targetY - 0.01 ) && 
       sourceY < ( targetY + 0.01 ) &&
       sourceZ > ( targetZ - 0.01 ) && 
       sourceZ < ( targetZ + 0.01 )
       )
     {
       noOfSelfLoops++;
     }
   }
 
   return noOfSelfLoops;
 }
 
 double mitk::ConnectomicsNetwork::GetAverageDegree()
 {
   double vertices = (double) GetNumberOfVertices();
   double edges = (double) GetNumberOfEdges();
 
   return ( ( edges * 2.0 ) / vertices );
 }
 
 double mitk::ConnectomicsNetwork::GetConnectionDensity()
 {
   double vertices = (double) GetNumberOfVertices();
   double edges = (double) GetNumberOfEdges();
   double numberOfPossibleEdges = vertices * ( vertices - 1 ) / 2 ;
 
   return ( edges / numberOfPossibleEdges );
 }
 
 std::vector< int > mitk::ConnectomicsNetwork::GetDegreeOfNodes( ) const
 {
   std::vector< int > vectorOfDegree;
 
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie( iterator, end ) = boost::vertices( m_Network );
 
   vectorOfDegree.resize( this->GetNumberOfVertices() );
 
   for ( ; iterator != end; ++iterator)
   {
     // the value of an iterator is a descriptor
     vectorOfDegree[ m_Network[ *iterator ].id ] = GetVectorOfAdjacentNodes( *iterator ).size();
   }
   return vectorOfDegree;
 }
 
 std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType > 
 mitk::ConnectomicsNetwork::GetVectorOfAdjacentNodes( mitk::ConnectomicsNetwork::VertexDescriptorType vertex ) const
 {
   std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType > vectorOfAdjacentNodes;
 
   boost::graph_traits<NetworkType>::adjacency_iterator adjIter, adjEnd;
 
   boost::tie( adjIter, adjEnd ) = boost::adjacent_vertices( vertex, m_Network);
 
   for ( ; adjIter != adjEnd; ++adjIter)
   {
     vectorOfAdjacentNodes.push_back( *adjIter );
   }
 
   return vectorOfAdjacentNodes;
 }
 
 int mitk::ConnectomicsNetwork::GetMaximumDegree() const
 {
   int maximumDegree( 0 );
 
   std::vector< int > vectorOfDegree = GetDegreeOfNodes();
 
   for( int index( 0 ); index < vectorOfDegree.size(); ++index )
   {
     if( maximumDegree < vectorOfDegree[ index ] )
     {
       maximumDegree = vectorOfDegree[ index ];
     }
   }
 
   return maximumDegree;
 }
 
 std::vector< double > mitk::ConnectomicsNetwork::GetLocalClusteringCoefficients( )
 {
   std::vector< double > vectorOfClusteringCoefficients;
 
   typedef boost::graph_traits<NetworkType>::vertex_iterator vertexIter;
 
   vectorOfClusteringCoefficients.resize( this->GetNumberOfVertices() );
 
   std::pair<vertexIter, vertexIter> vertexPair;
 
   //for every vertex calculate the clustering coefficient
   for (vertexPair = vertices(m_Network); vertexPair.first != vertexPair.second; ++vertexPair.first) 
   {
     vectorOfClusteringCoefficients[ m_Network[ *vertexPair.first ].id ] = 
       boost::clustering_coefficient(m_Network,*vertexPair.first) ;        
   }
 
   return vectorOfClusteringCoefficients;
 }
 
 std::vector< double > mitk::ConnectomicsNetwork::GetClusteringCoefficientsByDegree( )
 {
   std::vector< double > vectorOfClusteringCoefficients = GetLocalClusteringCoefficients();
   std::vector< int > vectorOfDegree = GetDegreeOfNodes();
 
   std::vector< double > vectorOfClusteringCoefficientsByDegree;
   vectorOfClusteringCoefficientsByDegree.resize( GetMaximumDegree() + 1, 0 );
 
   // c_{mean}(k) = frac{1}_{N_{k}} sum_{i in Y(k)} c_{i}
   // where N_{k} is the number of vertices of degree k
   // Y(k) is the set of vertices of degree k
   // c_{i} is the local clustering coefficient of vertex i
   for( int degree( 0 ); degree < vectorOfClusteringCoefficientsByDegree.size(); ++degree )
   {
     vectorOfClusteringCoefficientsByDegree[ degree ] = 0;
     int n_k( 0 );
     for( int index( 0 ); index < vectorOfDegree.size(); ++index )
     {
       if( degree == vectorOfDegree[ index ] )
       {// if in Y( degree )
         vectorOfClusteringCoefficientsByDegree[ degree ] += vectorOfClusteringCoefficients[ index ];
         n_k++;
       }
     }
     if( n_k != 0 )
     {
       vectorOfClusteringCoefficientsByDegree[ degree ] =
         vectorOfClusteringCoefficientsByDegree[ degree ] / n_k;
     }
   }
 
   return vectorOfClusteringCoefficientsByDegree;
 }
 
 double mitk::ConnectomicsNetwork::GetGlobalClusteringCoefficient( )
 {
   double globalClusteringCoefficient( 0.0 );
 
   std::vector< double > vectorOfClusteringCoefficientsByDegree = GetClusteringCoefficientsByDegree();
   std::vector< int > vectorOfDegree = GetDegreeOfNodes();
   std::vector< int > degreeDistribution;
   degreeDistribution.resize( vectorOfClusteringCoefficientsByDegree.size(), 0 );
 
   int normalizationParameter( 0 );
 
   for( int index( 0 ); index < vectorOfDegree.size(); ++index )
   {
     degreeDistribution[ vectorOfDegree[ index ] ]++;
     normalizationParameter++;
   }
   // c_{mean} = sum_{k} P_{k} c_{mean}(k)
   // where P_{k} is the degree distribution
   // k is the degree
   for( int degree( 0 ); degree < degreeDistribution.size(); ++degree )
   {
     globalClusteringCoefficient += 
       degreeDistribution[ degree ] / ( (double) normalizationParameter) 
       * vectorOfClusteringCoefficientsByDegree[ degree ];
   }
 
   return globalClusteringCoefficient;
 }
 
 mitk::ConnectomicsNetwork::NetworkType* mitk::ConnectomicsNetwork::GetBoostGraph()
 {
   return &m_Network;
 }
 
 
 bool mitk::ConnectomicsNetwork::GetIsModified() const
 {
   return m_IsModified;
 }
 
 
 void mitk::ConnectomicsNetwork::SetIsModified( bool value)
 {
   m_IsModified = value;
 }
 
 
 mitk::ConnectomicsNetwork::NetworkNode mitk::ConnectomicsNetwork::GetNode( VertexDescriptorType vertex ) const
 {
   return m_Network[ vertex ];
 }
 
 
 mitk::ConnectomicsNetwork::NetworkEdge mitk::ConnectomicsNetwork::GetEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB ) const
 {
   return m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ];
+}
+
+void mitk::ConnectomicsNetwork::UpdateBounds( )
+{
+  float min = itk::NumericTraits<float>::min();
+  float max = itk::NumericTraits<float>::max();
+  float bounds[] = {max, min, max, min, max, min};
+
+  std::vector< mitk::ConnectomicsNetwork::NetworkNode > nodeVector = this->GetVectorOfAllNodes();
+
+  if( nodeVector.size() == 0 )
+  {
+    bounds[0] = 0;
+    bounds[1] = 1;
+    bounds[2] = 0;
+    bounds[3] = 1;
+    bounds[4] = 0;
+    bounds[5] = 1;
+  }
+
+  // for each direction, make certain the point is in between
+  for( int index(0), end(nodeVector.size()) ; index < end; index++ )
+  {
+    for( int direction(0); direction < nodeVector.at( index ).coordinates.size(); direction++ )
+    {
+      if( nodeVector.at( index ).coordinates.at(direction) < bounds[ 2 * direction ]  )
+      {
+        bounds[ 2 * direction ] = nodeVector.at( index ).coordinates.at(direction);
+      }
+
+      if( nodeVector.at( index ).coordinates.at(direction) > bounds[ 2 * direction + 1]  )
+      {
+        bounds[ 2 * direction + 1] = nodeVector.at( index ).coordinates.at(direction);
+      }
+    }
+  }
+
+
+  // provide some border margin
+  for(int i=0; i<=4; i+=2)
+  {
+    bounds[i] -=10;
+  }
+
+  for(int i=1; i<=5; i+=2)
+  {
+    bounds[i] +=10;
+  }
+
+  this->GetGeometry()->SetFloatBounds(bounds);
+  this->GetTimeSlicedGeometry()->UpdateInformation();
 }
\ No newline at end of file
diff --git a/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetwork.h b/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetwork.h
index 0f60898443..bed837ce1e 100644
--- a/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetwork.h
+++ b/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetwork.h
@@ -1,177 +1,180 @@
 
 /*=========================================================================
 
  Program:   Medical Imaging & Interaction Toolkit
  Module:    $RCSfile$
  Language:  C++
  Date:      $Date$
  Version:   $Revision: 11989 $
 
  Copyright (c) German Cancer Research Center, Division of Medical and
  Biological Informatics. All rights reserved.
  See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.  See the above copyright notices for more information.
 
  =========================================================================*/
 
 
 #ifndef _MITK_ConnectomicsNetwork_H
 #define _MITK_ConnectomicsNetwork_H
 
 #include "MitkDiffusionImagingExports.h"
 
 #include "mitkBaseData.h"
 
 #include <boost/graph/adjacency_list.hpp>
 
 namespace mitk {
 
   /**
   * \brief Base Class for Connectomics Networks   */
   class MitkDiffusionImaging_EXPORT ConnectomicsNetwork : public BaseData
   {
   public:
     /** Structs for the graph */
 
     /** The Node */
     struct NetworkNode
     {
       int id;
       std::string label;
       std::vector< float > coordinates;
     };
 
     /** The Edge */
     struct NetworkEdge
     {
       int sourceId;
       int targetId;
       int weight; // For now the number of times it was present
       double edge_weight; // For boost, currently set to 1 by default for unweighted calculations
     };
 
     /** Typedefs **/
     //typedef boost::adjacency_list< boost::listS, boost::listS, boost::undirectedS, NetworkNode, NetworkEdge > NetworkType;
     typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::undirectedS, NetworkNode, NetworkEdge > NetworkType;
     typedef boost::graph_traits<NetworkType>::vertex_descriptor VertexDescriptorType;
     typedef boost::graph_traits<NetworkType>::edge_descriptor EdgeDescriptorType;
 
     // virtual methods that need to be implemented
     virtual void UpdateOutputInformation();
     virtual void SetRequestedRegionToLargestPossibleRegion();
     virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
     virtual bool VerifyRequestedRegion();
     virtual void SetRequestedRegion( itk::DataObject *data );
 
 
     // Macros
     mitkClassMacro( ConnectomicsNetwork, BaseData );
     itkNewMacro( Self );
 
     ////////////////// Interface ///////////////////
     /** return whether an edge exists between the two given vertices */
     bool EdgeExists( VertexDescriptorType vertexA, VertexDescriptorType vertexB ) const; 
 
     /** increase the weight of an edge between the two given vertices */
     void IncreaseEdgeWeight( VertexDescriptorType vertexA, VertexDescriptorType vertexB );
 
     /** add an edge between two given vertices */
     void AddEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB);
 
     /** add an edge between two given vertices ( with a specific weight ) */
     void AddEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB, int sourceID, int targetID, int weight = 1 );
 
     /** add a vertex with a specified id */
     VertexDescriptorType AddVertex( int id);
 
     /** set the label of a vertex */
     void SetLabel( VertexDescriptorType vertex, std::string inLabel );
 
     /** set the coordinates of a vertex */
     void SetCoordinates( VertexDescriptorType vertex, std::vector< float > inCoordinates );
 
     /** clear the graph */
     void clear();
 
     /** return the node struct for a given node descriptor */
     NetworkNode GetNode( VertexDescriptorType vertex ) const;
 
     /** return the edge struct for two given node descriptors */
     NetworkEdge GetEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB ) const;
 
     /** get vector containing all the nodes of the network */
     std::vector< NetworkNode > GetVectorOfAllNodes() const;
 
     /** get vector containing all the vertex descriptors of the network */
     std::vector< VertexDescriptorType > GetVectorOfAllVertexDescriptors() const;
 
     /** get vector containing the descriptors of nodes adjacent to the vertex denoted by the given descriptor  */
     std::vector< VertexDescriptorType > GetVectorOfAdjacentNodes( VertexDescriptorType vertex ) const;
 
     /** get vector containing all the edges of the network and the connected nodes */
     std::vector< std::pair< std::pair< NetworkNode, NetworkNode > , NetworkEdge > > GetVectorOfAllEdges() const;
 
     /** get overall number of vertices in the network */
     int GetNumberOfVertices() const;
 
     /** get overall number of edges in the network */
     int GetNumberOfEdges();
 
     /** get number of vertices, that are connected to themselves */
     int GetNumberOfSelfLoops();
 
     /** get number of vertices, that are connected to themselves */
     double GetAverageDegree();
 
     /** get number of edges divided by number of possible edges */
     double GetConnectionDensity();
 
     /** Get the maximum weight of all edges */
     int GetMaximumWeight() const;
 
     /** Get a vector in the format vector[ vertexID ] = degree */
     std::vector< int > GetDegreeOfNodes( ) const;
 
     /** Get the maximum degree of all nodes */
     int GetMaximumDegree() const;
 
     /** Get a vector in the format vector[ vertexID ] = clustering coefficient */
     std::vector< double > GetLocalClusteringCoefficients( );
 
     /** Get a vector in the format vector[ degree ] = average clustering coefficient */
     std::vector< double > GetClusteringCoefficientsByDegree( );
 
     /** Get the global clustering coefficient */
     double GetGlobalClusteringCoefficient( );
 
     /** Access boost graph directly */
     NetworkType* GetBoostGraph();
 
     /** Get the modified flag */
     bool GetIsModified() const;
 
     /** Set the modified flag */
     void SetIsModified( bool );
 
+    /** Update the bounds of the geometry to fit the network */
+    void UpdateBounds( );
+
   protected:
     ConnectomicsNetwork();
     virtual ~ConnectomicsNetwork();
 
     NetworkType m_Network;
 
     /// Flag which indicates whether the network has been modified since the last check
     ///
     /// mainly for rendering purposes
 
     bool m_IsModified;
 
   private:
 
   };
 
 } // namespace mitk
 
 #endif /*  _MITK_ConnectomicsNetwork_H */
diff --git a/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetworkReader.cpp b/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetworkReader.cpp
index a1d3fcd1e2..0d6a39a44a 100644
--- a/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetworkReader.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/ConnectomicsNetwork/mitkConnectomicsNetworkReader.cpp
@@ -1,252 +1,253 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-07-14 19:11:20 +0200 (Tue, 14 Jul 2009) $
 Version:   $Revision: 18127 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkConnectomicsNetworkReader.h"
 #include "mitkConnectomicsNetworkDefinitions.h"
 #include <tinyxml.h>
 #include "itksys/SystemTools.hxx"
 #include <vtkMatrix4x4.h>
 
 void mitk::ConnectomicsNetworkReader::GenerateData()
 {
   MITK_INFO << "Reading connectomics network";
   if ( ( ! m_OutputCache ) )
   {
     Superclass::SetNumberOfRequiredOutputs(0);
     this->GenerateOutputInformation();
   }
 
   if (!m_OutputCache)
   {
     itkWarningMacro("Tree cache is empty!");
   }
 
 
   Superclass::SetNumberOfRequiredOutputs(1);
   Superclass::SetNthOutput(0, m_OutputCache.GetPointer());
 }
 
 void mitk::ConnectomicsNetworkReader::GenerateOutputInformation()
 {
   m_OutputCache = OutputType::New();
 
   std::string ext = itksys::SystemTools::GetFilenameLastExtension(m_FileName);
   ext = itksys::SystemTools::LowerCase(ext);
 
   if ( m_FileName == "")
   {
     MITK_ERROR << "No file name specified.";
   }
   else if (ext == ".cnf")
   {
     try
     {
       TiXmlDocument doc( m_FileName );
       doc.LoadFile();
 
       TiXmlHandle hDoc(&doc);
       TiXmlElement* pElem;
       TiXmlHandle hRoot(0);
 
       pElem = hDoc.FirstChildElement().Element();
 
       // save this for later
       hRoot = TiXmlHandle(pElem);
 
       pElem = hRoot.FirstChildElement(mitk::ConnectomicsNetworkDefinitions::XML_GEOMETRY).Element();
 
       // read geometry
       mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
 
       // read origin
       mitk::Point3D origin;
       double temp = 0;
       pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_ORIGIN_X, &temp);
       origin[0] = temp;
       pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_ORIGIN_Y, &temp);
       origin[1] = temp;
       pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_ORIGIN_Z, &temp);
       origin[2] = temp;
       geometry->SetOrigin(origin);
 
       // read spacing
       float spacing[3];
       pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_SPACING_X, &temp);
       spacing[0] = temp;
       pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_SPACING_Y, &temp);
       spacing[1] = temp;
       pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_SPACING_Z, &temp);
       spacing[2] = temp;
       geometry->SetSpacing(spacing);
 
       // read transform
       vtkMatrix4x4* m = vtkMatrix4x4::New();
       pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_XX, &temp);
       m->SetElement(0,0,temp);
       pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_XY, &temp);
       m->SetElement(1,0,temp);
       pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_XZ, &temp);
       m->SetElement(2,0,temp);
       pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_YX, &temp);
       m->SetElement(0,1,temp);
       pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_YY, &temp);
       m->SetElement(1,1,temp);
       pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_YZ, &temp);
       m->SetElement(2,1,temp);
       pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_ZX, &temp);
       m->SetElement(0,2,temp);
       pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_ZY, &temp);
       m->SetElement(1,2,temp);
       pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_ZZ, &temp);
       m->SetElement(2,2,temp);
 
       m->SetElement(0,3,origin[0]);
       m->SetElement(1,3,origin[1]);
       m->SetElement(2,3,origin[2]);
       m->SetElement(3,3,1);
       geometry->SetIndexToWorldTransformByVtkMatrix(m);
 
       geometry->SetImageGeometry(true);
       m_OutputCache->SetGeometry(geometry);
 
       // read network
       std::map< int, mitk::ConnectomicsNetwork::VertexDescriptorType > idToVertexMap;
       // read vertices
       pElem = hRoot.FirstChildElement(mitk::ConnectomicsNetworkDefinitions::XML_VERTICES).Element();
       {
         // walk through the vertices
         TiXmlElement* vertexElement = pElem->FirstChildElement();
 
         for( vertexElement; vertexElement; vertexElement=vertexElement->NextSiblingElement())
         {
           std::vector< float > pos;
           std::string label;
           int vertexID(0);
 
           vertexElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_X, &temp);
           pos.push_back(temp);
           vertexElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_Y, &temp);
           pos.push_back(temp);
           vertexElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_Z, &temp);
           pos.push_back(temp);
           vertexElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_ID, &vertexID);
           vertexElement->QueryStringAttribute(mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_LABEL, &label);
 
           mitk::ConnectomicsNetwork::VertexDescriptorType newVertex = m_OutputCache->AddVertex( vertexID );
           m_OutputCache->SetLabel( newVertex, label );
           m_OutputCache->SetCoordinates( newVertex, pos );
 
           if ( idToVertexMap.count( vertexID ) > 0 )
           {
             MITK_ERROR << "Aborting network creation, duplicate vertex ID in file.";
             return;
           }
           idToVertexMap.insert( std::pair< int, mitk::ConnectomicsNetwork::VertexDescriptorType >( vertexID, newVertex) );
         }
       }
 
       // read edges
       pElem = hRoot.FirstChildElement(mitk::ConnectomicsNetworkDefinitions::XML_EDGES).Element();
       {
         // walk through the edges
         TiXmlElement* edgeElement = pElem->FirstChildElement();
 
         for( edgeElement; edgeElement; edgeElement=edgeElement->NextSiblingElement())
         {
           int edgeID(0), edgeSourceID(0), edgeTargetID(0), edgeWeight(0);
 
           edgeElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_EDGE_ID, &edgeID);
           edgeElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_EDGE_SOURCE_ID, &edgeSourceID);
           edgeElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_EDGE_TARGET_ID, &edgeTargetID);
           edgeElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_EDGE_WEIGHT_ID, &edgeWeight);
 
           mitk::ConnectomicsNetwork::VertexDescriptorType source = idToVertexMap.find( edgeSourceID )->second;
           mitk::ConnectomicsNetwork::VertexDescriptorType target = idToVertexMap.find( edgeTargetID )->second;
           m_OutputCache->AddEdge( source, target, edgeSourceID, edgeTargetID, edgeWeight);
         }
       }
 
+      m_OutputCache->UpdateBounds();
       MITK_INFO << "Network read";
     }
     catch(...)
     {
       MITK_INFO << "Could not read file ";
     }
   }
 }
 
 void mitk::ConnectomicsNetworkReader::Update()
 {
   this->GenerateData();
 }
 
 const char* mitk::ConnectomicsNetworkReader::GetFileName() const
 {
   return m_FileName.c_str();
 }
 
 
 void mitk::ConnectomicsNetworkReader::SetFileName(const char* aFileName)
 {
   m_FileName = aFileName;
 }
 
 
 const char* mitk::ConnectomicsNetworkReader::GetFilePrefix() const
 {
   return m_FilePrefix.c_str();
 }
 
 
 void mitk::ConnectomicsNetworkReader::SetFilePrefix(const char* aFilePrefix)
 {
   m_FilePrefix = aFilePrefix;
 }
 
 
 const char* mitk::ConnectomicsNetworkReader::GetFilePattern() const
 {
   return m_FilePattern.c_str();
 }
 
 
 void mitk::ConnectomicsNetworkReader::SetFilePattern(const char* aFilePattern)
 {
   m_FilePattern = aFilePattern;
 }
 
 
 bool mitk::ConnectomicsNetworkReader::CanReadFile(
   const std::string filename, const std::string /*filePrefix*/, 
   const std::string /*filePattern*/)
 {
   // First check the extension
   if(  filename == "" )
   {
     return false;
   }
   std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
   ext = itksys::SystemTools::LowerCase(ext);
 
   if (ext == ".cnf")
   {
     return true;
   }
 
   return false;
 }