diff --git a/Core/Code/Rendering/mitkMapper.cpp b/Core/Code/Rendering/mitkMapper.cpp
index 185edb5c02..6310f2875a 100644
--- a/Core/Code/Rendering/mitkMapper.cpp
+++ b/Core/Code/Rendering/mitkMapper.cpp
@@ -1,164 +1,164 @@
 /*===================================================================
 
 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 "mitkMapper.h"
 #include "mitkDataNode.h"
 #include "mitkBaseRenderer.h"
 #include "mitkProperties.h"
 
 
 mitk::Mapper::Mapper()
   :m_TimeStep( 0 )
 {
 }
 
 
 mitk::Mapper::~Mapper()
 {
 }
 
 
 mitk::BaseData* mitk::Mapper::GetData() const
 {
 return m_DataNode->GetData();
 }
 
 
 mitk::DataNode* mitk::Mapper::GetDataNode() const
 {
   return this->m_DataNode.GetPointer();
 }
 
 
 bool mitk::Mapper::GetColor(float rgb[3], mitk::BaseRenderer* renderer, const char* name) const
 {
     const mitk::DataNode* node=GetDataNode();
     if(node==NULL)
         return false;
 
     return node->GetColor(rgb, renderer, name);
 }
 
 bool mitk::Mapper::GetVisibility(bool &visible, mitk::BaseRenderer* renderer, const char* name) const
 {
     const mitk::DataNode* node=GetDataNode();
     if(node==NULL)
         return false;
 
     return node->GetVisibility(visible, renderer, name);
 }
 
 bool mitk::Mapper::GetOpacity(float &opacity, mitk::BaseRenderer* renderer, const char* name) const
 {
     const mitk::DataNode* node=GetDataNode();
     if(node==NULL)
         return false;
 
     return node->GetOpacity(opacity, renderer, name);
 }
 
 bool mitk::Mapper::GetLevelWindow(mitk::LevelWindow& levelWindow, mitk::BaseRenderer* renderer, const char* name) const
 {
     const mitk::DataNode* node=GetDataNode();
     if(node==NULL)
         return false;
 
     return node->GetLevelWindow(levelWindow, renderer, name);
 }
 
 
 bool mitk::Mapper::IsVisible(mitk::BaseRenderer* renderer, const char* name) const
 {
     bool visible = true;
     GetDataNode()->GetVisibility(visible, renderer, name);
     return visible;
 }
 
 
 void mitk::Mapper::CalculateTimeStep( mitk::BaseRenderer *renderer )
 {
   if ( ( renderer != NULL ) && ( m_DataNode.GetPointer() != NULL ) )
   {
     m_TimeStep = renderer->GetTimeStep(m_DataNode->GetData());
   }
   else
   {
     m_TimeStep = 0;
   }
 }
 
 void mitk::Mapper::Update(mitk::BaseRenderer *renderer)
 {
   const DataNode* node = GetDataNode();
 
   assert(node!=NULL);
 
   mitk::BaseData * data = static_cast<mitk::BaseData *>(node->GetData());
 
   if (!data)
     return;
 
   // Calculate time step of the input data for the specified renderer (integer value)
   this->CalculateTimeStep( renderer );
 
   // Check if time step is valid
   const TimeSlicedGeometry *dataTimeGeometry = data->GetTimeSlicedGeometry();
   if ( ( dataTimeGeometry == NULL )
     || ( dataTimeGeometry->GetTimeSteps() == 0 )
     || ( !dataTimeGeometry->IsValidTime( m_TimeStep ) ) )
   {
     // TimeSlicedGeometry or time step is not valid for this data:
     // reset mapper so that nothing is displayed
     this->ResetMapper( renderer );
     return;
   }
 
   this->GenerateDataForRenderer(renderer);
 }
 
 
-const bool mitk::Mapper::BaseLocalStorage::IsGenerateDataRequired(
+bool mitk::Mapper::BaseLocalStorage::IsGenerateDataRequired(
     mitk::BaseRenderer *renderer,
     mitk::Mapper *mapper,
     mitk::DataNode *dataNode)
 {
   if( mapper && m_LastGenerateDataTime < mapper -> GetMTime () )
     return true;
 
   if( dataNode )
   {
     if( m_LastGenerateDataTime < dataNode -> GetDataReferenceChangedTime () )
       return true;
 
     mitk::BaseData * data = dataNode -> GetData ( ) ;
 
     if( data && m_LastGenerateDataTime < data -> GetMTime ( ) )
       return true;
   }
 
   if( renderer && m_LastGenerateDataTime < renderer -> GetTimeStepUpdateTime ( ) )
     return true;
 
   return false;
 }
 
 void mitk::Mapper::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "visible", mitk::BoolProperty::New(true), renderer, overwrite );
   node->AddProperty( "layer", mitk::IntProperty::New(0), renderer, overwrite);
   node->AddProperty( "name", mitk::StringProperty::New("No Name!"), renderer, overwrite );
 }
diff --git a/Core/Code/Rendering/mitkMapper.h b/Core/Code/Rendering/mitkMapper.h
index fb1260eaf0..d09127bfda 100644
--- a/Core/Code/Rendering/mitkMapper.h
+++ b/Core/Code/Rendering/mitkMapper.h
@@ -1,241 +1,241 @@
 /*===================================================================
 
 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 MAPPER_H_HEADER_INCLUDED_C1E6EA08
 #define MAPPER_H_HEADER_INCLUDED_C1E6EA08
 
 #include <MitkExports.h>
 #include "mitkBaseRenderer.h"
 #include "mitkVtkPropRenderer.h"
 #include "mitkLevelWindow.h"
 #include "mitkCommon.h"
 #include "mitkLocalStorageHandler.h"
 
 #include <itkObject.h>
 #include <itkWeakPointer.h>
 
 //Just included to get VTK version
 #include <vtkConfigure.h>
 
 class vtkWindow;
 class vtkProp;
 
 namespace mitk {
 
   class BaseRenderer;
   class BaseData;
   class DataNode;
 
 
   /** \brief Base class of all mappers, Vtk as well as OpenGL mappers
   *
   * By the help of mappers, the input data is transformed to tangible primitives,
   * such as surfaces, points, lines, etc.
   * This is the base class of all mappers, Vtk as well as OpenGL mappers.
   * Subclasses of mitk::Mapper control the creation of rendering primitives
   * that interface to the graphics library (e.g., OpenGL, vtk).
   *
   * \todo Should Mapper be a subclass of ImageSource?
   * \ingroup Mapper
   */
   class MITK_CORE_EXPORT Mapper : public itk::Object
   {
   public:
 
     mitkClassMacro(Mapper, itk::Object);
 
     /** \brief Set the DataNode containing the data to map */
     itkSetObjectMacro(DataNode, DataNode);
 
 
     /** \brief Get the DataNode containing the data to map */
     virtual DataNode* GetDataNode() const;
 
 
     /**\brief Get the data to map
     *
     * Returns the mitk::BaseData object associated with this mapper.
     * \return the mitk::BaseData associated with this mapper.
     * \deprecatedSince{2013_03} Use GetDataNode()->GetData() instead to access the data
     */
     DEPRECATED(BaseData* GetData() const);
 
     /** \brief Convenience access method for color properties (instances of
     * ColorProperty)
     * \return \a true property was found
     * \deprecatedSince{2013_03} Use GetDataNode()->GetColor(...) instead to get the color
     */
     DEPRECATED(virtual bool GetColor(float rgb[3], BaseRenderer* renderer, const char* name = "color") const);
 
 
     /** \brief Convenience access method for visibility properties (instances
     * of BoolProperty)
     * \return \a true property was found
     * \sa IsVisible
     * \deprecatedSince{2013_03} Use GetDataNode()->GetVisibility(...) instead to get the visibility
     */
     DEPRECATED(virtual bool GetVisibility(bool &visible, BaseRenderer* renderer, const char* name = "visible") const);
 
 
     /** \brief Convenience access method for opacity properties (instances of
     * FloatProperty)
     * \return \a true property was found
     * \deprecatedSince{2013_03} Use GetDataNode()->GetOpacity(...) instead to get the opacity
     */
     DEPRECATED(virtual bool GetOpacity(float &opacity, BaseRenderer* renderer, const char* name = "opacity") const);
 
 
     /** \brief Convenience access method for color properties (instances of
     * LevelWindoProperty)
     * \return \a true property was found
     * \deprecatedSince{2013_03} Use GetDataNode->GetLevelWindow(...) instead to get the levelwindow
     */
     DEPRECATED(virtual bool GetLevelWindow(LevelWindow &levelWindow, BaseRenderer* renderer, const char* name = "levelwindow") const);
 
 
     /** \brief Convenience access method for visibility properties (instances
     * of BoolProperty). Return value is the visibility. Default is
     * visible==true, i.e., true is returned even if the property (\a
     * propertyKey) is not found.
     *
     * Thus, the return value has a different meaning than in the
     * GetVisibility method!
     * \sa GetVisibility
     * \deprecatedSince{2013_03} Use GetDataNode()->GetVisibility(...) instead
     */
     DEPRECATED(virtual bool IsVisible(BaseRenderer* renderer, const char* name = "visible") const);
 
 
      /** \brief Returns whether this is an vtk-based mapper
     * \deprecatedSince{2013_03} All mappers of superclass VTKMapper are vtk based, use a dynamic_cast instead
     */
     virtual bool IsVtkBased() const = 0;
 
 
     /** \brief Calls the time step of the input data for the specified renderer and checks
     * whether the time step is valid and calls method GenerateDataForRenderer()
     */
     virtual void Update(BaseRenderer* renderer);
 
     /** \brief Responsible for calling the appropriate render functions.
     *   To be implemented in sub-classes.
     */
     virtual void MitkRender(mitk::BaseRenderer* renderer, mitk::VtkPropRenderer::RenderType type) = 0;
 
     /**
     * \brief Apply specific color and opacity properties read from the PropertyList.
     * Reimplemented in GLmapper (does not use the actor) and the VtkMapper class.
     * The function is called by the individual mapper (mostly in the ApplyProperties() or ApplyAllProperties()
     * method).
     */
     virtual void ApplyColorAndOpacityProperties(mitk::BaseRenderer* renderer, vtkActor* actor = NULL) = 0;
 
 
     /** \brief Set default values of properties used by this mapper
     * to \a node
     *
     * \param node The node for which the properties are set
     * \param overwrite overwrite existing properties (default: \a false)
     * \param renderer defines which property list of node is used
     * (default: \a NULL, i.e. default property list)
     */
     static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false);
 
     /** \brief Returns the current time step as calculated from the renderer */
     int GetTimestep() const { return m_TimeStep; }
 
     /** Returns true if this Mapper currently allows for Level-of-Detail rendering.
      * This reflects whether this Mapper currently invokes StartEvent, EndEvent, and
      * ProgressEvent on BaseRenderer. */
     virtual bool IsLODEnabled( BaseRenderer * /*renderer*/ ) const { return false; }
 
   protected:
 
     /** \brief explicit constructor which disallows implicit conversions */
     explicit Mapper();
 
     /** \brief virtual destructor in order to derive from this class */
     virtual ~Mapper();
 
     /** \brief Generate the data needed for rendering (independent of a specific renderer)
      *  \deprecatedSince{2013_03} Use GenerateDataForRenderer(BaseRenderer* renderer) instead.
      */
     DEPRECATED( virtual void GenerateData() ) { }
 
     /** \brief Generate the data needed for rendering into \a renderer */
     virtual void GenerateDataForRenderer(BaseRenderer* /* renderer */) { }
 
     /** \brief Updates the time step, which is sometimes needed in subclasses */
     virtual void CalculateTimeStep( BaseRenderer* renderer );
 
     /** \brief Reset the mapper (i.e., make sure that nothing is displayed) if no
     * valid data is present. In most cases the reimplemented function
     * disables the according actors (toggling visibility off)
     *
     * To be implemented in sub-classes.
     */
     virtual void ResetMapper( BaseRenderer* /*renderer*/ ) { }
 
     //\brief not thread-safe
     itk::WeakPointer<DataNode> m_DataNode;
 
 
   private:
 
     /** \brief The current time step of the dataset to be rendered,
     * for use in subclasses.
     * The current timestep can be accessed via the GetTimestep() method.
     */
     int m_TimeStep;
 
     /** \brief copy constructor */
     Mapper( const Mapper &);
 
     /** \brief assignment operator */
     Mapper &operator=(const Mapper &);
 
 
   public:
 
     /** \brief Base class for mapper specific rendering ressources.
      */
     class MITK_CORE_EXPORT BaseLocalStorage
     {
       public:
 
 
-      const bool IsGenerateDataRequired(mitk::BaseRenderer *renderer,mitk::Mapper *mapper,mitk::DataNode *dataNode);
+      bool IsGenerateDataRequired(mitk::BaseRenderer *renderer,mitk::Mapper *mapper,mitk::DataNode *dataNode);
 
-      inline const void UpdateGenerateDataTime()
+      inline void UpdateGenerateDataTime()
       {
         m_LastGenerateDataTime.Modified();
       }
 
       inline const itk::TimeStamp & GetLastGenerateDataTime() { return m_LastGenerateDataTime; }
 
       protected:
 
       /** \brief timestamp of last update of stored data */
       itk::TimeStamp m_LastGenerateDataTime;
 
     };
 
   };
 
 } // namespace mitk
 
 #endif /* MAPPER_H_HEADER_INCLUDED_C1E6EA08 */
