diff --git a/Modules/DiffusionImaging/Rendering/mitkFiberBundleXMapper2D.cpp b/Modules/DiffusionImaging/Rendering/mitkFiberBundleXMapper2D.cpp
new file mode 100644
index 0000000000..55df715ef7
--- /dev/null
+++ b/Modules/DiffusionImaging/Rendering/mitkFiberBundleXMapper2D.cpp
@@ -0,0 +1,314 @@
+/*
+ *  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()
+{
+    return dynamic_cast<const 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
+    
+    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_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
new file mode 100644
index 0000000000..1957719b66
--- /dev/null
+++ b/Modules/DiffusionImaging/Rendering/mitkFiberBundleXMapper2D.h
@@ -0,0 +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();
+    
+    
+    /** \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