diff --git a/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp b/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
index 02fb878c1a..89656da9f8 100644
--- a/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
+++ b/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
@@ -1,445 +1,446 @@
 /*===================================================================
 
 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 "mitkGeometry2DDataToSurfaceFilter.h"
 #include "mitkSurface.h"
 #include "mitkGeometry3D.h"
 #include "mitkGeometry2DData.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkAbstractTransformGeometry.h"
 
 #include <vtkPolyData.h>
 #include <vtkPlaneSource.h>
 #include <vtkTransformPolyDataFilter.h>
 
 #include <vtkCubeSource.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkTransform.h>
 #include <vtkGeneralTransform.h>
 #include <vtkPlane.h>
 #include <vtkPPolyDataNormals.h>
 #include <vtkCutter.h>
 #include <vtkStripper.h>
 #include <vtkTriangleFilter.h>
 #include <vtkBox.h>
 #include <vtkClipPolyData.h>
 #include <vtkTextureMapToPlane.h>
 
 
 mitk::Geometry2DDataToSurfaceFilter::Geometry2DDataToSurfaceFilter()
 : m_UseGeometryParametricBounds( true ), m_XResolution( 10 ),
   m_YResolution( 10 ), m_PlaceByGeometry( false ), m_UseBoundingBox( false )
 {
   m_PlaneSource = vtkPlaneSource::New();
   m_Transform = vtkTransform::New();
 
   m_CubeSource = vtkCubeSource::New();
   m_PolyDataTransformer = vtkTransformPolyDataFilter::New();
 
   m_Plane = vtkPlane::New();
   m_PlaneCutter = vtkCutter::New();
   m_PlaneStripper = vtkStripper::New();
   m_PlanePolyData = vtkPolyData::New();
   m_NormalsUpdater = vtkPPolyDataNormals::New();
   m_PlaneTriangler = vtkTriangleFilter::New();
   m_TextureMapToPlane = vtkTextureMapToPlane::New();
 
   m_Box = vtkBox::New();
   m_PlaneClipper = vtkClipPolyData::New();
 
   m_VtkTransformPlaneFilter = vtkTransformPolyDataFilter::New();
   m_VtkTransformPlaneFilter->SetInputData( m_PlaneSource->GetOutput() );
 }
 
 
 mitk::Geometry2DDataToSurfaceFilter::~Geometry2DDataToSurfaceFilter()
 {
   m_PlaneSource->Delete();
   m_Transform->Delete();
 
   m_CubeSource->Delete();
   m_PolyDataTransformer->Delete();
 
   m_Plane->Delete();
   m_PlaneCutter->Delete();
   m_PlaneStripper->Delete();
   m_PlanePolyData->Delete();
   m_NormalsUpdater->Delete();
   m_PlaneTriangler->Delete();
   m_TextureMapToPlane->Delete();
 
   m_Box->Delete();
   m_PlaneClipper->Delete();
 
   m_VtkTransformPlaneFilter->Delete();
 }
 
 
 void mitk::Geometry2DDataToSurfaceFilter::GenerateOutputInformation()
 {
   mitk::Geometry2DData::ConstPointer input = this->GetInput();
   mitk::Surface::Pointer output = this->GetOutput();
 
   if ( input.IsNull() || (input->GetGeometry2D() == NULL)
     || (input->GetGeometry2D()->IsValid() == false)
     || (m_UseBoundingBox && (m_BoundingBox.IsNull() || (m_BoundingBox->GetDiagonalLength2() < mitk::eps))) )
   {
     return;
   }
 
   Point3D origin;
   Point3D right, bottom;
 
   vtkPolyData *planeSurface = NULL;
 
 
   // Does the Geometry2DData contain a PlaneGeometry?
   if ( dynamic_cast< PlaneGeometry * >( input->GetGeometry2D() ) != NULL )
   {
     mitk::PlaneGeometry *planeGeometry =
       dynamic_cast< PlaneGeometry * >( input->GetGeometry2D() );
 
     if ( m_PlaceByGeometry )
     {
       // Let the output use the input geometry to appropriately transform the
       // coordinate system.
       mitk::Geometry3D::TransformType *affineTransform =
         planeGeometry->GetIndexToWorldTransform();
 
       TimeGeometry *timeGeometry = output->GetTimeGeometry();
       Geometry3D *geometrie3d = timeGeometry->GetGeometryForTimeStep( 0 );
       geometrie3d->SetIndexToWorldTransform( affineTransform );
     }
 
     if ( !m_UseBoundingBox)
     {
       // We do not have a bounding box, so no clipping is required.
 
       if ( m_PlaceByGeometry )
       {
         // Derive coordinate axes and origin from input geometry extent
         origin.Fill( 0.0 );
         FillVector3D( right,  planeGeometry->GetExtent(0), 0.0, 0.0 );
         FillVector3D( bottom, 0.0, planeGeometry->GetExtent(1), 0.0 );
       }
       else
       {
         // Take the coordinate axes and origin directly from the input geometry.
         origin = planeGeometry->GetOrigin();
         right = planeGeometry->GetCornerPoint( false, true );
         bottom = planeGeometry->GetCornerPoint( true, false );
       }
 
       // Since the plane is planar, there is no need to subdivide the grid
       // (cf. AbstractTransformGeometry case)
       m_PlaneSource->SetXResolution( 1 );
       m_PlaneSource->SetYResolution( 1 );
 
       m_PlaneSource->SetOrigin( origin[0], origin[1], origin[2] );
       m_PlaneSource->SetPoint1( right[0], right[1], right[2] );
       m_PlaneSource->SetPoint2( bottom[0], bottom[1], bottom[2] );
 
+      m_PlaneSource->Update();
       planeSurface = m_PlaneSource->GetOutput();
-//      planeSurface->Update(); //VTK6_TODO vtk pipeline
+
     }
     else
     {
       // Set up a cube with the extent and origin of the bounding box. This
       // cube will be clipped by a plane later on. The intersection of the
       // cube and the plane will be the surface we are interested in. Note
       // that the bounding box needs to be explicitly specified by the user
       // of this class, since it is not necessarily clear from the data
       // available herein which bounding box to use. In most cases, this
       // would be the bounding box of the input geometry's reference
       // geometry, but this is not an inevitable requirement.
       mitk::BoundingBox::PointType boundingBoxMin = m_BoundingBox->GetMinimum();
       mitk::BoundingBox::PointType boundingBoxMax = m_BoundingBox->GetMaximum();
       mitk::BoundingBox::PointType boundingBoxCenter = m_BoundingBox->GetCenter();
 
       m_CubeSource->SetXLength( boundingBoxMax[0] - boundingBoxMin[0] );
       m_CubeSource->SetYLength( boundingBoxMax[1] - boundingBoxMin[1] );
       m_CubeSource->SetZLength( boundingBoxMax[2] - boundingBoxMin[2] );
       m_CubeSource->SetCenter(
         boundingBoxCenter[0],
         boundingBoxCenter[1],
         boundingBoxCenter[2] );
 
 
       // Now we have to transform the cube, so that it will cut our plane
       // appropriately. (As can be seen below, the plane corresponds to the
       // z-plane in the coordinate system and is *not* transformed.) Therefore,
       // we get the inverse of the plane geometry's transform and concatenate
       // it with the transform of the reference geometry, if available.
       m_Transform->Identity();
       m_Transform->Concatenate(
         planeGeometry->GetVtkTransform()->GetLinearInverse()
       );
 
       Geometry3D *referenceGeometry = planeGeometry->GetReferenceGeometry();
       if ( referenceGeometry )
       {
         m_Transform->Concatenate(
           referenceGeometry->GetVtkTransform()
         );
       }
 
       // Transform the cube accordingly (s.a.)
       m_PolyDataTransformer->SetInputData( m_CubeSource->GetOutput() );
       m_PolyDataTransformer->SetTransform( m_Transform );
 
       // Initialize the plane to clip the cube with, as lying on the z-plane
       m_Plane->SetOrigin( 0.0, 0.0, 0.0 );
       m_Plane->SetNormal( 0.0, 0.0, 1.0 );
 
       // Cut the plane with the cube.
       m_PlaneCutter->SetInputData( m_PolyDataTransformer->GetOutput() );
       m_PlaneCutter->SetCutFunction( m_Plane );
 
       // The output of the cutter must be converted into appropriate poly data.
       m_PlaneStripper->SetInputData( m_PlaneCutter->GetOutput() );
       m_PlaneStripper->Update();
 
       if ( m_PlaneStripper->GetOutput()->GetNumberOfPoints() < 3 )
       {
         return;
       }
 
       m_PlanePolyData->SetPoints( m_PlaneStripper->GetOutput()->GetPoints() );
       m_PlanePolyData->SetPolys( m_PlaneStripper->GetOutput()->GetLines() );
 
       m_PlaneTriangler->SetInputData( m_PlanePolyData );
 
 
       // Get bounds of the resulting surface and use it to generate the texture
       // mapping information
       m_PlaneTriangler->Update();
       m_PlaneTriangler->GetOutput()->ComputeBounds();
       double *surfaceBounds =
         m_PlaneTriangler->GetOutput()->GetBounds();
 
       origin[0] = surfaceBounds[0];
       origin[1] = surfaceBounds[2];
       origin[2] = surfaceBounds[4];
 
       right[0] = surfaceBounds[1];
       right[1] = surfaceBounds[2];
       right[2] = surfaceBounds[4];
 
       bottom[0] = surfaceBounds[0];
       bottom[1] = surfaceBounds[3];
       bottom[2] = surfaceBounds[4];
 
       // Now we tell the data how it shall be textured afterwards;
       // description see above.
       m_TextureMapToPlane->SetInputData( m_PlaneTriangler->GetOutput() );
       m_TextureMapToPlane->AutomaticPlaneGenerationOn();
       m_TextureMapToPlane->SetOrigin( origin[0], origin[1], origin[2] );
       m_TextureMapToPlane->SetPoint1( right[0], right[1], right[2] );
       m_TextureMapToPlane->SetPoint2( bottom[0], bottom[1], bottom[2] );
 
       // Need to call update so that output data and bounds are immediately
       // available
       m_TextureMapToPlane->Update();
 
 
       // Return the output of this generation process
       planeSurface = dynamic_cast< vtkPolyData * >(
         m_TextureMapToPlane->GetOutput()
       );
     }
   }
 
   // Does the Geometry2DData contain an AbstractTransformGeometry?
   else if ( mitk::AbstractTransformGeometry *abstractGeometry =
     dynamic_cast< AbstractTransformGeometry * >( input->GetGeometry2D() ) )
   {
     // In the case of an AbstractTransformGeometry (which holds a possibly
     // non-rigid transform), we proceed slightly differently: since the
     // plane can be arbitrarily deformed, we need to transform it by the
     // abstract transform before clipping it. The setup for this is partially
     // done in the constructor.
     origin = abstractGeometry->GetPlane()->GetOrigin();
     right = origin + abstractGeometry->GetPlane()->GetAxisVector( 0 );
     bottom = origin + abstractGeometry->GetPlane()->GetAxisVector( 1 );
 
     // Define the plane
     m_PlaneSource->SetOrigin( origin[0], origin[1], origin[2] );
     m_PlaneSource->SetPoint1( right[0], right[1], right[2] );
     m_PlaneSource->SetPoint2( bottom[0], bottom[1], bottom[2] );
 
     // Set the plane's resolution (unlike for non-deformable planes, the plane
     // grid needs to have a certain resolution so that the deformation has the
     // desired effect).
     if ( m_UseGeometryParametricBounds )
     {
       m_PlaneSource->SetXResolution(
         (int)abstractGeometry->GetParametricExtent(0)
       );
       m_PlaneSource->SetYResolution(
         (int)abstractGeometry->GetParametricExtent(1)
       );
     }
     else
     {
       m_PlaneSource->SetXResolution( m_XResolution );
       m_PlaneSource->SetYResolution( m_YResolution );
     }
     if ( m_PlaceByGeometry )
     {
       // Let the output use the input geometry to appropriately transform the
       // coordinate system.
       mitk::Geometry3D::TransformType *affineTransform =
         abstractGeometry->GetIndexToWorldTransform();
 
       TimeGeometry *timeGeometry = output->GetTimeGeometry();
       Geometry3D *g3d = timeGeometry->GetGeometryForTimeStep( 0 );
       g3d->SetIndexToWorldTransform( affineTransform );
 
       vtkGeneralTransform *composedResliceTransform = vtkGeneralTransform::New();
       composedResliceTransform->Identity();
       composedResliceTransform->Concatenate(
         abstractGeometry->GetVtkTransform()->GetLinearInverse() );
       composedResliceTransform->Concatenate(
         abstractGeometry->GetVtkAbstractTransform()
         );
       // Use the non-rigid transform for transforming the plane.
       m_VtkTransformPlaneFilter->SetTransform(
         composedResliceTransform
       );
     }
     else
     {
       // Use the non-rigid transform for transforming the plane.
       m_VtkTransformPlaneFilter->SetTransform(
         abstractGeometry->GetVtkAbstractTransform()
       );
     }
 
     if ( m_UseBoundingBox )
     {
       mitk::BoundingBox::PointType boundingBoxMin = m_BoundingBox->GetMinimum();
       mitk::BoundingBox::PointType boundingBoxMax = m_BoundingBox->GetMaximum();
       //mitk::BoundingBox::PointType boundingBoxCenter = m_BoundingBox->GetCenter();
 
       m_Box->SetXMin( boundingBoxMin[0], boundingBoxMin[1], boundingBoxMin[2] );
       m_Box->SetXMax( boundingBoxMax[0], boundingBoxMax[1], boundingBoxMax[2] );
     }
     else
     {
       // Plane will not be clipped
       m_Box->SetXMin( -10000.0, -10000.0, -10000.0 );
       m_Box->SetXMax( 10000.0, 10000.0, 10000.0 );
     }
 
     m_Transform->Identity();
     m_Transform->Concatenate( input->GetGeometry2D()->GetVtkTransform() );
     m_Transform->PreMultiply();
 
     m_Box->SetTransform( m_Transform );
 
     m_PlaneClipper->SetInputData( m_VtkTransformPlaneFilter->GetOutput() );
     m_PlaneClipper->SetClipFunction( m_Box );
     m_PlaneClipper->GenerateClippedOutputOff(); // important to NOT generate normals data for clipped part
     m_PlaneClipper->InsideOutOn();
     m_PlaneClipper->SetValue( 0.0 );
 
     planeSurface = m_PlaneClipper->GetOutput();
   }
 
   m_NormalsUpdater->SetInputData( planeSurface );
   m_NormalsUpdater->AutoOrientNormalsOn(); // that's the trick! Brings consistency between
                                           //  normals direction and front/back faces direction (see bug 1440)
   m_NormalsUpdater->ComputePointNormalsOn();
   m_NormalsUpdater->Update();
 
   output->SetVtkPolyData( m_NormalsUpdater->GetOutput() );
   output->CalculateBoundingBox();
 }
 
 
 void mitk::Geometry2DDataToSurfaceFilter::GenerateData()
 {
   mitk::Surface::Pointer output = this->GetOutput();
 
   if (output.IsNull()) return;
   if (output->GetVtkPolyData()==NULL) return;
 
 //  output->GetVtkPolyData()->Update(); //VTK6_TODO vtk pipeline
 }
 
 const mitk::Geometry2DData *mitk::Geometry2DDataToSurfaceFilter::GetInput()
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return 0;
   }
 
   return static_cast<const mitk::Geometry2DData * >
     ( this->ProcessObject::GetInput(0) );
 }
 
 
 const mitk::Geometry2DData *
 mitk::Geometry2DDataToSurfaceFilter
 ::GetInput(unsigned int idx)
 {
   return static_cast< const mitk::Geometry2DData * >
     ( this->ProcessObject::GetInput(idx) );
 }
 
 
 void
 mitk::Geometry2DDataToSurfaceFilter
 ::SetInput(const mitk::Geometry2DData *input)
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput( 0,
   const_cast< mitk::Geometry2DData * >( input )
   );
 }
 
 
 void
 mitk::Geometry2DDataToSurfaceFilter
 ::SetInput(unsigned int index, const mitk::Geometry2DData *input)
 {
   if( index+1 > this->GetNumberOfInputs() )
   {
     this->SetNumberOfRequiredInputs( index + 1 );
   }
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput(index,
     const_cast< mitk::Geometry2DData *>( input )
   );
 }
 
 
 void
 mitk::Geometry2DDataToSurfaceFilter
 ::SetBoundingBox( const mitk::BoundingBox *boundingBox )
 {
   m_BoundingBox = boundingBox;
   this->UseBoundingBoxOn();
 }
 
 
 const mitk::BoundingBox *
 mitk::Geometry2DDataToSurfaceFilter
 ::GetBoundingBox() const
 {
   return m_BoundingBox.GetPointer();
 }
diff --git a/Core/Code/Algorithms/mitkImageToSurfaceFilter.cpp b/Core/Code/Algorithms/mitkImageToSurfaceFilter.cpp
index 027e3ff46f..1ef29729fa 100644
--- a/Core/Code/Algorithms/mitkImageToSurfaceFilter.cpp
+++ b/Core/Code/Algorithms/mitkImageToSurfaceFilter.cpp
@@ -1,234 +1,232 @@
 /*===================================================================
 
 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 <mitkImageToSurfaceFilter.h>
 #include "mitkException.h"
 #include <vtkImageData.h>
 #include <vtkDecimatePro.h>
 #include <vtkImageChangeInformation.h>
 #include <vtkLinearTransform.h>
 #include <vtkMath.h>
 #include <vtkMatrix4x4.h>
 #include <vtkQuadricDecimation.h>
 
 #include <vtkSmartPointer.h>
 #include <vtkPolyDataNormals.h>
 #include <vtkCleanPolyData.h>
 
 #include "mitkProgressBar.h"
 
 mitk::ImageToSurfaceFilter::ImageToSurfaceFilter():
   m_Smooth(false),
   m_Decimate( NoDecimation),
   m_Threshold(1.0),
   m_TargetReduction(0.95f),
   m_SmoothIteration(50),
   m_SmoothRelaxation(0.1)
 {
 }
 
 mitk::ImageToSurfaceFilter::~ImageToSurfaceFilter()
 {
 }
 
 void mitk::ImageToSurfaceFilter::CreateSurface(int time, vtkImageData *vtkimage, mitk::Surface * surface, const ScalarType threshold)
 {
   vtkImageChangeInformation *indexCoordinatesImageFilter = vtkImageChangeInformation::New();
   indexCoordinatesImageFilter->SetInputData(vtkimage);
   indexCoordinatesImageFilter->SetOutputOrigin(0.0,0.0,0.0);
 
   //MarchingCube -->create Surface
   vtkMarchingCubes *skinExtractor = vtkMarchingCubes::New();
   skinExtractor->ComputeScalarsOff();
   skinExtractor->SetInputData(indexCoordinatesImageFilter->GetOutput());//RC++
   indexCoordinatesImageFilter->Delete();
   skinExtractor->SetValue(0, threshold);
 
   vtkPolyData *polydata;
+  skinExtractor->Update();
   polydata = skinExtractor->GetOutput();
   polydata->Register(NULL);//RC++
   skinExtractor->Delete();
 
   if (m_Smooth)
   {
     vtkSmoothPolyDataFilter *smoother = vtkSmoothPolyDataFilter::New();
     //read poly1 (poly1 can be the original polygon, or the decimated polygon)
     smoother->SetInputData(polydata);//RC++
     smoother->SetNumberOfIterations( m_SmoothIteration );
     smoother->SetRelaxationFactor( m_SmoothRelaxation );
     smoother->SetFeatureAngle( 60 );
     smoother->FeatureEdgeSmoothingOff();
     smoother->BoundarySmoothingOff();
     smoother->SetConvergence( 0 );
 
     polydata->Delete();//RC--
     polydata = smoother->GetOutput();
     polydata->Register(NULL);//RC++
     smoother->Delete();
   }
   ProgressBar::GetInstance()->Progress();
 
   //decimate = to reduce number of polygons
   if(m_Decimate==DecimatePro)
   {
     vtkDecimatePro *decimate = vtkDecimatePro::New();
     decimate->SplittingOff();
     decimate->SetErrorIsAbsolute(5);
     decimate->SetFeatureAngle(30);
     decimate->PreserveTopologyOn();
     decimate->BoundaryVertexDeletionOff();
     decimate->SetDegree(10); //std-value is 25!
 
     decimate->SetInputData(polydata);//RC++
     decimate->SetTargetReduction(m_TargetReduction);
     decimate->SetMaximumError(0.002);
 
     polydata->Delete();//RC--
     polydata = decimate->GetOutput();
     polydata->Register(NULL);//RC++
     decimate->Delete();
   }
   else if (m_Decimate==QuadricDecimation)
   {
     vtkQuadricDecimation* decimate = vtkQuadricDecimation::New();
     decimate->SetTargetReduction(m_TargetReduction);
 
     decimate->SetInputData(polydata);
     polydata->Delete();
     polydata = decimate->GetOutput();
     polydata->Register(NULL);
     decimate->Delete();
   }
 
-//  polydata->Update(); //VTK6_TODO vtk pipeline
   ProgressBar::GetInstance()->Progress();
 
-//  polydata->SetSource(NULL); //VTK6_TODO vtk pipeline
-
   if(polydata->GetNumberOfPoints() > 0)
   {
     mitk::Vector3D spacing = GetInput()->GetGeometry(time)->GetSpacing();
 
     vtkPoints * points = polydata->GetPoints();
     vtkMatrix4x4 *vtkmatrix = vtkMatrix4x4::New();
     GetInput()->GetGeometry(time)->GetVtkTransform()->GetMatrix(vtkmatrix);
     double (*matrix)[4] = vtkmatrix->Element;
 
     unsigned int i,j;
     for(i=0;i<3;++i)
       for(j=0;j<3;++j)
         matrix[i][j]/=spacing[j];
 
     unsigned int n = points->GetNumberOfPoints();
     double point[3];
 
     for (i = 0; i < n; i++)
     {
       points->GetPoint(i, point);
       mitkVtkLinearTransformPoint(matrix,point,point);
       points->SetPoint(i, point);
     }
     vtkmatrix->Delete();
   }
   ProgressBar::GetInstance()->Progress();
 
   // determine point_data normals for the poly data points.
   vtkSmartPointer<vtkPolyDataNormals> normalsGenerator = vtkSmartPointer<vtkPolyDataNormals>::New();
   normalsGenerator->SetInputData( polydata );
 
   vtkSmartPointer<vtkCleanPolyData> cleanPolyDataFilter = vtkSmartPointer<vtkCleanPolyData>::New();
   cleanPolyDataFilter->SetInputData(normalsGenerator->GetOutput());
   cleanPolyDataFilter->PieceInvariantOff();
   cleanPolyDataFilter->ConvertLinesToPointsOff();
   cleanPolyDataFilter->ConvertPolysToLinesOff();
   cleanPolyDataFilter->ConvertStripsToPolysOff();
   cleanPolyDataFilter->PointMergingOn();
   cleanPolyDataFilter->Update();
 
   surface->SetVtkPolyData(cleanPolyDataFilter->GetOutput(), time);
   polydata->UnRegister(NULL);
 }
 
 
 void mitk::ImageToSurfaceFilter::GenerateData()
 {
   mitk::Surface *surface = this->GetOutput();
   mitk::Image * image        =  (mitk::Image*)GetInput();
   if(image == NULL || !image->IsInitialized())
     mitkThrow() << "No input image set, please set an valid input image!";
 
   mitk::Image::RegionType outputRegion = image->GetRequestedRegion();
 
   int tstart=outputRegion.GetIndex(3);
   int tmax=tstart+outputRegion.GetSize(3); //GetSize()==1 - will aber 0 haben, wenn nicht zeitaufgeloest
 
   if ((tmax-tstart) > 0)
   {
     ProgressBar::GetInstance()->AddStepsToDo( 4 * (tmax - tstart)  );
   }
 
 
   int t;
   for( t=tstart; t < tmax; ++t)
   {
     vtkImageData *vtkimagedata =  image->GetVtkImageData(t);
     CreateSurface(t,vtkimagedata,surface,m_Threshold);
     ProgressBar::GetInstance()->Progress();
   }
 }
 
 void mitk::ImageToSurfaceFilter::SetSmoothIteration(int smoothIteration)
 {
   m_SmoothIteration = smoothIteration;
 }
 
 void mitk::ImageToSurfaceFilter::SetSmoothRelaxation(float smoothRelaxation)
 {
   m_SmoothRelaxation = smoothRelaxation;
 }
 
 void mitk::ImageToSurfaceFilter::SetInput(const mitk::Image *image)
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput(0, const_cast< mitk::Image * >( image ) );
 }
 
 
 const mitk::Image *mitk::ImageToSurfaceFilter::GetInput(void)
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return 0;
   }
 
   return static_cast<const mitk::Image * >
     ( this->ProcessObject::GetInput(0) );
 }
 
 
 void mitk::ImageToSurfaceFilter::GenerateOutputInformation()
 {
   mitk::Image::ConstPointer inputImage  =(mitk::Image*) this->GetInput();
 
   //mitk::Image *inputImage = (mitk::Image*)this->GetImage();
   mitk::Surface::Pointer output = this->GetOutput();
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
   if(inputImage.IsNull()) return;
 
   //Set Data
 }
diff --git a/Core/Code/Rendering/mitkPointSetVtkMapper3D.cpp b/Core/Code/Rendering/mitkPointSetVtkMapper3D.cpp
index cd761c196e..d7142b22ad 100644
--- a/Core/Code/Rendering/mitkPointSetVtkMapper3D.cpp
+++ b/Core/Code/Rendering/mitkPointSetVtkMapper3D.cpp
@@ -1,642 +1,641 @@
 /*===================================================================
 
 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 "mitkPointSetVtkMapper3D.h"
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 #include "mitkColorProperty.h"
 #include "mitkVtkPropRenderer.h"
 #include "mitkPointSet.h"
 
 #include <vtkActor.h>
 #include <vtkAppendPolyData.h>
 #include <vtkPropAssembly.h>
 #include <vtkTubeFilter.h>
 #include <vtkRenderer.h>
 #include <vtkSphereSource.h>
 #include <vtkCubeSource.h>
 #include <vtkConeSource.h>
 #include <vtkCylinderSource.h>
 #include <vtkProperty.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkCellArray.h>
 #include <vtkVectorText.h>
 #include <vtkTransform.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkPolyDataAlgorithm.h>
 
 #include <stdlib.h>
 
 
 
 const mitk::PointSet* mitk::PointSetVtkMapper3D::GetInput()
 {
   return static_cast<const mitk::PointSet * > ( GetDataNode()->GetData() );
 }
 
 mitk::PointSetVtkMapper3D::PointSetVtkMapper3D()
 : m_vtkSelectedPointList(NULL),
  m_vtkUnselectedPointList(NULL),
  m_VtkSelectedPolyDataMapper(NULL),
  m_VtkUnselectedPolyDataMapper(NULL),
  m_vtkTextList(NULL),
  m_NumberOfSelectedAdded(0),
  m_NumberOfUnselectedAdded(0),
  m_PointSize(1.0),
  m_ContourRadius(0.5)
 {
   //propassembly
   m_PointsAssembly = vtkSmartPointer<vtkPropAssembly>::New();
 
   //creating actors to be able to set transform
   m_SelectedActor = vtkSmartPointer<vtkActor>::New();
   m_UnselectedActor = vtkSmartPointer<vtkActor>::New();
   m_ContourActor = vtkSmartPointer<vtkActor>::New();
 }
 
 mitk::PointSetVtkMapper3D::~PointSetVtkMapper3D()
 {
 }
 
 void mitk::PointSetVtkMapper3D::ReleaseGraphicsResources(vtkWindow *renWin)
 {
   m_PointsAssembly->ReleaseGraphicsResources(renWin);
 
   m_SelectedActor->ReleaseGraphicsResources(renWin);
   m_UnselectedActor->ReleaseGraphicsResources(renWin);
   m_ContourActor->ReleaseGraphicsResources(renWin);
 }
 
 void mitk::PointSetVtkMapper3D::ReleaseGraphicsResources(mitk::BaseRenderer* renderer)
 {
   m_PointsAssembly->ReleaseGraphicsResources(renderer->GetRenderWindow());
 
   m_SelectedActor->ReleaseGraphicsResources(renderer->GetRenderWindow());
   m_UnselectedActor->ReleaseGraphicsResources(renderer->GetRenderWindow());
   m_ContourActor->ReleaseGraphicsResources(renderer->GetRenderWindow());
 
 }
 
 void mitk::PointSetVtkMapper3D::CreateVTKRenderObjects()
 {
   m_vtkSelectedPointList = vtkSmartPointer<vtkAppendPolyData>::New();
   m_vtkUnselectedPointList = vtkSmartPointer<vtkAppendPolyData>::New();
 
   m_PointsAssembly->VisibilityOn();
 
   if(m_PointsAssembly->GetParts()->IsItemPresent(m_SelectedActor))
     m_PointsAssembly->RemovePart(m_SelectedActor);
   if(m_PointsAssembly->GetParts()->IsItemPresent(m_UnselectedActor))
     m_PointsAssembly->RemovePart(m_UnselectedActor);
   if(m_PointsAssembly->GetParts()->IsItemPresent(m_ContourActor))
     m_PointsAssembly->RemovePart(m_ContourActor);
 
   // exceptional displaying for PositionTracker -> MouseOrientationTool
   int mapperID;
   bool isInputDevice=false;
   if( this->GetDataNode()->GetBoolProperty("inputdevice",isInputDevice) && isInputDevice )
   {
     if( this->GetDataNode()->GetIntProperty("BaseRendererMapperID",mapperID) && mapperID == 2)
       return; //The event for the PositionTracker came from the 3d widget and  not needs to be displayed
   }
 
   // get and update the PointSet
   mitk::PointSet::Pointer input  = const_cast<mitk::PointSet*>(this->GetInput());
 
   /* only update the input data, if the property tells us to */
   bool update = true;
   this->GetDataNode()->GetBoolProperty("updateDataOnRender", update);
   if (update == true)
     input->Update();
 
   int timestep = this->GetTimestep();
 
   mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timestep );
 
   if ( itkPointSet.GetPointer() == NULL)
   {
     m_PointsAssembly->VisibilityOff();
     return;
   }
 
   mitk::PointSet::PointsContainer::Iterator pointsIter;
   mitk::PointSet::PointDataContainer::Iterator pointDataIter;
   int j;
 
   m_NumberOfSelectedAdded = 0;
   m_NumberOfUnselectedAdded = 0;
 
   //create contour
   bool makeContour = false;
   this->GetDataNode()->GetBoolProperty("show contour", makeContour);
   if (makeContour)
   {
     this->CreateContour();
   }
 
   //now fill selected and unselected pointList
   //get size of Points in Property
   m_PointSize = 2;
   mitk::FloatProperty::Pointer pointSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("pointsize"));
   if ( pointSizeProp.IsNotNull() )
     m_PointSize = pointSizeProp->GetValue();
 
   //get the property for creating a label onto every point only once
   bool showLabel = true;
   this->GetDataNode()->GetBoolProperty("show label", showLabel);
   const char * pointLabel=NULL;
   if(showLabel)
   {
     if(dynamic_cast<mitk::StringProperty *>(this->GetDataNode()->GetPropertyList()->GetProperty("label")) != NULL)
       pointLabel =dynamic_cast<mitk::StringProperty *>(this->GetDataNode()->GetPropertyList()->GetProperty("label"))->GetValue();
     else
       showLabel = false;
   }
 
 
   //check if the list for the PointDataContainer is the same size as the PointsContainer. Is not, then the points were inserted manually and can not be visualized according to the PointData (selected/unselected)
   bool pointDataBroken = (itkPointSet->GetPointData()->Size() != itkPointSet->GetPoints()->Size());
   //now add an object for each point in data
   pointDataIter = itkPointSet->GetPointData()->Begin();
   for (j=0, pointsIter=itkPointSet->GetPoints()->Begin();
     pointsIter!=itkPointSet->GetPoints()->End();
     pointsIter++, j++)
   {
     //check for the pointtype in data and decide which geom-object to take and then add to the selected or unselected list
     int pointType;
 
     if(itkPointSet->GetPointData()->size() == 0 || pointDataBroken)
       pointType = mitk::PTUNDEFINED;
     else
       pointType = pointDataIter.Value().pointSpec;
 
     vtkSmartPointer<vtkPolyDataAlgorithm> source;
 
     switch (pointType)
     {
     case mitk::PTUNDEFINED:
       {
         vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
         sphere->SetRadius(m_PointSize);
         itk::Point<float> point1 = pointsIter->Value();
         sphere->SetCenter(point1[0],point1[1],point1[2]);
         //sphere->SetCenter(pointsIter.Value()[0],pointsIter.Value()[1],pointsIter.Value()[2]);
 
         //MouseOrientation Tool (PositionTracker)
         if(isInputDevice)
         {
           sphere->SetThetaResolution(10);
           sphere->SetPhiResolution(10);
         }
         else
         {
           sphere->SetThetaResolution(20);
           sphere->SetPhiResolution(20);
         }
         source = sphere;
       }
       break;
     case mitk::PTSTART:
       {
         vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New();
         cube->SetXLength(m_PointSize/2);
         cube->SetYLength(m_PointSize/2);
         cube->SetZLength(m_PointSize/2);
         itk::Point<float> point1 = pointsIter->Value();
         cube->SetCenter(point1[0],point1[1],point1[2]);
         source = cube;
       }
       break;
     case mitk::PTCORNER:
       {
         vtkSmartPointer<vtkConeSource> cone = vtkSmartPointer<vtkConeSource>::New();
         cone->SetRadius(m_PointSize);
         itk::Point<float> point1 = pointsIter->Value();
         cone->SetCenter(point1[0],point1[1],point1[2]);
         cone->SetResolution(20);
         source = cone;
       }
       break;
     case mitk::PTEDGE:
       {
         vtkSmartPointer<vtkCylinderSource> cylinder = vtkSmartPointer<vtkCylinderSource>::New();
         cylinder->SetRadius(m_PointSize);
         itk::Point<float> point1 = pointsIter->Value();
         cylinder->SetCenter(point1[0],point1[1],point1[2]);
         cylinder->SetResolution(20);
         source = cylinder;
       }
       break;
     case mitk::PTEND:
       {
         vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
         sphere->SetRadius(m_PointSize);
         //itk::Point<float> point1 = pointsIter->Value();
         sphere->SetThetaResolution(20);
         sphere->SetPhiResolution(20);
         source = sphere;
       }
       break;
     default:
       {
         vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
         sphere->SetRadius(m_PointSize);
         itk::Point<float> point1 = pointsIter->Value();
         sphere->SetCenter(point1[0],point1[1],point1[2]);
         sphere->SetThetaResolution(20);
         sphere->SetPhiResolution(20);
         source = sphere;
       }
       break;
     }
     if (!pointDataBroken)
     {
       if (pointDataIter.Value().selected)
       {
         m_vtkSelectedPointList->AddInputData(source->GetOutput());
         ++m_NumberOfSelectedAdded;
       }
       else
       {
         m_vtkUnselectedPointList->AddInputData(source->GetOutput());
         ++m_NumberOfUnselectedAdded;
       }
     }
     else
     {
       m_vtkUnselectedPointList->AddInputData(source->GetOutput());
       ++m_NumberOfUnselectedAdded;
     }
 
     if (showLabel)
     {
       char buffer[20];
       std::string l = pointLabel;
       if ( input->GetSize()>1 )
       {
         sprintf(buffer,"%d",j+1);
         l.append(buffer);
       }
       // Define the text for the label
       vtkSmartPointer<vtkVectorText> label = vtkSmartPointer<vtkVectorText>::New();
       label->SetText(l.c_str());
 
       //# Set up a transform to move the label to a new position.
       vtkSmartPointer<vtkTransform> aLabelTransform = vtkSmartPointer<vtkTransform>::New();
       aLabelTransform->Identity();
       itk::Point<float> point1 = pointsIter->Value();
       aLabelTransform->Translate(point1[0]+2,point1[1]+2,point1[2]);
       aLabelTransform->Scale(5.7,5.7,5.7);
 
       //# Move the label to a new position.
       vtkSmartPointer<vtkTransformPolyDataFilter> labelTransform = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
       labelTransform->SetTransform(aLabelTransform);
       labelTransform->SetInputData(label->GetOutput());
 
       //add it to the wright PointList
       if (pointType)
       {
         m_vtkSelectedPointList->AddInputData(labelTransform->GetOutput());
         ++m_NumberOfSelectedAdded;
       }
       else
       {
         m_vtkUnselectedPointList->AddInputData(labelTransform->GetOutput());
         ++m_NumberOfUnselectedAdded;
       }
     }
 
     if(pointDataIter != itkPointSet->GetPointData()->End())
       pointDataIter++;
   } // end FOR
 
 
   //now according to number of elements added to selected or unselected, build up the rendering pipeline
   if (m_NumberOfSelectedAdded > 0)
   {
     m_VtkSelectedPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     m_VtkSelectedPolyDataMapper->SetInputData(m_vtkSelectedPointList->GetOutput());
 
     //create a new instance of the actor
     m_SelectedActor = vtkSmartPointer<vtkActor>::New();
 
     m_SelectedActor->SetMapper(m_VtkSelectedPolyDataMapper);
     m_PointsAssembly->AddPart(m_SelectedActor);
   }
 
   if (m_NumberOfUnselectedAdded > 0)
   {
     m_VtkUnselectedPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     m_VtkUnselectedPolyDataMapper->SetInputData(m_vtkUnselectedPointList->GetOutput());
 
     //create a new instance of the actor
     m_UnselectedActor = vtkSmartPointer<vtkActor>::New();
 
     m_UnselectedActor->SetMapper(m_VtkUnselectedPolyDataMapper);
     m_PointsAssembly->AddPart(m_UnselectedActor);
   }
 }
 
 
 void mitk::PointSetVtkMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if(!visible)
   {
     m_UnselectedActor->VisibilityOff();
     m_SelectedActor->VisibilityOff();
     m_ContourActor->VisibilityOff();
     return;
   }
 
   // create new vtk render objects (e.g. sphere for a point)
 
   SetVtkMapperImmediateModeRendering(m_VtkSelectedPolyDataMapper);
   SetVtkMapperImmediateModeRendering(m_VtkUnselectedPolyDataMapper);
 
   BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
   bool needGenerateData = ls->IsGenerateDataRequired( renderer, this, GetDataNode() );
 
   if(!needGenerateData)
   {
     mitk::FloatProperty * pointSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("pointsize"));
     mitk::FloatProperty * contourSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("contoursize"));
 
     // only create new vtk render objects if property values were changed
     if(pointSizeProp && m_PointSize!=pointSizeProp->GetValue() )
       needGenerateData = true;
     if(contourSizeProp && m_ContourRadius!=contourSizeProp->GetValue() )
       needGenerateData = true;
   }
 
   if(needGenerateData)
   {
     this->CreateVTKRenderObjects();
     ls->UpdateGenerateDataTime();
   }
 
   this->ApplyAllProperties(renderer, m_ContourActor);
 
   bool showPoints = true;
   this->GetDataNode()->GetBoolProperty("show points", showPoints);
 
   if(showPoints)
   {
     m_UnselectedActor->VisibilityOn();
     m_SelectedActor->VisibilityOn();
   }
   else
   {
     m_UnselectedActor->VisibilityOff();
     m_SelectedActor->VisibilityOff();
   }
 
   if(dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("opacity")) != NULL)
   {
     mitk::FloatProperty::Pointer pointOpacity =dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("opacity"));
     float opacity = pointOpacity->GetValue();
     m_ContourActor->GetProperty()->SetOpacity(opacity);
     m_UnselectedActor->GetProperty()->SetOpacity(opacity);
     m_SelectedActor->GetProperty()->SetOpacity(opacity);
   }
 
   bool makeContour = false;
   this->GetDataNode()->GetBoolProperty("show contour", makeContour);
   if (makeContour)
   {
     m_ContourActor->VisibilityOn();
   }
   else
   {
     m_ContourActor->VisibilityOff();
   }
 }
 
 
 void mitk::PointSetVtkMapper3D::ResetMapper( BaseRenderer* /*renderer*/ )
 {
   m_PointsAssembly->VisibilityOff();
 }
 
 
 vtkProp* mitk::PointSetVtkMapper3D::GetVtkProp(mitk::BaseRenderer * /*renderer*/)
 {
   return m_PointsAssembly;
 }
 
 void mitk::PointSetVtkMapper3D::UpdateVtkTransform(mitk::BaseRenderer * /*renderer*/)
 {
   vtkSmartPointer<vtkLinearTransform> vtktransform =
     this->GetDataNode()->GetVtkTransform(this->GetTimestep());
 
   m_SelectedActor->SetUserTransform(vtktransform);
   m_UnselectedActor->SetUserTransform(vtktransform);
   m_ContourActor->SetUserTransform(vtktransform);
 }
 
 void mitk::PointSetVtkMapper3D::ApplyAllProperties(mitk::BaseRenderer* renderer, vtkActor* actor)
 {
   Superclass::ApplyColorAndOpacityProperties(renderer, actor);
   //check for color props and use it for rendering of selected/unselected points and contour
   //due to different params in VTK (double/float) we have to convert!
 
   //vars to convert to
   double unselectedColor[4]={1.0f,1.0f,0.0f,1.0f};//yellow
   double selectedColor[4]={1.0f,0.0f,0.0f,1.0f};//red
   double contourColor[4]={1.0f,0.0f,0.0f,1.0f};//red
 
   //different types for color!!!
   mitk::Color tmpColor;
   double opacity = 1.0;
 
   //check if there is an unselected property
   if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("unselectedcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("unselectedcolor"))->GetValue();
     unselectedColor[0] = tmpColor[0];
     unselectedColor[1] = tmpColor[1];
     unselectedColor[2] = tmpColor[2];
     unselectedColor[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
   }
   else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("unselectedcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("unselectedcolor"))->GetValue();
     unselectedColor[0] = tmpColor[0];
     unselectedColor[1] = tmpColor[1];
     unselectedColor[2] = tmpColor[2];
     unselectedColor[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
   }
   else
   {
     //check if the node has a color
     float unselectedColorTMP[4]={1.0f,1.0f,0.0f,1.0f};//yellow
     m_DataNode->GetColor(unselectedColorTMP, NULL);
     unselectedColor[0] = unselectedColorTMP[0];
     unselectedColor[1] = unselectedColorTMP[1];
     unselectedColor[2] = unselectedColorTMP[2];
     //unselectedColor[3] stays 1.0f
   }
 
   //get selected property
   if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor"))->GetValue();
     selectedColor[0] = tmpColor[0];
     selectedColor[1] = tmpColor[1];
     selectedColor[2] = tmpColor[2];
     selectedColor[3] = 1.0f;
   }
   else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor"))->GetValue();
     selectedColor[0] = tmpColor[0];
     selectedColor[1] = tmpColor[1];
     selectedColor[2] = tmpColor[2];
     selectedColor[3] = 1.0f;
   }
 
   //get contour property
   if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor"))->GetValue();
     contourColor[0] = tmpColor[0];
     contourColor[1] = tmpColor[1];
     contourColor[2] = tmpColor[2];
     contourColor[3] = 1.0f;
   }
   else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor"))->GetValue();
     contourColor[0] = tmpColor[0];
     contourColor[1] = tmpColor[1];
     contourColor[2] = tmpColor[2];
     contourColor[3] = 1.0f;
   }
 
   if(dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("opacity")) != NULL)
   {
     mitk::FloatProperty::Pointer pointOpacity =dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("opacity"));
     opacity = pointOpacity->GetValue();
   }
   else if(dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("opacity")) != NULL)
   {
     mitk::FloatProperty::Pointer pointOpacity =dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("opacity"));
     opacity = pointOpacity->GetValue();
   }
   //finished color / opacity fishing!
 
   //check if a contour shall be drawn
   bool makeContour = false;
   this->GetDataNode()->GetBoolProperty("show contour", makeContour, renderer);
   if(makeContour && (m_ContourActor != NULL) )
   {
     this->CreateContour();
     m_ContourActor->GetProperty()->SetColor(contourColor);
     m_ContourActor->GetProperty()->SetOpacity(opacity);
   }
 
   m_SelectedActor->GetProperty()->SetColor(selectedColor);
   m_SelectedActor->GetProperty()->SetOpacity(opacity);
 
   m_UnselectedActor->GetProperty()->SetColor(unselectedColor);
   m_UnselectedActor->GetProperty()->SetOpacity(opacity);
 
 }
 
 void mitk::PointSetVtkMapper3D::CreateContour()
 {
   vtkSmartPointer<vtkAppendPolyData> vtkContourPolyData = vtkSmartPointer<vtkAppendPolyData>::New();
   vtkSmartPointer<vtkPolyDataMapper> vtkContourPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
 
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> polys = vtkSmartPointer<vtkCellArray>::New();
 
   mitk::PointSet::PointsContainer::Iterator pointsIter;
 //  mitk::PointSet::PointDataContainer::Iterator pointDataIter;
   int j;
 
   // get and update the PointSet
   mitk::PointSet::Pointer input  = const_cast<mitk::PointSet*>(this->GetInput());
 
   int timestep = this->GetTimestep();
   mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timestep );
   if ( itkPointSet.GetPointer() == NULL)
   {
     return;
   }
 
   for (j=0, pointsIter=itkPointSet->GetPoints()->Begin(); pointsIter!=itkPointSet->GetPoints()->End() ; pointsIter++,j++)
   {
     vtkIdType cell[2] = {j-1,j};
     itk::Point<float> point1 = pointsIter->Value();
     points->InsertPoint(j,point1[0],point1[1],point1[2]);
     if (j>0)
       polys->InsertNextCell(2,cell);
   }
 
   bool close = false;
   this->GetDataNode()->GetBoolProperty("close contour", close);
   if (close)
   {
     vtkIdType cell[2] = {j-1,0};
     polys->InsertNextCell(2,cell);
   }
 
   vtkSmartPointer<vtkPolyData> contour = vtkSmartPointer<vtkPolyData>::New();
   contour->SetPoints(points);
   contour->SetLines(polys);