diff --git a/Core/Code/Rendering/mitkVtkMapper.cpp b/Core/Code/Rendering/mitkVtkMapper.cpp
index e4f925429a..a272fba01e 100644
--- a/Core/Code/Rendering/mitkVtkMapper.cpp
+++ b/Core/Code/Rendering/mitkVtkMapper.cpp
@@ -1,129 +1,129 @@
 /*===================================================================
 
 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 "mitkVtkMapper.h"
 
 mitk::VtkMapper::VtkMapper()
 {
 }
 
 mitk::VtkMapper::~VtkMapper()
 {
 }
 
 void mitk::VtkMapper::MitkRender(mitk::BaseRenderer* renderer, mitk::VtkPropRenderer::RenderType type){
 
  switch(type)
     {
     case mitk::VtkPropRenderer::Opaque: this->MitkRenderOpaqueGeometry(renderer); break;
     case mitk::VtkPropRenderer::Translucent: this->MitkRenderTranslucentGeometry(renderer); break;
     case mitk::VtkPropRenderer::Overlay:       this->MitkRenderOverlay(renderer); break;
     case mitk::VtkPropRenderer::Volumetric:    this->MitkRenderVolumetricGeometry(renderer); break;
     }
 }
 
 bool mitk::VtkMapper::IsVtkBased() const
 {
   return true;
 }
 
 void mitk::VtkMapper::MitkRenderOverlay(BaseRenderer* renderer)
 {
 
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if ( !visible) return;
 
   if ( this->GetVtkProp(renderer)->GetVisibility() )
   {
     GetVtkProp(renderer)->RenderOverlay(renderer->GetVtkRenderer());
   }
 }
 
 void mitk::VtkMapper::MitkRenderOpaqueGeometry(BaseRenderer* renderer)
 {
   bool visible = true;
 
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if ( !visible) return;
 
   if ( this->GetVtkProp(renderer)->GetVisibility() )
   {
     GetVtkProp(renderer)->RenderOpaqueGeometry( renderer->GetVtkRenderer() );
   }
 }
 
 void mitk::VtkMapper::MitkRenderTranslucentGeometry(BaseRenderer* renderer)
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if ( !visible) return;
 
   if ( this->GetVtkProp(renderer)->GetVisibility() )
   {
     GetVtkProp(renderer)->RenderTranslucentPolygonalGeometry(renderer->GetVtkRenderer());
   }
 }
 
 void mitk::VtkMapper::MitkRenderVolumetricGeometry(BaseRenderer* renderer)
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if ( !visible) return;
 
   if ( GetVtkProp(renderer)->GetVisibility() )
   {
     GetVtkProp(renderer)->RenderVolumetricGeometry(renderer->GetVtkRenderer());
   }
 }
 
-const bool mitk::VtkMapper::HasVtkProp( const vtkProp *prop, BaseRenderer *renderer )
+bool mitk::VtkMapper::HasVtkProp( const vtkProp *prop, BaseRenderer *renderer )
 {
   vtkProp *myProp = this->GetVtkProp( renderer );
 
   // TODO: check if myProp is a vtkAssembly and if so, check if prop is contained in its leafs
   return ( prop == myProp );
 }
 
 void mitk::VtkMapper::SetVtkMapperImmediateModeRendering(vtkMapper *mapper)
 {
   if(mapper)
     mapper->SetImmediateModeRendering(mitk::VtkPropRenderer::useImmediateModeRendering());
 }
 
 void mitk::VtkMapper::UpdateVtkTransform(mitk::BaseRenderer *renderer)
 {
   vtkLinearTransform * vtktransform = GetDataNode()->GetVtkTransform(this->GetTimestep());
 
   vtkProp3D *prop = dynamic_cast<vtkProp3D*>( GetVtkProp(renderer) );
   if(prop)
     prop->SetUserTransform(vtktransform);
 }
 
 void mitk::VtkMapper::ApplyColorAndOpacityProperties(BaseRenderer* renderer, vtkActor* actor)
 {
   float rgba[4]={1.0f,1.0f,1.0f,1.0f};
   DataNode * node = GetDataNode();
 
   // check for color prop and use it for rendering if it exists
   node->GetColor(rgba, renderer, "color");
   // check for opacity prop and use it for rendering if it exists
   node->GetOpacity(rgba[3], renderer, "opacity");
 
   double drgba[4]={rgba[0],rgba[1],rgba[2],rgba[3]};
   actor->GetProperty()->SetColor(drgba);
   actor->GetProperty()->SetOpacity(drgba[3]);
 }
diff --git a/Core/Code/Rendering/mitkVtkMapper.h b/Core/Code/Rendering/mitkVtkMapper.h
index c5b8ee68ea..6344bcfe5d 100644
--- a/Core/Code/Rendering/mitkVtkMapper.h
+++ b/Core/Code/Rendering/mitkVtkMapper.h
@@ -1,145 +1,145 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // change number
 #ifndef VTKMAPPER_H_HEADER_INCLUDED_C1C5453B
 #define VTKMAPPER_H_HEADER_INCLUDED_C1C5453B
 
 #include <MitkExports.h>
 #include "mitkMapper.h"
 #include "mitkBaseRenderer.h"
 #include "mitkDataNode.h"
 #include "mitkVtkPropRenderer.h"
 
 #include <vtkProp3D.h>
 #include <vtkActor.h>
 #include <vtkProperty.h>
 #include <vtkLinearTransform.h>
 #include <vtkMapper.h>
 #include <vtkPropAssembly.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkProp3DCollection.h>
 
 class vtkProp;
 class vtkProp3D;
 class vtkActor;
 
 namespace mitk {
 
 /** \brief Base class of all Vtk Mappers in order to display primitives
 * by exploiting Vtk functionality.
 *
 * Rendering of opaque, translucent or volumetric geometry and overlays
 * is done in consecutive render passes.
 *
 * \ingroup Mapper
 */
 class MITK_CORE_EXPORT VtkMapper : public Mapper
 {
   public:
     mitkClassMacro(VtkMapper,Mapper);
 
     virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer) = 0;
 
     /** \brief Re-issues all drawing commands required to describe
     * the entire scene each time a new frame is required,
     * regardless of actual changes.
     */
     static void SetVtkMapperImmediateModeRendering(vtkMapper *mapper);
 
      /**
      * \brief Returns whether this is an vtk-based mapper
      * \deprecatedSince{2013_03} All mappers of superclass VTKMapper are vtk based, use a dynamic_cast instead
      */
     DEPRECATED( virtual bool IsVtkBased() const );
 
 
     /** \brief Determines which geometry should be rendered
     * (opaque, translucent, volumetric, overlay)
     * and calls the appropriate function.
     *
     * Called by mitk::VtkPropRenderer::Render
     */
     void MitkRender(mitk::BaseRenderer* renderer, mitk::VtkPropRenderer::RenderType type);
 
     /** \brief Checks visibility and renders the overlay */
     virtual void MitkRenderOverlay(BaseRenderer* renderer);
 
     /** \brief Checks visibility and renders untransparent geometry */
     virtual void MitkRenderOpaqueGeometry(BaseRenderer* renderer);
 
     /** \brief Checks visiblity and renders transparent geometry */
     virtual void MitkRenderTranslucentGeometry(BaseRenderer* renderer);
 
     /** \brief Checks visibility and renders volumes */
     virtual void MitkRenderVolumetricGeometry(BaseRenderer* renderer);
 
     /** \brief Returns true if this mapper owns the specified vtkProp for
     * the given BaseRenderer.
     *
     * Note: returns false by default; should be implemented for VTK-based
     * Mapper subclasses. */
