diff --git a/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp b/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp
index 2a5e9c1684..86e856ef3c 100644
--- a/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp
@@ -1,435 +1,435 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-06-18 15:59:04 +0200 (Do, 18 Jun 2009) $
 Version:   $Revision: 16916 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkDiffusionImagingObjectFactory.h"
 
 #include "mitkProperties.h"
 #include "mitkBaseRenderer.h"
 #include "mitkDataNode.h"
 
 #include "mitkNrrdDiffusionImageIOFactory.h"
 #include "mitkNrrdDiffusionImageWriterFactory.h"
 #include "mitkNrrdDiffusionImageWriter.h"
 #include "mitkDiffusionImage.h"
 
 #include "mitkNrrdQBallImageIOFactory.h"
 #include "mitkNrrdQBallImageWriterFactory.h"
 #include "mitkNrrdQBallImageWriter.h"
 
 #include "mitkNrrdTensorImageIOFactory.h"
 #include "mitkNrrdTensorImageWriterFactory.h"
 #include "mitkNrrdTensorImageWriter.h"
 
 #include "mitkCompositeMapper.h"
 #include "mitkDiffusionImageMapper.h"
 #include "mitkGPUVolumeMapper3D.h"
 #include "mitkVolumeDataVtkMapper3D.h"
 #include "mitkTbssImageMapper.h"
 #include "mitkTbssGradientImageMapper.h"
 
 //====depricated fiberstructure=====
 #include "mitkFiberBundle.h"
 #include "mitkFiberBundleMapper2D.h"
 #include "mitkFiberBundleMapper3D.h"
 #include "mitkFiberBundleIOFactory.h"
 #include "mitkFiberBundleWriterFactory.h"
 #include "mitkFiberBundleWriter.h"
 //==================================
 
 //modernized fiberbundle datastrucutre
 #include "mitkFiberBundleX.h"
 #include "mitkFiberBundleXIOFactory.h"
 #include "mitkFiberBundleXWriterFactory.h"
 #include "mitkFiberBundleXWriter.h"
 #include "mitkFiberBundleXMapper3D.h"
 #include "mitkFiberBundleXMapper2D.h"
 
 #include "mitkFiberBundleXThreadMonitorMapper3D.h"
 #include "mitkFiberBundleXThreadMonitor.h"
 
 #include "mitkNrrdTbssImageIOFactory.h"
 #include "mitkNrrdTbssImageWriterFactory.h"
 #include "mitkNrrdTbssImageWriter.h"
 
 #include "mitkNrrdTbssRoiImageIOFactory.h"
 #include "mitkNrrdTbssRoiImageWriterFactory.h"
 #include "mitkNrrdTbssRoiImageWriter.h"
 
 
 #include "mitkNrrdTbssGradientImageWriterFactory.h"
 #include "mitkNrrdTbssGradientImageWriter.h"
 
 #include "mitkPlanarCircleMapper3D.h"
 #include "mitkPlanarPolygonMapper3D.h"
 
 
 
 typedef short DiffusionPixelType;
 typedef char TbssRoiPixelType;
 typedef float TbssPixelType;
 typedef int TbssGradientPixelType;
 
 
 typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageShort;
 typedef std::multimap<std::string, std::string> MultimapType;
 
 mitk::DiffusionImagingObjectFactory::DiffusionImagingObjectFactory(bool /*registerSelf*/)
 :CoreObjectFactoryBase()
 {
 
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "DiffusionImagingObjectFactory c'tor" << std::endl;
     RegisterIOFactories();
 
 
     mitk::NrrdDiffusionImageIOFactory::RegisterOneFactory();
     mitk::NrrdQBallImageIOFactory::RegisterOneFactory();
     mitk::NrrdTensorImageIOFactory::RegisterOneFactory();
     mitk::FiberBundleIOFactory::RegisterOneFactory();
     mitk::NrrdTbssImageIOFactory::RegisterOneFactory();
     mitk::NrrdTbssRoiImageIOFactory::RegisterOneFactory();
     mitk::FiberBundleXIOFactory::RegisterOneFactory(); //modernized
 
 
     mitk::NrrdDiffusionImageWriterFactory::RegisterOneFactory();
     mitk::NrrdQBallImageWriterFactory::RegisterOneFactory();
     mitk::NrrdTensorImageWriterFactory::RegisterOneFactory();
     mitk::FiberBundleWriterFactory::RegisterOneFactory();
     mitk::NrrdTbssImageWriterFactory::RegisterOneFactory();
     mitk::NrrdTbssRoiImageWriterFactory::RegisterOneFactory();
     mitk::FiberBundleXWriterFactory::RegisterOneFactory();//modernized
     mitk::NrrdTbssGradientImageWriterFactory::RegisterOneFactory();
 
     m_FileWriters.push_back( NrrdDiffusionImageWriter<DiffusionPixelType>::New().GetPointer() );
     m_FileWriters.push_back( NrrdQBallImageWriter::New().GetPointer() );
     m_FileWriters.push_back( NrrdTensorImageWriter::New().GetPointer() );
     m_FileWriters.push_back( mitk::FiberBundleWriter::New().GetPointer() );
     m_FileWriters.push_back( NrrdTbssImageWriter::New().GetPointer() );
     m_FileWriters.push_back( NrrdTbssRoiImageWriter::New().GetPointer() );
     m_FileWriters.push_back( mitk::FiberBundleXWriter::New().GetPointer() );//modernized
     m_FileWriters.push_back( mitk::NrrdTbssGradientImageWriter::New().GetPointer() );
 
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(this);
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 
 }
 
 mitk::Mapper::Pointer mitk::DiffusionImagingObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper=NULL;
 
   if ( id == mitk::BaseRenderer::Standard2D )
   {
     std::string classname("QBallImage");
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::CompositeMapper::New();
       newMapper->SetDataNode(node);
       node->SetMapper(3, ((CompositeMapper*)newMapper.GetPointer())->GetImageMapper());
     }
     classname = "TensorImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::CompositeMapper::New();
       newMapper->SetDataNode(node);
       node->SetMapper(3, ((CompositeMapper*)newMapper.GetPointer())->GetImageMapper());
     }
 
     classname = "DiffusionImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::DiffusionImageMapper<short>::New();
       newMapper->SetDataNode(node);
     }
 
     classname = "TbssRoiImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::ImageVtkMapper2D::New();
       newMapper->SetDataNode(node);
     }
     
     classname = "FiberBundle";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::FiberBundleMapper2D::New();
       newMapper->SetDataNode(node);
     }
     
     classname = "FiberBundleX";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::FiberBundleXMapper2D::New();
       newMapper->SetDataNode(node);
     }
 
     classname = "TbssImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::TbssImageMapper::New();
       newMapper->SetDataNode(node);
     }
 
     classname = "TbssGradientImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::TbssGradientImageMapper::New();
       newMapper->SetDataNode(node);
     }
 
   }
   else if ( id == mitk::BaseRenderer::Standard3D )
   {
     std::string classname("QBallImage");
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::GPUVolumeMapper3D::New();
       newMapper->SetDataNode(node);
     }
     classname = "TensorImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::GPUVolumeMapper3D::New();
       newMapper->SetDataNode(node);
     }
     classname = "DiffusionImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::GPUVolumeMapper3D::New();
       newMapper->SetDataNode(node);
     }
     classname = "FiberBundle";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::FiberBundleMapper3D::New();
       newMapper->SetDataNode(node);
     }
 
     classname = "FiberBundleX";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::FiberBundleXMapper3D::New();
       newMapper->SetDataNode(node);
     }
     
     classname = "FiberBundleXThreadMonitor";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::FiberBundleXThreadMonitorMapper3D::New();
       newMapper->SetDataNode(node); 
     }
 
     classname = "TbssRoiImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::VolumeDataVtkMapper3D::New();
       newMapper->SetDataNode(node);
     }
 
     classname = "TbssImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {  
       newMapper = mitk::TbssImageMapper::New();
       newMapper->SetDataNode(node);
     }
     
     classname =  "PlanarCircle";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::PlanarCircleMapper3D::New();
       newMapper->SetDataNode(node);
     }
     
     classname = "PlanarPolygon";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::PlanarPolygonMapper3D::New();
       newMapper->SetDataNode(node);
     }
     
 
     classname = "TbssGradientImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::TbssGradientImageMapper::New();
       newMapper->SetDataNode(node);
     }
 
   }
 
   return newMapper;
 }
 
 void mitk::DiffusionImagingObjectFactory::SetDefaultProperties(mitk::DataNode* node)
 {
   std::string classname = "QBallImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::CompositeMapper::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
 
   classname = "TensorImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::CompositeMapper::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
 
   classname = "DiffusionImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::DiffusionImageMapper<short>::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
 
   classname = "FiberBundle";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::FiberBundleMapper3D::SetDefaultProperties(node);
     mitk::FiberBundleMapper2D::SetDefaultProperties(node);
   }
 
   classname = "FiberBundleX";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::FiberBundleXMapper3D::SetDefaultProperties(node);
