diff --git a/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp b/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp
index 53a0afa814..edfd9c4234 100644
--- a/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp
@@ -1,338 +1,338 @@
 /*=========================================================================
 
 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"
 
 //====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 "mitkFiberBundleXThreadMonitorMapper3D.h"
 #include "mitkFiberBundleXThreadMonitor.h"
 
 #include "mitkNrrdTbssImageIOFactory.h"
 #include "mitkNrrdTbssImageWriterFactory.h"
 #include "mitkNrrdTbssImageWriter.h"
 
 
 typedef short DiffusionPixelType;
 typedef char TbssRoiPixelType;
 
 
 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_INFO << "DiffusionImagingObjectFactory c'tor" << std::endl;
     RegisterIOFactories();
 
 
     mitk::NrrdDiffusionImageIOFactory::RegisterOneFactory();
     mitk::NrrdQBallImageIOFactory::RegisterOneFactory();
     mitk::NrrdTensorImageIOFactory::RegisterOneFactory();
     mitk::FiberBundleIOFactory::RegisterOneFactory();
     mitk::NrrdTbssImageIOFactory::RegisterOneFactory();
     mitk::FiberBundleXIOFactory::RegisterOneFactory(); //modernized
 
 
     mitk::NrrdDiffusionImageWriterFactory::RegisterOneFactory();
     mitk::NrrdQBallImageWriterFactory::RegisterOneFactory();
     mitk::NrrdTensorImageWriterFactory::RegisterOneFactory();
     mitk::FiberBundleWriterFactory::RegisterOneFactory();
     mitk::NrrdTbssImageWriterFactory::RegisterOneFactory();
     mitk::FiberBundleXWriterFactory::RegisterOneFactory();//modernized
 
     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<TbssRoiPixelType>::New().GetPointer() );
     m_FileWriters.push_back( mitk::FiberBundleXWriter::New().GetPointer() );//modernized
 
     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 = "TbssImage";
     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::FiberBundleMapper2D::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 = "TbssImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::VolumeDataVtkMapper3D::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);
+    mitk::FiberBundleMapper2D::SetDefaultProperties(node);
   }
 
   classname = "FiberBundleX";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::FiberBundleXMapper3D::SetDefaultProperties(node);
 //    mitk::FiberBundleXMapper2D::SetDefaultProperties(node);
   }
 
   classname = "FiberBundleXThreadMonitor";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::FiberBundleXThreadMonitorMapper3D::SetDefaultProperties(node);
   }
   
   classname = "TbssImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::ImageVtkMapper2D::SetDefaultProperties(node);
     mitk::VolumeDataVtkMapper3D::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_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"));
 }
 
 void mitk::DiffusionImagingObjectFactory::RegisterIOFactories()
 {
 }
 
 void RegisterDiffusionImagingObjectFactory()
 {
   static bool oneDiffusionImagingObjectFactoryRegistered = false;
   if ( ! oneDiffusionImagingObjectFactoryRegistered ) {
     MITK_INFO << "Registering DiffusionImagingObjectFactory..." << std::endl;
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(mitk::DiffusionImagingObjectFactory::New());
 
     oneDiffusionImagingObjectFactoryRegistered = true;
   }
 }
diff --git a/Modules/DiffusionImaging/Rendering/mitkFiberBundleMapper2D.cpp b/Modules/DiffusionImaging/Rendering/mitkFiberBundleMapper2D.cpp
index 21242a3fb7..8f1db55c0c 100644
--- a/Modules/DiffusionImaging/Rendering/mitkFiberBundleMapper2D.cpp
+++ b/Modules/DiffusionImaging/Rendering/mitkFiberBundleMapper2D.cpp
@@ -1,475 +1,507 @@
 /*
  *  mitkFiberBundleMapper2D.cpp
  *  mitk-all
  *
  *  Created by HAL9000 on 1/17/11.
  *  Copyright 2011 __MyCompanyName__. All rights reserved.
  *
  */
 
 #include "mitkFiberBundleMapper2D.h"
 #include <mitkBaseRenderer.h>
 #include "mitkFiberBundleMapper3D.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 <mitkPlaneGeometry.h>
 #include <mitkSliceNavigationController.h>
 
