diff --git a/Modules/DiffusionImaging/DiffusionCore/include/Rendering/mitkOdfVtkMapper2D.txx b/Modules/DiffusionImaging/DiffusionCore/include/Rendering/mitkOdfVtkMapper2D.txx
index c2f796c13a..6e06fd997c 100644
--- a/Modules/DiffusionImaging/DiffusionCore/include/Rendering/mitkOdfVtkMapper2D.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/include/Rendering/mitkOdfVtkMapper2D.txx
@@ -1,984 +1,984 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #ifndef __mitkOdfVtkMapper2D_txx__
 #define __mitkOdfVtkMapper2D_txx__
 
 #include "mitkOdfVtkMapper2D.h"
 #include "mitkDataNode.h"
 #include "mitkBaseRenderer.h"
 #include "mitkMatrixConvert.h"
 #include "mitkGeometry3D.h"
 #include "mitkTimeGeometry.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include "mitkProperties.h"
 #include "mitkTensorImage.h"
 #include "mitkShImage.h"
 
 #include "vtkSphereSource.h"
 #include "vtkPropCollection.h"
 #include "vtkMaskedGlyph3D.h"
 #include "vtkGlyph2D.h"
 #include "vtkGlyph3D.h"
 #include "vtkMaskedProgrammableGlyphFilter.h"
 #include "vtkImageData.h"
 #include "vtkLinearTransform.h"
 #include "vtkCamera.h"
 #include "vtkPointData.h"
 #include "vtkTransformPolyDataFilter.h"
 #include "vtkTransform.h"
 #include "vtkOdfSource.h"
 #include "vtkDoubleArray.h"
 #include "vtkLookupTable.h"
 #include "vtkProperty.h"
 #include "vtkPolyDataNormals.h"
 #include "vtkLight.h"
 #include "vtkLightCollection.h"
 #include "vtkMath.h"
 #include "vtkFloatArray.h"
 #include "vtkDelaunay2D.h"
 #include "vtkMapper.h"
 #include <vtkInformationVector.h>
 #include <vtkInformation.h>
 #include "vtkRenderer.h"
 
 #include "itkOrientationDistributionFunction.h"
 
 #include "itkFixedArray.h"
 
 #include <mitkGL.h>
 #include "vtkOpenGLRenderer.h"
 
 #define _USE_MATH_DEFINES
 #include <cmath>
 
 #include <ciso646>
 
 
 template<class T, int N>
 vtkSmartPointer<vtkTransform> mitk::OdfVtkMapper2D<T,N>::m_OdfTransform = vtkSmartPointer<vtkTransform>::New();
 
 template<class T, int N>
 vtkSmartPointer<vtkOdfSource> mitk::OdfVtkMapper2D<T,N>::m_OdfSource = vtkSmartPointer<vtkOdfSource>::New();
 
 template<class T, int N>
 float mitk::OdfVtkMapper2D<T,N>::m_Scaling;
 
 template<class T, int N>
 int mitk::OdfVtkMapper2D<T,N>::m_Normalization;
 
 template<class T, int N>
 int mitk::OdfVtkMapper2D<T,N>::m_ScaleBy;
 
 template<class T, int N>
 float mitk::OdfVtkMapper2D<T,N>::m_IndexParam1;
 
 template<class T, int N>
 float mitk::OdfVtkMapper2D<T,N>::m_IndexParam2;
 
 template<class T, int N>
 bool mitk::OdfVtkMapper2D<T, N>::m_ToggleTensorEllipsoidView = false;
 
 template<class T, int N>
 bool mitk::OdfVtkMapper2D<T, N>::m_ToggleColourisationMode = false;
 
 template<class T, int N>
 bool mitk::OdfVtkMapper2D<T, N>::m_ToggleGlyphPlacementMode = true;
 
 template<class T, int N>
 vtkSmartPointer<vtkDoubleArray> mitk::OdfVtkMapper2D<T, N>::m_ColourScalars = nullptr;
 
 
 template<class T, int N>
 vnl_matrix<float> mitk::OdfVtkMapper2D<T, N>::m_Sh2Basis =  mitk::sh::CalcShBasisForDirections(2, itk::PointShell<N, vnl_matrix_fixed<double, 3, N> >::DistributePointShell()->as_matrix());
 template<class T, int N>
 vnl_matrix<float> mitk::OdfVtkMapper2D<T, N>::m_Sh4Basis =  mitk::sh::CalcShBasisForDirections(4, itk::PointShell<N, vnl_matrix_fixed<double, 3, N> >::DistributePointShell()->as_matrix());
 template<class T, int N>
 vnl_matrix<float> mitk::OdfVtkMapper2D<T, N>::m_Sh6Basis =  mitk::sh::CalcShBasisForDirections(6, itk::PointShell<N, vnl_matrix_fixed<double, 3, N> >::DistributePointShell()->as_matrix());
 template<class T, int N>
 vnl_matrix<float> mitk::OdfVtkMapper2D<T, N>::m_Sh8Basis =  mitk::sh::CalcShBasisForDirections(8, itk::PointShell<N, vnl_matrix_fixed<double, 3, N> >::DistributePointShell()->as_matrix());
 template<class T, int N>
 vnl_matrix<float> mitk::OdfVtkMapper2D<T, N>::m_Sh10Basis =  mitk::sh::CalcShBasisForDirections(10, itk::PointShell<N, vnl_matrix_fixed<double, 3, N> >::DistributePointShell()->as_matrix());
 template<class T, int N>
 vnl_matrix<float> mitk::OdfVtkMapper2D<T, N>::m_Sh12Basis =  mitk::sh::CalcShBasisForDirections(12, itk::PointShell<N, vnl_matrix_fixed<double, 3, N> >::DistributePointShell()->as_matrix());
 
 
 template<class T, int N>
 mitk::OdfVtkMapper2D<T,N>::LocalStorage::LocalStorage()
 {
   m_PropAssemblies.push_back(vtkPropAssembly::New());
   m_PropAssemblies.push_back(vtkPropAssembly::New());
   m_PropAssemblies.push_back(vtkPropAssembly::New());
 
   m_OdfsPlanes.push_back(vtkAppendPolyData::New());
   m_OdfsPlanes.push_back(vtkAppendPolyData::New());
   m_OdfsPlanes.push_back(vtkAppendPolyData::New());
 
   m_OdfsPlanes[0]->AddInputData(vtkPolyData::New());
   m_OdfsPlanes[1]->AddInputData(vtkPolyData::New());
   m_OdfsPlanes[2]->AddInputData(vtkPolyData::New());
 
   m_OdfsActors.push_back(vtkActor::New());
   m_OdfsActors.push_back(vtkActor::New());
   m_OdfsActors.push_back(vtkActor::New());
 
   m_OdfsActors[0]->GetProperty()->SetInterpolationToGouraud();
   m_OdfsActors[1]->GetProperty()->SetInterpolationToGouraud();
   m_OdfsActors[2]->GetProperty()->SetInterpolationToGouraud();
 
   m_OdfsMappers.push_back(vtkPolyDataMapper::New());
   m_OdfsMappers.push_back(vtkPolyDataMapper::New());
   m_OdfsMappers.push_back(vtkPolyDataMapper::New());
 
-  vtkLookupTable *lut = vtkLookupTable::New();
+  vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
 
   m_OdfsMappers[0]->SetLookupTable(lut);
   m_OdfsMappers[1]->SetLookupTable(lut);
   m_OdfsMappers[2]->SetLookupTable(lut);
 
   m_OdfsActors[0]->SetMapper(m_OdfsMappers[0]);
   m_OdfsActors[1]->SetMapper(m_OdfsMappers[1]);
   m_OdfsActors[2]->SetMapper(m_OdfsMappers[2]);
 }
 
 template<class T, int N>
 mitk::OdfVtkMapper2D<T,N>
 ::OdfVtkMapper2D()
 {
   m_LastDisplayGeometry.push_back(OdfDisplayGeometry());
   m_LastDisplayGeometry.push_back(OdfDisplayGeometry());
   m_LastDisplayGeometry.push_back(OdfDisplayGeometry());
 
   m_Planes.push_back(vtkPlane::New());
   m_Planes.push_back(vtkPlane::New());
   m_Planes.push_back(vtkPlane::New());
 
   m_Cutters.push_back(vtkCutter::New());
   m_Cutters.push_back(vtkCutter::New());
   m_Cutters.push_back(vtkCutter::New());
 
   m_Cutters[0]->SetCutFunction( m_Planes[0] );
   m_Cutters[0]->GenerateValues( 1, 0, 1 );
 
   m_Cutters[1]->SetCutFunction( m_Planes[1] );
   m_Cutters[1]->GenerateValues( 1, 0, 1 );
 
   m_Cutters[2]->SetCutFunction( m_Planes[2] );
   m_Cutters[2]->GenerateValues( 1, 0, 1 );
 
   // Windowing the cutted planes in direction 1
   m_ThickPlanes1.push_back(vtkThickPlane::New());
   m_ThickPlanes1.push_back(vtkThickPlane::New());
   m_ThickPlanes1.push_back(vtkThickPlane::New());
 
   m_Clippers1.push_back(vtkClipPolyData::New());
   m_Clippers1.push_back(vtkClipPolyData::New());
   m_Clippers1.push_back(vtkClipPolyData::New());
 
   m_Clippers1[0]->SetClipFunction( m_ThickPlanes1[0] );
   m_Clippers1[1]->SetClipFunction( m_ThickPlanes1[1] );
   m_Clippers1[2]->SetClipFunction( m_ThickPlanes1[2] );
 
   // Windowing the cutted planes in direction 2
   m_ThickPlanes2.push_back(vtkThickPlane::New());
   m_ThickPlanes2.push_back(vtkThickPlane::New());
   m_ThickPlanes2.push_back(vtkThickPlane::New());
 
   m_Clippers2.push_back(vtkClipPolyData::New());
   m_Clippers2.push_back(vtkClipPolyData::New());
   m_Clippers2.push_back(vtkClipPolyData::New());
 
   m_Clippers2[0]->SetClipFunction( m_ThickPlanes2[0] );
   m_Clippers2[1]->SetClipFunction( m_ThickPlanes2[1] );
   m_Clippers2[2]->SetClipFunction( m_ThickPlanes2[2] );
 
   m_ShowMaxNumber = 500;
 }
 
 template<class T, int N>
 mitk::OdfVtkMapper2D<T,N>
 ::~OdfVtkMapper2D()
 {
 
 }
 
 template<class T, int N>
 mitk::Image* mitk::OdfVtkMapper2D<T,N>
 ::GetInput()
 {
   return static_cast<mitk::Image * > ( m_DataNode->GetData() );
 }
 
 template<class T, int N>
 vtkProp*  mitk::OdfVtkMapper2D<T,N>
 ::GetVtkProp(mitk::BaseRenderer* renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
   return localStorage->m_PropAssemblies[GetIndex(renderer)];
 }
 
 template<class T, int N>
 int  mitk::OdfVtkMapper2D<T,N>
 ::GetIndex(mitk::BaseRenderer* renderer)
 {
   if(!strcmp(renderer->GetName(),"stdmulti.widget1"))
     return 0;
 
   if(!strcmp(renderer->GetName(),"stdmulti.widget2"))
     return 1;
 
   if(!strcmp(renderer->GetName(),"stdmulti.widget3"))
     return 2;
 
   return 0;
 }
 
 template<class T, int N>
 void  mitk::OdfVtkMapper2D<T,N>
 ::GlyphMethod(void *arg)
 {
   vtkMaskedProgrammableGlyphFilter* pfilter=(vtkMaskedProgrammableGlyphFilter*)arg;
 
   double point[3];
   double debugpoint[3];
   pfilter->GetPoint(point);
   pfilter->GetPoint(debugpoint);
 
   itk::Point<double,3> p(point);
   Vector3D spacing = pfilter->GetGeometry()->GetSpacing();
   p[0] /= spacing[0];
   p[1] /= spacing[1];
   p[2] /= spacing[2];
 
   mitk::Point3D p2;
   pfilter->GetGeometry()->IndexToWorld( p, p2 );
   point[0] = p2[0];
   point[1] = p2[1];
   point[2] = p2[2];
 
   vtkPointData* data = pfilter->GetPointData();
   vtkDataArray* image_vals = data->GetArray("vector");
   vtkIdType id = pfilter->GetPointId();
   m_OdfTransform->Identity();
   m_OdfTransform->Translate(point[0],point[1],point[2]);
 
   typedef itk::OrientationDistributionFunction<float,N> OdfType;
   OdfType odf;
 
   if( image_vals->GetNumberOfComponents()==6 && !m_ToggleTensorEllipsoidView )
   {
     float tensorelems[6] = {
       (float)image_vals->GetComponent(id,0),
       (float)image_vals->GetComponent(id,1),
       (float)image_vals->GetComponent(id,2),
       (float)image_vals->GetComponent(id,3),
       (float)image_vals->GetComponent(id,4),
       (float)image_vals->GetComponent(id,5),
     };
     itk::DiffusionTensor3D<float> tensor(tensorelems);
     odf.InitFromTensor(tensor);
   }
   else if( image_vals->GetNumberOfComponents()==6 && m_ToggleTensorEllipsoidView )
   {
     float tensorelems[6] = {
       (float)image_vals->GetComponent(id,0),
       (float)image_vals->GetComponent(id,1),
       (float)image_vals->GetComponent(id,2),
       (float)image_vals->GetComponent(id,3),
       (float)image_vals->GetComponent(id,4),
       (float)image_vals->GetComponent(id,5),
     };
     itk::DiffusionTensor3D<float> tensor( tensorelems );
     odf.InitFromEllipsoid( tensor );
   }
   else if (image_vals->GetNumberOfComponents() == ODF_SAMPLING_SIZE)
   {
     for(int i=0; i<N; i++)
       odf[i] = (double)image_vals->GetComponent(id,i);
   }
   else
   {
     int nrCoeffs = image_vals->GetNumberOfComponents();
     Vector< float, N > odf_vals;
     vnl_vector< float > coeffs(nrCoeffs);
     for(int i=0; i<nrCoeffs; i++)
       coeffs[i] = (float)image_vals->GetComponent(id,i);
 
     switch (nrCoeffs)
     {
     case 6:
       odf_vals = ( m_Sh2Basis * coeffs ).data_block();
       break;
     case 15:
       odf_vals = ( m_Sh4Basis * coeffs ).data_block();
       break;
     case 28:
       odf_vals = ( m_Sh6Basis * coeffs ).data_block();
       break;
     case 45:
       odf_vals = ( m_Sh8Basis * coeffs ).data_block();
       break;
     case 66:
       odf_vals = ( m_Sh10Basis * coeffs ).data_block();
       break;
     case 91:
       odf_vals = ( m_Sh12Basis * coeffs ).data_block();
       break;
     default :
       mitkThrow() << "SH order larger 12 not supported in current ODF mapper version";
     }
 
     for(int i=0; i<N; i++)
       odf[i] = odf_vals[i];
   }
 
   if (m_ToggleColourisationMode)
   {
     m_OdfSource->SetUseCustomColor(true);
     vnl_vector_fixed<double,3> d = odf.GetPrincipalDiffusionDirection();
     m_OdfSource->SetColor(fabs(d[0])*255,fabs(d[1])*255,fabs(d[2])*255);
   }
   else
   {
     m_OdfSource->SetUseCustomColor(false);
   }
 
   switch(m_ScaleBy)
   {
   case ODFSB_NONE:
     m_OdfSource->SetScale(m_Scaling);
     break;
   case ODFSB_GFA:
     m_OdfSource->SetScale(m_Scaling*odf.GetGeneralizedFractionalAnisotropy());
     break;
   case ODFSB_PC:
     m_OdfSource->SetScale(m_Scaling*odf.GetPrincipleCurvature(m_IndexParam1, m_IndexParam2, 0));
     break;
   }
 
   m_OdfSource->SetNormalization(m_Normalization);
   m_OdfSource->SetOdf(odf);
   m_OdfSource->Modified();
 }
 
 template<class T, int N>
 typename mitk::OdfVtkMapper2D<T,N>::OdfDisplayGeometry mitk::OdfVtkMapper2D<T,N>
 ::MeasureDisplayedGeometry(mitk::BaseRenderer* renderer)
 {
   PlaneGeometry::ConstPointer worldPlaneGeometry = renderer->GetCurrentWorldPlaneGeometry();
 
   // set up the cutter orientation according to the current geometry of
   // the renderers plane
   double vp[ 3 ], vnormal[ 3 ];
   Point3D point = worldPlaneGeometry->GetOrigin();
   Vector3D normal = worldPlaneGeometry->GetNormal(); normal.Normalize();
   vnl2vtk( point.GetVnlVector(), vp );
   vnl2vtk( normal.GetVnlVector(), vnormal );
 
   Point2D dispSizeInMM = renderer->GetViewportSizeInMM();
 
   Point2D displayGeometryOriginInMM = renderer->GetOriginInMM();
 
   mitk::Vector2D size = dispSizeInMM.GetVectorFromOrigin();
   mitk::Vector2D origin = displayGeometryOriginInMM.GetVectorFromOrigin();
 
   //
   //  |------O------|
   //  |      d2     |
   //  L  d1  M      |
   //  |             |
   //  |-------------|
   //
 
   mitk::Vector2D M;
   mitk::Vector2D L;
   mitk::Vector2D O;
 
   M[0] = origin[0] + size[0]/2;
   M[1] = origin[1] + size[1]/2;
 
   L[0] = origin[0];
   L[1] = origin[1] + size[1]/2;
 
   O[0] = origin[0] + size[0]/2;
   O[1] = origin[1] + size[1];
 
   mitk::Point2D point1;
   point1[0] = M[0]; point1[1] = M[1];
   mitk::Point3D M3D;
   renderer->GetCurrentWorldPlaneGeometry()->Map(point1, M3D);
 
   point1[0] = L[0]; point1[1] = L[1];
   mitk::Point3D L3D;
   renderer->GetCurrentWorldPlaneGeometry()->Map(point1, L3D);
 
   point1[0] = O[0]; point1[1] = O[1];
   mitk::Point3D O3D;
   renderer->GetCurrentWorldPlaneGeometry()->Map(point1, O3D);
 
   double d1 = sqrt((M3D[0]-L3D[0])*(M3D[0]-L3D[0])
       + (M3D[1]-L3D[1])*(M3D[1]-L3D[1])
       + (M3D[2]-L3D[2])*(M3D[2]-L3D[2]));
   double d2 = sqrt((M3D[0]-O3D[0])*(M3D[0]-O3D[0])
       + (M3D[1]-O3D[1])*(M3D[1]-O3D[1])
       + (M3D[2]-O3D[2])*(M3D[2]-O3D[2]));
   double d = d1>d2 ? d1 : d2;
   d = d2;
 
   OdfDisplayGeometry retval;
   retval.vp[0] = vp[0];
   retval.vp[1] = vp[1];
   retval.vp[2] = vp[2];
   retval.vnormal[0] = vnormal[0];
   retval.vnormal[1] = vnormal[1];
   retval.vnormal[2] = vnormal[2];
   retval.normal[0] = normal[0];
   retval.normal[1] = normal[1];
   retval.normal[2] = normal[2];
   retval.d = d;
   retval.d1 = d1;
   retval.d2 = d2;
   retval.M3D[0] = M3D[0];
   retval.M3D[1] = M3D[1];
   retval.M3D[2] = M3D[2];
   retval.L3D[0] = L3D[0];
   retval.L3D[1] = L3D[1];
   retval.L3D[2] = L3D[2];
   retval.O3D[0] = O3D[0];
   retval.O3D[1] = O3D[1];
   retval.O3D[2] = O3D[2];
 
   retval.vp_original[0] = vp[0];
   retval.vp_original[1] = vp[1];
   retval.vp_original[2] = vp[2];
   retval.vnormal_original[0] = vnormal[0];
   retval.vnormal_original[1] = vnormal[1];
   retval.vnormal_original[2] = vnormal[2];
   retval.size[0] = size[0];
   retval.size[1] = size[1];
   retval.origin[0] = origin[0];
   retval.origin[1] = origin[1];
 
   return retval;
 }
 
 template<class T, int N>
 void  mitk::OdfVtkMapper2D<T,N>
 ::Slice(mitk::BaseRenderer* renderer, OdfDisplayGeometry dispGeo)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   vtkLinearTransform * vtktransform =
       this->GetDataNode()->GetVtkTransform(this->GetTimestep());
 
   int index = GetIndex(renderer);
 
   vtkSmartPointer<vtkTransform> inversetransform = vtkSmartPointer<vtkTransform>::New();
   inversetransform->Identity();
   inversetransform->Concatenate(vtktransform->GetLinearInverse());
   double myscale[3];
   ((vtkTransform*)vtktransform)->GetScale(myscale);
   myscale[0] = fabs(myscale[0]);
   myscale[1] = fabs(myscale[1]);
   myscale[2] = fabs(myscale[2]);
   inversetransform->PostMultiply();
   inversetransform->Scale(myscale[0],myscale[1],myscale[2]);
   inversetransform->TransformPoint( dispGeo.vp, dispGeo.vp );
   inversetransform->TransformNormalAtPoint( dispGeo.vp, dispGeo.vnormal, dispGeo.vnormal );
 
   // vtk works in axis align coords
   // thus the normal also must be axis align, since
   // we do not allow arbitrary cutting through volume
   //
   // vnormal should already be axis align, but in order
   // to get rid of precision effects, we set the two smaller
   // components to zero here
   int dims[3];
   m_VtkImage->GetDimensions(dims);
   double spac[3];
   m_VtkImage->GetSpacing(spac);
   if(fabs(dispGeo.vnormal[0]) > fabs(dispGeo.vnormal[1])
      && fabs(dispGeo.vnormal[0]) > fabs(dispGeo.vnormal[2]) )
   {
     if(fabs(dispGeo.vp[0]/spac[0]) < 0.4)
       dispGeo.vp[0] = 0.4*spac[0];
     if(fabs(dispGeo.vp[0]/spac[0]) > (dims[0]-1)-0.4)
       dispGeo.vp[0] = ((dims[0]-1)-0.4)*spac[0];
     dispGeo.vnormal[1] = 0;
     dispGeo.vnormal[2] = 0;
   }
 
   if(fabs(dispGeo.vnormal[1]) > fabs(dispGeo.vnormal[0]) && fabs(dispGeo.vnormal[1]) > fabs(dispGeo.vnormal[2]) )
   {
     if(fabs(dispGeo.vp[1]/spac[1]) < 0.4)
       dispGeo.vp[1] = 0.4*spac[1];
     if(fabs(dispGeo.vp[1]/spac[1]) > (dims[1]-1)-0.4)
       dispGeo.vp[1] = ((dims[1]-1)-0.4)*spac[1];
     dispGeo.vnormal[0] = 0;
     dispGeo.vnormal[2] = 0;
   }
 
   if(fabs(dispGeo.vnormal[2]) > fabs(dispGeo.vnormal[1]) && fabs(dispGeo.vnormal[2]) > fabs(dispGeo.vnormal[0]) )
   {
     if(fabs(dispGeo.vp[2]/spac[2]) < 0.4)
       dispGeo.vp[2] = 0.4*spac[2];
     if(fabs(dispGeo.vp[2]/spac[2]) > (dims[2]-1)-0.4)
       dispGeo.vp[2] = ((dims[2]-1)-0.4)*spac[2];
     dispGeo.vnormal[0] = 0;
     dispGeo.vnormal[1] = 0;
   }
 
 
   m_Planes[index]->SetTransform( (vtkAbstractTransform*)nullptr );
   m_Planes[index]->SetOrigin( dispGeo.vp );
   m_Planes[index]->SetNormal( dispGeo.vnormal );
 
   vtkSmartPointer<vtkPoints> points;
   vtkSmartPointer<vtkPoints> tmppoints;
   vtkSmartPointer<vtkPolyData> polydata;
   vtkSmartPointer<vtkFloatArray> pointdata;
   vtkSmartPointer<vtkDelaunay2D> delaunay;
   vtkSmartPointer<vtkPolyData> cuttedPlane;
 
   // the cutter only works if we do not have a 2D-image
   // or if we have a 2D-image and want to see the whole image.
   //
   // for side views of 2D-images, we need some special treatment
   if(!( (dims[0] == 1 && dispGeo.vnormal[0] != 0) ||
         (dims[1] == 1 && dispGeo.vnormal[1] != 0) ||
         (dims[2] == 1 && dispGeo.vnormal[2] != 0) ))
   {
     m_Cutters[index]->SetCutFunction( m_Planes[index] );
     m_Cutters[index]->SetInputData( m_VtkImage );
     m_Cutters[index]->Update();
     cuttedPlane = m_Cutters[index]->GetOutput();
   }
   else
   {
     // cutting of a 2D-Volume does not work,
     // so we have to build up our own polydata object
     cuttedPlane = vtkPolyData::New();
     points = vtkPoints::New();
     points->SetNumberOfPoints(m_VtkImage->GetNumberOfPoints());
     for(int i=0; i<m_VtkImage->GetNumberOfPoints(); i++)
     {
       points->SetPoint(i, m_VtkImage->GetPoint(i));
     }
     cuttedPlane->SetPoints(points);
 
     int nZero1, nZero2;
     if(dims[0]==1)
     {
       nZero1 = 1; nZero2 = 2;
     }
     else if(dims[1]==1)
     {
       nZero1 = 0; nZero2 = 2;
     }
     else
     {
       nZero1 = 0; nZero2 = 1;
     }
 
     tmppoints = vtkPoints::New();
     for(int j=0; j<m_VtkImage->GetNumberOfPoints(); j++){
       double pt[3];
       m_VtkImage->GetPoint(j,pt);
       tmppoints->InsertNextPoint(pt[nZero1],pt[nZero2],0);
     }
 
     polydata = vtkPolyData::New();
     polydata->SetPoints( tmppoints );
     delaunay = vtkDelaunay2D::New();
     delaunay->SetInputData( polydata );
     delaunay->Update();
     vtkCellArray* polys = delaunay->GetOutput()->GetPolys();
     cuttedPlane->SetPolys(polys);
   }
 
   if(cuttedPlane->GetNumberOfPoints())
   {
     //  WINDOWING HERE
     dispGeo.vnormal[0] = dispGeo.M3D[0]-dispGeo.O3D[0];
     dispGeo.vnormal[1] = dispGeo.M3D[1]-dispGeo.O3D[1];
     dispGeo.vnormal[2] = dispGeo.M3D[2]-dispGeo.O3D[2];
     vtkMath::Normalize(dispGeo.vnormal);
     dispGeo.vp[0] = dispGeo.M3D[0];
     dispGeo.vp[1] = dispGeo.M3D[1];
     dispGeo.vp[2] = dispGeo.M3D[2];
 
     inversetransform->TransformPoint( dispGeo.vp, dispGeo.vp );
     inversetransform->TransformNormalAtPoint( dispGeo.vp, dispGeo.vnormal, dispGeo.vnormal );
 
     m_ThickPlanes1[index]->count = 0;
     m_ThickPlanes1[index]->SetTransform((vtkAbstractTransform*)nullptr );
     m_ThickPlanes1[index]->SetPose( dispGeo.vnormal, dispGeo.vp );
     m_ThickPlanes1[index]->SetThickness(dispGeo.d2);
     m_Clippers1[index]->SetClipFunction( m_ThickPlanes1[index] );
     m_Clippers1[index]->SetInputData( cuttedPlane );
     m_Clippers1[index]->SetInsideOut(1);
     m_Clippers1[index]->Update();
 
     dispGeo.vnormal[0] = dispGeo.M3D[0]-dispGeo.L3D[0];
     dispGeo.vnormal[1] = dispGeo.M3D[1]-dispGeo.L3D[1];
     dispGeo.vnormal[2] = dispGeo.M3D[2]-dispGeo.L3D[2];
     vtkMath::Normalize(dispGeo.vnormal);
     dispGeo.vp[0] = dispGeo.M3D[0];
     dispGeo.vp[1] = dispGeo.M3D[1];
     dispGeo.vp[2] = dispGeo.M3D[2];
 
     inversetransform->TransformPoint( dispGeo.vp, dispGeo.vp );
     inversetransform->TransformNormalAtPoint( dispGeo.vp, dispGeo.vnormal, dispGeo.vnormal );
 
     m_ThickPlanes2[index]->count = 0;
     m_ThickPlanes2[index]->SetTransform((vtkAbstractTransform*)nullptr );
     m_ThickPlanes2[index]->SetPose( dispGeo.vnormal, dispGeo.vp );
     m_ThickPlanes2[index]->SetThickness(dispGeo.d1);
     m_Clippers2[index]->SetClipFunction( m_ThickPlanes2[index] );
     m_Clippers2[index]->SetInputData( m_Clippers1[index]->GetOutput() );
     m_Clippers2[index]->SetInsideOut(1);
     m_Clippers2[index]->Update();
 
     cuttedPlane = m_Clippers2[index]->GetOutput ();
 
     if(cuttedPlane->GetNumberOfPoints())
     {
       localStorage->m_OdfsPlanes[index]->RemoveAllInputs();
 
       vtkSmartPointer<vtkPolyDataNormals> normals = vtkSmartPointer<vtkPolyDataNormals>::New();
       normals->SetInputConnection( m_OdfSource->GetOutputPort() );
       normals->SplittingOff();
       normals->ConsistencyOff();
       normals->AutoOrientNormalsOff();
       normals->ComputePointNormalsOn();
       normals->ComputeCellNormalsOff();
       normals->FlipNormalsOff();
       normals->NonManifoldTraversalOff();
 
       vtkSmartPointer<vtkTransformPolyDataFilter> trans = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
       trans->SetInputConnection( normals->GetOutputPort() );
       trans->SetTransform(m_OdfTransform);
 
       vtkSmartPointer<vtkMaskedProgrammableGlyphFilter> glyphGenerator = vtkSmartPointer<vtkMaskedProgrammableGlyphFilter>::New();
       glyphGenerator->SetMaximumNumberOfPoints(std::min(m_ShowMaxNumber,(int)cuttedPlane->GetNumberOfPoints()));
       glyphGenerator->SetRandomMode( m_ToggleGlyphPlacementMode );
       glyphGenerator->SetUseMaskPoints(1);
       glyphGenerator->SetSourceConnection(trans->GetOutputPort() );
       glyphGenerator->SetInput(cuttedPlane);
       glyphGenerator->SetColorModeToColorBySource();
       glyphGenerator->SetGeometry(this->GetDataNode()->GetData()->GetGeometry());
       glyphGenerator->SetGlyphMethod(&(GlyphMethod),(void *)glyphGenerator);
 
       try
       {
         glyphGenerator->Update();
       }
       catch( itk::ExceptionObject& err )
       {
         std::cout << err << std::endl;
       }
 
       localStorage->m_OdfsPlanes[index]->AddInputConnection(glyphGenerator->GetOutputPort());
       localStorage->m_OdfsPlanes[index]->Update();
     }
   }
   localStorage->m_OdfsMappers[index]->ScalarVisibilityOn();
   localStorage->m_OdfsMappers[index]->SetScalarModeToUsePointFieldData();
   localStorage->m_OdfsMappers[index]->SelectColorArray("ODF_COLORS");
 
   localStorage->m_PropAssemblies[index]->VisibilityOn();
   if(localStorage->m_PropAssemblies[index]->GetParts()->IsItemPresent(localStorage->m_OdfsActors[index]))
   {
     localStorage->m_PropAssemblies[index]->RemovePart(localStorage->m_OdfsActors[index]);
   }
   localStorage->m_OdfsMappers[index]->SetInputData(localStorage->m_OdfsPlanes[index]->GetOutput());
   localStorage->m_PropAssemblies[index]->AddPart(localStorage->m_OdfsActors[index]);
 }
 
 template<class T, int N>
 bool mitk::OdfVtkMapper2D<T,N>
 ::IsVisibleOdfs(mitk::BaseRenderer* renderer)
 {
   mitk::Image::Pointer input  = const_cast<mitk::Image*>(this->GetInput());
   const TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
   if(inputTimeGeometry==nullptr || inputTimeGeometry->CountTimeSteps()==0 || !inputTimeGeometry->IsValidTimeStep(this->GetTimestep()))
     return false;
 
   if(this->IsPlaneRotated(renderer))
     return false;
 
   bool retval = false;
   switch(GetIndex(renderer))
   {
   case 0:
     GetDataNode()->GetVisibility(retval, renderer, "VisibleOdfs_T");
     break;
   case 1:
     GetDataNode()->GetVisibility(retval, renderer, "VisibleOdfs_S");
     break;
   case 2:
     GetDataNode()->GetVisibility(retval, renderer, "VisibleOdfs_C");
     break;
   }
 
   return retval;
 }
 
 template<class T, int N>
 void  mitk::OdfVtkMapper2D<T,N>
 ::MitkRenderOverlay(mitk::BaseRenderer* renderer)
 {
   if ( this->IsVisibleOdfs(renderer)==false )
     return;
 
   if ( this->GetVtkProp(renderer)->GetVisibility() )
     this->GetVtkProp(renderer)->RenderOverlay(renderer->GetVtkRenderer());
 }
 
 template<class T, int N>
 void  mitk::OdfVtkMapper2D<T,N>
 ::MitkRenderOpaqueGeometry(mitk::BaseRenderer* renderer)
 {
   if ( this->IsVisibleOdfs( renderer )==false )
     return;
 
   if ( this->GetVtkProp(renderer)->GetVisibility() )
   {
     // adapt cam pos
     this->GetVtkProp(renderer)->RenderOpaqueGeometry( renderer->GetVtkRenderer() );
   }
 }
 
 template<class T, int N>
 void  mitk::OdfVtkMapper2D<T,N>
 ::MitkRenderTranslucentGeometry(mitk::BaseRenderer* renderer)
 {
   if ( this->IsVisibleOdfs(renderer)==false )
     return;
 
   if ( this->GetVtkProp(renderer)->GetVisibility() )
     this->GetVtkProp(renderer)->RenderTranslucentPolygonalGeometry(renderer->GetVtkRenderer());
 
 }
 
 template<class T, int N>
 void mitk::OdfVtkMapper2D<T,N>
 ::Update(mitk::BaseRenderer* renderer)
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if ( !visible ) return;
 
   mitk::Image::Pointer input = const_cast<mitk::Image*>( this->GetInput() );
   if ( input.IsNull() ) return ;
 
   std::string classname("TensorImage");
   if(classname.compare(input->GetNameOfClass())==0)
     m_VtkImage = dynamic_cast<mitk::TensorImage*>( this->GetInput() )->GetNonRgbVtkImageData();
 
   std::string qclassname("OdfImage");
   if(qclassname.compare(input->GetNameOfClass())==0)
     m_VtkImage = dynamic_cast<mitk::OdfImage*>( this->GetInput() )->GetNonRgbVtkImageData();
 
   std::string shclassname("ShImage");
   if(shclassname.compare(input->GetNameOfClass())==0)
     m_VtkImage = dynamic_cast<mitk::ShImage*>( this->GetInput() )->GetNonRgbVtkImageData();
 
   if( m_VtkImage )
   {
     // make sure, that we have point data with more than 1 component (as vectors)
     vtkPointData* pointData = m_VtkImage->GetPointData();
     if ( pointData == nullptr )
     {
       itkWarningMacro( << "m_VtkImage->GetPointData() returns NULL!" );
       return ;
     }
     if ( pointData->GetNumberOfArrays() == 0 )
     {
       itkWarningMacro( << "m_VtkImage->GetPointData()->GetNumberOfArrays() is 0!" );
       return ;
     }
     else if ( pointData->GetArrayName( 0 ) == nullptr )
     {
       m_VtkImage->GetPointData()->GetArray(0)->SetName("vector");
     }
 
     GenerateDataForRenderer(renderer);
   }
   else
   {
     itkWarningMacro( << "m_VtkImage is NULL!" );
     return ;
   }
 }
 
 template<class T, int N>
 void  mitk::OdfVtkMapper2D<T,N>
 ::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   OdfDisplayGeometry dispGeo = MeasureDisplayedGeometry( renderer);
 
   if ((localStorage->m_LastUpdateTime >= m_DataNode->GetMTime()) //was the node modified?
       && (localStorage->m_LastUpdateTime >= m_DataNode->GetPropertyList()->GetMTime()) //was a property modified?
       && (localStorage->m_LastUpdateTime >= m_DataNode->GetPropertyList(renderer)->GetMTime())
       && dispGeo.Equals(m_LastDisplayGeometry.at(GetIndex(renderer))))
   {
     return;
   }
 
   localStorage->m_LastUpdateTime.Modified();
 
   if(!IsVisibleOdfs(renderer))
   {
     localStorage->m_OdfsActors[0]->VisibilityOff();
     localStorage->m_OdfsActors[1]->VisibilityOff();
     localStorage->m_OdfsActors[2]->VisibilityOff();
   }
   else
   {
     localStorage->m_OdfsActors[0]->VisibilityOn();
     localStorage->m_OdfsActors[1]->VisibilityOn();
     localStorage->m_OdfsActors[2]->VisibilityOn();
 
     m_OdfSource->SetAdditionalScale(GetMinImageSpacing(GetIndex(renderer)));
     ApplyPropertySettings();
     Slice(renderer, dispGeo);
     m_LastDisplayGeometry[GetIndex(renderer)] = dispGeo;
   }
 }
 
 template<class T, int N>
 double  mitk::OdfVtkMapper2D<T,N>::GetMinImageSpacing( int index )
 {
   // Spacing adapted scaling
   double spacing[3];
   m_VtkImage->GetSpacing(spacing);
   double min = spacing[0];
   if(index==0)
   {
     min = spacing[0];
     min = min > spacing[1] ? spacing[1] : min;
   }
   if(index==1)
   {
     min = spacing[1];
     min = min > spacing[2] ? spacing[2] : min;
   }
   if(index==2)
   {
     min = spacing[0];
     min = min > spacing[2] ? spacing[2] : min;
   }
   return min;
 }
 
 template<class T, int N>
 void  mitk::OdfVtkMapper2D<T,N>
 ::ApplyPropertySettings()
 {
   this->GetDataNode()->GetFloatProperty( "Scaling", m_Scaling );
   this->GetDataNode()->GetIntProperty( "ShowMaxNumber", m_ShowMaxNumber );
 
   OdfNormalizationMethodProperty* nmp = dynamic_cast<OdfNormalizationMethodProperty*>(this->GetDataNode()->GetProperty( "Normalization" ));
   if(nmp)
     m_Normalization = nmp->GetNormalization();
 
   OdfScaleByProperty* sbp = dynamic_cast<OdfScaleByProperty*>(this->GetDataNode()->GetProperty( "ScaleBy" ));
   if(sbp)
     m_ScaleBy = sbp->GetScaleBy();
 
   this->GetDataNode()->GetFloatProperty( "IndexParam1", m_IndexParam1);
   this->GetDataNode()->GetFloatProperty( "IndexParam2", m_IndexParam2);
 
   this->GetDataNode()->GetBoolProperty( "DiffusionCore.Rendering.OdfVtkMapper.SwitchTensorView", m_ToggleTensorEllipsoidView );
   this->GetDataNode()->GetBoolProperty( "DiffusionCore.Rendering.OdfVtkMapper.ColourisationModeBit", m_ToggleColourisationMode );
   this->GetDataNode()->GetBoolProperty( "DiffusionCore.Rendering.OdfVtkMapper.RandomModeBit", m_ToggleGlyphPlacementMode);
 }
 
 template <class T, int N>
 bool mitk::OdfVtkMapper2D<T,N>
 ::IsPlaneRotated(mitk::BaseRenderer* renderer)
 {
   PlaneGeometry::ConstPointer worldPlaneGeometry = renderer->GetCurrentWorldPlaneGeometry();
 
   double vnormal[ 3 ];
   Vector3D normal = worldPlaneGeometry->GetNormal(); normal.Normalize();
   vnl2vtk( normal.GetVnlVector(), vnormal );
 
   mitk::Image* currentImage = dynamic_cast<mitk::Image* >( this->GetDataNode()->GetData() );
   if( currentImage == nullptr )
     return false;
   mitk::Vector3D imageNormal0 = currentImage->GetSlicedGeometry()->GetAxisVector(0);
   mitk::Vector3D imageNormal1 = currentImage->GetSlicedGeometry()->GetAxisVector(1);
   mitk::Vector3D imageNormal2 = currentImage->GetSlicedGeometry()->GetAxisVector(2);
   imageNormal0.Normalize();
   imageNormal1.Normalize();
   imageNormal2.Normalize();
 
   double eps = 0.000001; // Did you mean: std::numeric_limits<T>::epsilon(); ?
   int test = 0;
   if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal0.GetVnlVector()))-1) > eps )
     test++;
   if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal1.GetVnlVector()))-1) > eps )
     test++;
   if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal2.GetVnlVector()))-1) > eps )
     test++;
   if (test==3)
     return true;
   return false;
 }
 
 template<class T, int N>
 void  mitk::OdfVtkMapper2D<T,N>
 ::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer*  /*renderer*/, bool  /*overwrite*/)
 {
   node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 500 ) );
   node->SetProperty( "Normalization", mitk::OdfNormalizationMethodProperty::New());
 
   mitk::OdfScaleByProperty::Pointer prop = mitk::OdfScaleByProperty::New();
   prop->SetScaleByGFA();
   node->SetProperty( "ScaleBy", prop);
 
   if (dynamic_cast<mitk::TensorImage*>(node->GetData()))
   {
     node->AddProperty( "DiffusionCore.Rendering.OdfVtkMapper.ColourisationModeBit", mitk::BoolProperty::New( true ) );
     node->SetProperty( "Scaling", mitk::FloatProperty::New( 3.0 ) );
   }
   else
   {
     node->AddProperty( "DiffusionCore.Rendering.OdfVtkMapper.ColourisationModeBit", mitk::BoolProperty::New( false ) );
     node->SetProperty( "Scaling", mitk::FloatProperty::New( 1.5 ) );
   }
 
   node->SetProperty( "IndexParam1", mitk::FloatProperty::New(2));
   node->SetProperty( "IndexParam2", mitk::FloatProperty::New(1));
   node->SetProperty( "visible", mitk::BoolProperty::New( true ) );
   node->SetProperty( "VisibleOdfs_T", mitk::BoolProperty::New( false ) );
   node->SetProperty( "VisibleOdfs_C", mitk::BoolProperty::New( false ) );
   node->SetProperty( "VisibleOdfs_S", mitk::BoolProperty::New( false ) );
   node->SetProperty( "layer", mitk::IntProperty::New(100));
   node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) );
   node->AddProperty( "DiffusionCore.Rendering.OdfVtkMapper.SwitchTensorView", mitk::BoolProperty::New( true) );
   node->AddProperty( "DiffusionCore.Rendering.OdfVtkMapper.RandomModeBit", mitk::BoolProperty::New( true ) );
 }
 
 #endif // __mitkOdfVtkMapper2D_txx__
 
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp
index f87a75c3da..1231b5e3c7 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp
@@ -1,277 +1,277 @@
 /*===================================================================
 
 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 "mitkFiberBundleMapper2D.h"
 #include "mitkBaseRenderer.h"
 #include "mitkDataNode.h"
 #include <vtkActor.h>
 #include <vtkOpenGLPolyDataMapper.h>
 #include <vtkOpenGLHelper.h>
 #include <vtkShaderProgram.h>
 #include <vtkPlane.h>
 #include <vtkPolyData.h>
 #include <vtkPointData.h>
 #include <vtkProperty.h>
 #include <vtkLookupTable.h>
 #include <vtkPoints.h>
 #include <vtkCamera.h>
 #include <vtkPolyLine.h>
 #include <vtkRenderer.h>
 #include <vtkCellArray.h>
 #include <vtkMatrix4x4.h>
 #include <vtkTubeFilter.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkSliceNavigationController.h>
 #include <mitkCoreServices.h>
 
 class vtkShaderCallback : public vtkCommand
 {
 public:
   static vtkShaderCallback *New()
   {
     return new vtkShaderCallback;
   }
   mitk::BaseRenderer *renderer;
   mitk::DataNode *node;
 
   void Execute(vtkObject *, unsigned long, void*cbo) override
   {
     vtkShaderProgram *program = reinterpret_cast<vtkShaderProgram*>(cbo);
 
     float fiberOpacity;
     bool fiberFading = false;
     float fiberThickness = 0.0;
 
     node->GetOpacity(fiberOpacity, nullptr);
     node->GetFloatProperty("Fiber2DSliceThickness", fiberThickness);
     node->GetBoolProperty("Fiber2DfadeEFX", fiberFading);
 
     program->SetUniformf("fiberOpacity", fiberOpacity);
     program->SetUniformi("fiberFadingON", fiberFading);
     program->SetUniformf("fiberThickness", fiberThickness);
 
     if (this->renderer)
     {
       //get information about current position of views
       mitk::SliceNavigationController::Pointer sliceContr = renderer->GetSliceNavigationController();
       mitk::PlaneGeometry::ConstPointer planeGeo = sliceContr->GetCurrentPlaneGeometry();
 
       //generate according cutting planes based on the view position
       float planeNormal[3];
       planeNormal[0] = planeGeo->GetNormal()[0];
       planeNormal[1] = planeGeo->GetNormal()[1];
       planeNormal[2] = planeGeo->GetNormal()[2];
 
       float tmp1 = planeGeo->GetOrigin()[0] * planeNormal[0];
       float tmp2 = planeGeo->GetOrigin()[1] * planeNormal[1];
       float tmp3 = planeGeo->GetOrigin()[2] * planeNormal[2];
       float thickness = tmp1 + tmp2 + tmp3; //attention, correct normalvector
 
-      float* a = new float[4];
+      float a[4];
       for (int i = 0; i < 3; ++i)
         a[i] = planeNormal[i];
 
       a[3] = thickness;
       program->SetUniform4f("slicingPlane", a);
 
     }
   }
 
   vtkShaderCallback() { this->renderer = nullptr; }
 };
 
 
 
 mitk::FiberBundleMapper2D::FiberBundleMapper2D()
   : m_LineWidth(1)
 {
-  m_lut = vtkLookupTable::New();
+  m_lut = vtkSmartPointer<vtkLookupTable>::New();
   m_lut->Build();
 
 }
 
 mitk::FiberBundleMapper2D::~FiberBundleMapper2D()
 {
 }
 
 
 mitk::FiberBundle* mitk::FiberBundleMapper2D::GetInput()
 {
   return dynamic_cast< mitk::FiberBundle * > ( GetDataNode()->GetData() );
 }
 
 
 
 void mitk::FiberBundleMapper2D::Update(mitk::BaseRenderer * renderer)
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if ( !visible )
     return;
 
   // Calculate time step of the input data for the specified renderer (integer value)
   // this method is implemented in mitkMapper
   this->CalculateTimeStep( renderer );
 
   //check if updates occured in the node or on the display
   FBXLocalStorage *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
 
   //set renderer independent shader properties
   const DataNode::Pointer node = this->GetDataNode();
   float thickness = 2.0;
   if(!this->GetDataNode()->GetPropertyValue("Fiber2DSliceThickness",thickness))
     MITK_INFO << "FIBER2D SLICE THICKNESS PROPERTY ERROR";
 
   bool fiberfading = false;
   if(!this->GetDataNode()->GetPropertyValue("Fiber2DfadeEFX",fiberfading))
     MITK_INFO << "FIBER2D SLICE FADE EFX PROPERTY ERROR";
 
   mitk::FiberBundle* fiberBundle = this->GetInput();
   if (fiberBundle==nullptr)
     return;
 
   int lineWidth = 0;
   node->GetIntProperty("LineWidth", lineWidth);
   if (m_LineWidth!=lineWidth)
   {
     m_LineWidth = lineWidth;
     fiberBundle->RequestUpdate2D();
   }
 
   if ( localStorage->m_LastUpdateTime<renderer->GetCurrentWorldPlaneGeometryUpdateTime() || localStorage->m_LastUpdateTime<fiberBundle->GetUpdateTime2D() )
   {
     this->UpdateShaderParameter(renderer);
     this->GenerateDataForRenderer( renderer );
   }
 }
 
 void mitk::FiberBundleMapper2D::UpdateShaderParameter(mitk::BaseRenderer *)
 {
   // see new vtkShaderCallback
 }
 
 // vtkActors and Mappers are feeded here
 void mitk::FiberBundleMapper2D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
 {
   mitk::FiberBundle* fiberBundle = this->GetInput();
 
   //the handler of local storage gets feeded in this method with requested data for related renderwindow
   FBXLocalStorage *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
 
   mitk::DataNode* node = this->GetDataNode();
   if (node == nullptr)
     return;
 
   vtkSmartPointer<vtkPolyData> fiberPolyData = fiberBundle->GetFiberPolyData();
   if (fiberPolyData == nullptr)
     return;
 
   fiberPolyData->GetPointData()->AddArray(fiberBundle->GetFiberColors());
   localStorage->m_FiberMapper->ScalarVisibilityOn();
   localStorage->m_FiberMapper->SetScalarModeToUsePointFieldData();
   localStorage->m_FiberMapper->SetLookupTable(m_lut);  //apply the properties after the slice was set
   localStorage->m_PointActor->GetProperty()->SetOpacity(0.999);
   localStorage->m_FiberMapper->SelectColorArray("FIBER_COLORS");
   localStorage->m_FiberMapper->SetInputData(fiberPolyData);
 
   localStorage->m_FiberMapper->SetVertexShaderCode(
         "//VTK::System::Dec\n"
         "attribute vec4 vertexMC;\n"
 
         "//VTK::Normal::Dec\n"
         "uniform mat4 MCDCMatrix;\n"
 
         "//VTK::Color::Dec\n"
 
         "varying vec4 positionWorld;\n"
         "varying vec4 colorVertex;\n"
 
         "void main(void)\n"
         "{\n"
         "  colorVertex = scalarColor;\n"
         "  positionWorld = vertexMC;\n"
         "  gl_Position = MCDCMatrix * vertexMC;\n"
         "}\n"
         );
   localStorage->m_FiberMapper->SetFragmentShaderCode(
         "//VTK::System::Dec\n"  // always start with this line
         "//VTK::Output::Dec\n"  // always have this line in your FS
         "uniform vec4 slicingPlane;\n"
         "uniform float fiberThickness;\n"
         "uniform int fiberFadingON;\n"
         "uniform float fiberOpacity;\n"
 
         "varying vec4 positionWorld;\n"
         "varying vec4 colorVertex;\n"
         "out vec4 out_Color;\n"
 
         "void main(void)\n"
         "{\n"
         "  float r1 = dot(positionWorld.xyz, slicingPlane.xyz) - slicingPlane.w;\n"
 
         "  if (abs(r1) >= fiberThickness)\n"
         "    discard;\n"
 
         "  if (fiberFadingON != 0)\n"
         "  {\n"
         "    float x = (r1 + fiberThickness) / (fiberThickness*2.0);\n"
         "    x = 1.0 - x;\n"
         "    out_Color = vec4(colorVertex.xyz*x, fiberOpacity);\n"
         "  }\n"
         "  else{\n"
         "    out_Color = vec4(colorVertex.xyz,fiberOpacity);\n"
         "  }\n"
         "}\n"
         );
 
   vtkSmartPointer<vtkShaderCallback> myCallback = vtkSmartPointer<vtkShaderCallback>::New();
   myCallback->renderer = renderer;
   myCallback->node = this->GetDataNode();
   localStorage->m_FiberMapper->AddObserver(vtkCommand::UpdateShaderEvent,myCallback);
 
   localStorage->m_PointActor->SetMapper(localStorage->m_FiberMapper);
   localStorage->m_PointActor->GetProperty()->ShadingOn();
   localStorage->m_PointActor->GetProperty()->SetLineWidth(m_LineWidth);
 
   // We have been modified => save this for next Update()
   localStorage->m_LastUpdateTime.Modified();
 }
 
 
 vtkProp* mitk::FiberBundleMapper2D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
   this->Update(renderer);
   return m_LocalStorageHandler.GetLocalStorage(renderer)->m_PointActor;
 }
 
 
 void mitk::FiberBundleMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   Superclass::SetDefaultProperties(node, renderer, overwrite);
   //    node->SetProperty("shader",mitk::ShaderProperty::New("mitkShaderFiberClipping"));
 
   //add other parameters to propertylist
   node->AddProperty( "Fiber2DSliceThickness", mitk::FloatProperty::New(1.0f), renderer, overwrite );
   node->AddProperty( "Fiber2DfadeEFX", mitk::BoolProperty::New(true), renderer, overwrite );
   node->AddProperty( "color", mitk::ColorProperty::New(1.0,1.0,1.0), renderer, overwrite);
 }
 
 
 mitk::FiberBundleMapper2D::FBXLocalStorage::FBXLocalStorage()
 {
   m_PointActor = vtkSmartPointer<vtkActor>::New();
   m_FiberMapper = vtkSmartPointer<MITKFIBERBUNDLEMAPPER2D_POLYDATAMAPPER>::New();
 }
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.cpp
index 1b5a8310a8..88fbf014b5 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.cpp
@@ -1,421 +1,421 @@
 /*===================================================================
 
 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 "mitkFiberBundleMapper3D.h"
 #include <mitkProperties.h>
 
 #include <vtkPropAssembly.h>
 #include <vtkPointData.h>
 #include <vtkProperty.h>
 #include <vtkCellArray.h>
 #include <vtkDepthSortPolyData.h>
 #include <vtkCamera.h>
 #include <vtkTubeFilter.h>
 #include <vtkRibbonFilter.h>
 #include <vtkLookupTable.h>
 #include <vtkOpenGLHelper.h>
 #include <vtkShaderProgram.h>
 #include <mitkVectorProperty.h>
 
 class vtkShaderCallback3D : public vtkCommand
 {
 public:
   static vtkShaderCallback3D *New()
   {
     return new vtkShaderCallback3D;
   }
   mitk::BaseRenderer *renderer;
   mitk::DataNode *node;
 
   void Execute(vtkObject *, unsigned long, void* cbo) override
   {
     vtkShaderProgram *program = reinterpret_cast<vtkShaderProgram*>(cbo);
 
     float fiberOpacity;
     node->GetOpacity(fiberOpacity, nullptr);
     program->SetUniformf("fiberOpacity", fiberOpacity);
 
     if (this->renderer)
     {
       mitk::Vector3D plane_vec; plane_vec.Fill(0);
       node->GetPropertyValue("Fiber3DClippingPlane",plane_vec);
       float distance = plane_vec.GetNorm();
       plane_vec.Normalize();
 
       bool flip;
       node->GetBoolProperty("Fiber3DClippingPlaneFlip",flip);
 
       if (flip)
       {
         plane_vec *= -1;
         distance *= -1;
       }
 
       node->GetBoolProperty("Fiber3DClippingPlaneSecondFlip",flip);
       if (flip)
       {
         plane_vec *= -1;
         distance *= -1;
       }
 
       float a[4];
       for (int i = 0; i < 3; ++i)
         a[i] = plane_vec[i];
 
       a[3] = distance;
       program->SetUniform4f("slicingPlane", a);
 
       float v = 1;
       node->GetFloatProperty("light.ambient", v);
       program->SetUniformf("ambient", v);
 
       node->GetFloatProperty("light.diffuse", v);
       program->SetUniformf("diffuse", v);
 
       node->GetFloatProperty("light.specular", v);
       program->SetUniformf("intensity", v);
 
       node->GetFloatProperty("light.intensity", v);
       program->SetUniformf("intensity", v);
 
       bool enable_light = false;
       node->GetBoolProperty("light.enable_light", enable_light);
       program->SetUniformi("enable_light", enable_light);
     }
   }
 
   vtkShaderCallback3D() { this->renderer = nullptr; }
 };
 
 mitk::FiberBundleMapper3D::FiberBundleMapper3D()
   : m_TubeRadius(0.0)
   , m_TubeSides(15)
   , m_LineWidth(1)
 {
-  m_lut = vtkLookupTable::New();
+  m_lut = vtkSmartPointer<vtkLookupTable>::New();
   m_lut->Build();
 }
 
 
 mitk::FiberBundleMapper3D::~FiberBundleMapper3D()
 {
 
 }
 
 
 const mitk::FiberBundle* mitk::FiberBundleMapper3D::GetInput()
 {
   return static_cast<const mitk::FiberBundle * > ( GetDataNode()->GetData() );
 }
 
 
 /*
  This method is called once the mapper gets new input,
  for UI rotation or changes in colorcoding this method is NOT called
  */
 void mitk::FiberBundleMapper3D::InternalGenerateData(mitk::BaseRenderer *renderer)
 {
   m_FiberPolyData->GetPointData()->AddArray(m_FiberBundle->GetFiberColors());
   float tmpopa;
   this->GetDataNode()->GetOpacity(tmpopa, nullptr);
   FBXLocalStorage3D *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
 
   if (m_TubeRadius>0.0)
   {
     vtkSmartPointer<vtkTubeFilter> tubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
     tubeFilter->SetInputData(m_FiberPolyData);
     tubeFilter->SetNumberOfSides(m_TubeSides);
     tubeFilter->SetRadius(m_TubeRadius);
     tubeFilter->Update();
     m_FiberPolyData = tubeFilter->GetOutput();
   }
   else if (m_RibbonWidth>0.0)
   {
     vtkSmartPointer<vtkRibbonFilter> tubeFilter = vtkSmartPointer<vtkRibbonFilter>::New();
     tubeFilter->SetInputData(m_FiberPolyData);
     tubeFilter->SetWidth(m_RibbonWidth);
     tubeFilter->Update();
     m_FiberPolyData = tubeFilter->GetOutput();
   }
 
   if (tmpopa<1)
   {
     vtkSmartPointer<vtkDepthSortPolyData> depthSort = vtkSmartPointer<vtkDepthSortPolyData>::New();
     depthSort->SetInputData( m_FiberPolyData );
     depthSort->SetCamera( renderer->GetVtkRenderer()->GetActiveCamera() );
     depthSort->SetDirectionToBackToFront();
     depthSort->Update();
     localStorage->m_FiberMapper->SetInputConnection(depthSort->GetOutputPort());
 
   }
   else
   {
     localStorage->m_FiberMapper->SetInputData(m_FiberPolyData);
   }
 
   if (m_Lighting)
   {
     float floatProp = 1.0;
     GetDataNode()->GetFloatProperty("light.ambient", floatProp);
     localStorage->m_FiberActor->GetProperty()->SetAmbient(floatProp);
     GetDataNode()->GetFloatProperty("light.diffuse", floatProp);
     localStorage->m_FiberActor->GetProperty()->SetDiffuse(floatProp);
     GetDataNode()->GetFloatProperty("light.specular", floatProp);
     localStorage->m_FiberActor->GetProperty()->SetSpecular(floatProp);
     GetDataNode()->GetFloatProperty("light.specularpower", floatProp);
     localStorage->m_FiberActor->GetProperty()->SetSpecularPower( floatProp );
 
     mitk::ColorProperty* ambientC = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty("light.ambientcolor"));
     mitk::ColorProperty* diffuseC = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty("light.diffusecolor"));
     mitk::ColorProperty* specularC = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty("light.specularcolor"));
 
     localStorage->m_FiberActor->GetProperty()->SetAmbientColor( ambientC->GetColor()[0], ambientC->GetColor()[1], ambientC->GetColor()[2] );
     localStorage->m_FiberActor->GetProperty()->SetDiffuseColor( diffuseC->GetColor()[0], diffuseC->GetColor()[1], diffuseC->GetColor()[2] );
     localStorage->m_FiberActor->GetProperty()->SetSpecularColor( specularC->GetColor()[0], specularC->GetColor()[1], specularC->GetColor()[2] );
     localStorage->m_FiberActor->GetProperty()->SetLighting(true);
   }
   else
   {
     localStorage->m_FiberActor->GetProperty()->SetLighting(false);
   }
 
   localStorage->m_FiberMapper->SelectColorArray("FIBER_COLORS");
   localStorage->m_FiberMapper->ScalarVisibilityOn();
   localStorage->m_FiberMapper->SetScalarModeToUsePointFieldData();
   localStorage->m_FiberActor->SetMapper(localStorage->m_FiberMapper);
   localStorage->m_FiberMapper->SetLookupTable(m_lut);
 
   // set Opacity
   localStorage->m_FiberActor->GetProperty()->SetOpacity((double) tmpopa);
   localStorage->m_FiberActor->GetProperty()->SetLineWidth(m_LineWidth);
 
   localStorage->m_FiberAssembly->AddPart(localStorage->m_FiberActor);
 
 //  localStorage->m_FiberMapper->AddShaderReplacement(
 //        vtkShader::Vertex,
 //        "//VTK::Normal::Dec\n",
 //        true,
 //        "//VTK::Normal::Dec\n"
 //        "uniform mat4 MCVCMatrix;\n"
 //        "attribute vec3 normalMC;\n"
 //        "uniform mat3 normalMatrix;\n"
 //        "varying vec4 positionWorld;\n"
 //        "varying vec4 colorVertex;\n"
 //        "varying vec3 N;\n"
 //        "varying vec4 v;\n",
 //        false
 //        );
 
   localStorage->m_FiberMapper->SetVertexShaderCode(
         "//VTK::System::Dec\n"
         "attribute vec4 vertexMC;\n"
 
         "//VTK::Normal::Dec\n"
         "uniform mat4 MCDCMatrix;\n"
         "uniform mat4 MCVCMatrix;\n"
 
         "//VTK::Color::Dec\n"
         "attribute vec3 normalMC;\n"
         "uniform mat3 normalMatrix;\n"
 
         "varying vec4 positionWorld;\n"
         "varying vec4 colorVertex;\n"
         "varying vec3 N;\n"
         "varying vec4 v;\n"
 
         "void main(void)\n"
         "{\n"
         "  colorVertex = scalarColor;\n"
         "  positionWorld = vertexMC;\n"
         "  v = MCVCMatrix * vertexMC;\n"
         "  mat4 glNormalMatrix = transpose(inverse(MCVCMatrix));\n"
         "  N = normalize(normalMatrix * normalMC);\n"
         "  gl_Position = MCDCMatrix * vertexMC;\n"
         "}\n"
         );
   localStorage->m_FiberMapper->SetFragmentShaderCode(
         "//VTK::System::Dec\n"  // always start with this line
         "//VTK::Output::Dec\n"  // always have this line in your FS
 
         "uniform vec4 slicingPlane;\n"
         "uniform float fiberOpacity;\n"
         "uniform float ambient;\n"
         "uniform float diffuse;\n"
         "uniform float specular;\n"
         "uniform float intensity;\n"
         "uniform int enable_light;\n"
         "varying vec4 positionWorld;\n"
         "varying vec4 colorVertex;\n"
 
         "varying vec3 N;\n"
         "varying vec4 v;\n"
         "out vec4 out_Color;\n"
 
         "void main(void)\n"
         "{\n"
         "   float r1 = dot(positionWorld.xyz, slicingPlane.xyz) - slicingPlane.w;\n"
         "   if ( r1 > 0 )\n"
         "     discard;\n"
 
         "   if (enable_light!=0)\n"
         "   {\n"
         "     vec3 L = normalize(-v.xyz);\n"
 //        "normalize(gl_LightSource[0].position.xyz - v.xyz);\n"
         "     vec3 E = normalize(-v.xyz); // we are in Eye Coordinates, so EyePos is (0,0,0)\n"
         "     vec3 R = normalize(-reflect(L,N));\n"
 
         //calculate Diffuse Term:
         "     float Idiff = diffuse * max(dot(N,L), 0.0);\n"
         "     Idiff = clamp(Idiff, 0.0, 1.0);\n"
 
         // calculate Specular Term:
         "     float Ispec = specular * pow(max(dot(R,E),0.0),0.3);\n"
         "     Ispec = clamp(Ispec, 0.0, 1.0);\n"
 
         "     out_Color = vec4(colorVertex.xyz, fiberOpacity)*(1-intensity) + vec4(colorVertex.xyz * (ambient + Idiff + Ispec) * intensity, fiberOpacity);\n"
         "   }\n"
         "   else\n"
         "   {\n"
         "     out_Color = vec4(colorVertex.xyz, fiberOpacity);\n"
         "   }\n"
 
         "}\n"
         );
 
 
   vtkSmartPointer<vtkShaderCallback3D> myCallback = vtkSmartPointer<vtkShaderCallback3D>::New();
   myCallback->renderer = renderer;
   myCallback->node = this->GetDataNode();
   localStorage->m_FiberMapper->AddObserver(vtkCommand::UpdateShaderEvent,myCallback);
 
 
   localStorage->m_LastUpdateTime.Modified();
 }
 
 
 
 void mitk::FiberBundleMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if ( !visible )
     return;
 
   const DataNode* node = this->GetDataNode();
   FBXLocalStorage3D* localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
 
   m_FiberBundle = dynamic_cast<mitk::FiberBundle*>(node->GetData());
   m_FiberPolyData = m_FiberBundle->GetFiberPolyData();
 
   //  this->ApplyShaderProperties(renderer, "shader_3d");
 
   // did any rendering properties change?
   float tubeRadius = 0;
   node->GetFloatProperty("shape.tuberadius", tubeRadius);
   if (m_TubeRadius!=tubeRadius)
   {
     m_TubeRadius = tubeRadius;
     m_FiberBundle->RequestUpdate3D();
   }
 
   int tubeSides = 0;
   node->GetIntProperty("shape.tubesides", tubeSides);
   if (m_TubeSides!=tubeSides)
   {
     m_TubeSides = tubeSides;
     m_FiberBundle->RequestUpdate3D();
   }
 
   int lineWidth = 0;
   node->GetIntProperty("shape.linewidth", lineWidth);
   if (m_LineWidth!=lineWidth)
   {
     m_LineWidth = lineWidth;
     m_FiberBundle->RequestUpdate3D();
   }
 
   float ribbonWidth = 0;
   node->GetFloatProperty("shape.ribbonwidth", ribbonWidth);
   if (m_RibbonWidth!=ribbonWidth)
   {
     m_RibbonWidth = ribbonWidth;
     m_FiberBundle->RequestUpdate3D();
   }
 
   bool lighting = false;
   node->GetBoolProperty("light.enable", lighting);
   if (m_Lighting!=lighting)
   {
     m_Lighting = lighting;
     m_FiberBundle->RequestUpdate3D();
   }
 
   if (localStorage->m_LastUpdateTime>=m_FiberBundle->GetUpdateTime3D())
     return;
 
   // Calculate time step of the input data for the specified renderer (integer value)
   // this method is implemented in mitkMapper
   this->CalculateTimeStep( renderer );
   this->InternalGenerateData(renderer);
 }
 
 void mitk::FiberBundleMapper3D::UpdateShaderParameter(mitk::BaseRenderer * )
 {
   // see new vtkShaderCallback3D
 }
 
 void mitk::FiberBundleMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 
   mitk::Vector3D plane_vec; plane_vec.Fill(0.0);
   node->AddProperty( "Fiber3DClippingPlane", mitk::Vector3DProperty::New( plane_vec ), renderer, overwrite );
   node->AddProperty( "Fiber3DClippingPlaneId", mitk::IntProperty::New( 0 ), renderer, overwrite );
   node->AddProperty( "Fiber3DClippingPlaneFlip", mitk::BoolProperty::New( false ), renderer, overwrite );
   node->AddProperty( "Fiber3DClippingPlaneSecondFlip", mitk::BoolProperty::New( false ), renderer, overwrite );
 
   node->AddProperty( "opacity", mitk::FloatProperty::New( 1.0 ), renderer, overwrite);
   node->AddProperty( "color", mitk::ColorProperty::New(1.0,1.0,1.0), renderer, overwrite);
   node->AddProperty( "pickable", mitk::BoolProperty::New( true ), renderer, overwrite);
 
   node->AddProperty( "shape.linewidth", mitk::IntProperty::New( true ), renderer, overwrite );
   node->AddProperty( "shape.tuberadius",mitk::FloatProperty::New( 0.0 ), renderer, overwrite);
   node->AddProperty( "shape.tubesides",mitk::IntProperty::New( 15 ), renderer, overwrite);
   node->AddProperty( "shape.ribbonwidth", mitk::FloatProperty::New( 0.0 ), renderer, overwrite);
 
   node->AddProperty( "light.intensity", mitk::FloatProperty::New( 0.6 ), renderer, overwrite);
   node->AddProperty( "light.enable_light", mitk::BoolProperty::New( false ), renderer, overwrite);
   node->AddProperty( "light.ambient", mitk::FloatProperty::New( 0.05 ), renderer, overwrite);
   node->AddProperty( "light.diffuse", mitk::FloatProperty::New( 1.0 ), renderer, overwrite);
   node->AddProperty( "light.specular", mitk::FloatProperty::New( 0.0 ), renderer, overwrite);
   node->AddProperty( "light.specularpower", mitk::FloatProperty::New( 1.0 ), renderer, overwrite);
   node->AddProperty( "light.ambientcolor", mitk::ColorProperty::New(1,1,1), renderer, overwrite);
   node->AddProperty( "light.diffusecolor", mitk::ColorProperty::New(1,1,1), renderer, overwrite);
   node->AddProperty( "light.specularcolor", mitk::ColorProperty::New(1,1,1), renderer, overwrite);
 }
 
 vtkProp* mitk::FiberBundleMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
   return m_LocalStorageHandler.GetLocalStorage(renderer)->m_FiberAssembly;
 }
 
 mitk::FiberBundleMapper3D::FBXLocalStorage3D::FBXLocalStorage3D()
 {
   m_FiberActor = vtkSmartPointer<vtkActor>::New();
   m_FiberMapper = vtkSmartPointer<vtkOpenGLPolyDataMapper>::New();
   m_FiberAssembly = vtkSmartPointer<vtkPropAssembly>::New();
 }
 
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkPeakImageMapper2D.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkPeakImageMapper2D.cpp
index e9d5e1a7ad..3eaba5361c 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkPeakImageMapper2D.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkPeakImageMapper2D.cpp
@@ -1,240 +1,240 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkPeakImageMapper2D.h"
 #include "mitkBaseRenderer.h"
 #include "mitkDataNode.h"
 #include <vtkActor.h>
 #include <vtkOpenGLPolyDataMapper.h>
 #include <vtkOpenGLHelper.h>
 #include <vtkShaderProgram.h>
 #include <vtkPlane.h>
 #include <vtkPolyData.h>
 #include <vtkPointData.h>
 #include <vtkProperty.h>
 #include <vtkLookupTable.h>
 #include <vtkPoints.h>
 #include <vtkCamera.h>
 #include <vtkPolyLine.h>
 #include <vtkRenderer.h>
 #include <vtkCellArray.h>
 #include <vtkMatrix4x4.h>
 #include <vtkTubeFilter.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkSliceNavigationController.h>
 #include <mitkCoreServices.h>
 
 class vtkPeakShaderCallback : public vtkCommand
 {
 public:
   static vtkPeakShaderCallback *New()
   {
     return new vtkPeakShaderCallback;
   }
   mitk::BaseRenderer *renderer;
   mitk::DataNode *node;
 
   void Execute(vtkObject *, unsigned long, void*cbo) override
   {
     vtkShaderProgram *program = reinterpret_cast<vtkShaderProgram*>(cbo);
 
 
     mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
     mitk::Vector3D spacing = image->GetGeometry()->GetSpacing();
 
     float minSpacing = 1;
     if(spacing[0]<spacing[1] && spacing[0]<spacing[2])
       minSpacing = spacing[0];
     else if (spacing[1] < spacing[2])
       minSpacing = spacing[1];
     else
       minSpacing = spacing[2];
 
     float peakOpacity;
     node->GetOpacity(peakOpacity, nullptr);
 
     program->SetUniformf("peakOpacity", peakOpacity);
     program->SetUniformf("clippingPlaneThickness", minSpacing/2);
 
     if (this->renderer)
     {
       //get information about current position of views
       mitk::SliceNavigationController::Pointer sliceContr = renderer->GetSliceNavigationController();
       mitk::PlaneGeometry::ConstPointer planeGeo = sliceContr->GetCurrentPlaneGeometry();
 
       //generate according cutting planes based on the view position
       float planeNormal[3];
       planeNormal[0] = planeGeo->GetNormal()[0];
       planeNormal[1] = planeGeo->GetNormal()[1];
       planeNormal[2] = planeGeo->GetNormal()[2];
 
       float tmp1 = planeGeo->GetOrigin()[0] * planeNormal[0];
       float tmp2 = planeGeo->GetOrigin()[1] * planeNormal[1];
       float tmp3 = planeGeo->GetOrigin()[2] * planeNormal[2];
       float thickness = tmp1 + tmp2 + tmp3; //attention, correct normalvector
 
       float* a = new float[4];
       for (int i = 0; i < 3; ++i)
         a[i] = planeNormal[i];
 
       a[3] = thickness;
       program->SetUniform4f("slicingPlane", a);
     }
   }
 
   vtkPeakShaderCallback() { this->renderer = nullptr; }
 };
 
 
 
 mitk::PeakImageMapper2D::PeakImageMapper2D()
 {
-  m_lut = vtkLookupTable::New();
+  m_lut = vtkSmartPointer<vtkLookupTable>::New();
   m_lut->Build();
 }
 
 mitk::PeakImageMapper2D::~PeakImageMapper2D()
 {
 }
 
 
 mitk::PeakImage* mitk::PeakImageMapper2D::GetInput()
 {
   return dynamic_cast< mitk::PeakImage * > ( GetDataNode()->GetData() );
 }
 
 void mitk::PeakImageMapper2D::UpdateVtkTransform(mitk::BaseRenderer *)
 {
   // don't apply transform since the peak polydata is already in world coordinates.
   return;
 }
 
 void mitk::PeakImageMapper2D::Update(mitk::BaseRenderer * renderer)
 {
   mitk::DataNode* node = this->GetDataNode();
   if (node == nullptr)
     return;
 
   bool visible = true;
   node->GetVisibility(visible, renderer, "visible");
   if ( !visible )
     return;
 
   this->GenerateDataForRenderer( renderer );
 }
 
 void mitk::PeakImageMapper2D::UpdateShaderParameter(mitk::BaseRenderer *)
 {
   // see new vtkPeakShaderCallback
 }
 
 // vtkActors and Mappers are feeded here
 void mitk::PeakImageMapper2D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
 {
   mitk::PeakImage* peakImage = this->GetInput();
 
   //the handler of local storage gets feeded in this method with requested data for related renderwindow
   FBXLocalStorage *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
 
   vtkSmartPointer<vtkPolyData> polyData = peakImage->GetPolyData();
   if (polyData == nullptr)
     return;
 
   localStorage->m_Mapper->ScalarVisibilityOn();
   localStorage->m_Mapper->SetScalarModeToUsePointFieldData();
   localStorage->m_Mapper->SetLookupTable(m_lut);  //apply the properties after the slice was set
 //  localStorage->m_PointActor->GetProperty()->SetOpacity(0.999);
   localStorage->m_Mapper->SelectColorArray("FIBER_COLORS");
 
   localStorage->m_Mapper->SetInputData(polyData);
   localStorage->m_Mapper->SetVertexShaderCode(
         "//VTK::System::Dec\n"
         "attribute vec4 vertexMC;\n"
 
         "//VTK::Normal::Dec\n"
         "uniform mat4 MCDCMatrix;\n"
 
         "//VTK::Color::Dec\n"
 
         "varying vec4 positionWorld;\n"
         "varying vec4 colorVertex;\n"
 
         "void main(void)\n"
         "{\n"
         "  colorVertex = scalarColor;\n"
         "  positionWorld = vertexMC;\n"
         "  gl_Position = MCDCMatrix * vertexMC;\n"
         "}\n"
         );
   localStorage->m_Mapper->SetFragmentShaderCode(
         "//VTK::System::Dec\n"  // always start with this line
         "//VTK::Output::Dec\n"  // always have this line in your FS
         "uniform vec4 slicingPlane;\n"
         "uniform float clippingPlaneThickness;\n"
         "uniform float peakOpacity;\n"
         "varying vec4 positionWorld;\n"
         "varying vec4 colorVertex;\n"
         "out vec4 out_Color;\n"
 
         "void main(void)\n"
         "{\n"
         "  float r1 = dot(positionWorld.xyz, slicingPlane.xyz) - slicingPlane.w;\n"
 
         "  if (abs(r1) >= clippingPlaneThickness)\n"
         "    discard;\n"
         "  out_Color = vec4(colorVertex.xyz,peakOpacity);\n"
         "}\n"
         );
 
   vtkSmartPointer<vtkPeakShaderCallback> myCallback = vtkSmartPointer<vtkPeakShaderCallback>::New();
   myCallback->renderer = renderer;
   myCallback->node = this->GetDataNode();
   localStorage->m_Mapper->AddObserver(vtkCommand::UpdateShaderEvent,myCallback);
 
   localStorage->m_PointActor->SetMapper(localStorage->m_Mapper);
   localStorage->m_PointActor->GetProperty()->ShadingOn();
 
   float linewidth = 1.0;
   this->GetDataNode()->GetFloatProperty("shape.linewidth",linewidth);
   localStorage->m_PointActor->GetProperty()->SetLineWidth(linewidth);
 
   // We have been modified => save this for next Update()
   localStorage->m_LastUpdateTime.Modified();
 }
 
 
 vtkProp* mitk::PeakImageMapper2D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
   this->Update(renderer);
   return m_LocalStorageHandler.GetLocalStorage(renderer)->m_PointActor;
 }
 
 
 void mitk::PeakImageMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 
   //add other parameters to propertylist
   node->AddProperty( "color", mitk::ColorProperty::New(1.0,1.0,1.0), renderer, overwrite);
   node->AddProperty( "shape.linewidth", mitk::FloatProperty::New(1.0), renderer, overwrite);
 }
 
 
 mitk::PeakImageMapper2D::FBXLocalStorage::FBXLocalStorage()
 {
   m_PointActor = vtkSmartPointer<vtkActor>::New();
   m_Mapper = vtkSmartPointer<MITKPeakImageMapper2D_POLYDATAMAPPER>::New();
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberMapper3DTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberMapper3DTest.cpp
index 9bb495e950..12c5198d57 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberMapper3DTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberMapper3DTest.cpp
@@ -1,124 +1,87 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkNodePredicateDataType.h>
 #include <mitkRenderingTestHelper.h>
 #include <mitkSmartPointerProperty.h>
 #include <mitkTestingMacros.h>
 
 #include <vtkSmartPointer.h>
-#include <vtkTexturedSphereSource.h>
-
-
-/*===================================================================
-
-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 <vtkRenderLargeImage.h>
 
 #include "mitkTestingMacros.h"
 #include <mitkFiberBundle.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkTestingConfig.h>
 #include <mitkIOUtil.h>
-#include <omp.h>
 #include <mitkTestFixture.h>
-#include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <vtkTesting.h>
 
 class mitkFiberMapper3DTestSuite : public mitk::TestFixture
 {
 
   CPPUNIT_TEST_SUITE(mitkFiberMapper3DTestSuite);
   MITK_TEST(Test1);
   CPPUNIT_TEST_SUITE_END();
 
   typedef itk::Image<float, 3> ItkFloatImgType;
 
 private:
 
   /** Members used inside the different (sub-)tests. All members are initialized via setUp().*/
 
   mitk::FiberBundle::Pointer fib;
+  mitk::DataNode::Pointer node;
 
 public:
 
   void setUp() override
   {
     fib = mitk::IOUtil::Load<mitk::FiberBundle>(GetTestDataFilePath("DiffusionImaging/FiberFit/Cluster_0.fib"));
+
+    node = mitk::DataNode::New();
+    node->SetData(fib);
   }
 
   void tearDown() override
   {
 
   }
 
   void AddGeneratedDataToStorage(mitk::DataStorage *dataStorage)
   {
     auto node = mitk::DataNode::New();
     node->SetData(fib);
 
     dataStorage->Add(node);
   }
 
   void Test1()
   {
-    MITK_INFO << "1";
-    omp_set_num_threads(1);
-
-    MITK_INFO << "2";
-    auto node = mitk::DataNode::New();
-    node->SetData(fib);
-
-    MITK_INFO << "3";
     mitk::RenderingTestHelper renderingHelper(640, 480);
     renderingHelper.AddNodeToStorage(node);
-
-    MITK_INFO << "4";
-    renderingHelper.SetMapperID(mitk::BaseRenderer::Standard3D);
+    renderingHelper.SetMapperIDToRender3D();
     renderingHelper.GetVtkRenderer()->SetBackground(0.0, 0.0, 0.0);
-
-    MITK_INFO << "5";
     mitk::RenderingManager::GetInstance()->InitializeViews(fib->GetGeometry(), mitk::RenderingManager::RequestType::REQUEST_UPDATE_ALL);
 
-    MITK_INFO << "6";
-    renderingHelper.SaveReferenceScreenShot(mitk::IOUtil::GetTempPath()+"fib_renderingtest.png");
-    MITK_INFO << "7";
-
-    CPPUNIT_ASSERT_MESSAGE("No rendering crash", true);
-//    MITK_INFO << "1";
-//    char* argv[4];
-//    argv[0] = (char*)"";
-//    argv[1] = (char*)"";
-//    argv[1] = (char*)"-V";
-//    argv[3] = (char*)GetTestDataFilePath("fib_renderingtest.png").c_str();
-//    MITK_INFO << "2";
-//    CPPUNIT_ASSERT_MESSAGE("CompareRenderWindowAgainstReference test result positive?", renderingHelper.CompareRenderWindowAgainstReference(4, argv));
+    renderingHelper.SaveReferenceScreenShot(mitk::IOUtil::GetTempPath()+"fib_3D.png");
+    mitk::Image::Pointer test_image = mitk::IOUtil::Load<mitk::Image>(mitk::IOUtil::GetTempPath()+"fib_3D.png");
+    mitk::Image::Pointer ref_image = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("DiffusionImaging/fib_renderingtest.png"));
+    MITK_ASSERT_EQUAL(test_image, ref_image, "Check if images are equal.");
   }