-//    mitk::FiberBundleXMapper2D::SetDefaultProperties(node);
+    mitk::FiberBundleXMapper2D::SetDefaultProperties(node);
   }
 
   classname = "FiberBundleXThreadMonitor";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::FiberBundleXThreadMonitorMapper3D::SetDefaultProperties(node);
   }
   
   classname = "TbssRoiImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::ImageVtkMapper2D::SetDefaultProperties(node);
     mitk::VolumeDataVtkMapper3D::SetDefaultProperties(node);
   }
 
   classname = "TbssImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::TbssImageMapper::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
 
   classname = "TbssGradientImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::TbssGradientImageMapper::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
   
   classname = "PlanarCircle";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::PlanarCircleMapper3D::SetDefaultProperties(node);
   }
   
   classname = "PlanarPolygon";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::PlanarPolygonMapper3D::SetDefaultProperties(node);
   }
 
 
 }
 
 const char* mitk::DiffusionImagingObjectFactory::GetFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_FileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 };
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::DiffusionImagingObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 const char* mitk::DiffusionImagingObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 };
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::DiffusionImagingObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 void mitk::DiffusionImagingObjectFactory::CreateFileExtensionsMap()
 {
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dwi", "Diffusion Weighted Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdwi", "Diffusion Weighted Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii", "Diffusion Weighted Images for FSL"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.fsl", "Diffusion Weighted Images for FSL"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.fslgz", "Diffusion Weighted Images for FSL"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.qbi", "Q-Ball Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hqbi", "Q-Ball Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dti", "Tensor Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdti", "Tensor Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.fib", "Fiber Bundle"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.vfib", "Fiber Bundle Polydata"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "Fiber Bundle Polydata"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.tbss", "TBSS data"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pf", "Planar Figure File"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.roi", "TBSS ROI data"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.tgi", "TBSS gradient image"));
 
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.dwi", "Diffusion Weighted Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdwi", "Diffusion Weighted Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii", "Diffusion Weighted Images for FSL"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.fsl", "Diffusion Weighted Images for FSL"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.fslgz", "Diffusion Weighted Images for FSL"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.qbi", "Q-Ball Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hqbi", "Q-Ball Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.dti", "Tensor Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdti", "Tensor Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.fib", "Fiber Bundle"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.vfib", "Fiber Bundle Polydata"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "Fiber Bundle Polydata"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.tbss", "TBSS data"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.pf", "Planar Figure File"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.roi", "TBSS ROI data"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.tgi", "TBSS gradient image"));
 }
 
 void mitk::DiffusionImagingObjectFactory::RegisterIOFactories()
 {
 }
 
 void RegisterDiffusionImagingObjectFactory()
 {
   static bool oneDiffusionImagingObjectFactoryRegistered = false;
   if ( ! oneDiffusionImagingObjectFactoryRegistered ) {
     MITK_DEBUG << "Registering DiffusionImagingObjectFactory..." << std::endl;
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(mitk::DiffusionImagingObjectFactory::New());
 
     oneDiffusionImagingObjectFactoryRegistered = true;
   }
 }