+#include <mitkShaderRepository.h>
+#include <mitkShaderProperty.h>
+#include <mitkStandardFileLocations.h>
+
+
+
 mitk::FiberBundleMapper2D::FiberBundleMapper2D()
 {
+
+
 }
 
 mitk::FiberBundleMapper2D::~FiberBundleMapper2D()
 {
 }
 
 
 const mitk::FiberBundle* mitk::FiberBundleMapper2D::GetInput()
 {
   return dynamic_cast<const mitk::FiberBundle * > ( GetData() );
 }
 
 
 
 void mitk::FiberBundleMapper2D::Update(mitk::BaseRenderer * renderer)
 {
 
 
 
   if ( !this->IsVisible( renderer ) )
   {
     return;
   }
 
 //  const mitk::FiberBundle::Pointer data  = const_cast< mitk::FiberBundle* > ( this->GetInput() );
 //  if ( data == NULL )
 //  {
 //    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
   FBLocalStorage *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)
   {
     MITK_INFO << "update clipping range only:";
     //get information about current position of views
     mitk::SliceNavigationController::Pointer sliceContr = renderer->GetSliceNavigationController();
     mitk::PlaneGeometry::ConstPointer planeGeo = sliceContr->GetCurrentPlaneGeometry();
 
     //
      vtkCamera* camera = renderer->GetVtkRenderer()->GetActiveCamera();
     double *focPnt = camera->GetFocalPoint();
     double *camPos = camera->GetPosition();
     double dist1 = sqrt( pow( (focPnt[0]-camPos[0]), 2.0) +  pow( (focPnt[1]-camPos[1]), 2.0) + pow( (focPnt[2]-camPos[2]), 2.0));
     MITK_INFO << "DIST for CLIPPING RANGE: " << dist1;
     camera->SetClippingRange( (dist1-1.0),(dist1+1.0) );
     double cl1 =  camera->GetClippingRange()[0];
     double cl2 = camera->GetClippingRange()[1];
     MITK_INFO << "Camera clipping range: " << cl1 << " " << cl2;
 
 
 
   }
 
 
 
 
 
 
 
 
 }
 
 
 // ALL RAW DATA FOR VISUALIZATION IS GENERATED HERE.
 // vtkActors and Mappers are feeded here
 void mitk::FiberBundleMapper2D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
 {
   MITK_INFO << "FiberBundlemapper2D _ GENERATE DATA";
 
   //the handler of local storage gets feeded in this method with requested data for related renderwindow
   FBLocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
 //  if ( !this->IsVisible( renderer ) )
 //  {
 //    return;
 //  }
 //
   //this procedure is depricated,
   //not needed after initializaton anymore
-  mitk::DataNode::ConstPointer node = this->GetDataNode();
-  if ( node.IsNull() )
+  mitk::DataNode* node = this->GetDataNode();
+  if ( node == NULL )
   {
     MITK_INFO << "check DATANODE: ....[Fail] ";
     return;
   }
   ///////////////////////////////////
 
+
+  
+  
+  
+
   mitk::FiberBundleMapper3D::Pointer FBMapper3D = dynamic_cast< mitk::FiberBundleMapper3D* > (node->GetMapper( 2 ));
   if ( FBMapper3D->GetInput() == NULL )
   {
     MITK_INFO << "check FBMapper3D Input: ....[Fail] ";
     return;
   }
 
 
   //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
 //  double planeN[3], planeOrigin[3], cutParams[3];
 ////
 //  planeN[0] = planeGeo->GetNormal()[0];
 //  planeN[1] = planeGeo->GetNormal()[1];
 //  planeN[2] = planeGeo->GetNormal()[2];
 //
 //  planeOrigin[0] = planeGeo->GetOrigin()[0];
 //  planeOrigin[1] = planeGeo->GetOrigin()[1];
 //  planeOrigin[2] = planeGeo->GetOrigin()[2];
 ////
 //  MITK_INFO << "renWinNAME: " << renderer->GetName();
 //  MITK_INFO << "PlaneNormal: " << planeN[0] << " | " << planeN[1] << " | " << planeN[2];
 //  MITK_INFO << "PlaneOrigin: " << planeOrigin[0] << " | " << planeOrigin[1] << " | " << planeOrigin[2];
 //
 //
 //  //cutParams[0] = this->GetDataNode()->GetPropertyValue("ColorCoding", nodeCC);;
 
   //feed cutter with parameters gathered from GUI
 //  int numSlices;
 //  bool existsPropNS = this->GetDataNode()->GetPropertyValue("2DPlanes", numSlices);
 //  if ( !existsPropNS ){
 //    return;
 //  }
 //
 //  int distFront;
 //  bool existsPropDF = this->GetDataNode()->GetPropertyValue("2DFront", distFront);
 //  if ( !existsPropDF ){
 //    return;
 //  }
 //
 //  int distBackDB;
 //  bool existsProp = this->GetDataNode()->GetPropertyValue("2DBack", distBackDB);
 //  if ( !existsProp ){
 //    return;
 //  }
 //
 //
 //  cutParams[0] = numSlices;
 //  cutParams[1] = distFront;
 //  cutParams[2] = distBackDB;
 
 
 
 
   //feed local storage with data we want to visualize
 //  localStorage->m_SlicedResult = FBMapper3D->GetCut(planeOrigin, planeN, cutParams);
  // localStorage->m_SlicedResult = FBMapper3D->GetVtkFBPolyDataMapper();
   localStorage->m_SlicedResult = (vtkPolyData*) FBMapper3D->getVtkFiberBundleMapper()->GetInputAsDataSet();
-  MITK_INFO << renderer->GetName() << " OutputPoints#: " << localStorage->m_SlicedResult->GetNumberOfPoints();
+  //MITK_INFO << renderer->GetName() << " OutputPoints#: " << localStorage->m_SlicedResult->GetNumberOfPoints();
 
 
   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
-  this->ApplyProperties( renderer );
+  //this->ApplyProperties( renderer );
 
   //setup the camera according to the actor with zooming/panning etc.
  // this->AdjustCamera( renderer, planeGeo );
 
   //get distance from camera to focal point
 
 
   vtkCamera* camera = renderer->GetVtkRenderer()->GetActiveCamera();
   double *focPnt = camera->GetFocalPoint();
   double *camPos = camera->GetPosition();
   double dist1 = sqrt( pow( (focPnt[0]-camPos[0]), 2.0) +  pow( (focPnt[1]-camPos[1]), 2.0) + pow( (focPnt[2]-camPos[2]), 2.0));
   MITK_INFO << "DIST for CLIPPING RANGE: " << dist1;
   camera->SetClippingRange( (dist1-1.0),(dist1+1.0) );
   double cl1 =  camera->GetClippingRange()[0];
   double cl2 = camera->GetClippingRange()[1];
   MITK_INFO << "Camera clipping range: " << cl1 << " " << cl2;
 
   //  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_PointActor->SetMapper(localStorage->m_PointMapper);
 
 
 
 
   // We have been modified => save this for next Update()
   localStorage->m_LastUpdateTime.Modified();
 
 }
 
 
 vtkProp* mitk::FiberBundleMapper2D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
 
   //MITK_INFO << "FiberBundleMapper2D GetVtkProp(renderer)";
   this->Update(renderer);
   return m_LSH.GetLocalStorage(renderer)->m_PointActor;
 
 }
 
 void mitk::FiberBundleMapper2D::AdjustCamera(mitk::BaseRenderer* renderer, mitk::PlaneGeometry::ConstPointer planeGeo )
 {
 
 
   //activate parallel projection for 2D
   renderer->GetVtkRenderer()->GetActiveCamera()->SetParallelProjection(true);
 
   //get the display geometry of the current renderer.
   const mitk::DisplayGeometry* displayGeometry = renderer->GetDisplayGeometry();
 
   //get hight and width of current point set
   double fibMapHeightInMM = 0.0;
   double displayHeightInMM = displayGeometry->GetSizeInMM()[1]; //the display height in mm (gets smaller when you zoom in)
   double zoomFactor = 0.0;
 
 //============ ugly hack start ================================
   // ugly hack...better do it in generate data and use normal of plane or view to get requested dimensions
   // and set 2Ddimension in local storage
 
   std::string renWinName = renderer->GetName();
   std::string renWinTransveral = "stdmulti.widget1";
   std::string renWinSaggital = "stdmulti.widget2";
   std::string renWinCoronal = "stdmulti.widget3";
 
   double cameraUp[3];
 
 
   double fibmapspacing = 0.0;
   double fibmapsize = 0.0;
 
   double cameraPosition[3];
 
 //
 
 
   if (renWinName == renWinTransveral) {
     MITK_INFO << renWinTransveral << "----use Z (width) and Y (height) ---";
 // origin of Y = -106.737
     fibmapspacing = 2.5;
     fibmapsize = 82;
     cameraUp[0] = 0.0;
     cameraUp[1] = 1.0;
     cameraUp[2] = 0.0;
     cameraPosition[0] = -1.25;
     cameraPosition[1] = 454.0;
     cameraPosition[2] = 487.0; //Reason for 900000: VTK seems to calculate the clipping planes wrong for small values. See VTK bug (id #7823) in VTK bugtracker.
 //renderer->GetVtkRenderer()->GetActiveCamera()->SetPosition( cameraPosition );
 
   } else if (renWinName == renWinSaggital) {
     MITK_INFO << renWinSaggital << "--use X (width) and Z (height) ------";
     fibmapspacing = 2.5;
     fibmapsize = 40;
     cameraUp[0] = 0.0;
     cameraUp[1] = 0.0;
     cameraUp[2] = 1.0;
     cameraPosition[0] = 600;
     cameraPosition[1] = 16.0;
     cameraPosition[2] = 43.0; //Reason for 900000: VTK seems to calculate the clipping planes wrong for small values. See VTK bug (id #7823) in VTK bugtracker.
     //renderer->GetVtkRenderer()->GetActiveCamera()->Elevation(2.0);
     //renderer->GetVtkRenderer()->GetActiveCamera()->SetPosition( cameraPosition );
 
   } else if (renWinName == renWinCoronal) {
     MITK_INFO << renWinCoronal << "--use X (width) and Y (height)------";
     fibmapspacing = 2.5;
     fibmapsize = 82;
     cameraUp[0] = 0.0;
     cameraUp[1] = 0.0;
     cameraUp[2] = 1.0;
     cameraPosition[0] = -1.25;
     cameraPosition[1] = -644.0;
     cameraPosition[2] = 43.0; //Reason for 900000: VTK seems to calculate the clipping planes wrong for small values. See VTK bug (id #7823) in VTK bugtracker.
     //renderer->GetVtkRenderer()->GetActiveCamera()->SetPosition( cameraPosition );
   }
 
   fibMapHeightInMM = fibmapspacing * fibmapsize;
 //========== ugly hack end ==================================
 
   zoomFactor = fibMapHeightInMM / displayHeightInMM;
 
   Vector2D displayGeometryOriginInMM = displayGeometry->GetOriginInMM();  //top left of the render window (Origin)
   Vector2D displayGeometryCenterInMM = displayGeometryOriginInMM + displayGeometry->GetSizeInMM()*0.5; //center of the render window: (Origin + Size/2)
 
 
 
   mitk::Point2D dispCenterMM;
   dispCenterMM[0] = displayGeometryCenterInMM[0];
   dispCenterMM[1] = displayGeometryCenterInMM[1];
 
   mitk::Point3D dispCenter3D;
   //map diplay-geo to centerpoint
   displayGeometry->Map(dispCenterMM, dispCenter3D);
 
   Vector3D normal, dispCenter3Dv;
   normal[0] = planeGeo->GetNormal()[0];
   normal[1] = planeGeo->GetNormal()[1];
   normal[2] = planeGeo->GetNormal()[2];
   normal.Normalize();
 
   double focalPoint[3];
   focalPoint[0] = dispCenter3D[0];
   focalPoint[1] =  dispCenter3D[1];
   focalPoint[2] =  dispCenter3D[2];
 
   dispCenter3Dv[0] = dispCenter3D[0];
   dispCenter3Dv[1] = dispCenter3D[1];
   dispCenter3Dv[2] = dispCenter3D[2];
 
   //Vector3D camPos =  dispCenter3Dv * normal;
  // normal * dispCenter3D ;
 
 
   cameraPosition[0] = dispCenter3D[0] + 500 * normal[0];
   cameraPosition[1] = dispCenter3D[1] + 500 * normal[1];
   cameraPosition[2] = dispCenter3D[2] + 500 * normal[2];
 
 
 
 
 
   //calculate distance
   //po§sition = mittelpunkt + distanz * normierte_normale
 
   //Scale the rendered object:
   //The image is scaled by a single factor, because in an orthographic projection sizes
   //are preserved (so you cannot scale X and Y axis with different parameters). The
   //parameter sets the size of the total display-volume. If you set this to the image
   //height, the image plus a border with the size of the image will be rendered.
   //Therefore, the size is imageHeightInMM / 2.
   renderer->GetVtkRenderer()->GetActiveCamera()->SetParallelScale(fibMapHeightInMM*0.5 );
   //zooming with the factor calculated by dividing displayHeight through imegeHeight. The factor is inverse, because the VTK zoom method is working inversely.
   renderer->GetVtkRenderer()->GetActiveCamera()->Zoom(zoomFactor);
 
 
     //set the camera corresponding to the textured plane
   vtkSmartPointer<vtkCamera> camera = renderer->GetVtkRenderer()->GetActiveCamera();
   if (camera)
   {
     camera->SetPosition( cameraPosition ); //set the camera position on the textured plane normal (in our case this is the view plane normal)
     camera->SetFocalPoint( focalPoint ); //set the focal point to the center of the textured plane
     camera->SetViewUp( cameraUp ); //set the view-up for the camera
     camera->SetClippingRange(0.1, 1000000.0);
     //Reason for huge range: VTK seems to calculate the clipping planes wrong for small values. See VTK bug (id #7823) in VTK bugtracker.
 
     MITK_INFO << "CamPos: " << camera->GetPosition()[0] << " "<< camera->GetPosition()[1] << " "<< camera->GetPosition()[2];
     MITK_INFO << "CamFoc: " << camera->GetFocalPoint()[0] << " "<< camera->GetFocalPoint()[1] << " "<< camera->GetFocalPoint()[2];
     MITK_INFO << "upVec: " << camera->GetViewUp()[0] << " " << camera->GetViewUp()[1] << " " << camera->GetViewUp()[2];
 
   }
 
 
 
 }
 