-
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkFiberMapper3D)
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.reconstruction/src/QmitkODFRenderWidget.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.reconstruction/src/QmitkODFRenderWidget.cpp
index 8fe3c644ac..2fd0f35086 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.reconstruction/src/QmitkODFRenderWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.reconstruction/src/QmitkODFRenderWidget.cpp
@@ -1,123 +1,123 @@
 /*===================================================================
 
 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 "QmitkODFRenderWidget.h"
 #include <mitkLookupTable.h>
 #include <mitkLookupTableProperty.h>
 #include <vtkSmartPointer.h>
 #include <mitkPlaneGeometry.h>
 
 QmitkODFRenderWidget::QmitkODFRenderWidget(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f)
 {
   //create Layouts
   QmitkODFRenderWidgetLayout = new QHBoxLayout( this );
 
   //Set Layout to widget
   this->setLayout(QmitkODFRenderWidgetLayout);
 
   //Create RenderWindow
   m_RenderWindow = new QmitkRenderWindow(this, "odf render widget");
   m_RenderWindow->setMaximumSize(300,300);
   m_RenderWindow->GetRenderer()->SetMapperID( mitk::BaseRenderer::Standard3D );
 
   //m_RenderWindow->SetLayoutIndex( 3 );
   QmitkODFRenderWidgetLayout->addWidget( m_RenderWindow );
 }
 
 
 QmitkODFRenderWidget::~QmitkODFRenderWidget()
 {
 }
 
 void QmitkODFRenderWidget::GenerateODF( itk::OrientationDistributionFunction<double, ODF_SAMPLING_SIZE> odf )
 {
   try
   {
   m_Surface = mitk::Surface::New();
   m_ds = mitk::StandaloneDataStorage::New();
   m_Node = mitk::DataNode::New();
 
   vtkPolyData* m_TemplateOdf = itk::OrientationDistributionFunction<float,ODF_SAMPLING_SIZE>::GetBaseMesh();
 
   vtkPolyData *polyData = vtkPolyData::New();
   vtkPoints *points = vtkPoints::New();
   vtkFloatArray *scalars = vtkFloatArray::New();
 
   for (int i=0; i<ODF_SAMPLING_SIZE; i++){
     double p[3];
     m_TemplateOdf->GetPoints()->GetPoint(i,p);
     double val = odf[i];
 
     p[0] *= val;
     p[1] *= val;
     p[2] *= val;
     points->InsertPoint(i,p);
 
     scalars->InsertTuple1(i, 1-val);
   }
 
   polyData->SetPoints(points);
   vtkCellArray* polys = m_TemplateOdf->GetPolys();
   polyData->SetPolys(polys);
   polyData->GetPointData()->SetScalars(scalars);
 
   polys->Delete();
   scalars->Delete();
   points->Delete();
 
   m_Surface->SetVtkPolyData(polyData);
   m_Node->SetData(m_Surface);
 
   mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
 
   // assign an empty vtk lookup table to the odf renderer, it is the same
   // the ODF 2D Mapper has
-  vtkLookupTable *lut = vtkLookupTable::New();
+  vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
   mitkLut->SetVtkLookupTable( lut );
 
   mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
   mitkLutProp->SetLookupTable(mitkLut);
   m_Node->SetProperty( "LookupTable", mitkLutProp );
 
   m_Node->SetProperty("scalar visibility", mitk::BoolProperty::New(true));
   m_Node->SetProperty("color mode", mitk::BoolProperty::New(true));
   m_Node->SetProperty("material.specularCoefficient", mitk::FloatProperty::New(0.5));
 
   m_ds->Add(m_Node);
 
   m_RenderWindow->GetRenderer()->SetDataStorage( m_ds );
 
   // adjust camera to current plane rotation
   mitk::PlaneGeometry::ConstPointer worldPlaneGeometry = mitk::BaseRenderer::GetInstance(m_RenderWindow->GetVtkRenderWindow())->GetCurrentWorldPlaneGeometry();
   mitk::Vector3D normal = worldPlaneGeometry->GetNormal();
   mitk::Vector3D up = worldPlaneGeometry->GetAxisVector(1);
   normal.Normalize();
   up.Normalize();
 
   vtkSmartPointer<vtkCamera> cam = vtkSmartPointer<vtkCamera>::New();
   const double camPos[3] = {normal[0],normal[1],normal[2]};
   const double camUp[3] = {up[0],up[1],up[2]};
   cam->SetPosition(camPos);
   cam->SetViewUp(camUp);
   cam->SetParallelProjection(1);
   m_RenderWindow->GetRenderer()->GetVtkRenderer()->SetActiveCamera(cam);
   m_RenderWindow->update();
   }
   catch (...)
   {
 
   }
 }