diff --git a/Modules/DiffusionImaging/Rendering/mitkFiberBundleXMapper2D.cpp b/Modules/DiffusionImaging/Rendering/mitkFiberBundleXMapper2D.cpp
index 55df715ef7..4cd1c22508 100644
--- a/Modules/DiffusionImaging/Rendering/mitkFiberBundleXMapper2D.cpp
+++ b/Modules/DiffusionImaging/Rendering/mitkFiberBundleXMapper2D.cpp
@@ -1,314 +1,312 @@
 /*
  *  mitkFiberBundleMapper2D.cpp
  *  mitk-all
  *
  *  Created by HAL9000 on 1/17/11.
  *  Copyright 2011 __MyCompanyName__. All rights reserved.
  *
  */
 
 #include "mitkFiberBundleXMapper2D.h"
 #include <mitkBaseRenderer.h>
 
 
 #include <vtkActor.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkPlane.h>
 #include <vtkPolyData.h>
 //#include <vtkPropAssembly.h>
 
 //#include <vtkPainterPolyDataMapper.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 <mitkGeometry3D.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkSliceNavigationController.h>
 
 #include <mitkShaderRepository.h>
 #include <mitkShaderProperty.h>
 #include <mitkStandardFileLocations.h>
 
 #include <QCoreApplication>
 #include <QFile>
 
 mitk::FiberBundleXMapper2D::FiberBundleXMapper2D()
 {
 
 
 }
 
 mitk::FiberBundleXMapper2D::~FiberBundleXMapper2D()
 {
 }
 
 