+void mitk::FiberBundleMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
+{    //add shader to datano
+  
+  
+  //####### load shader from file #########
+  std::string m_VolumeDir = MITK_ROOT;
+  m_VolumeDir += "Modules/DiffusionImaging/Rendering/";
+  mitk::StandardFileLocations::GetInstance()->AddDirectoryForSearch( m_VolumeDir.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);
+  Superclass::SetDefaultProperties(node, renderer, overwrite);
+}
+
 // this method prepares data for VTK mapping and rendering
 void mitk::FiberBundleMapper2D::ApplyProperties(mitk::BaseRenderer* renderer)
 {
 
   //get the current localStorage for the corresponding renderer
   //FBLocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
-//  renderer->GetVtkRenderer()->GetRenderWindow()->SetInteractor(NULL);
+
+
+  //renderer->GetVtkRenderer()->GetRenderWindow()->SetInteractor(NULL);
+
   //float opacity = 1.0f;
   //float rgb[3] = {1.0f, 1.0f, 1.0f};
 
   //set opacity (from propertyList) to visualized fibers
   //GetOpacity( opacity, renderer );
   //localStorage->m_PointActor->GetProperty()->SetOpacity((double)opacity);
 
   //set color (from propertyList) to visualized fibers
  // GetColor( rgb, renderer);
   //localStorage->m_PointActor->GetProperty()->SetColor((double)rgb[0], (double)rgb[1], (double)rgb[2]);
 
 
 
 }
 
 
 // following methods are essential, they actually call the GetVtkProp() method
 // which returns the desired actors
 void mitk::FiberBundleMapper2D::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::FiberBundleMapper2D::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::FiberBundleMapper2D::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::FiberBundleMapper2D::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::FiberBundleMapper2D::FBLocalStorage::FBLocalStorage()
 {
   m_PointActor = vtkSmartPointer<vtkActor>::New();
   m_PointMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
 
 }