-//  contour->Update(); //VTK6_TODO pipeline changes
 
   vtkSmartPointer<vtkTubeFilter> tubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
   tubeFilter->SetNumberOfSides( 12 );
   tubeFilter->SetInputData(contour);
 
   //check for property contoursize.
   m_ContourRadius = 0.5;
   mitk::FloatProperty::Pointer contourSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("contoursize") );
 
   if (contourSizeProp.IsNotNull())
     m_ContourRadius = contourSizeProp->GetValue();
 
   tubeFilter->SetRadius( m_ContourRadius );
   tubeFilter->Update();
 
   //add to pipeline
   vtkContourPolyData->AddInputData(tubeFilter->GetOutput());
   vtkContourPolyDataMapper->SetInputData(vtkContourPolyData->GetOutput());
 
   m_ContourActor->SetMapper(vtkContourPolyDataMapper);
   m_PointsAssembly->AddPart(m_ContourActor);
 }
 
 void mitk::PointSetVtkMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "line width", mitk::IntProperty::New(2), renderer, overwrite );
   node->AddProperty( "pointsize", mitk::FloatProperty::New(1.0), renderer, overwrite);
   node->AddProperty( "selectedcolor", mitk::ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite);  //red
   node->AddProperty( "color", mitk::ColorProperty::New(1.0f, 1.0f, 0.0f), renderer, overwrite);  //yellow
   node->AddProperty( "opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite );
   node->AddProperty( "show contour", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "close contour", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "contourcolor", mitk::ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite);
   node->AddProperty( "contoursize", mitk::FloatProperty::New(0.5), renderer, overwrite );
   node->AddProperty( "show points", mitk::BoolProperty::New(true), renderer, overwrite );
   node->AddProperty( "updateDataOnRender", mitk::BoolProperty::New(true), renderer, overwrite );
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
index 92904a0661..8214f30e9a 100755
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
@@ -1,1799 +1,1800 @@
 /*===================================================================
 
 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 "mitkImagePixelReadAccessor.h"
 #include <mitkPixelTypeMultiplex.h>
 
 #include <vtkPointData.h>
 #include <vtkDataArray.h>
 #include <vtkUnsignedCharArray.h>
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 #include <vtkCellData.h>
 #include <vtkIdFilter.h>
 #include <vtkClipPolyData.h>
 #include <vtkPlane.h>
 #include <vtkDoubleArray.h>
 #include <vtkKochanekSpline.h>
 #include <vtkParametricFunctionSource.h>
 #include <vtkParametricSpline.h>
 #include <vtkPolygon.h>
 #include <vtkCleanPolyData.h>
 #include <cmath>
 #include <boost/progress.hpp>
 
 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(i2);
             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)
 {
    mitkPixelTypeMultiplex1( SetFAMap, FAimage->GetPixelType(), FAimage );
 }
 
 template <typename TPixel>
 void mitk::FiberBundleX::SetFAMap(const mitk::PixelType pixelType, 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());
 
   mitk::ImagePixelReadAccessor<TPixel,3> readFAimage (FAimage, FAimage->GetVolumeData(0));
 
   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-readFAimage.GetPixelByWorldCoordinates(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->SetInputData(m_FiberPolyData);
     idFiberFilter->CellIdsOn();
     //  idFiberFilter->PointIdsOn(); // point id's are not needed
     idFiberFilter->SetIdsArrayName(FIBER_ID_ARRAY);
     idFiberFilter->FieldDataOn();
     idFiberFilter->Update();
 
     m_FiberIdDataSet = idFiberFilter->GetOutput();
 
     MITK_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 = cellOriginal->GetNumberOfPoints();
         vtkPoints* pointsOriginal = cellOriginal->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
 
         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 && 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 = pointsOriginal->GetPoint(0);
                 itk::Point<float, 3> itkStart;
                 itkStart[0] = start[0]; itkStart[1] = start[1]; itkStart[2] = start[2];
                 itk::Index<3> idxStart;
                 mask->TransformPhysicalPointToIndex(itkStart, idxStart);
 
                 double* end = pointsOriginal->GetPoint(numPointsOriginal-1);
                 itk::Point<float, 3> itkEnd;
                 itkEnd[0] = end[0]; itkEnd[1] = end[1]; itkEnd[2] = end[2];
                 itk::Index<3> idxEnd;
                 mask->TransformPhysicalPointToIndex(itkEnd, idxEnd);
 
                 if ( mask->GetPixel(idxStart)>0 && mask->GetPixel(idxEnd)>0 && mask->GetLargestPossibleRegion().IsInside(idxStart) && mask->GetLargestPossibleRegion().IsInside(idxEnd) )
                 {
                     for (int j=0; j<numPointsOriginal; j++)
                     {
                         double* p = pointsOriginal->GetPoint(j);
                         vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                         container->GetPointIds()->InsertNextId(id);
                     }
                 }
             }
         }
 
         vtkNewCells->InsertNextCell(container);
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return NULL;
 
     vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
     newPolyData->SetPoints(vtkNewPoints);
     newPolyData->SetLines(vtkNewCells);
     return mitk::FiberBundleX::New(newPolyData);
 }
 
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::RemoveFibersOutside(ItkUcharImgType* mask, bool invert)
 {
     float minSpacing = 1;
     if(mask->GetSpacing()[0]<mask->GetSpacing()[1] && mask->GetSpacing()[0]<mask->GetSpacing()[2])
         minSpacing = mask->GetSpacing()[0];
     else if (mask->GetSpacing()[1] < mask->GetSpacing()[2])
         minSpacing = mask->GetSpacing()[1];
     else
         minSpacing = mask->GetSpacing()[2];
 
     mitk::FiberBundleX::Pointer fibCopy = this->GetDeepCopy();
     fibCopy->ResampleFibers(minSpacing/10);
     vtkSmartPointer<vtkPolyData> polyData =fibCopy->GetFiberPolyData();
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     MITK_INFO << "Cutting fibers";
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
 
         vtkCell* cell = polyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         if (numPoints>1)
         {
             int newNumPoints = 0;
             for (int j=0; j<numPoints; j++)
             {
                 double* p = points->GetPoint(j);
 
                 itk::Point<float, 3> itkP;
                 itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
                 itk::Index<3> idx;
                 mask->TransformPhysicalPointToIndex(itkP, idx);
 
                 if ( mask->GetPixel(idx)>0 && mask->GetLargestPossibleRegion().IsInside(idx) && !invert )
                 {
                     vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                     container->GetPointIds()->InsertNextId(id);
                     newNumPoints++;
                 }
                 else if ( (mask->GetPixel(idx)<=0 || !mask->GetLargestPossibleRegion().IsInside(idx)) && invert )
                 {
                     vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                     container->GetPointIds()->InsertNextId(id);
                     newNumPoints++;
                 }
                 else if (newNumPoints>0)
                 {
                     vtkNewCells->InsertNextCell(container);
 
                     newNumPoints = 0;
                     container = vtkSmartPointer<vtkPolyLine>::New();
                 }
             }
 
             if (newNumPoints>0)
                 vtkNewCells->InsertNextCell(container);
         }
 
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return NULL;
 
     vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
     newPolyData->SetPoints(vtkNewPoints);
     newPolyData->SetLines(vtkNewCells);
     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->SetInputData(m_FiberIdDataSet);
         clipper->SetClipFunction(plane);
         clipper->GenerateClipScalarsOn();
         clipper->GenerateClippedOutputOn();
+        clipper->Update();
         vtkSmartPointer<vtkPolyData> clipperout = clipper->GetClippedOutput();
         MITK_DEBUG << "end clipping";
 
         MITK_DEBUG << "init and update clipperoutput";
-        clipperout->GetPointData()->Initialize();
+//        clipperout->GetPointData()->Initialize();
 //        clipperout->Update(); //VTK6_TODO
         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->SetInputData(m_FiberPolyData);
     cleaner->PointMergingOff();
     cleaner->Update();
     m_FiberPolyData = cleaner->GetOutput();
 
     m_FiberLengths.clear();
     m_MeanFiberLength = 0;
     m_MedianFiberLength = 0;
     m_LengthStDev = 0;
     m_NumFibers = m_FiberPolyData->GetNumberOfCells();
 
     if (m_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);
 }
 
 std::vector<std::string> mitk::FiberBundleX::GetAvailableColorCodings()
 {
     std::vector<std::string> availableColorCodings;
     int numColors = m_FiberPolyData->GetPointData()->GetNumberOfArrays();
     for(int i=0; i<numColors; i++)
     {
         availableColorCodings.push_back(m_FiberPolyData->GetPointData()->GetArrayName(i));
     }
 
     //this controlstructure shall be implemented by the calling method
     if (availableColorCodings.empty())
         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)
 {
     MITK_INFO << "Removing short fibers";
     if (lengthInMM<=0 || lengthInMM<m_MinFiberLength)
     {
         MITK_INFO << "No fibers shorter than " << lengthInMM << " mm found!";
         return true;
     }
 
     if (lengthInMM>m_MaxFiberLength)    // can't remove all fibers
     {
         MITK_WARN << "Process aborted. No fibers would be left!";
         return false;
     }
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
     float min = m_MaxFiberLength;
 
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         if (m_FiberLengths.at(i)>=lengthInMM)
         {
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (int j=0; j<numPoints; j++)
             {
                 double* p = points->GetPoint(j);
                 vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                 container->GetPointIds()->InsertNextId(id);
             }
             vtkNewCells->InsertNextCell(container);
             if (m_FiberLengths.at(i)<min)
                 min = m_FiberLengths.at(i);
         }
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return false;
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
 
     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(float pointDistance, double tension, double continuity, double bias )
 {
     if (pointDistance<=0)
         return;
 
     vtkSmartPointer<vtkPoints> vtkSmoothPoints = vtkSmartPointer<vtkPoints>::New(); //in smoothpoints the interpolated points representing a fiber are stored.
 
     //in vtkcells all polylines are stored, actually all id's of them are stored
     vtkSmartPointer<vtkCellArray> vtkSmoothCells = vtkSmartPointer<vtkCellArray>::New(); //cellcontainer for smoothed lines
     vtkIdType pointHelperCnt = 0;
 
     MITK_INFO << "Smoothing fibers";
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPoints> newPoints = vtkSmartPointer<vtkPoints>::New();
         for (int j=0; j<numPoints; j++)
             newPoints->InsertNextPoint(points->GetPoint(j));
 
         float length = m_FiberLengths.at(i);
         int sampling = std::ceil(length/pointDistance);
 
         vtkSmartPointer<vtkKochanekSpline> xSpline = vtkSmartPointer<vtkKochanekSpline>::New();
         vtkSmartPointer<vtkKochanekSpline> ySpline = vtkSmartPointer<vtkKochanekSpline>::New();
         vtkSmartPointer<vtkKochanekSpline> zSpline = vtkSmartPointer<vtkKochanekSpline>::New();
         xSpline->SetDefaultBias(bias); xSpline->SetDefaultTension(tension); xSpline->SetDefaultContinuity(continuity);
         ySpline->SetDefaultBias(bias); ySpline->SetDefaultTension(tension); ySpline->SetDefaultContinuity(continuity);
         zSpline->SetDefaultBias(bias); zSpline->SetDefaultTension(tension); zSpline->SetDefaultContinuity(continuity);
 
         vtkSmartPointer<vtkParametricSpline> spline = vtkSmartPointer<vtkParametricSpline>::New();
         spline->SetXSpline(xSpline);
         spline->SetYSpline(ySpline);
         spline->SetZSpline(zSpline);
         spline->SetPoints(newPoints);
 
         vtkSmartPointer<vtkParametricFunctionSource> functionSource = vtkSmartPointer<vtkParametricFunctionSource>::New();
         functionSource->SetParametricFunction(spline);
         functionSource->SetUResolution(sampling);
         functionSource->SetVResolution(sampling);
         functionSource->SetWResolution(sampling);
         functionSource->Update();
 
         vtkPolyData* outputFunction = functionSource->GetOutput();
         vtkPoints* tmpSmoothPnts = outputFunction->GetPoints(); //smoothPoints of current fiber
 
         vtkSmartPointer<vtkPolyLine> smoothLine = vtkSmartPointer<vtkPolyLine>::New();
         smoothLine->GetPointIds()->SetNumberOfIds(tmpSmoothPnts->GetNumberOfPoints());
 
         for (int j=0; j<smoothLine->GetNumberOfPoints(); j++)
         {
             smoothLine->GetPointIds()->SetId(j, j+pointHelperCnt);
             vtkSmoothPoints->InsertNextPoint(tmpSmoothPnts->GetPoint(j));
         }
         vtkSmoothCells->InsertNextCell(smoothLine);
         pointHelperCnt += tmpSmoothPnts->GetNumberOfPoints();
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkSmoothPoints);
     m_FiberPolyData->SetLines(vtkSmoothCells);
     UpdateColorCoding();
     UpdateFiberGeometry();
     m_FiberSampling = 10/pointDistance;
 }
 
 void mitk::FiberBundleX::DoFiberSmoothing(float pointDistance)
 {
     DoFiberSmoothing(pointDistance, 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/IGT/IGTFilters/mitkTrackingVolumeGenerator.cpp b/Modules/IGT/IGTFilters/mitkTrackingVolumeGenerator.cpp
index 5415037cf5..51e7bc5498 100644
--- a/Modules/IGT/IGTFilters/mitkTrackingVolumeGenerator.cpp
+++ b/Modules/IGT/IGTFilters/mitkTrackingVolumeGenerator.cpp
@@ -1,117 +1,117 @@
 /*===================================================================
 
 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 "mitkTrackingVolumeGenerator.h"
 #include "mitkSTLFileReader.h"
 #include "mitkStandardFileLocations.h"
 #include "mitkConfig.h"
 #include <vtkCubeSource.h>
 #include <mitkTrackingTypes.h>
 #include <mitkTrackingDevice.h>
 #include <mitkVirtualTrackingDevice.h>
 #include <vtkSmartPointer.h>
 #include <mitkSurface.h>
 
 mitk::TrackingVolumeGenerator::TrackingVolumeGenerator()
 {
   try
     {
     std::string volumeDir = MITK_ROOT;
     volumeDir += "Modules/IGT/IGTTrackingDevices/TrackingVolumeData"; //folder which contains the trackingdevices configs
     mitk::StandardFileLocations::GetInstance()->AddDirectoryForSearch( volumeDir.c_str(), false ); //add this directory to StdFileLocations for the search
     }
   catch(std::exception e)
     {
     MITK_ERROR << "Error: cannot add path to mitk standard file locations";
     //TODO: add appropriate error handling as soon as there is an error handling concept for MITK
     }
 
   m_Data = mitk::DeviceDataUnspecified;
 }
 
 
 void mitk::TrackingVolumeGenerator::SetTrackingDevice (mitk::TrackingDevice::Pointer tracker)
 {
   this->m_Data = mitk::GetFirstCompatibleDeviceDataForLine(tracker->GetType());
 }
 
 void mitk::TrackingVolumeGenerator::GenerateData()
 {
     mitk::Surface::Pointer output = this->GetOutput();  //the surface wich represents the tracking volume
 
     std::string filepath = ""; // Full path to file (wil be resolved later)
   std::string filename = this->m_Data.VolumeModelLocation; // Name of the file or possibly a magic String, e.g. "cube"
 
   // See if filename matches a magic string.
   if (filename.compare("cube") == 0){
             vtkSmartPointer<vtkCubeSource> cubeSource = vtkSmartPointer<vtkCubeSource>::New();
             double bounds[6];
             bounds[0] = bounds[2] = bounds[4] = -400.0;  // initialize bounds to -400 ... +400 cube. This is the default value of the
             bounds[1] = bounds[3] = bounds[5] =  400.0;  // virtual tracking device, but it can be changed. In that case,
                                                          // the tracking volume polydata has to be updated manually
             cubeSource->SetBounds(bounds);
-//            cubeSource->GetOutput()->Update(); //VTK6_TODO
+            cubeSource->->Update();
 
             output->SetVtkPolyData(cubeSource->GetOutput()); //set the vtkCubeSource as polyData of the surface
             return;
   }
   if (filename.compare("") == 0) // empty String means no model, return empty output
   {
       output->SetVtkPolyData(vtkPolyData::New()); //initialize with empty poly data (otherwise old surfaces may be returned) => so an empty surface is returned
       return;
   }
 
   // from here on, we assume that filename contains an actual filename and not a magic string
 
   filepath = mitk::StandardFileLocations::GetInstance()->FindFile(filename.c_str());
 
     if (filepath.empty())
     {
         MITK_ERROR << ("Volume Generator could not find the specified file " + filename);
         return;
     }
 
     mitk::STLFileReader::Pointer stlReader = mitk::STLFileReader::New();
     stlReader->SetFileName( filepath.c_str() );
     stlReader->Update();
 
     if ( stlReader->GetOutput() == NULL)
     {
         MITK_ERROR << "Error while reading file";
         return ;
     }
     output->SetVtkPolyData( stlReader->GetOutput()->GetVtkPolyData());//set the visible trackingvolume
 }
 
 void mitk::TrackingVolumeGenerator::SetTrackingDeviceType(mitk::TrackingDeviceType deviceType)
 {
   m_Data = mitk::GetFirstCompatibleDeviceDataForLine(deviceType);
 }
 
 mitk::TrackingDeviceType mitk::TrackingVolumeGenerator::GetTrackingDeviceType() const
 {
  return m_Data.Line;
 }
 
 void mitk::TrackingVolumeGenerator::SetTrackingDeviceData(mitk::TrackingDeviceData deviceData)
 {
   m_Data= deviceData;
 }
 
 mitk::TrackingDeviceData mitk::TrackingVolumeGenerator::GetTrackingDeviceData() const
 {
    return m_Data;
 }
diff --git a/Modules/MitkExt/Algorithms/mitkLabeledImageToSurfaceFilter.cpp b/Modules/MitkExt/Algorithms/mitkLabeledImageToSurfaceFilter.cpp
index 7d6d38fcbf..b729c365c3 100644
--- a/Modules/MitkExt/Algorithms/mitkLabeledImageToSurfaceFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkLabeledImageToSurfaceFilter.cpp
@@ -1,364 +1,364 @@
 /*===================================================================
 
 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 <mitkLabeledImageToSurfaceFilter.h>
 
 #include <vtkImageChangeInformation.h>
 #include <vtkImageThreshold.h>
 #include <vtkImageGaussianSmooth.h>
 #include <vtkImageMarchingCubes.h>
 #include <vtkPolyData.h>
 #include <vtkSmoothPolyDataFilter.h>
 #include <vtkDecimatePro.h>
 #include <vtkLinearTransform.h>
 #include <vtkMatrix4x4.h>
 
 #include <mitkImageAccessByItk.h>
 #include <mitkInstantiateAccessFunctions.h>
 #include <itkImageRegionIterator.h>
 #include <itkNumericTraits.h>
 
 
 mitk::LabeledImageToSurfaceFilter::LabeledImageToSurfaceFilter() :
 m_GaussianStandardDeviation(1.5),
 m_GenerateAllLabels(true),
 m_Label(1),
 m_BackgroundLabel(0)
 {
 }
 
 mitk::LabeledImageToSurfaceFilter::~LabeledImageToSurfaceFilter()
 {
 }
 
 void mitk::LabeledImageToSurfaceFilter::GenerateOutputInformation()
 {
   Superclass::GenerateOutputInformation();
   //
   // check which labels are available in the image
   //
   m_AvailableLabels = this->GetAvailableLabels();
   m_IdxToLabels.clear();
 
   //
   // if we don't want to generate surfaces for all labels
   // we have to remove all labels except m_Label and m_BackgroundLabel
   // from the list of available labels
   //
   if ( ! m_GenerateAllLabels )
   {
     LabelMapType tmp;
     LabelMapType::iterator it;
     it = m_AvailableLabels.find( m_Label );
     if ( it != m_AvailableLabels.end() )
       tmp[m_Label] = it->second;
     else
       tmp[m_Label] = 0;
 
     it = m_AvailableLabels.find( m_BackgroundLabel );
     if ( it != m_AvailableLabels.end() )
       tmp[m_BackgroundLabel] = it->second;
     else
       tmp[m_BackgroundLabel] = 0;
 
     m_AvailableLabels = tmp;
   }
 
   //
   // check for the number of labels: if the whole image is filled, no
   // background is available and thus the numberOfOutpus is equal to the
   // number of available labels in the image (which is a special case).
   // If we have background voxels, the number of outputs is one less than
   // then number of available labels.
   //
   unsigned int numberOfOutputs = 0;
   if ( m_AvailableLabels.find( m_BackgroundLabel ) == m_AvailableLabels.end() )
     numberOfOutputs = m_AvailableLabels.size();
   else
     numberOfOutputs = m_AvailableLabels.size() - 1;
   if ( numberOfOutputs == 0 )
   {
     itkWarningMacro("Number of outputs == 0");
   }
 
   //
   // determine the number of time steps of the input image
   //
   mitk::Image* image =  ( mitk::Image* )GetInput();
 
   unsigned int numberOfTimeSteps = image->GetTimeGeometry()->CountTimeSteps();
 
   //
   // set the number of outputs to the number of labels used.
   // initialize the output surfaces accordingly (incl. time steps)
   //
   this->SetNumberOfIndexedOutputs( numberOfOutputs );
   this->SetNumberOfRequiredOutputs( numberOfOutputs );
   for ( unsigned int i = 0 ; i < numberOfOutputs; ++i )
   {
     if ( ! this->GetOutput( i ) )
     {
       mitk::Surface::Pointer output = static_cast<mitk::Surface*>( this->MakeOutput(0).GetPointer() );
       assert ( output.IsNotNull() );
       output->Expand( numberOfTimeSteps );
       this->SetNthOutput( i, output.GetPointer() );
     }
   }
 }
 
 
 void mitk::LabeledImageToSurfaceFilter::GenerateData()
 {
   mitk::Image* image =  ( mitk::Image* )GetInput();
   if ( image == NULL )
   {
     itkWarningMacro("Image is NULL");
     return;
   }
 
   mitk::Image::RegionType outputRegion = image->GetRequestedRegion();
 
   m_IdxToLabels.clear();
 
   if ( this->GetNumberOfOutputs() == 0 )
     return;
 
   //
   // traverse the known labels and create surfaces for them.
   //
   unsigned int currentOutputIndex = 0;
   for ( LabelMapType::iterator it = m_AvailableLabels.begin() ; it != m_AvailableLabels.end() ; ++it )
   {
     if ( it->first == m_BackgroundLabel )
       continue;
     if ( ( it->second == 0 ) && m_GenerateAllLabels )
       continue;
 
     assert ( currentOutputIndex < this->GetNumberOfOutputs() );
     mitk::Surface::Pointer surface = this->GetOutput( currentOutputIndex );
     assert( surface.IsNotNull() );
 
     int tstart=outputRegion.GetIndex(3);
     int tmax=tstart+outputRegion.GetSize(3); //GetSize()==1 - will aber 0 haben, wenn nicht zeitaufgeloet
     int t;
     for( t=tstart; t < tmax; ++t)
     {
       vtkImageData *vtkimagedata =  image->GetVtkImageData( t );
       CreateSurface( t,vtkimagedata,surface.GetPointer(), it->first );
     }
     m_IdxToLabels[ currentOutputIndex ] = it->first;
     currentOutputIndex++;
   }
 }
 
 void mitk::LabeledImageToSurfaceFilter::CreateSurface( int time, vtkImageData *vtkimage, mitk::Surface * surface, mitk::LabeledImageToSurfaceFilter::LabelType label )
 {
   vtkImageChangeInformation *indexCoordinatesImageFilter = vtkImageChangeInformation::New();
   indexCoordinatesImageFilter->SetInputData(vtkimage);
   indexCoordinatesImageFilter->SetOutputOrigin(0.0,0.0,0.0);
 
     vtkImageThreshold* threshold = vtkImageThreshold::New();
     threshold->SetInputData( indexCoordinatesImageFilter->GetOutput() );
     //indexCoordinatesImageFilter->Delete();
     threshold->SetInValue( 100 );
     threshold->SetOutValue( 0 );
     threshold->ThresholdBetween( label, label );
     threshold->SetOutputScalarTypeToUnsignedChar();
     threshold->ReleaseDataFlagOn();
 
     vtkImageGaussianSmooth *gaussian = vtkImageGaussianSmooth::New();
     gaussian->SetInputData( threshold->GetOutput() );
     //threshold->Delete();
     gaussian->SetDimensionality( 3  );
     gaussian->SetRadiusFactor( 0.49 );
     gaussian->SetStandardDeviation( GetGaussianStandardDeviation() );
     gaussian->ReleaseDataFlagOn();
     gaussian->UpdateInformation();
     gaussian->Update();
 
   //MarchingCube -->create Surface
   vtkMarchingCubes *skinExtractor = vtkMarchingCubes::New();
   skinExtractor->ReleaseDataFlagOn();
   skinExtractor->SetInputData(gaussian->GetOutput());//RC++
   indexCoordinatesImageFilter->Delete();
   skinExtractor->SetValue(0, 50);
 
   vtkPolyData *polydata;
+  skinExtractor->Update();
   polydata = skinExtractor->GetOutput();
   polydata->Register(NULL);//RC++
   skinExtractor->Delete();
 
   if (m_Smooth)
   {
     vtkSmoothPolyDataFilter *smoother = vtkSmoothPolyDataFilter::New();
     //read poly1 (poly1 can be the original polygon, or the decimated polygon)
     smoother->SetInputData(polydata);//RC++
     smoother->SetNumberOfIterations( m_SmoothIteration );
     smoother->SetRelaxationFactor( m_SmoothRelaxation );
     smoother->SetFeatureAngle( 60 );
     smoother->FeatureEdgeSmoothingOff();
     smoother->BoundarySmoothingOff();
     smoother->SetConvergence( 0 );
 
     polydata->Delete();//RC--
+    smoother->Update();
     polydata = smoother->GetOutput();
     polydata->Register(NULL);//RC++
     smoother->Delete();
   }
 
   //decimate = to reduce number of polygons
   if(m_Decimate==DecimatePro)
   {
     vtkDecimatePro *decimate = vtkDecimatePro::New();
     decimate->SplittingOff();
     decimate->SetErrorIsAbsolute(5);
     decimate->SetFeatureAngle(30);
     decimate->PreserveTopologyOn();
     decimate->BoundaryVertexDeletionOff();
     decimate->SetDegree(10); //std-value is 25!
 
     decimate->SetInputData(polydata);//RC++
     decimate->SetTargetReduction(m_TargetReduction);
     decimate->SetMaximumError(0.002);
 
     polydata->Delete();//RC--
+    decimate->Update();
     polydata = decimate->GetOutput();
     polydata->Register(NULL);//RC++
     decimate->Delete();
   }
 
-//  polydata->Update(); //VTK6_TODO
-//  polydata->SetSource(NULL);
-
   if(polydata->GetNumberOfPoints() > 0)
   {
     mitk::Vector3D spacing = GetInput()->GetGeometry(time)->GetSpacing();
 
     vtkPoints * points = polydata->GetPoints();
     vtkMatrix4x4 *vtkmatrix = vtkMatrix4x4::New();
     GetInput()->GetGeometry(time)->GetVtkTransform()->GetMatrix(vtkmatrix);
     double (*matrix)[4] = vtkmatrix->Element;
 
     unsigned int i,j;
     for(i=0;i<3;++i)
       for(j=0;j<3;++j)
         matrix[i][j]/=spacing[j];
 
     unsigned int n = points->GetNumberOfPoints();
     double point[3];
 
     for (i = 0; i < n; i++)
     {
       points->GetPoint(i, point);
       mitkVtkLinearTransformPoint(matrix,point,point);
       points->SetPoint(i, point);
     }
     vtkmatrix->Delete();
   }
 
   surface->SetVtkPolyData(polydata, time);
   polydata->UnRegister(NULL);
 
   gaussian->Delete();
   threshold->Delete();
 }
 
 template < typename TPixel, unsigned int VImageDimension >
     void GetAvailableLabelsInternal( itk::Image<TPixel, VImageDimension>* image, mitk::LabeledImageToSurfaceFilter::LabelMapType& availableLabels )
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::ImageRegionIterator< ImageType > ImageRegionIteratorType;
   availableLabels.clear();
   ImageRegionIteratorType it( image, image->GetLargestPossibleRegion() );
   it.GoToBegin();
   mitk::LabeledImageToSurfaceFilter::LabelMapType::iterator labelIt;
   while( ! it.IsAtEnd() )
   {
     labelIt = availableLabels.find( ( mitk::LabeledImageToSurfaceFilter::LabelType ) ( it.Get() ) );
     if ( labelIt == availableLabels.end() )
     {
       availableLabels[ ( mitk::LabeledImageToSurfaceFilter::LabelType ) ( it.Get() ) ] = 1;
     }
     else
     {
       labelIt->second += 1;
     }
 
     ++it;
   }
 }
 
 #define InstantiateAccessFunction_GetAvailableLabelsInternal(pixelType, dim) \
 template void GetAvailableLabelsInternal(itk::Image<pixelType, dim>*, mitk::LabeledImageToSurfaceFilter::LabelMapType&);
 
 InstantiateAccessFunctionForFixedDimension(GetAvailableLabelsInternal, 3);
 
 
 mitk::LabeledImageToSurfaceFilter::LabelMapType mitk::LabeledImageToSurfaceFilter::GetAvailableLabels()
 {
   mitk::Image::Pointer image =  ( mitk::Image* )GetInput();
   LabelMapType availableLabels;
   AccessFixedDimensionByItk_1( image, GetAvailableLabelsInternal, 3, availableLabels );
   return availableLabels;
 }
 
 
 void mitk::LabeledImageToSurfaceFilter::CreateSurface(int, vtkImageData*, mitk::Surface*, const ScalarType)
 {
   itkWarningMacro( "This function should never be called!" );
   assert(false);
 }
 
 mitk::LabeledImageToSurfaceFilter::LabelType mitk::LabeledImageToSurfaceFilter::GetLabelForNthOutput( const unsigned int& idx )
 {
   IdxToLabelMapType::iterator it = m_IdxToLabels.find( idx );
   if ( it != m_IdxToLabels.end() )
   {
     return it->second;
   }
   else
   {
     itkWarningMacro( "Unknown index encountered: " << idx << ". There are " << this->GetNumberOfOutputs() << " outputs available." );
     return itk::NumericTraits<LabelType>::max();
   }
 }
 
 mitk::ScalarType mitk::LabeledImageToSurfaceFilter::GetVolumeForNthOutput( const unsigned int& i )
 {
   return GetVolumeForLabel( GetLabelForNthOutput( i ) );
 }
 
 mitk::ScalarType mitk::LabeledImageToSurfaceFilter::GetVolumeForLabel( const mitk::LabeledImageToSurfaceFilter::LabelType& label )
 {
   // get the image spacing
   mitk::Image* image =  ( mitk::Image* )GetInput();
   const float* spacing = image->GetSlicedGeometry()->GetFloatSpacing();
 
   // get the number of voxels encountered for the given label,
   // calculate the volume and return it.
   LabelMapType::iterator it = m_AvailableLabels.find( label );
   if ( it != m_AvailableLabels.end() )
   {
     return static_cast<float>(it->second) * ( spacing[0] * spacing[1] * spacing[2] / 1000.0f );
   }
   else
   {
     itkWarningMacro( "Unknown label encountered: " << label );
     return 0.0;
   }
 }
 
 
diff --git a/Modules/MitkExt/Rendering/vtkMitkVolumeTextureMapper3D.cpp b/Modules/MitkExt/Rendering/vtkMitkVolumeTextureMapper3D.cpp
index 621639e17a..433941cba8 100644
--- a/Modules/MitkExt/Rendering/vtkMitkVolumeTextureMapper3D.cpp
+++ b/Modules/MitkExt/Rendering/vtkMitkVolumeTextureMapper3D.cpp
@@ -1,740 +1,740 @@
 /*===================================================================
 
 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 "vtkMitkVolumeTextureMapper3D.h"
 #include "mitkCommon.h"
 
 #define GPU_INFO MITK_INFO("mapper.vr")
 #define GPU_WARN MITK_WARN("mapper.vr")
 
 #include "vtkCamera.h"
 #include "vtkColorTransferFunction.h"
 #include "vtkDataArray.h"
 #include "vtkImageData.h"
 #include "vtkMath.h"
 #include "vtkMatrix4x4.h"
 #include "vtkPiecewiseFunction.h"
 #include "vtkPointData.h"
 #include "vtkRenderer.h"
 #include "vtkVolume.h"
 #include "vtkVolumeProperty.h"
 //#include "vtkVolumeRenderingFactory.h" //VTK6_TODO
 
 
 //----------------------------------------------------------------------------
 // Needed when we don't use the vtkStandardNewMacro.
 vtkInstantiatorNewMacro(vtkMitkVolumeTextureMapper3D);
 //----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 vtkMitkVolumeTextureMapper3D::vtkMitkVolumeTextureMapper3D()
 {
   //GPU_INFO << "vtkMitkVolumeTextureMapper3D";
 
   this->PolygonBuffer                 = NULL;
   this->IntersectionBuffer            = NULL;
   this->NumberOfPolygons              = 0;
   this->BufferSize                    = 0;
 
   // The input used when creating the textures
   this->SavedTextureInput             = NULL;
 
   // The input used when creating the color tables
   this->SavedParametersInput           = NULL;
 
   this->SavedRGBFunction              = NULL;
   this->SavedGrayFunction             = NULL;
   this->SavedScalarOpacityFunction    = NULL;
   this->SavedGradientOpacityFunction  = NULL;
   this->SavedColorChannels            = 0;
   this->SavedSampleDistance           = 0;
   this->SavedScalarOpacityDistance    = 0;
 
 /*
   this->Volume1                       = NULL;
   this->Volume2                       = NULL;
   this->Volume3                       = NULL;
   */
   /*
   this->VolumeSize                    = 0;
   this->VolumeComponents              = 0;
     */
 
   this->VolumeSpacing[0] = this->VolumeSpacing[1] = this->VolumeSpacing[2] = 0;
   this->VolumeDimensions[0]=0;
   this->VolumeDimensions[1]=0;
   this->VolumeDimensions[2]=0;
 
   this->SampleDistance                = 1.0;
   this->ActualSampleDistance          = 1.0;
 
   this->UseCompressedTexture          = false;
   this->SupportsNonPowerOfTwoTextures = false;
 
   //GPU_INFO << "np2: " << (this->SupportsNonPowerOfTwoTextures?1:0);
 }
 
 //-----------------------------------------------------------------------------
 vtkMitkVolumeTextureMapper3D::~vtkMitkVolumeTextureMapper3D()
 {
   //GPU_INFO << "~vtkMitkVolumeTextureMapper3D";
 
   delete [] this->PolygonBuffer;
   delete [] this->IntersectionBuffer;
   /*
   delete [] this->Volume1;
   delete [] this->Volume2;
   delete [] this->Volume3;
   */
 }
 
 
 //-----------------------------------------------------------------------------
 //vtkMitkVolumeTextureMapper3D *vtkMitkVolumeTextureMapper3D::New() //VTK6_TODO
 //{
 //  //GPU_INFO << "New";
 
 //   // First try to create the object from the vtkObjectFactory
 //  vtkObject* ret =
 //    vtkVolumeRenderingFactory::CreateInstance("vtkMitkVolumeTextureMapper3D");
 //  return static_cast<vtkMitkVolumeTextureMapper3D *>(ret);
 //}
 
 //-----------------------------------------------------------------------------
 void vtkMitkVolumeTextureMapper3D::ComputePolygons( vtkRenderer *ren,
                                                 vtkVolume *vol,
                                                 double inBounds[6] )
 {
   //GPU_INFO << "ComputePolygons";
 
   // Get the camera position and focal point
   double focalPoint[4], position[4];
   double plane[4];
   vtkCamera *camera = ren->GetActiveCamera();
 
   camera->GetPosition( position );
   camera->GetFocalPoint( focalPoint );
 
   position[3]   = 1.0;
   focalPoint[3] = 1.0;
 
   // Pass the focal point and position through the inverse of the
   // volume's matrix to map back into the data coordinates. We
   // are going to compute these polygons in the coordinate system
   // of the input data - this is easiest since this data must be
   // axis aligned. Then we'll use OpenGL to transform these polygons
   // into the world coordinate system through the use of the
   // volume's matrix.
   vtkMatrix4x4 *matrix = vtkMatrix4x4::New();
   vol->GetMatrix( matrix );
   matrix->Invert();
   matrix->MultiplyPoint( position, position );
   matrix->MultiplyPoint( focalPoint, focalPoint );
   matrix->Delete();
 
   if ( position[3] )
     {
     position[0] /= position[3];
     position[1] /= position[3];
     position[2] /= position[3];
     }
 
   if ( focalPoint[3] )
     {
     focalPoint[0] /= focalPoint[3];
     focalPoint[1] /= focalPoint[3];
     focalPoint[2] /= focalPoint[3];
     }
 
   // Create a plane equation using the direction and position of the camera
   plane[0] = focalPoint[0] - position[0];
   plane[1] = focalPoint[1] - position[1];
   plane[2] = focalPoint[2] - position[2];
 
   vtkMath::Normalize( plane );
 
   plane[3] = -(plane[0] * position[0] + plane[1] * position[1] +
                plane[2] * position[2]);
 
   // Find the min and max distances of the boundary points of the volume
   double minDistance = VTK_DOUBLE_MAX;
   double maxDistance = VTK_DOUBLE_MIN;
 
   // The inBounds parameter is the bounds we are using for clipping the
   // texture planes against. First we need to clip these against the bounds
   // of the volume to make sure they don't exceed it.
   double volBounds[6];
   this->GetInput()->GetBounds( volBounds );
 
   double bounds[6];
   bounds[0] = (inBounds[0]>volBounds[0])?(inBounds[0]):(volBounds[0]);
   bounds[1] = (inBounds[1]<volBounds[1])?(inBounds[1]):(volBounds[1]);
   bounds[2] = (inBounds[2]>volBounds[2])?(inBounds[2]):(volBounds[2]);
   bounds[3] = (inBounds[3]<volBounds[3])?(inBounds[3]):(volBounds[3]);
   bounds[4] = (inBounds[4]>volBounds[4])?(inBounds[4]):(volBounds[4]);
   bounds[5] = (inBounds[5]<volBounds[5])?(inBounds[5]):(volBounds[5]);
 
   // Create 8 vertices for the bounding box we are rendering
   int i, j, k;
   double vertices[8][3];
 
   int idx = 0;
 
   for ( k = 0; k < 2; k++ )
     {
     for ( j = 0; j < 2; j++ )
       {
       for ( i = 0; i < 2; i++ )
         {
         vertices[idx][2] = bounds[4+k];
         vertices[idx][1] = bounds[2+j];
         vertices[idx][0] = bounds[i];
 
         double d =
           plane[0] * vertices[idx][0] +
           plane[1] * vertices[idx][1] +
           plane[2] * vertices[idx][2] +
           plane[3];
 
         idx++;
 
         // Keep track of closest and farthest point
         minDistance = (d<minDistance)?(d):(minDistance);
         maxDistance = (d>maxDistance)?(d):(maxDistance);
 
         }
       }
     }
 
   int dim[6];
   this->GetVolumeDimensions(dim);
 
   float tCoordOffset[3], tCoordScale[3];
 
   tCoordOffset[0] = 0.5 / dim[0];
   tCoordOffset[1] = 0.5 / dim[1];
   tCoordOffset[2] = 0.5 / dim[2];
 
   tCoordScale[0] =  (dim[0]-1) / static_cast<float>(dim[0]);
   tCoordScale[1] =  (dim[1]-1) / static_cast<float>(dim[1]);
   tCoordScale[2] =  (dim[2]-1) / static_cast<float>(dim[2]);
 
   float spacing[3];
   this->GetVolumeSpacing( spacing );
 
   double offset =
     0.333 * 0.5 * (spacing[0] + spacing[1] + spacing[2]);
 
   minDistance += 0.1*offset;
   maxDistance -= 0.1*offset;
 
   minDistance = (minDistance < offset)?(offset):(minDistance);
 
   double stepSize = this->ActualSampleDistance;
 
   // Determine the number of polygons
   int numPolys = static_cast<int>(
     (maxDistance - minDistance)/static_cast<double>(stepSize));
 
   // Check if we have space, free old space only if it is too small
   if ( this->BufferSize < numPolys )
     {
     delete [] this->PolygonBuffer;
     delete [] this->IntersectionBuffer;
 
     this->BufferSize = numPolys;
 
     this->PolygonBuffer = new float [36*this->BufferSize];
     this->IntersectionBuffer = new float [12*this->BufferSize];
     }
 
   this->NumberOfPolygons = numPolys;
 
   // Compute the intersection points for each edge of the volume
   int lines[12][2] = { {0,1}, {1,3}, {2,3}, {0,2},
                        {4,5}, {5,7}, {6,7}, {4,6},
                        {0,4}, {1,5}, {3,7}, {2,6} };
 
   float *iptr, *pptr;
 
   for ( i = 0; i < 12; i++ )
     {
     double line[3];
 
     line[0] = vertices[lines[i][1]][0] - vertices[lines[i][0]][0];
     line[1] = vertices[lines[i][1]][1] - vertices[lines[i][0]][1];
     line[2] = vertices[lines[i][1]][2] - vertices[lines[i][0]][2];
 
     double d = maxDistance;
 
     iptr = this->IntersectionBuffer + i;
 
     double planeDotLineOrigin = vtkMath::Dot( plane, vertices[lines[i][0]] );
     double planeDotLine       = vtkMath::Dot( plane, line );
 
     double t, increment;
 
     if ( planeDotLine != 0.0 )
       {
       t = (d - planeDotLineOrigin - plane[3] ) / planeDotLine;
       increment = -stepSize / planeDotLine;
       }
     else
       {
       t         = -1.0;
       increment =  0.0;
       }
 
     for ( j = 0; j < numPolys; j++ )
       {
       *iptr = (t > 0.0 && t < 1.0)?(t):(-1.0);
 
       t += increment;
       iptr += 12;
       }
     }
 
   // Compute the polygons by determining which edges were intersected
   int neighborLines[12][6] =
   { {  1,  2,  3,  4,  8,  9}, {  0,  2,  3,  5,  9, 10},
     {  0,  1,  3,  6, 10, 11}, {  0,  1,  2,  7,  8, 11},
     {  0,  5,  6,  7,  8,  9}, {  1,  4,  6,  7,  9, 10},
     {  2,  4,  5,  7, 10, 11}, {  3,  4,  5,  6,  8, 11},
     {  0,  3,  4,  7,  9, 11}, {  0,  1,  4,  5,  8, 10},
     {  1,  2,  5,  6,  9, 11}, {  2,  3,  6,  7,  8, 10} };
 
   float tCoord[12][4] =
   {{0,0,0,0}, {1,0,0,1}, {0,1,0,0}, {0,0,0,1},
    {0,0,1,0}, {1,0,1,1}, {0,1,1,0}, {0,0,1,1},
    {0,0,0,2}, {1,0,0,2}, {1,1,0,2}, {0,1,0,2}};
 
   double low[3];
   double high[3];
 
   low[0]  = (bounds[0] - volBounds[0]) / (volBounds[1] - volBounds[0]);
   high[0] = (bounds[1] - volBounds[0]) / (volBounds[1] - volBounds[0]);
   low[1]  = (bounds[2] - volBounds[2]) / (volBounds[3] - volBounds[2]);
   high[1] = (bounds[3] - volBounds[2]) / (volBounds[3] - volBounds[2]);
   low[2]  = (bounds[4] - volBounds[4]) / (volBounds[5] - volBounds[4]);
   high[2] = (bounds[5] - volBounds[4]) / (volBounds[5] - volBounds[4]);
 
   for ( i = 0; i < 12; i++ )
     {
     tCoord[i][0] = (tCoord[i][0])?(high[0]):(low[0]);
     tCoord[i][1] = (tCoord[i][1])?(high[1]):(low[1]);
     tCoord[i][2] = (tCoord[i][2])?(high[2]):(low[2]);
     }
 
   iptr = this->IntersectionBuffer;
   pptr = this->PolygonBuffer;
 
   for ( i = 0; i < numPolys; i++ )
     {
     // Look for a starting point
     int start = 0;
 
     while ( start < 12 && iptr[start] == -1.0 )
       {
       start++;
       }
 
     if ( start == 12 )
       {
       pptr[0] = -1.0;
       }
     else
       {
       int current = start;
       int previous = -1;
       int errFlag = 0;
 
       idx   = 0;
 
       while ( idx < 6 && !errFlag && ( idx == 0 || current != start) )
         {
         double t = iptr[current];
 
         *(pptr + idx*6)     =
           tCoord[current][0] * tCoordScale[0] + tCoordOffset[0];
         *(pptr + idx*6 + 1) =
           tCoord[current][1] * tCoordScale[1] + tCoordOffset[1];
         *(pptr + idx*6 + 2) =
           tCoord[current][2] * tCoordScale[2] + tCoordOffset[2];
 
         int coord = static_cast<int>(tCoord[current][3]);
         *(pptr + idx*6 + coord) =
           (low[coord] + t*(high[coord]-low[coord]))*tCoordScale[coord] + tCoordOffset[coord];
 
         *(pptr + idx*6 + 3) = static_cast<float>(
           vertices[lines[current][0]][0] +
           t*(vertices[lines[current][1]][0] - vertices[lines[current][0]][0]));
 
         *(pptr + idx*6 + 4) = static_cast<float>(
           vertices[lines[current][0]][1] +
           t*(vertices[lines[current][1]][1] - vertices[lines[current][0]][1]));
 
         *(pptr + idx*6 + 5) = static_cast<float>(
           vertices[lines[current][0]][2] +
           t*(vertices[lines[current][1]][2] - vertices[lines[current][0]][2]));
 
         idx++;
 
         j = 0;
 
         while ( j < 6 &&
                 (*(this->IntersectionBuffer + i*12 +
                    neighborLines[current][j]) < 0 ||
                  neighborLines[current][j] == previous) )
           {
           j++;
           }
 
         if ( j >= 6 )
           {
           errFlag = 1;
           }
         else
           {
           previous = current;
           current = neighborLines[current][j];
           }
         }
 
       if ( idx < 6 )
         {
         *(pptr + idx*6) = -1;
         }
       }
 
     iptr += 12;
     pptr += 36;
     }
 }
 
 void vtkMitkVolumeTextureMapper3D::UpdateMTime()
 {
   this->SavedTextureMTime.Modified();
 }
 
 
 
 
 //-----------------------------------------------------------------------------
 int vtkMitkVolumeTextureMapper3D::UpdateColorLookup( vtkVolume *vol )
 {
   //GPU_INFO << "UpdateColorLookup";
 
   int needToUpdate = 0;
 
   // Get the image data
   vtkImageData *input = this->GetInput();
-//  input->Update(); //VTK6_TODO
+  Update();
 
   // Has the volume changed in some way?
   if ( this->SavedParametersInput != input ||
        this->SavedParametersMTime.GetMTime() < input->GetMTime() )
     {
     needToUpdate = 1;
     }
 
   // What sample distance are we going to use for rendering? If we
   // have to render quickly according to our allocated render time,
   // don't necessary obey the sample distance requested by the user.
   // Instead set the sample distance to the average spacing.
   this->ActualSampleDistance = this->SampleDistance;
   if ( vol->GetAllocatedRenderTime() < 1.0 )
     {
     float spacing[3];
     this->GetVolumeSpacing(spacing);
     this->ActualSampleDistance =
       0.333 * (static_cast<double>(spacing[0]) + static_cast<double>(spacing[1]) + static_cast<double>(spacing[2]));
     }
 
   // How many components?
   int components = input->GetNumberOfScalarComponents();
 
   // Has the sample distance changed?
   if ( this->SavedSampleDistance != this->ActualSampleDistance )
     {
     needToUpdate = 1;
     }
 
   vtkColorTransferFunction *rgbFunc  = NULL;
   vtkPiecewiseFunction     *grayFunc = NULL;
 
   // How many color channels for this component?
   int colorChannels = vol->GetProperty()->GetColorChannels(0);
 
   if ( components < 3 )
     {
     // Has the number of color channels changed?
     if ( this->SavedColorChannels != colorChannels )
       {
       needToUpdate = 1;
       }
 
     // Has the color transfer function changed in some way,
     // and we are using it?
     if ( colorChannels == 3 )
       {
       rgbFunc  = vol->GetProperty()->GetRGBTransferFunction(0);
       if ( this->SavedRGBFunction != rgbFunc ||
            this->SavedParametersMTime.GetMTime() < rgbFunc->GetMTime() )
         {
         needToUpdate = 1;
         }
       }
 
     // Has the gray transfer function changed in some way,
     // and we are using it?
     if ( colorChannels == 1 )
       {
       grayFunc = vol->GetProperty()->GetGrayTransferFunction(0);
       if ( this->SavedGrayFunction != grayFunc ||
            this->SavedParametersMTime.GetMTime() < grayFunc->GetMTime() )
         {
         needToUpdate = 1;
         }
       }
     }
 
   // Has the scalar opacity transfer function changed in some way?
   vtkPiecewiseFunction *scalarOpacityFunc =
     vol->GetProperty()->GetScalarOpacity(0);
   if ( this->SavedScalarOpacityFunction != scalarOpacityFunc ||
        this->SavedParametersMTime.GetMTime() <
        scalarOpacityFunc->GetMTime() )
     {
     needToUpdate = 1;
     }
 
   // Has the gradient opacity transfer function changed in some way?
   vtkPiecewiseFunction *gradientOpacityFunc =
     vol->GetProperty()->GetGradientOpacity(0);
   if ( this->SavedGradientOpacityFunction != gradientOpacityFunc ||
        this->SavedParametersMTime.GetMTime() <
        gradientOpacityFunc->GetMTime() )
     {
     needToUpdate = 1;
     }
 
 
   double scalarOpacityDistance =
     vol->GetProperty()->GetScalarOpacityUnitDistance(0);
   if ( this->SavedScalarOpacityDistance != scalarOpacityDistance )
     {
     needToUpdate = 1;
     }
 
   // If we have not found any need to update, return now
   if ( !needToUpdate )
     {
     return 0;
     }
 
   this->SavedRGBFunction             = rgbFunc;
   this->SavedGrayFunction            = grayFunc;
   this->SavedScalarOpacityFunction   = scalarOpacityFunc;
   this->SavedGradientOpacityFunction = gradientOpacityFunc;
   this->SavedColorChannels           = colorChannels;
   this->SavedSampleDistance          = this->ActualSampleDistance;
   this->SavedScalarOpacityDistance   = scalarOpacityDistance;
   this->SavedParametersInput         = input;
 
   this->SavedParametersMTime.Modified();
 
   // Find the scalar range
   double scalarRange[2];
   input->GetPointData()->GetScalars()->GetRange(scalarRange, components-1);
 
   int arraySizeNeeded = this->ColorTableSize;
 
   if ( components < 3 )
     {
     // Sample the transfer functions between the min and max.
     if ( colorChannels == 1 )
       {
       grayFunc->GetTable( scalarRange[0], scalarRange[1],
                           arraySizeNeeded, this->TempArray1 );
       }
     else
       {
       rgbFunc->GetTable( scalarRange[0], scalarRange[1],
                          arraySizeNeeded, this->TempArray1 );
       }
     }
 
   scalarOpacityFunc->GetTable( scalarRange[0], scalarRange[1],
                                arraySizeNeeded, this->TempArray2 );
 
   float goArray[256];
   gradientOpacityFunc->GetTable( 0, (scalarRange[1] - scalarRange[0])*0.25,
                                  256, goArray );
 
   // Correct the opacity array for the spacing between the planes.
   int i;
 
   float *fptr2 = this->TempArray2;
   double factor = this->ActualSampleDistance / scalarOpacityDistance;
   for ( i = 0; i < arraySizeNeeded; i++ )
     {
     if ( *fptr2 > 0.0001 )
       {
       *fptr2 =  1.0-pow(static_cast<double>(1.0-(*fptr2)),factor);
       }
     fptr2++;
     }
 
   int goLoop;
   unsigned char *ptr, *rgbptr, *aptr;
   float *fptr1;
 
   switch (components)
     {
     case 1:
       // Move the two temp float arrays into one RGBA unsigned char array
       ptr = this->ColorLookup;
       for ( goLoop = 0; goLoop < 256; goLoop++ )
         {
         fptr1 = this->TempArray1;
         fptr2 = this->TempArray2;
         if ( colorChannels == 1 )
           {
           for ( i = 0; i < arraySizeNeeded; i++ )
             {
             *(ptr++) = static_cast<unsigned char>(*(fptr1)*255.0 + 0.5);
             *(ptr++) = static_cast<unsigned char>(*(fptr1)*255.0 + 0.5);
             *(ptr++) = static_cast<unsigned char>(*(fptr1++)*255.0 + 0.5);
             *(ptr++) = static_cast<unsigned char>(*(fptr2++)*goArray[goLoop]*255.0 + 0.5);
             }
           }
         else
           {
           for ( i = 0; i < arraySizeNeeded; i++ )
             {
             *(ptr++) = static_cast<unsigned char>(*(fptr1++)*255.0 + 0.5);
             *(ptr++) = static_cast<unsigned char>(*(fptr1++)*255.0 + 0.5);
             *(ptr++) = static_cast<unsigned char>(*(fptr1++)*255.0 + 0.5);
             *(ptr++) = static_cast<unsigned char>(*(fptr2++)*goArray[goLoop]*255.0 + 0.5);
             }
           }
 
         for ( ; i < 256; i++ )
           {
           *(ptr++) = 0;
           *(ptr++) = 0;
           *(ptr++) = 0;
           *(ptr++) = 0;
           }
         }
       break;
 
     case 2:
       // Move the two temp float arrays into one RGB unsigned char array and
       // one alpha array.
       rgbptr = this->ColorLookup;
       aptr   = this->AlphaLookup;
 
       if ( colorChannels == 1 )
         {
         for ( i = 0; i < arraySizeNeeded; i++ )
           {
           fptr1 = this->TempArray1;
           fptr2 = this->TempArray2;
           for ( goLoop = 0; goLoop < 256; goLoop++ )
             {
             *(rgbptr++) = static_cast<unsigned char>(*(fptr1)*255.0 + 0.5);
             *(rgbptr++) = static_cast<unsigned char>(*(fptr1)*255.0 + 0.5);
             *(rgbptr++) = static_cast<unsigned char>(*(fptr1++)*255.0 + 0.5);
             *(aptr++)   = static_cast<unsigned char>(*(fptr2++)*goArray[goLoop]*255.0 + 0.5);
             }
           }
         }
       else
         {
         fptr1 = this->TempArray1;
         fptr2 = this->TempArray2;
         for ( i = 0; i < arraySizeNeeded; i++ )
           {
           for ( goLoop = 0; goLoop < 256; goLoop++ )
             {
             *(rgbptr++) = static_cast<unsigned char>(*(fptr1)*255.0 + 0.5);
             *(rgbptr++) = static_cast<unsigned char>(*(fptr1+1)*255.0 + 0.5);
             *(rgbptr++) = static_cast<unsigned char>(*(fptr1+2)*255.0 + 0.5);
             *(aptr++)   = static_cast<unsigned char>(*(fptr2)*goArray[goLoop]*255.0 + 0.5);
             }
           fptr1+=3;
           fptr2++;
           }
         }
 
       for ( ; i < 256; i++ )
         {
         for ( goLoop = 0; goLoop < 256; goLoop++ )
           {
           *(rgbptr++) = 0;
           *(rgbptr++) = 0;
           *(rgbptr++) = 0;
           *(aptr++)   = 0;
           }
         }
       break;
 
     case 3:
     case 4:
       // Move the two temp float arrays into one alpha array
       aptr   = this->AlphaLookup;
 
       for ( goLoop = 0; goLoop < 256; goLoop++ )
         {
         fptr2 = this->TempArray2;
         for ( i = 0; i < arraySizeNeeded; i++ )
           {
           *(aptr++)   = static_cast<unsigned char>(*(fptr2++)*goArray[goLoop]*255.0 + 0.5);
           }
         for ( ; i < 256; i++ )
           {
           *(aptr++)   = 0;
           }
         }
 
       break;
     }
   return 1;
 }
 
 
 //-----------------------------------------------------------------------------
 // Print the vtkMitkVolumeTextureMapper3D
 void vtkMitkVolumeTextureMapper3D::PrintSelf(ostream& os, vtkIndent indent)
 {
   this->Superclass::PrintSelf(os,indent);
 
   os << indent << "Sample Distance: " << this->SampleDistance << endl;
   os << indent << "NumberOfPolygons: " << this->NumberOfPolygons << endl;
   os << indent << "ActualSampleDistance: "
      << this->ActualSampleDistance << endl;
   os << indent << "VolumeDimensions: " << this->VolumeDimensions[0] << " "
      << this->VolumeDimensions[1] << " " << this->VolumeDimensions[2] << endl;
   os << indent << "VolumeSpacing: " << this->VolumeSpacing[0] << " "
      << this->VolumeSpacing[1] << " " << this->VolumeSpacing[2] << endl;
 
   os << indent << "UseCompressedTexture: " << this->UseCompressedTexture
      << endl;
 }
 
 
 