-    virtual const bool HasVtkProp( const vtkProp *prop, BaseRenderer *renderer );
+    virtual bool HasVtkProp( const vtkProp *prop, BaseRenderer *renderer );
 
     /** \brief Set the vtkTransform of the m_Prop3D for
     * the current time step of \a renderer
     *
     * Called by mitk::VtkPropRenderer::Update before rendering
     */
     virtual void UpdateVtkTransform(mitk::BaseRenderer *renderer);
 
     /**
     * \brief Apply color and opacity properties read from the PropertyList
     * \deprecatedSince{2013_03} Use ApplyColorAndOpacityProperties(mitk::BaseRenderer* renderer, vtkActor * actor) instead
     */
     DEPRECATED(inline virtual void ApplyProperties(vtkActor* actor, mitk::BaseRenderer* renderer))
     {
       ApplyColorAndOpacityProperties(renderer, actor);
     }
 
     /**
     * \brief Apply color and opacity properties read from the PropertyList.
     * Called by mapper subclasses.
     */
     virtual void ApplyColorAndOpacityProperties(mitk::BaseRenderer* renderer, vtkActor * actor);
 
     /**
     * \brief  Release vtk-based graphics resources that are being consumed by this mapper.
     * The parameter window could be used to determine which graphic
     * resources to releases. Must be overwritten in individual subclasses
     * if vtkProps are used.
     */
     virtual void ReleaseGraphicsResources(vtkWindow* /*renWin*/) { };
 
   protected:
 
     /** constructor */
     VtkMapper();
 
     /** virtual destructor in order to derive from this class */
     virtual ~VtkMapper();
 
   private:
 
     /** copy constructor */
     VtkMapper( const VtkMapper &);
 
     /** assignment operator */
     VtkMapper & operator=(const VtkMapper &);
 
 };
 } // namespace mitk
 #endif /* VTKMAPPER_H_HEADER_INCLUDED_C1C5453B */