diff --git a/Modules/DiffusionImaging/Rendering/mitkFiberBundleMapper2D.h b/Modules/DiffusionImaging/Rendering/mitkFiberBundleMapper2D.h
index 10cdea9cd0..2f4d47ea98 100644
--- a/Modules/DiffusionImaging/Rendering/mitkFiberBundleMapper2D.h
+++ b/Modules/DiffusionImaging/Rendering/mitkFiberBundleMapper2D.h
@@ -1,118 +1,120 @@
 /*=========================================================================
  
  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 FIBERBUNDLEMAPPER2D_H_HEADER_INCLUDED
 #define FIBERBUNDLEMAPPER2D_H_HEADER_INCLUDED
 
 //MITK Rendering
 #include <mitkCommon.h>
 #include <mitkBaseRenderer.h>
 //#include "MitkDiffusionImagingExports.h"
 
 #include <mitkVtkMapper2D.h>
 #include <mitkFiberBundle.h>
 #include <vtkSmartPointer.h>
 
 
 //#include "FBLocalStorage.h"
 
 class vtkActor;
 //class vtkPropAssembly; //lets see if we need it
 class mitkBaseRenderer;
 class vtkPolyDataMapper;
 class vtkCutter;
 class vtkPlane;
 class vtkPolyData;
 
 
 
 namespace mitk {
   
   
   class FiberBundleMapper2D : public VtkMapper2D
   {
     
   public:
     mitkClassMacro(FiberBundleMapper2D, VtkMapper2D);
     itkNewMacro(Self);
     const mitk::FiberBundle* GetInput();
     
     
     /** \brief Checks whether this mapper needs to update itself and generate
      * data. */
     virtual void Update(mitk::BaseRenderer * renderer);
     
     