diff --git a/Modules/Segmentation/Rendering/mitkContourSetVtkMapper3D.cpp b/Modules/Segmentation/Rendering/mitkContourSetVtkMapper3D.cpp
index 5bae0c8f36..407fefd229 100644
--- a/Modules/Segmentation/Rendering/mitkContourSetVtkMapper3D.cpp
+++ b/Modules/Segmentation/Rendering/mitkContourSetVtkMapper3D.cpp
@@ -1,166 +1,165 @@
 /*===================================================================
 
 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 "mitkContourSetVtkMapper3D.h"
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 #include "mitkColorProperty.h"
 #include "mitkVtkPropRenderer.h"
 
 
 #include <vtkActor.h>
 #include <vtkActor.h>
 #include <vtkCellArray.h>
 #include <vtkAppendPolyData.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkFollower.h>
 #include <vtkAssembly.h>
 #include <vtkProp3DCollection.h>
 #include <vtkRenderer.h>
 #include <vtkLinearTransform.h>
 #include <vtkTubeFilter.h>
 #include <vtkPolygon.h>
 
 
 #include <vtkProperty.h>
 #include <vtkPolyDataMapper.h>
 #include <stdlib.h>
 
 
 mitk::ContourSetVtkMapper3D::ContourSetVtkMapper3D()
 {
   m_VtkPolyDataMapper = vtkPolyDataMapper::New();
   m_Actor = vtkActor::New();
   m_Actor->SetMapper(m_VtkPolyDataMapper);
 
   m_ContourSet = vtkPolyData::New();
   m_TubeFilter = vtkTubeFilter::New();
 }
 
 mitk::ContourSetVtkMapper3D::~ContourSetVtkMapper3D()
 {
   if( m_VtkPolyDataMapper )
     m_VtkPolyDataMapper->Delete();;
 
   if( m_TubeFilter )
     m_TubeFilter->Delete();;
 
   if( m_ContourSet )
     m_ContourSet->Delete();;
 
   if( m_Actor )
     m_Actor->Delete();;
 }
 
 vtkProp* mitk::ContourSetVtkMapper3D::GetVtkProp(mitk::BaseRenderer*  /*renderer*/)
 {
   return m_Actor;
 }
 
 void mitk::ContourSetVtkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer* renderer)
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if(!visible)
   {
     m_Actor->VisibilityOff();
     return;
   }
 
   m_Actor->VisibilityOn();
 
   mitk::ContourSet::Pointer input  = const_cast<mitk::ContourSet*>(this->GetInput());
 
   if ( renderer->GetDisplayGeometryUpdateTime() > this->GetInput()->GetMTime() )
   {
     m_ContourSet = vtkPolyData::New();
 
     vtkPoints *points = vtkPoints::New();
     vtkCellArray *lines = vtkCellArray::New();
 
     mitk::ContourSet::Pointer input =  const_cast<mitk::ContourSet*>(this->GetInput());
     mitk::ContourSet::ContourVectorType contourVec = input->GetContours();
     mitk::ContourSet::ContourIterator contourIt = contourVec.begin();
 
     vtkIdType firstPointIndex= 0, lastPointIndex=0;
 
     vtkIdType ptIndex = 0;
     while ( contourIt != contourVec.end() )
     {
       mitk::Contour* nextContour = (mitk::Contour*) (*contourIt).second;
       Contour::InputType idx = nextContour->GetContourPath()->StartOfInput();
 
 
       Contour::InputType end = nextContour->GetContourPath()->EndOfInput();
       if (end > 50000) end = 0;
 
       mitk::Contour::PointsContainerPointer contourPoints = nextContour->GetPoints();
       mitk::Contour::PointsContainerIterator pointsIt = contourPoints->Begin();
       unsigned int counter = 0;
 
       firstPointIndex=ptIndex;
       while ( pointsIt != contourPoints->End() )
       {
         if (counter %2 == 0)
         {
           Contour::BoundingBoxType::PointType point;
           point = pointsIt.Value();
           points->InsertPoint(ptIndex, point[0],point[1],point[2]);
           if (ptIndex > firstPointIndex)
           {
             int cell[2] = {ptIndex-1,ptIndex};
             lines->InsertNextCell((vtkIdType)2,(vtkIdType*) cell);
           }
           lastPointIndex=ptIndex;
           ptIndex++;
         }
         pointsIt++;
         idx+=1;
       }
 
       if (nextContour->GetClosed())
       {
         int cell[2] = {lastPointIndex,firstPointIndex};
         lines->InsertNextCell((vtkIdType)2,(vtkIdType*) cell);
       }
       contourIt++;
     }
 
     m_ContourSet->SetPoints(points);
     m_ContourSet->SetLines(lines);
-//    m_ContourSet->Update(); //VTK6_TODO
 
     m_TubeFilter->SetInputData(m_ContourSet);
     m_TubeFilter->SetRadius(1);
     m_TubeFilter->Update();
     m_VtkPolyDataMapper->SetInputData(m_TubeFilter->GetOutput());
 
     double rgba[4]={0.0f,1.0f,0.0f,0.6f};
 
     m_Actor->GetProperty()->SetColor(rgba);
     m_Actor->SetMapper(m_VtkPolyDataMapper);
   }
 
   SetVtkMapperImmediateModeRendering(m_VtkPolyDataMapper);
 }
 
 const mitk::ContourSet* mitk::ContourSetVtkMapper3D::GetInput()
 {
   return static_cast<const mitk::ContourSet* > ( GetDataNode()->GetData() );
 }