diff --git a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkCompositeMapper.h b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkCompositeMapper.h
index 783546ee1f..b587249019 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkCompositeMapper.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkCompositeMapper.h
@@ -1,159 +1,159 @@
 /*===================================================================
 
 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 COMPOSITEMAPPER_H_HEADER_INCLUDED
 #define COMPOSITEMAPPER_H_HEADER_INCLUDED
 
 #include "mitkGLMapper.h"
 #include "mitkVtkMapper.h"
 #include "mitkQBallImage.h"
 #include "mitkImageVtkMapper2D.h"
 #include "mitkOdfVtkMapper2D.h"
 #include "mitkLevelWindowProperty.h"
 
 namespace mitk {
 
   class CopyImageMapper2D : public ImageVtkMapper2D
   {
   public:
     mitkClassMacro(CopyImageMapper2D,ImageVtkMapper2D);
     itkNewMacro(Self);
 
     friend class CompositeMapper;
   };
 
   //##Documentation
   //## @brief Composite pattern for combination of different mappers
   //## @ingroup Mapper
   class CompositeMapper : public VtkMapper
   {
   public:
 
     mitkClassMacro(CompositeMapper,VtkMapper);
     itkNewMacro(Self);
 
     virtual void MitkRenderOverlay(BaseRenderer* renderer)
     {
       m_ImgMapper->MitkRenderOverlay(renderer);
       m_OdfMapper->MitkRenderOverlay(renderer);
     }
 
     virtual void MitkRenderOpaqueGeometry(BaseRenderer* renderer)
     {
       m_ImgMapper->MitkRenderOpaqueGeometry(renderer);
       m_OdfMapper->MitkRenderOpaqueGeometry(renderer);
       if( mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) == 0 )
       {
         renderer->Modified();
       }
     }
 
     virtual void MitkRenderTranslucentGeometry(BaseRenderer* renderer)
     {
       m_ImgMapper->MitkRenderTranslucentGeometry(renderer);
       m_OdfMapper->MitkRenderTranslucentGeometry(renderer);
     }
 
     virtual void MitkRenderVolumetricGeometry(BaseRenderer* renderer)
     {
       m_ImgMapper->MitkRenderVolumetricGeometry(renderer);
       m_OdfMapper->MitkRenderVolumetricGeometry(renderer);
     }
 
     void SetDataNode(DataNode* node)
     {
       m_DataNode = node;
       m_ImgMapper->SetDataNode(node);
       m_OdfMapper->SetDataNode(node);
     }
 
     mitk::ImageVtkMapper2D::Pointer GetImageMapper()
     {
       ImageVtkMapper2D* retval = m_ImgMapper;
       return retval;
     }
 
-    const bool HasVtkProp( const vtkProp* prop, BaseRenderer* renderer )
+    bool HasVtkProp( const vtkProp* prop, BaseRenderer* renderer )
     {
       return m_OdfMapper->HasVtkProp(prop, renderer);
     }
 
     void ReleaseGraphicsResources(vtkWindow* window)
     {
       m_ImgMapper->ReleaseGraphicsResources(window);
       m_OdfMapper->ReleaseGraphicsResources(window);
     }
 
     static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false )
     {
       mitk::OdfVtkMapper2D<float,QBALL_ODFSIZE>::SetDefaultProperties(node, renderer, overwrite);
       mitk::CopyImageMapper2D::SetDefaultProperties(node, renderer, overwrite);
 
       mitk::LevelWindow opaclevwin;
       opaclevwin.SetRangeMinMax(0,255);
       opaclevwin.SetWindowBounds(0,0);
       mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(opaclevwin);
       node->AddProperty( "opaclevelwindow", prop );
     }
 
     bool IsLODEnabled( BaseRenderer * renderer ) const
     {
       return m_ImgMapper->IsLODEnabled(renderer) || m_OdfMapper->IsLODEnabled(renderer);
     }
 
     vtkProp* GetVtkProp(mitk::BaseRenderer* renderer)
     {
       vtkPropAssembly* assembly = vtkPropAssembly::New();
       assembly->AddPart( m_OdfMapper->GetVtkProp(renderer));
       assembly->AddPart( m_ImgMapper->GetVtkProp(renderer));
       return assembly;
     }
 
   protected:
 
     virtual void Update(mitk::BaseRenderer* renderer)
     {
       m_OdfMapper->Update(renderer);
       GenerateDataForRenderer(renderer);
     }
 
     virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer)
     {
       m_ImgMapper->GenerateDataForRenderer(renderer);
 //      if( mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) > 0 )
 //      {
 //        m_OdfMapper->GenerateDataForRenderer(renderer);
 //      }
     }
 
     CompositeMapper();
 
     virtual ~CompositeMapper();
 
   private:
 
     mitk::OdfVtkMapper2D<float,QBALL_ODFSIZE>::Pointer m_OdfMapper;
     mitk::CopyImageMapper2D::Pointer m_ImgMapper;
 
   };
 
 } // namespace mitk
 
 
 
 #endif /* COMPOSITEMAPPER_H_HEADER_INCLUDED */