-    virtual void ApplyProperties(mitk::BaseRenderer* renderer);
+    virtual void ApplyProperties(mitk::BaseRenderer* renderer);//not necessary
+   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  FBLocalStorage : 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;
       /** \brief Point Actor of a 2D render window. */
     //  vtkSmartPointer<vtkOpenGLActor> m_TubeActor; //not in use right now
       /** \brief Point Mapper of a 2D render window. */
      // vtkSmartPointer<vtkOpenGLPolyDataMapper> m_TubeMapper; //not in use right now
       /** \brief Current slice of a 2D render window. */
     //  vtkSmartPointer<vtkCutter> m_cutter; //needed later when optimized 2D mapper
       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. */
       FBLocalStorage(); //if u copy&paste from this 2Dmapper, be aware that the implementation of this constructor is in the cpp file
       
       ~FBLocalStorage()
       {
       }
     };
     
     /** \brief This member holds all three LocalStorages for the three 2D render windows. */
     mitk::Mapper::LocalStorageHandler<FBLocalStorage> m_LSH;
 
     
     
   protected:
     FiberBundleMapper2D();
     virtual ~FiberBundleMapper2D();
     
     /** Does the actual resampling, without rendering. */
     virtual void GenerateDataForRenderer(mitk::BaseRenderer*);
     
     void AdjustCamera(mitk::BaseRenderer* , mitk::PlaneGeometry::ConstPointer);
    
    
 
   };
 
 
 }//end namespace
 
 #endif