diff --git a/Modules/Segmentation/Rendering/mitkContourVtkMapper3D.cpp b/Modules/Segmentation/Rendering/mitkContourVtkMapper3D.cpp
index e3948c22d2..e983741e67 100644
--- a/Modules/Segmentation/Rendering/mitkContourVtkMapper3D.cpp
+++ b/Modules/Segmentation/Rendering/mitkContourVtkMapper3D.cpp
@@ -1,183 +1,182 @@
 /*===================================================================
 
 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 "mitkContourVtkMapper3D.h"
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 #include "mitkColorProperty.h"
 #include "mitkVtkPropRenderer.h"
 #include "mitkContour.h"
 
 #include <vtkActor.h>
 #include <vtkAppendPolyData.h>
 #include <vtkAssembly.h>
 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #include <vtkCellArray.h>
 #pragma GCC diagnostic warning "-Wstrict-aliasing"
 #include <vtkFollower.h>
 #include <vtkLinearTransform.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkPolygon.h>
 #include <vtkProp3DCollection.h>
 #include <vtkProperty.h>
 #include <vtkRenderer.h>
 #include <vtkSphereSource.h>
 #include <vtkTubeFilter.h>
 
 mitk::ContourVtkMapper3D::ContourVtkMapper3D()
 {
   m_VtkPolyDataMapper = vtkPolyDataMapper::New();
   m_VtkPointList = vtkAppendPolyData::New();
   m_Actor = vtkActor::New();
   m_Actor->SetMapper(m_VtkPolyDataMapper);
 
   m_TubeFilter = vtkTubeFilter::New();
 }
 
 mitk::ContourVtkMapper3D::~ContourVtkMapper3D()
 {
   if(m_VtkPolyDataMapper)
     m_VtkPolyDataMapper->Delete();
 
   if(m_TubeFilter)
     m_TubeFilter->Delete();
 
   if(m_VtkPointList)
     m_VtkPointList->Delete();
 
   if(m_Contour)
     m_Contour->Delete();
 
   if(m_Actor)
     m_Actor->Delete();
 }
 
 vtkProp* mitk::ContourVtkMapper3D::GetVtkProp(mitk::BaseRenderer*  /*renderer*/)
 {
   return m_Actor;
 }
 
 void mitk::ContourVtkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer* renderer)
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if ( !visible )
   {
     m_Actor->VisibilityOff();
     return;
   }
   m_Actor->VisibilityOn();
 
   m_Contour = vtkPolyData::New();
 
   mitk::Contour::Pointer input  = const_cast<mitk::Contour*>(this->GetInput());
   bool makeContour = true;
 
   if ( makeContour )
   {
     vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
 
     int numPts=input->GetNumberOfPoints();
     if ( numPts > 200000 )
       numPts = 200000;
     mitk::Contour::PathPointer path = input->GetContourPath();
     mitk::Contour::PathType::InputType cstart = path->StartOfInput();
     mitk::Contour::PathType::InputType cend   = path->EndOfInput();
     mitk::Contour::PathType::InputType cstep  = (cend-cstart+1)/numPts;
     mitk::Contour::PathType::InputType ccur;
 
     vtkIdType ptIndex = 0;
     vtkIdType lastPointIndex = 0;
 
     mitk::Contour::PointsContainerPointer contourPoints = input->GetPoints();
     mitk::Contour::PointsContainerIterator pointsIt = contourPoints->Begin();
 
     double vtkpoint[3];
 
     int i;
     float pointSize = 2;
     this->GetDataNode()->GetFloatProperty("spheres size", pointSize);
 
     bool showPoints = true;
     this->GetDataNode()->GetBoolProperty("show points", showPoints);
     if ( showPoints )
     {
       m_VtkPointList = vtkAppendPolyData::New();
     }
     for ( i=0, ccur=cstart; i<numPts; ++i, ccur+=cstep )
     {
       itk2vtk(path->Evaluate(ccur), vtkpoint);
       points->InsertPoint(ptIndex, vtkpoint);
       if ( ptIndex > 0 )
       {
         int cell[2] = {ptIndex-1,ptIndex};
         lines->InsertNextCell((vtkIdType)2,(vtkIdType*) cell);
       }
       lastPointIndex = ptIndex;
       ++ptIndex;
 
       if ( showPoints )
       {
         vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
 
         sphere->SetRadius(pointSize);
         sphere->SetCenter(vtkpoint);
 
         m_VtkPointList->AddInputData(sphere->GetOutput());
         sphere->Update();
       }
     }
 
     if ( input->GetClosed() )
     {
       int cell[2] = {lastPointIndex,0};
       lines->InsertNextCell((vtkIdType)2,(vtkIdType*) cell);
     }
 
     m_Contour->SetPoints(points);
     m_Contour->SetLines(lines);
-//    m_Contour->Update(); //VTK6_TODO
 
     m_TubeFilter->SetInputData(m_Contour);
     m_TubeFilter->SetRadius(pointSize / 2.0f);
     m_TubeFilter->SetNumberOfSides(8);
     m_TubeFilter->Update();
 
     if ( showPoints )
     {
       m_VtkPointList->AddInputData(m_TubeFilter->GetOutput());
       m_VtkPolyDataMapper->SetInputData(m_VtkPointList->GetOutput());
     }
     else
     {
       m_VtkPolyDataMapper->SetInputData(m_TubeFilter->GetOutput());
     }
     double rgba[4]={0.0f,1.0f,0.0f,0.6f};
     m_Actor->GetProperty()->SetColor(rgba);
     m_Actor->SetMapper(m_VtkPolyDataMapper);
   }
 
   SetVtkMapperImmediateModeRendering(m_VtkPolyDataMapper);
 }
 
 const mitk::Contour* mitk::ContourVtkMapper3D::GetInput()
 {
   return static_cast<const mitk::Contour* > ( GetDataNode()->GetData() );
 }