-const mitk::FiberBundleX* mitk::FiberBundleXMapper2D::GetInput()
+mitk::FiberBundleX* mitk::FiberBundleXMapper2D::GetInput()
 {
-    return dynamic_cast<const mitk::FiberBundleX * > ( GetData() );
+    return dynamic_cast< mitk::FiberBundleX * > ( GetData() );
 }
 
 
 
 void mitk::FiberBundleXMapper2D::Update(mitk::BaseRenderer * renderer)
 {
 
     if ( !this->IsVisible( renderer ) )
     {
         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_LSH.GetLocalStorage(renderer);
     const DataNode *node = this->GetDataNode();
     if ( (localStorage->m_LastUpdateTime < node->GetMTime())
          || (localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) //was a property modified?
          || (localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime()) )
     {
         //    MITK_INFO << "UPDATE NEEDED FOR _ " << renderer->GetName();
         this->GenerateDataForRenderer( renderer );
     }
 
     if ((localStorage->m_LastUpdateTime < renderer->GetDisplayGeometry()->GetMTime()) ) //was the display geometry modified? e.g. zooming, panning)
     {
 
         this->UpdateShaderParameter(renderer);
 
     }
 
 }
 
 void mitk::FiberBundleXMapper2D::UpdateShaderParameter(mitk::BaseRenderer * renderer)
 {
     FBXLocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
     // MITK_INFO << "uSERWAAAAAAAS, da shader brauchat a poor neue zoin";
     //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 sliceN[3], planeOrigin[3];
 
 
     // since shader uses camera coordinates, transform origin and normal from worldcoordinates to cameracoordinates
 
 
     planeOrigin[0] = (float) planeGeo->GetOrigin()[0];
     planeOrigin[1] = (float) planeGeo->GetOrigin()[1];
     planeOrigin[2] = (float) planeGeo->GetOrigin()[2];
 
     sliceN[0] = planeGeo->GetNormal()[0];
     sliceN[1] = planeGeo->GetNormal()[1];
     sliceN[2] = planeGeo->GetNormal()[2];
 
 
     float tmp1 = planeOrigin[0] * sliceN[0];
     float tmp2 = planeOrigin[1] * sliceN[1];
     float tmp3 = planeOrigin[2] * sliceN[2];
     float d1 = tmp1 + tmp2 + tmp3; //attention, correct normalvector
 
 
     float plane1[4];
     plane1[0] = sliceN[0];
     plane1[1] = sliceN[1];
     plane1[2] = sliceN[2];
     plane1[3] = d1;
 
     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";
 
 
     int fiberfading_i = 1;
     if (!fiberfading)
         fiberfading_i = 0;
 
 
     localStorage->m_PointActor->GetProperty()->AddShaderVariable("slicingPlane",4, plane1);
     localStorage->m_PointActor->GetProperty()->AddShaderVariable("fiberThickness",1, &thickness);
     localStorage->m_PointActor->GetProperty()->AddShaderVariable("fiberFadingON",1,  &fiberfading_i);
 
 
 }
 
 // ALL RAW DATA FOR VISUALIZATION IS GENERATED HERE.
 // vtkActors and Mappers are feeded here
 void mitk::FiberBundleXMapper2D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
 {
 
     //the handler of local storage gets feeded in this method with requested data for related renderwindow
     FBXLocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
     //this procedure is depricated,
     //not needed after initializaton anymore
     mitk::DataNode* node = this->GetDataNode();
     if ( node == NULL )
     {
         MITK_INFO << "check DATANODE: ....[Fail] ";
         return;
     }
     ///////////////////////////////////
 
 
 
 
 
 ///THIS GET INPUT
-    const mitk::FiberBundleX* fbx = this->GetInput();
-//extract polydata
-    //todo
+    mitk::FiberBundleX* fbx = this->GetInput();
     
     vtkSmartPointer<vtkLookupTable> lut = vtkLookupTable::New();
     lut->Build();
     localStorage->m_PointMapper->SetScalarModeToUsePointFieldData();
     //m_VtkFiberDataMapperGL->SelectColorArray("FaColors");
     localStorage->m_PointMapper->SelectColorArray("ColorValues");
     localStorage->m_PointMapper->SetLookupTable(lut);  //apply the properties after the slice was set
 
 
     //  feed the vtk fiber mapper with point data ...TODO do in constructor
-    localStorage->m_PointMapper->SetInput(localStorage->m_SlicedResult);   // in optimized version, mapper is feeded by localStorage->m_cutter->GetOutput();
+    localStorage->m_PointMapper->SetInput(fbx->GetFiberPolyData());
     localStorage->m_PointActor->SetMapper(localStorage->m_PointMapper);
     localStorage->m_PointActor->GetProperty()->ShadingOn();
 
     // Applying shading properties
     {
         //Superclass::ApplyProperties( ls->m_Actor, renderer ) ;
         // VTK Properties
         //ApplyMitkPropertiesToVtkProperty( this->GetDataNode(), ls->m_Actor->GetProperty(), renderer );
         // Shaders
         mitk::ShaderRepository::GetGlobalShaderRepository()->ApplyProperties(this->GetDataNode(),localStorage->m_PointActor,renderer, localStorage->m_LastUpdateTime);
     }
 
 
 
     this->UpdateShaderParameter(renderer);
 
 
     // We have been modified => save this for next Update()
     localStorage->m_LastUpdateTime.Modified();
 
 
 }
 
 
 vtkProp* mitk::FiberBundleXMapper2D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
 
     //MITK_INFO << "FiberBundleMapper2D GetVtkProp(renderer)";
     this->Update(renderer);
     return m_LSH.GetLocalStorage(renderer)->m_PointActor;
 
 }
 
 
 void mitk::FiberBundleXMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {    //add shader to datano
 
 
     //####### load shader from file #########
     QString applicationDir = QCoreApplication::applicationDirPath();
 
     if (applicationDir.endsWith("bin"))
         applicationDir.append("/");
     else if (applicationDir.endsWith("MacOS"))
     {
         //on osx, check if path for installer or MITK development is needed
         applicationDir.append("/");
         QFile f( applicationDir+"FiberTrackingLUTBaryCoords.bin" );
         if( !f.exists() ) // if file does not exist, then look in MITK development build directory
             applicationDir.append("../../../");
     }else
         applicationDir.append("\\..\\");
 
     mitk::StandardFileLocations::GetInstance()->AddDirectoryForSearch( applicationDir.toStdString().c_str(), false );
     mitk::ShaderRepository::Pointer shaderRepository = mitk::ShaderRepository::GetGlobalShaderRepository();
     shaderRepository->LoadShader(mitk::StandardFileLocations::GetInstance()->FindFile("mitkShaderFiberClipping.xml"));
 
 
 
     //####################################################################
     node->SetProperty("shader",mitk::ShaderProperty::New("mitkShaderFiberClipping"));
     mitk::ShaderRepository::GetGlobalShaderRepository()->AddDefaultProperties(node,renderer,overwrite);
 
 
     //add other parameters to propertylist
     node->AddProperty( "Fiber2DSliceThickness", mitk::FloatProperty::New(2.0f), renderer, overwrite );
     node->AddProperty( "Fiber2DfadeEFX", mitk::BoolProperty::New(true), renderer, overwrite );
 
 
     Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 
 
 
 
 // following methods are essential, they actually call the GetVtkProp() method
 // which returns the desired actors
 void mitk::FiberBundleXMapper2D::MitkRenderOverlay(BaseRenderer* renderer)
 {
     //   MITK_INFO << "FiberBundleMapper2D MitkRenderOVerlay(renderer)";
     if ( this->IsVisible(renderer)==false )
         return;
 
     if ( this->GetVtkProp(renderer)->GetVisibility() )
     {
         this->GetVtkProp(renderer)->RenderOverlay(renderer->GetVtkRenderer());
     }
 }
 
 void mitk::FiberBundleXMapper2D::MitkRenderOpaqueGeometry(BaseRenderer* renderer)
 {
     //  MITK_INFO << "FiberBundleMapper2D MitkRenderOpaqueGeometry(renderer)";
     if ( this->IsVisible( renderer )==false )
         return;
 
     if ( this->GetVtkProp(renderer)->GetVisibility() )
         this->GetVtkProp(renderer)->RenderOpaqueGeometry( renderer->GetVtkRenderer() );
 }
 void mitk::FiberBundleXMapper2D::MitkRenderTranslucentGeometry(BaseRenderer* renderer)
 {
     //  MITK_INFO << "FiberBundleMapper2D MitkRenderTranslucentGeometry(renderer)";
     if ( this->IsVisible(renderer)==false )
         return;
 
     //TODO is it possible to have a visible BaseRenderer AND an invisible VtkRenderer???
     if ( this->GetVtkProp(renderer)->GetVisibility() )
         this->GetVtkProp(renderer)->RenderTranslucentPolygonalGeometry(renderer->GetVtkRenderer());
 
 }
 void mitk::FiberBundleXMapper2D::MitkRenderVolumetricGeometry(BaseRenderer* renderer)
 {
     //  MITK_INFO << "FiberBundleMapper2D MitkRenderVolumentricGeometry(renderer)";
     if(IsVisible(renderer)==false)
         return;
 
     //TODO is it possible to have a visible BaseRenderer AND an invisible VtkRenderer???
     if ( GetVtkProp(renderer)->GetVisibility() )
         this->GetVtkProp(renderer)->RenderVolumetricGeometry(renderer->GetVtkRenderer());
 
 }
 
 mitk::FiberBundleXMapper2D::FBXLocalStorage::FBXLocalStorage()
 {
     m_PointActor = vtkSmartPointer<vtkActor>::New();
     m_PointMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
 
 }
diff --git a/Modules/DiffusionImaging/Rendering/mitkFiberBundleXMapper2D.h b/Modules/DiffusionImaging/Rendering/mitkFiberBundleXMapper2D.h
index 1957719b66..e520ddc131 100644
--- a/Modules/DiffusionImaging/Rendering/mitkFiberBundleXMapper2D.h
+++ b/Modules/DiffusionImaging/Rendering/mitkFiberBundleXMapper2D.h
@@ -1,110 +1,110 @@
 /*=========================================================================
  
  Program:   Medical Imaging & Interaction Toolkit
  Language:  C++
  Date:      $Date: 2010-09-26 20:40:22 +0200 (So, 26 Sep 2010) $
  Version:   $Revision$
  
  Copyright (c) German Cancer Research Center, Division of Medical and
  Biological Informatics. All rights reserved.
  See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
  
  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.  See the above copyright notices for more information.
  
  =========================================================================*/
 
 #ifndef FIBERBUNDLEXMAPPER2D_H_HEADER_INCLUDED
 #define FIBERBUNDLEXMAPPER2D_H_HEADER_INCLUDED
 
 //MITK Rendering
 #include <mitkCommon.h>
 #include <mitkBaseRenderer.h>
 //#include "MitkDiffusionImagingExports.h"
 
 #include <mitkVtkMapper2D.h>
 #include <mitkFiberBundleX.h>
 #include <vtkSmartPointer.h>
 
 
 class vtkActor;
 //class vtkPropAssembly; //lets see if we need it
 class mitkBaseRenderer;
 class vtkPolyDataMapper;
 class vtkCutter;
 class vtkPlane;
 class vtkPolyData;
 
 
 
 namespace mitk {
   
   
   class FiberBundleXMapper2D : public VtkMapper2D
   {
     
   public:
     mitkClassMacro(FiberBundleXMapper2D, VtkMapper2D);
     itkNewMacro(Self);
-    const mitk::FiberBundleX* GetInput();
+    mitk::FiberBundleX* GetInput();
     
     
     /** \brief Checks whether this mapper needs to update itself and generate
      * data. */
     virtual void Update(mitk::BaseRenderer * renderer);
     
     
    static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false );
 
     
     //### methods of MITK-VTK rendering pipeline
     virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer);
     virtual void MitkRenderOverlay(BaseRenderer* renderer);
     virtual void MitkRenderOpaqueGeometry(BaseRenderer* renderer);
     virtual void MitkRenderTranslucentGeometry(BaseRenderer* renderer);
     virtual void MitkRenderVolumetricGeometry(BaseRenderer* renderer);
     //### end of methods of MITK-VTK rendering pipeline
     
    
     class  FBXLocalStorage : public mitk::Mapper::BaseLocalStorage
     {
     public:
       /** \brief Point Actor of a 2D render window. */
       vtkSmartPointer<vtkActor> m_PointActor;
       /** \brief Point Mapper of a 2D render window. */
       vtkSmartPointer<vtkPolyDataMapper> m_PointMapper;
       vtkSmartPointer<vtkPlane> m_SlicingPlane;  //needed later when optimized 2D mapper
       vtkSmartPointer<vtkPolyData> m_SlicedResult; //might be depricated in optimized 2D mapper
       
       /** \brief Timestamp of last update of stored data. */
       itk::TimeStamp m_LastUpdateTime;
       /** \brief Constructor of the local storage. Do as much actions as possible in here to avoid double executions. */
       FBXLocalStorage(); //if u copy&paste from this 2Dmapper, be aware that the implementation of this constructor is in the cpp file
       
       ~FBXLocalStorage()
       {
       }
     };
     
     /** \brief This member holds all three LocalStorages for the three 2D render windows. */
     mitk::Mapper::LocalStorageHandler<FBXLocalStorage> m_LSH;
 
     
     
   protected:
     FiberBundleXMapper2D();
     virtual ~FiberBundleXMapper2D();
     
     /** Does the actual resampling, without rendering. */
     virtual void GenerateDataForRenderer(mitk::BaseRenderer*);
     
     void UpdateShaderParameter(mitk::BaseRenderer*);
    
 
   };
 
 
 }//end namespace
 
-#endif
\ No newline at end of file
+#endif