\ No newline at end of file
diff --git a/Modules/DiffusionImaging/Rendering/mitkShaderFiberClipping.xml b/Modules/DiffusionImaging/Rendering/mitkShaderFiberClipping.xml
new file mode 100644
index 0000000000..5ba3fa344a
--- /dev/null
+++ b/Modules/DiffusionImaging/Rendering/mitkShaderFiberClipping.xml
@@ -0,0 +1,45 @@
+<?xml version='1.0' encoding='UTF-8'?>
+  <Material name='GenericAttributes1'>
+  <Shader 
+    scope='Vertex' 
+    name='VertexShader' 
+    location='Inline' 
+    language='GLSL' 
+    entry='main'> 
+  
+  <Uniform name="LightPosition" type="vec3" number_of_elements="3" value="0.0 1000.0 0.0"></Uniform>
+  <Uniform name="SkyColor" type="vec3" number_of_elements="3" value="0.9 0.8 0.5"></Uniform>
+  <Uniform name="GroundColor" type="vec3" number_of_elements="3" value="0.0 0.0 0.0"></Uniform>
+  
+  attribute vec3 scalars; 
+  
+  uniform vec3 LightPosition;
+  uniform vec3 SkyColor;
+  uniform vec3 GroundColor;
+  
+  varying vec3  DiffuseColor;
+  
+
+  void main(void) 
+  {
+    vec3 ecPosition = vec3(gl_ModelViewMatrix * gl_Vertex);
+    vec3 tnorm      = normalize(gl_NormalMatrix * gl_Normal);
+    vec3 lightVec   = normalize(LightPosition - ecPosition);
+    float costheta  = dot(tnorm, lightVec);
+    float a         = 0.5 + 0.5 * costheta;
+
+    DiffuseColor  = mix(GroundColor, SkyColor, a);
+
+    gl_Position     = ftransform();
+
+  }
+  </Shader>
+  <Shader scope='Fragment' name='FragmentShader' location='Inline'
+  language='GLSL' entry='main'>
+  varying vec3  DiffuseColor;
+  void main(void)
+  {
+    gl_FragColor = vec4(DiffuseColor, 1.0);
+  }
+  </Shader>
+</Material>