diff --git a/Core/Code/Controllers/mitkRenderingManager.cpp b/Core/Code/Controllers/mitkRenderingManager.cpp
index 5069225c2c..8c39fa5615 100644
--- a/Core/Code/Controllers/mitkRenderingManager.cpp
+++ b/Core/Code/Controllers/mitkRenderingManager.cpp
@@ -1,1033 +1,1031 @@
 /*===================================================================
 
 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 "mitkRenderingManager.h"
 #include "mitkRenderingManagerFactory.h"
 #include "mitkBaseRenderer.h"
 #include "mitkGlobalInteraction.h"
 
 #include <vtkRenderWindow.h>
 
 #include <itkCommand.h>
 #include "mitkVector.h"
 #include <itkAffineGeometryFrame.h>
 #include <itkScalableAffineTransform.h>
 #include <mitkVtkPropRenderer.h>
 
 #include <algorithm>
 
 namespace mitk
 {
 
 RenderingManager::Pointer RenderingManager::s_Instance = 0;
 RenderingManagerFactory *RenderingManager::s_RenderingManagerFactory = 0;
 
 
 RenderingManager
 ::RenderingManager()
 : m_UpdatePending( false ),
   m_MaxLOD( 1 ),
   m_LODIncreaseBlocked( false ),
   m_LODAbortMechanismEnabled( false ),
   m_ClippingPlaneEnabled( false ),
   m_TimeNavigationController( SliceNavigationController::New("dummy") ),
   m_DataStorage( NULL ),
   m_ConstrainedPaddingZooming ( true )
 {
   m_ShadingEnabled.assign( 3, false );
   m_ShadingValues.assign( 4, 0.0 );
 
   m_GlobalInteraction = mitk::GlobalInteraction::GetInstance();
 
   InitializePropertyList();
 }
 
 
 RenderingManager
 ::~RenderingManager()
 {
   // Decrease reference counts of all registered vtkRenderWindows for
   // proper destruction
   RenderWindowVector::iterator it;
   for ( it = m_AllRenderWindows.begin(); it != m_AllRenderWindows.end(); ++it )
   {
     (*it)->UnRegister( NULL );
 
     RenderWindowCallbacksList::iterator callbacks_it = this->m_RenderWindowCallbacksList.find(*it);
 
     if (callbacks_it != this->m_RenderWindowCallbacksList.end())
     {
       (*it)->RemoveObserver(callbacks_it->second.commands[0u]);
       (*it)->RemoveObserver(callbacks_it->second.commands[1u]);
       (*it)->RemoveObserver(callbacks_it->second.commands[2u]);
     }
   }
 }
 
 
 void
 RenderingManager
 ::SetFactory( RenderingManagerFactory *factory )
 {
   s_RenderingManagerFactory = factory;
 }
 
 
 const RenderingManagerFactory *
 RenderingManager
 ::GetFactory()
 {
   return s_RenderingManagerFactory;
 }
 
 
 bool
 RenderingManager
 ::HasFactory()
 {
   if ( RenderingManager::s_RenderingManagerFactory )
   {
     return true;
   }
   else
   {
     return false;
   }
 }
 
 
 RenderingManager::Pointer
 RenderingManager
 ::New()
 {
   const RenderingManagerFactory* factory = GetFactory();
   if(factory == NULL)
     return NULL;
   return factory->CreateRenderingManager();
 }
 
 RenderingManager *
 RenderingManager
 ::GetInstance()
 {
   if ( !RenderingManager::s_Instance )
   {
     if ( s_RenderingManagerFactory )
     {
       s_Instance = s_RenderingManagerFactory->CreateRenderingManager();
     }
   }
 
   return s_Instance;
 }
 
 
 bool
 RenderingManager
 ::IsInstantiated()
 {
   if ( RenderingManager::s_Instance )
     return true;
   else
     return false;
 }
 
 
 void
 RenderingManager
 ::AddRenderWindow( vtkRenderWindow *renderWindow )
 {
   if ( renderWindow
     && (m_RenderWindowList.find( renderWindow ) == m_RenderWindowList.end()) )
   {
     m_RenderWindowList[renderWindow] = RENDERING_INACTIVE;
     m_AllRenderWindows.push_back( renderWindow );
 
     if ( m_DataStorage.IsNotNull() )
       mitk::BaseRenderer::GetInstance( renderWindow )->SetDataStorage( m_DataStorage.GetPointer() );
 
 
     // Register vtkRenderWindow instance
     renderWindow->Register( NULL );
 
-    typedef itk::MemberCommand< RenderingManager > MemberCommandType;
-
     // Add callbacks for rendering abort mechanism
     //BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow );
     vtkCallbackCommand *startCallbackCommand = vtkCallbackCommand::New();
     startCallbackCommand->SetCallback(
       RenderingManager::RenderingStartCallback );
     renderWindow->AddObserver( vtkCommand::StartEvent, startCallbackCommand );
 
     vtkCallbackCommand *progressCallbackCommand = vtkCallbackCommand::New();
     progressCallbackCommand->SetCallback(
       RenderingManager::RenderingProgressCallback );
     renderWindow->AddObserver( vtkCommand::AbortCheckEvent, progressCallbackCommand );
 
     vtkCallbackCommand *endCallbackCommand = vtkCallbackCommand::New();
     endCallbackCommand->SetCallback(
       RenderingManager::RenderingEndCallback );
     renderWindow->AddObserver( vtkCommand::EndEvent, endCallbackCommand );
 
     RenderWindowCallbacks callbacks;
 
     callbacks.commands[0u] = startCallbackCommand;
     callbacks.commands[1u] = progressCallbackCommand;
     callbacks.commands[2u] = endCallbackCommand;
     this->m_RenderWindowCallbacksList[renderWindow] = callbacks;
 
     //Delete vtk variables correctly
     startCallbackCommand->Delete();
     progressCallbackCommand->Delete();
     endCallbackCommand->Delete();
 
   }
 }
 
 
 void
 RenderingManager
 ::RemoveRenderWindow( vtkRenderWindow *renderWindow )
 {
   if (m_RenderWindowList.erase( renderWindow ))
   {
     RenderWindowCallbacksList::iterator callbacks_it = this->m_RenderWindowCallbacksList.find(renderWindow);
     if(callbacks_it != this->m_RenderWindowCallbacksList.end())
     {
       renderWindow->RemoveObserver(callbacks_it->second.commands[0u]);
       renderWindow->RemoveObserver(callbacks_it->second.commands[1u]);
       renderWindow->RemoveObserver(callbacks_it->second.commands[2u]);
       this->m_RenderWindowCallbacksList.erase(callbacks_it);
     }
 
     RenderWindowVector::iterator rw_it = std::find( m_AllRenderWindows.begin(), m_AllRenderWindows.end(), renderWindow );
 
     if(rw_it != m_AllRenderWindows.end())
     {
       // Decrease reference count for proper destruction
       (*rw_it)->UnRegister(NULL);
       m_AllRenderWindows.erase( rw_it );
     }
   }
 }
 
 
 const RenderingManager::RenderWindowVector&
 RenderingManager
 ::GetAllRegisteredRenderWindows()
 {
   return m_AllRenderWindows;
 }
 
 
 void
 RenderingManager
 ::RequestUpdate( vtkRenderWindow *renderWindow )
 {
 
   // If the renderWindow is not valid, we do not want to inadvertantly create
   // an entry in the m_RenderWindowList map. It is possible if the user is
   // regularly calling AddRenderer and RemoveRenderer for a rendering update
   // to come into this method with a renderWindow pointer that is valid in the
   // sense that the window does exist within the application, but that
   // renderWindow has been temporarily removed from this RenderingManager for
   // performance reasons.
   if (m_RenderWindowList.find( renderWindow ) == m_RenderWindowList.end())
   {
     return;
   }
 
   m_RenderWindowList[renderWindow] = RENDERING_REQUESTED;
 
   if ( !m_UpdatePending )
   {
     m_UpdatePending = true;
     this->GenerateRenderingRequestEvent();
   }
 }
 
 
 void
 RenderingManager
 ::ForceImmediateUpdate( vtkRenderWindow *renderWindow )
 {
   // If the renderWindow is not valid, we do not want to inadvertantly create
   // an entry in the m_RenderWindowList map. It is possible if the user is
   // regularly calling AddRenderer and RemoveRenderer for a rendering update
   // to come into this method with a renderWindow pointer that is valid in the
   // sense that the window does exist within the application, but that
   // renderWindow has been temporarily removed from this RenderingManager for
   // performance reasons.
   if (m_RenderWindowList.find( renderWindow ) == m_RenderWindowList.end())
   {
     return;
   }
 
   // Erase potentially pending requests for this window
   m_RenderWindowList[renderWindow] = RENDERING_INACTIVE;
 
   m_UpdatePending = false;
 
   // Immediately repaint this window (implementation platform specific)
   // If the size is 0 it crahses
   int *size = renderWindow->GetSize();
   if ( 0 != size[0] && 0 != size[1] )
   {
     //prepare the camera etc. before rendering
     //Note: this is a very important step which should be called before the VTK render!
     //If you modify the camera anywhere else or after the render call, the scene cannot be seen.
     mitk::VtkPropRenderer *vPR =
         dynamic_cast<mitk::VtkPropRenderer*>(mitk::BaseRenderer::GetInstance( renderWindow ));
     if(vPR)
        vPR->PrepareRender();
     // Execute rendering
     renderWindow->Render();
   }
 }
 
 
 void
 RenderingManager
 ::RequestUpdateAll( RequestType type )
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     int id = BaseRenderer::GetInstance(it->first)->GetMapperID();
     if ( (type == REQUEST_UPDATE_ALL)
       || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
       || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)) )
     {
        this->RequestUpdate( it->first );
     }
   }
 }
 
 
 void
 RenderingManager
 ::ForceImmediateUpdateAll( RequestType type )
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     int id = BaseRenderer::GetInstance(it->first)->GetMapperID();
     if ( (type == REQUEST_UPDATE_ALL)
       || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
       || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)) )
     {
       // Immediately repaint this window (implementation platform specific)
       // If the size is 0, it crashes
       this->ForceImmediateUpdate(it->first);
 
   //    int *size = it->first->GetSize();
   //    if ( 0 != size[0] && 0 != size[1] )
   //    {
   //      //prepare the camera before rendering
   //      //Note: this is a very important step which should be called before the VTK render!
   //      //If you modify the camera anywhere else or after the render call, the scene cannot be seen.
   //      mitk::VtkPropRenderer *vPR =
   //          dynamic_cast<mitk::VtkPropRenderer*>(mitk::BaseRenderer::GetInstance( it->first ));
       //      if(vPR)
       //         vPR->PrepareRender();
       //      // Execute rendering
       //      it->first->Render();
       //    }
 
       //    it->second = RENDERING_INACTIVE;
     }
   }
 
   //m_UpdatePending = false;
 }
 
 
 //bool RenderingManager::InitializeViews( const mitk::DataStorage * storage, const DataNode* node = NULL, RequestType type, bool preserveRoughOrientationInWorldSpace )
 //{
 //  mitk::Geometry3D::Pointer geometry;
 //  if ( storage != NULL )
 //  {
 //    geometry = storage->ComputeVisibleBoundingGeometry3D(node, "visible", NULL, "includeInBoundingBox" );
 //
 //    if ( geometry.IsNotNull() )
 //    {
 //      // let's see if we have data with a limited live-span ...
 //      mitk::TimeBounds timebounds = geometry->GetTimeBounds();
 //      if ( timebounds[1] < mitk::ScalarTypeNumericTraits::max() )
 //      {
 //        mitk::ScalarType duration = timebounds[1]-timebounds[0];
 //
 //        mitk::TimeSlicedGeometry::Pointer timegeometry =
 //          mitk::TimeSlicedGeometry::New();
 //        timegeometry->InitializeEvenlyTimed(
 //          geometry, (unsigned int) duration );
 //        timegeometry->SetTimeBounds( timebounds );
 //
 //        timebounds[1] = timebounds[0] + 1.0;
 //        geometry->SetTimeBounds( timebounds );
 //
 //        geometry = timegeometry;
 //      }
 //    }
 //  }
 //
 //  // Use geometry for initialization
 //  return this->InitializeViews( geometry.GetPointer(), type );
 //}
 
 
 bool
 RenderingManager
 ::InitializeViews( const Geometry3D * dataGeometry, RequestType type, bool preserveRoughOrientationInWorldSpace )
 {
   MITK_DEBUG << "initializing views";
 
   bool boundingBoxInitialized = false;
 
   Geometry3D::ConstPointer geometry = dataGeometry;
 
   if (dataGeometry && preserveRoughOrientationInWorldSpace)
   {
 
     // clone the input geometry
     Geometry3D::Pointer modifiedGeometry = dynamic_cast<Geometry3D*>( dataGeometry->Clone().GetPointer() );
     assert(modifiedGeometry.IsNotNull());
 
     // construct an affine transform from it
     AffineGeometryFrame3D::TransformType::Pointer transform = AffineGeometryFrame3D::TransformType::New();
     assert( modifiedGeometry->GetIndexToWorldTransform() );
     transform->SetMatrix( modifiedGeometry->GetIndexToWorldTransform()->GetMatrix() );
     transform->SetOffset( modifiedGeometry->GetIndexToWorldTransform()->GetOffset() );
 
     // get transform matrix
     AffineGeometryFrame3D::TransformType::MatrixType::InternalMatrixType& oldMatrix =
       const_cast< AffineGeometryFrame3D::TransformType::MatrixType::InternalMatrixType& > ( transform->GetMatrix().GetVnlMatrix() );
     AffineGeometryFrame3D::TransformType::MatrixType::InternalMatrixType newMatrix(oldMatrix);
 
     // get offset and bound
     Vector3D offset = modifiedGeometry->GetIndexToWorldTransform()->GetOffset();
     Geometry3D::BoundsArrayType oldBounds = modifiedGeometry->GetBounds();
     Geometry3D::BoundsArrayType newBounds = modifiedGeometry->GetBounds();
 
     // get rid of rotation other than pi/2 degree
     for ( unsigned int i = 0; i < 3; ++i )
     {
 
       // i-th column of the direction matrix
       Vector3D currentVector;
       currentVector[0] = oldMatrix(0,i);
       currentVector[1] = oldMatrix(1,i);
       currentVector[2] = oldMatrix(2,i);
 
       // matchingRow will store the row that holds the biggest
       // value in the column
       unsigned int matchingRow = 0;
 
       // maximum value in the column
       float max = std::numeric_limits<float>::min();
 
       // sign of the maximum value (-1 or 1)
       int sign = 1;
 
       // iterate through the column vector
       for (unsigned int dim = 0; dim < 3; ++dim)
       {
         if ( fabs(currentVector[dim]) > max )
         {
           matchingRow = dim;
           max = fabs(currentVector[dim]);
           if(currentVector[dim]<0)
             sign = -1;
           else
             sign = 1;
         }
       }
 
       // in case we found a negative maximum,
       // we negate the column and adjust the offset
       // (in order to run through the dimension in the opposite direction)
       if(sign == -1)
       {
         currentVector *= sign;
         offset += modifiedGeometry->GetAxisVector(i);
       }
 
 
       // matchingRow is now used as column index to place currentVector
       // correctly in the new matrix
       vnl_vector<ScalarType> newMatrixColumn(3);
       newMatrixColumn[0] = currentVector[0];
       newMatrixColumn[1] = currentVector[1];
       newMatrixColumn[2] = currentVector[2];
       newMatrix.set_column( matchingRow, newMatrixColumn );
 
       // if a column is moved, we also have to adjust the bounding
       // box accordingly, this is done here
       newBounds[2*matchingRow  ] = oldBounds[2*i  ];
       newBounds[2*matchingRow+1] = oldBounds[2*i+1];
     }
 
     // set the newly calculated bounds array
     modifiedGeometry->SetBounds(newBounds);
 
     // set new offset and direction matrix
     AffineGeometryFrame3D::TransformType::MatrixType newMatrixITK( newMatrix );
     transform->SetMatrix( newMatrixITK );
     transform->SetOffset( offset );
     modifiedGeometry->SetIndexToWorldTransform( transform );
     geometry = modifiedGeometry;
 
   }
 
   int warningLevel = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
   if ( (geometry.IsNotNull() ) && (const_cast< mitk::BoundingBox * >(
     geometry->GetBoundingBox())->GetDiagonalLength2() > mitk::eps) )
   {
     boundingBoxInitialized = true;
   }
 
   if (geometry.IsNotNull() )
   {// make sure bounding box has an extent bigger than zero in any direction
     // clone the input geometry
     Geometry3D::Pointer modifiedGeometry = dynamic_cast<Geometry3D*>( dataGeometry->Clone().GetPointer() );
     assert(modifiedGeometry.IsNotNull());
     Geometry3D::BoundsArrayType newBounds = modifiedGeometry->GetBounds();
     for( unsigned int dimension = 0; ( 2 * dimension ) < newBounds.Size() ; dimension++ )
     {
       //check for equality but for an epsilon
       if( Equal( newBounds[ 2 * dimension ], newBounds[ 2 * dimension + 1 ] ) )
       {
         newBounds[ 2 * dimension + 1 ] += 1;
       }
     }
 
     // set the newly calculated bounds array
     modifiedGeometry->SetBounds(newBounds);
 
     geometry = modifiedGeometry;
   }
 
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     mitk::BaseRenderer *baseRenderer =
       mitk::BaseRenderer::GetInstance( it->first );
 
     baseRenderer->GetDisplayGeometry()->SetConstrainZoomingAndPanning(m_ConstrainedPaddingZooming);
 
     int id = baseRenderer->GetMapperID();
     if ( ((type == REQUEST_UPDATE_ALL)
       || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
       || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)))
       )
     {
       this->InternalViewInitialization( baseRenderer, geometry,
         boundingBoxInitialized, id );
     }
   }
 
   if ( boundingBoxInitialized )
   {
     m_TimeNavigationController->SetInputWorldGeometry( geometry );
   }
   m_TimeNavigationController->Update();
 
   this->RequestUpdateAll( type );
 
   vtkObject::SetGlobalWarningDisplay( warningLevel );
 
   // Inform listeners that views have been initialized
   this->InvokeEvent( mitk::RenderingManagerViewsInitializedEvent() );
 
 
   return boundingBoxInitialized;
 }
 
 
 bool
 RenderingManager
 ::InitializeViews( RequestType type )
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     mitk::BaseRenderer *baseRenderer =
       mitk::BaseRenderer::GetInstance( it->first );
     int id = baseRenderer->GetMapperID();
     if ( (type == REQUEST_UPDATE_ALL)
       || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
       || ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)) )
     {
 
       mitk::SliceNavigationController *nc =
 
       baseRenderer->GetSliceNavigationController();
 
       // Re-initialize view direction
       nc->SetViewDirectionToDefault();
 
       // Update the SNC
       nc->Update();
     }
   }
 
   this->RequestUpdateAll( type );
 
   return true;
 }
 
 //bool RenderingManager::InitializeView( vtkRenderWindow * renderWindow, const DataStorage* ds, const DataNode node = NULL,  bool initializeGlobalTimeSNC )
 //{
 //  mitk::Geometry3D::Pointer geometry;
 //  if ( ds != NULL )
 //  {
 //    geometry = ds->ComputeVisibleBoundingGeometry3D(node, NULL, "includeInBoundingBox" );
 //
 //    if ( geometry.IsNotNull() )
 //    {
 //      // let's see if we have data with a limited live-span ...
 //      mitk::TimeBounds timebounds = geometry->GetTimeBounds();
 //      if ( timebounds[1] < mitk::ScalarTypeNumericTraits::max() )
 //      {
 //        mitk::ScalarType duration = timebounds[1]-timebounds[0];
 //
 //        mitk::TimeSlicedGeometry::Pointer timegeometry =
 //          mitk::TimeSlicedGeometry::New();
 //        timegeometry->InitializeEvenlyTimed(
 //          geometry, (unsigned int) duration );
 //        timegeometry->SetTimeBounds( timebounds );
 //
 //        timebounds[1] = timebounds[0] + 1.0;
 //        geometry->SetTimeBounds( timebounds );
 //
 //        geometry = timegeometry;
 //      }
 //    }
 //  }
 //
 //  // Use geometry for initialization
 //  return this->InitializeView( renderWindow,
 //    geometry.GetPointer(), initializeGlobalTimeSNC );
 //}
 
 bool RenderingManager::InitializeView( vtkRenderWindow * renderWindow, const Geometry3D * geometry, bool initializeGlobalTimeSNC )
 {
   bool boundingBoxInitialized = false;
 
   int warningLevel = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
   if ( (geometry != NULL ) && (const_cast< mitk::BoundingBox * >(
    geometry->GetBoundingBox())->GetDiagonalLength2() > mitk::eps) )
   {
    boundingBoxInitialized = true;
   }
 
   mitk::BaseRenderer *baseRenderer =
    mitk::BaseRenderer::GetInstance( renderWindow );
 
   int id = baseRenderer->GetMapperID();
 
   this->InternalViewInitialization( baseRenderer, geometry,
    boundingBoxInitialized, id );
 
   if ( boundingBoxInitialized && initializeGlobalTimeSNC )
   {
     m_TimeNavigationController->SetInputWorldGeometry( geometry );
   }
   m_TimeNavigationController->Update();
 
   this->RequestUpdate( renderWindow );
 
   vtkObject::SetGlobalWarningDisplay( warningLevel );
 
   return boundingBoxInitialized;
 }
 
 
 bool RenderingManager::InitializeView( vtkRenderWindow * renderWindow )
 {
   mitk::BaseRenderer *baseRenderer =
       mitk::BaseRenderer::GetInstance( renderWindow );
 
   mitk::SliceNavigationController *nc =
     baseRenderer->GetSliceNavigationController();
 
   // Re-initialize view direction
   nc->SetViewDirectionToDefault();
 
   // Update the SNC
   nc->Update();
 
   this->RequestUpdate( renderWindow );
 
   return true;
 }
 
 
 void RenderingManager::InternalViewInitialization(mitk::BaseRenderer *baseRenderer, const mitk::Geometry3D *geometry, bool boundingBoxInitialized, int mapperID )
 {
   mitk::SliceNavigationController *nc = baseRenderer->GetSliceNavigationController();
 
   // Re-initialize view direction
   nc->SetViewDirectionToDefault();
 
   if ( boundingBoxInitialized )
   {
     // Set geometry for NC
     nc->SetInputWorldGeometry( geometry );
     nc->Update();
 
     if ( mapperID == 1 )
     {
       // For 2D SNCs, steppers are set so that the cross is centered
       // in the image
       nc->GetSlice()->SetPos( nc->GetSlice()->GetSteps() / 2 );
     }
 
     // Fit the render window DisplayGeometry
     baseRenderer->GetDisplayGeometry()->Fit();
     baseRenderer->GetCameraController()->SetViewToAnterior();
   }
   else
   {
     nc->Update();
   }
 }
 
 
 const SliceNavigationController* RenderingManager::GetTimeNavigationController() const
 {
   return m_TimeNavigationController.GetPointer();
 }
 
 
 SliceNavigationController* RenderingManager::GetTimeNavigationController()
 {
   return m_TimeNavigationController.GetPointer();
 }
 
 
 void RenderingManager::ExecutePendingRequests()
 {
   m_UpdatePending = false;
 
   // Satisfy all pending update requests
   RenderWindowList::iterator it;
   int i = 0;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it, ++i )
   {
     if ( it->second == RENDERING_REQUESTED )
     {
       this->ForceImmediateUpdate( it->first );
     }
   }
 }
 
 
 void RenderingManager::RenderingStartCallback( vtkObject *caller, unsigned long , void *, void * )
 {
   vtkRenderWindow *renderWindow  = dynamic_cast< vtkRenderWindow * >( caller );
   mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
   RenderWindowList &renderWindowList = renman->m_RenderWindowList;
 
   if ( renderWindow )
   {
     renderWindowList[renderWindow] = RENDERING_INPROGRESS;
   }
 
   renman->m_UpdatePending = false;
 }
 
 
 void
 RenderingManager
 ::RenderingProgressCallback( vtkObject *caller, unsigned long , void *, void * )
 {
   vtkRenderWindow *renderWindow  = dynamic_cast< vtkRenderWindow * >( caller );
   mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
 
   if ( renman->m_LODAbortMechanismEnabled )
   {
     vtkRenderWindow *renderWindow = dynamic_cast< vtkRenderWindow * >( caller );
     if ( renderWindow )
     {
       BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow );
       if ( renderer && (renderer->GetNumberOfVisibleLODEnabledMappers() > 0) )
       {
         renman->DoMonitorRendering();
       }
     }
   }
 }
 
 void
 RenderingManager
 ::RenderingEndCallback( vtkObject *caller, unsigned long , void *, void * )
 {
   vtkRenderWindow *renderWindow  = dynamic_cast< vtkRenderWindow * >( caller );
 
   mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
 
   RenderWindowList &renderWindowList = renman->m_RenderWindowList;
 
   RendererIntMap &nextLODMap = renman->m_NextLODMap;
 
   if ( renderWindow )
   {
     BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow );
     if ( renderer )
     {
       renderWindowList[renderer->GetRenderWindow()] = RENDERING_INACTIVE;
 
       // Level-of-Detail handling
       if ( renderer->GetNumberOfVisibleLODEnabledMappers() > 0 )
       {
         if(nextLODMap[renderer]==0)
           renman->StartOrResetTimer();
         else
           nextLODMap[renderer] = 0;
       }
     }
   }
 }
 
 
 bool
 RenderingManager
 ::IsRendering() const
 {
   RenderWindowList::const_iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     if ( it->second == RENDERING_INPROGRESS )
     {
       return true;
     }
   }
   return false;
 }
 
 
 void
 RenderingManager
 ::AbortRendering()
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     if ( it->second == RENDERING_INPROGRESS )
     {
       it->first->SetAbortRender( true );
       m_RenderingAbortedMap[BaseRenderer::GetInstance(it->first)] = true;
     }
   }
 }
 
 
 int
 RenderingManager
 ::GetNextLOD( BaseRenderer *renderer )
 {
   if ( renderer != NULL )
   {
     return m_NextLODMap[renderer];
   }
   else
   {
     return 0;
   }
 }
 
 
 void
 RenderingManager
 ::ExecutePendingHighResRenderingRequest()
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     BaseRenderer *renderer = BaseRenderer::GetInstance( it->first );
 
     if(renderer->GetNumberOfVisibleLODEnabledMappers()>0)
     {
       if(m_NextLODMap[renderer]==0)
       {
         m_NextLODMap[renderer]=1;
         RequestUpdate( it->first );
       }
     }
   }
 }
 
 void
 RenderingManager
 ::SetMaximumLOD( unsigned int max )
 {
   m_MaxLOD = max;
 }
 
 
 //enable/disable shading
 void
 RenderingManager
 ::SetShading(bool state, unsigned int lod)
 {
   if(lod>m_MaxLOD)
   {
     itkWarningMacro(<<"LOD out of range requested: " << lod << " maxLOD: " << m_MaxLOD);
     return;
   }
   m_ShadingEnabled[lod] = state;
 
 }
 
 bool
 RenderingManager
 ::GetShading(unsigned int lod)
 {
   if(lod>m_MaxLOD)
   {
     itkWarningMacro(<<"LOD out of range requested: " << lod << " maxLOD: " << m_MaxLOD);
     return false;
   }
   return m_ShadingEnabled[lod];
 }
 
 
 //enable/disable the clipping plane
 void
 RenderingManager
 ::SetClippingPlaneStatus(bool status)
 {
   m_ClippingPlaneEnabled = status;
 }
 
 
 bool
 RenderingManager
 ::GetClippingPlaneStatus()
 {
   return m_ClippingPlaneEnabled;
 }
 
 
 void
 RenderingManager
 ::SetShadingValues(float ambient, float diffuse, float specular, float specpower)
 {
   m_ShadingValues[0] = ambient;
   m_ShadingValues[1] = diffuse;
   m_ShadingValues[2] = specular;
   m_ShadingValues[3] = specpower;
 }
 
 
 RenderingManager::FloatVector &
 RenderingManager
 ::GetShadingValues()
 {
   return m_ShadingValues;
 }
 
 void RenderingManager::SetDepthPeelingEnabled( bool enabled )
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance( it->first );
     baseRenderer->SetDepthPeelingEnabled(enabled);
   }
 }
 
 void RenderingManager::SetMaxNumberOfPeels( int maxNumber )
 {
   RenderWindowList::iterator it;
   for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
   {
     mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance( it->first );
     baseRenderer->SetMaxNumberOfPeels(maxNumber);
   }
 }
 
 void RenderingManager::InitializePropertyList()
 {
   if (m_PropertyList.IsNull())
   {
     m_PropertyList = PropertyList::New();
   }
 
   this->SetProperty("coupled-zoom", BoolProperty::New(false));
   this->SetProperty("coupled-plane-rotation", BoolProperty::New(false));
   this->SetProperty("MIP-slice-rendering", BoolProperty::New(false));
 }
 
 PropertyList::Pointer RenderingManager::GetPropertyList() const
 {
   return m_PropertyList;
 }
 
 BaseProperty* RenderingManager::GetProperty(const char *propertyKey) const
 {
   return m_PropertyList->GetProperty(propertyKey);
 }
 
 void RenderingManager::SetProperty(const char *propertyKey, BaseProperty* propertyValue)
 {
   m_PropertyList->SetProperty(propertyKey, propertyValue);
 }
 
 
 void RenderingManager::SetDataStorage( DataStorage* storage )
 {
   if ( storage != NULL )
   {
     m_DataStorage = storage;
 
     RenderingManager::RenderWindowVector::iterator iter;
     for ( iter = m_AllRenderWindows.begin(); iter<m_AllRenderWindows.end(); iter++ )
     {
       mitk::BaseRenderer::GetInstance( (*iter) )->SetDataStorage( m_DataStorage.GetPointer() );
     }
   }
 }
 
 mitk::DataStorage* RenderingManager::GetDataStorage()
 {
   return m_DataStorage;
 }
 
 
 void RenderingManager::SetGlobalInteraction( mitk::GlobalInteraction* globalInteraction )
 {
   if ( globalInteraction != NULL )
   {
     m_GlobalInteraction = globalInteraction;
   }
 }
 
 mitk::GlobalInteraction* RenderingManager::GetGlobalInteraction()
 {
   return m_GlobalInteraction;
 }
 
 // Create and register generic RenderingManagerFactory.
 TestingRenderingManagerFactory renderingManagerFactory;
 
 
 } // namespace
diff --git a/Core/Code/DataManagement/mitkDataNodeFactory.cpp b/Core/Code/DataManagement/mitkDataNodeFactory.cpp
index aefff0c901..6665197e52 100644
--- a/Core/Code/DataManagement/mitkDataNodeFactory.cpp
+++ b/Core/Code/DataManagement/mitkDataNodeFactory.cpp
@@ -1,490 +1,489 @@
 /*===================================================================
 
 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 <mitkConfig.h>
 #include <mitkDataNodeFactory.h>
 #include <mitkBaseDataIOFactory.h>
 #include <mitkCoreObjectFactory.h>
 #include <mitkITKImageImport.h>
 
 // C-Standard library includes
 #include <stdlib.h>
 #include <locale.h>
 
 // STL-related includes
 #include <vector>
 #include <map>
 #include <istream>
 #include <cstdlib>
 #include <locale>
 
 
 // VTK-related includes
 #include <vtkSTLReader.h>
 #include <vtkOBJReader.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataNormals.h>
 
 #include <vtkDataReader.h>
 #include <vtkPolyDataReader.h>
 #include <vtkStructuredPointsReader.h>
 
 #include <vtkStructuredPoints.h>
 #include <vtkLookupTable.h>
 #include <vtkPointData.h>
 #include <vtkXMLImageDataReader.h>
 
 // ITK-related includes
 
 #include <itksys/SystemTools.hxx>
 #include <itksys/Directory.hxx>
 #include <itkImage.h>
 #include <itkImageSeriesReader.h>
 #include <itkImageFileReader.h>
 #include <itkImageIOFactory.h>
 #include <itkImageIORegion.h>
 #include <itkImageSeriesReader.h>
 #include <itkGDCMImageIO.h>
 
 #ifdef NOMINMAX
 #  define DEF_NOMINMAX
 #  undef NOMINMAX
 #endif
 
 #include <itkGDCMSeriesFileNames.h>
 
 #ifdef DEF_NOMINMAX
 #  ifndef NOMINMAX
 #    define NOMINMAX
 #  endif
 #  undef DEF_NOMINMAX
 #endif
 
 #include <itkNumericSeriesFileNames.h>
 #include <itkCommand.h>
 
 // MITK-related includes
 #include "mitkSurface.h"
 #include "mitkPointSet.h"
 #include "mitkStringProperty.h"
 #include "mitkProperties.h"
 //#include "mitkMaterialProperty.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkVtkRepresentationProperty.h"
 #include "mitkVtkInterpolationProperty.h"
 #include "mitkVtkScalarModeProperty.h"
 #include "mitkImage.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkImageChannelSelector.h"
 #include "mitkImageSliceSelector.h"
 #include "mitkCoreObjectFactory.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 #include "mitkProgressBar.h"
 #include <mitkDicomSeriesReader.h>
 
 bool mitk::DataNodeFactory::m_TextureInterpolationActive = false;    // default value for texture interpolation if nothing is defined in global options (see QmitkMainTemplate.ui.h)
 
 mitk::DataNodeFactory::DataNodeFactory()
 {
   m_Serie = false;
   m_OldProgress = 0;
   this->Modified();
   //ensure that a CoreObjectFactory has been instantiated
   mitk::CoreObjectFactory::GetInstance();
 }
 
 mitk::DataNodeFactory::~DataNodeFactory()
 {}
 
 void mitk::DataNodeFactory::SetImageSerie(bool serie)
 {
   m_Serie = serie;
 }
 
 void mitk::DataNodeFactory::GenerateData()
 {
   // IF filename is something.pic, and something.pic does not exist, try to read something.pic.gz
   // if there are both, something.pic and something.pic.gz, only the requested file is read
   // not only for images, but for all formats
   std::ifstream exists(m_FileName.c_str());
   if (!exists)
   {
     std::string testfilename = m_FileName + ".gz";
 
     std::ifstream exists(testfilename.c_str());
     if (exists.good())
     {
       m_FileName += ".gz";
     }
     else
     {
       testfilename = m_FileName + ".GZ";
       std::ifstream exists(testfilename.c_str());
       if (exists.good())
       {
         m_FileName += ".GZ";
       }
       else
       {
         std::string message("File does not exist, or cannot be read. Filename = ");
         message += m_FileName;
         MITK_ERROR << message;
         itkExceptionMacro( << message );
       }
     }
   }
 
   // part for DICOM
 //  const char *numbers = "0123456789.";
 //  std::string::size_type first_non_number;
 //  first_non_number = itksys::SystemTools::GetFilenameName(m_FileName).find_first_not_of ( numbers );
 
   if (DicomSeriesReader::IsDicom(this->m_FileName) /*|| first_non_number == std::string::npos*/)
   {
     this->ReadFileSeriesTypeDCM();
   }
   else
   {
     bool usedNewDTNF = false;
 
     // the mitkBaseDataIO class returns a pointer of a vector of BaseData objects
     std::vector<mitk::BaseData::Pointer> baseDataVector = mitk::BaseDataIO::LoadBaseDataFromFile( m_FileName, m_FilePrefix, m_FilePattern, m_Serie );
 
     if( !baseDataVector.empty() )
       this->ResizeOutputs((unsigned int)baseDataVector.size());
 
     for(int i=0; i<(int)baseDataVector.size(); i++)
     {
       mitk::BaseData::Pointer baseData = baseDataVector.at(i);
 
       if( baseData.IsNotNull() )
       {
         usedNewDTNF = true;
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData(baseData);
         this->SetDefaultCommonProperties( node );
 
         this->SetOutput(this->MakeNameFromOutputIndex(i), node);
       }
     }
     if(!usedNewDTNF && ( m_FileName != "" ) && !(m_Serie == false))
         ReadFileSeriesTypeITKImageSeriesReader();
   }
 }
 
 void mitk::DataNodeFactory::ResizeOutputs( const unsigned int& num )
 {
   unsigned int prevNum = this->GetNumberOfOutputs();
   this->SetNumberOfIndexedOutputs( num );
   for ( unsigned int i = prevNum; i < num; ++i )
   {
     this->SetNthOutput( i, this->MakeOutput( i ).GetPointer() );
   }
 }
 
 bool mitk::DataNodeFactory::FileNameEndsWith( const std::string& name )
 {
   if (m_FileName.size() < name.size()) return false;
 
   return m_FileName.substr(m_FileName.size() - name.size()) == name;
 }
 
 bool mitk::DataNodeFactory::FilePatternEndsWith( const std::string& name )
 {
   return m_FilePattern.find( name ) != std::string::npos;
 }
 
 std::string mitk::DataNodeFactory::GetBaseFileName()
 {
   return itksys::SystemTools::GetFilenameName( m_FileName );
 }
 
 std::string mitk::DataNodeFactory::GetBaseFilePrefix()
 {
   return itksys::SystemTools::GetFilenameName( m_FilePrefix );
 }
 
 std::string mitk::DataNodeFactory::GetDirectory()
 {
   if ( !m_FileName.empty() )   return itksys::SystemTools::GetFilenamePath( m_FileName );
   if ( !m_FilePrefix.empty() ) return itksys::SystemTools::GetFilenamePath( m_FilePrefix );
 
   return std::string();
 }
 
 void mitk::DataNodeFactory::ReadFileSeriesTypeDCM()
 {
   const char* previousCLocale = setlocale(LC_NUMERIC, NULL);
   setlocale(LC_NUMERIC, "C");
   std::locale previousCppLocale( std::cin.getloc() );
   std::locale l( "C" );
   std::cin.imbue(l);
 
   if (  DicomSeriesReader::IsPhilips3DDicom(this->GetFileName()) )
   {
     MITK_INFO << "it is a Philips3D US Dicom file" << std::endl;
     this->ResizeOutputs(1);
     DataNode::Pointer node = this->GetOutput();
     mitk::DicomSeriesReader::StringContainer stringvec;
     stringvec.push_back(this->GetFileName());
     if (DicomSeriesReader::LoadDicomSeries(stringvec, *node))
     {
       node->SetName(this->GetBaseFileName());
     }
     setlocale(LC_NUMERIC, previousCLocale);
     std::cin.imbue(previousCppLocale);
     return;
 
   }
 
   DicomSeriesReader::FileNamesGrouping imageBlocks = DicomSeriesReader::GetSeries(this->GetDirectory(), true, this->m_SeriesRestrictions); // true = group gantry tilt images
   const unsigned int size = imageBlocks.size();
 
   this->ResizeOutputs(size);
   ProgressBar::GetInstance()->AddStepsToDo(size);
   ProgressBar::GetInstance()->Progress();
 
   unsigned int outputIndex = 0u;
   const DicomSeriesReader::FileNamesGrouping::const_iterator n_end = imageBlocks.end();
 
   for (DicomSeriesReader::FileNamesGrouping::const_iterator n_it = imageBlocks.begin(); n_it != n_end; ++n_it)
   {
     const std::string &uid = n_it->first;
     DataNode::Pointer node = this->GetOutput(outputIndex);
 
     const DicomSeriesReader::ImageBlockDescriptor& imageBlockDescriptor( n_it->second );
 
     MITK_INFO << "--------------------------------------------------------------------------------";
     MITK_INFO << "DataNodeFactory: Loading DICOM series " << outputIndex << ": Series UID " << imageBlockDescriptor.GetSeriesInstanceUID() << std::endl;
     MITK_INFO << "  " << imageBlockDescriptor.GetFilenames().size() << " '" << imageBlockDescriptor.GetModality() << "' files (" << imageBlockDescriptor.GetSOPClassUIDAsString() << ") loaded into 1 mitk::Image";
     MITK_INFO << "  multi-frame: " << (imageBlockDescriptor.IsMultiFrameImage()?"Yes":"No");
     MITK_INFO << "  reader support: " << DicomSeriesReader::ReaderImplementationLevelToString(imageBlockDescriptor.GetReaderImplementationLevel());
     MITK_INFO << "  pixel spacing type: " << DicomSeriesReader::PixelSpacingInterpretationToString( imageBlockDescriptor.GetPixelSpacingType() );
     MITK_INFO << "  gantry tilt corrected: " << (imageBlockDescriptor.HasGantryTiltCorrected()?"Yes":"No");
     MITK_INFO << "  3D+t: " << (imageBlockDescriptor.HasMultipleTimePoints()?"Yes":"No");
     MITK_INFO << "--------------------------------------------------------------------------------";
 
     if (DicomSeriesReader::LoadDicomSeries(n_it->second.GetFilenames(), *node, true, true, true))
     {
       std::string nodeName(uid);
       std::string studyDescription;
       if ( node->GetStringProperty( "dicom.study.StudyDescription", studyDescription ) )
       {
         nodeName = studyDescription;
         std::string seriesDescription;
         if ( node->GetStringProperty( "dicom.series.SeriesDescription", seriesDescription ) )
         {
           nodeName += "/" + seriesDescription;
         }
       }
 
       node->SetName(nodeName);
 
       ++outputIndex;
     }
     else
     {
       MITK_ERROR << "DataNodeFactory: Skipping series " << outputIndex << " due to some unspecified error..." << std::endl;
     }
 
     ProgressBar::GetInstance()->Progress();
   }
 
   setlocale(LC_NUMERIC, previousCLocale);
   std::cin.imbue(previousCppLocale);
 }
 
 
 
 void mitk::DataNodeFactory::ReadFileSeriesTypeITKImageSeriesReader()
 {
   typedef itk::Image<int, 3> ImageType;
   typedef itk::ImageSeriesReader< ImageType > ReaderType;
-  typedef itk::NumericSeriesFileNames NameGenerator;
 
   if ( ! this->GenerateFileList() )
   {
     itkWarningMacro( "Sorry, file list could not be generated!" );
     return ;
   }
   if ( m_MatchedFileNames.size() == 0 )
   {
     itkWarningMacro( "Sorry, no files matched the given filename ("<< m_FileName <<")!" );
     return ;
   }
 
   //
   // Finally, initialize the ITK-reader and load the files!
   //
   ReaderType::Pointer reader = ReaderType::New();
   reader->SetFileNames( m_MatchedFileNames );
   try
   {
     reader->Update();
     ResizeOutputs( reader->GetNumberOfOutputs() );
     for ( unsigned int i = 0; i < reader->GetNumberOfOutputs(); ++i )
     {
       //Initialize mitk image from itk
       mitk::Image::Pointer image = mitk::Image::New();
       image->InitializeByItk( reader->GetOutput( i ) );
       image->SetVolume( reader->GetOutput( i )->GetBufferPointer() );
 
       //add the mitk image to the node
       mitk::DataNode::Pointer node = this->GetOutput( i );
       node->SetData( image );
 
       mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New( m_FileName );
       node->SetProperty( "name", nameProp );
     }
   }
   catch ( const std::exception & e )
   {
     itkWarningMacro( << e.what() );
     return ;
   }
 }
 
 
 
 mitk::ColorProperty::Pointer mitk::DataNodeFactory::DefaultColorForOrgan( const std::string& organ )
 {
   static bool initialized = false;
   static std::map< std::string, std::string > s_ColorMap;
 
   if (!initialized)
   {
     // all lowercase here, please!
 
     s_ColorMap.insert( std::make_pair( "ankle",               "0xe38686") );
     s_ColorMap.insert( std::make_pair( "appendix",            "0xe38686") );
     s_ColorMap.insert( std::make_pair( "blood vessels",       "0xff3131") );
     s_ColorMap.insert( std::make_pair( "bronchial tree",      "0x3168ff") );
     s_ColorMap.insert( std::make_pair( "bone",                "0xd5d5d5") );
     s_ColorMap.insert( std::make_pair( "brain",               "0xff9cca") );
     s_ColorMap.insert( std::make_pair( "coccyx",              "0xe38686") );
     s_ColorMap.insert( std::make_pair( "colon",               "0xe38686") );
     s_ColorMap.insert( std::make_pair( "cyst",                "0xe38686") );
     s_ColorMap.insert( std::make_pair( "elbow",               "0xe38686") );
     s_ColorMap.insert( std::make_pair( "eye",                 "0xe38686") );
     s_ColorMap.insert( std::make_pair( "fallopian tube",      "0xe38686") );
     s_ColorMap.insert( std::make_pair( "fat",                 "0xff2bee") );
     s_ColorMap.insert( std::make_pair( "hand",                "0xe38686") );
     s_ColorMap.insert( std::make_pair( "gall bladder",        "0x567f18") );
     s_ColorMap.insert( std::make_pair( "heart",               "0xeb1d32") );
     s_ColorMap.insert( std::make_pair( "hip",                 "0xe38686") );
     s_ColorMap.insert( std::make_pair( "kidney",              "0xd33f00") );
     s_ColorMap.insert( std::make_pair( "knee",                "0xe38686") );
     s_ColorMap.insert( std::make_pair( "larynx",              "0xe38686") );
     s_ColorMap.insert( std::make_pair( "liver",               "0xffcc3d") );
     s_ColorMap.insert( std::make_pair( "lung",                "0x6bdcff") );
     s_ColorMap.insert( std::make_pair( "lymph node",          "0xff0000") );
     s_ColorMap.insert( std::make_pair( "muscle",              "0xff456a") );
     s_ColorMap.insert( std::make_pair( "nerve",               "0xffea4f") );
     s_ColorMap.insert( std::make_pair( "nose",                "0xe38686") );
     s_ColorMap.insert( std::make_pair( "oesophagus",          "0xe38686") );
     s_ColorMap.insert( std::make_pair( "ovaries",             "0xe38686") );
     s_ColorMap.insert( std::make_pair( "pancreas",            "0xf9ab3d") );
     s_ColorMap.insert( std::make_pair( "pelvis",              "0xe38686") );
     s_ColorMap.insert( std::make_pair( "penis",               "0xe38686") );
     s_ColorMap.insert( std::make_pair( "pharynx",             "0xe38686") );
     s_ColorMap.insert( std::make_pair( "prostate",            "0xe38686") );
     s_ColorMap.insert( std::make_pair( "rectum",              "0xe38686") );
     s_ColorMap.insert( std::make_pair( "sacrum",              "0xe38686") );
     s_ColorMap.insert( std::make_pair( "seminal vesicle",     "0xe38686") );
     s_ColorMap.insert( std::make_pair( "shoulder",            "0xe38686") );
     s_ColorMap.insert( std::make_pair( "spinal cord",         "0xf5f93d") );
     s_ColorMap.insert( std::make_pair( "spleen",              "0xf96c3d") );
     s_ColorMap.insert( std::make_pair( "stomach",             "0xf96c3d") );
     s_ColorMap.insert( std::make_pair( "teeth",               "0xfffcd8") );
     s_ColorMap.insert( std::make_pair( "testicles",           "0xe38686") );
     s_ColorMap.insert( std::make_pair( "thyroid",             "0xfff694") );
     s_ColorMap.insert( std::make_pair( "tongue",              "0xe38686") );
     s_ColorMap.insert( std::make_pair( "tumor",               "0x937011") );
     s_ColorMap.insert( std::make_pair( "urethra",             "0xf8ff32") );
     s_ColorMap.insert( std::make_pair( "urinary bladder",     "0xf8ff32") );
     s_ColorMap.insert( std::make_pair( "uterus",              "0xe38686") );
     s_ColorMap.insert( std::make_pair( "vagina",              "0xe38686") );
     s_ColorMap.insert( std::make_pair( "vertebra",            "0xe38686") );
     s_ColorMap.insert( std::make_pair( "wrist",               "0xe38686") );
     initialized = true;
   }
 
   std::string lowercaseOrgan(organ);
   for(unsigned int i = 0; i < organ.length(); i++)
   {
     lowercaseOrgan[i] = tolower(lowercaseOrgan[i]);
   }
 
   std::map< std::string, std::string >::iterator iter = s_ColorMap.find( lowercaseOrgan );
   if ( iter != s_ColorMap.end() )
   {
     std::string hexColor = iter->second;
     std::string hexRed   = std::string("0x") + hexColor.substr( 2, 2 );
     std::string hexGreen = std::string("0x") + hexColor.substr( 4, 2 );
     std::string hexBlue  = std::string("0x") + hexColor.substr( 6, 2 );
 
     long int red   = strtol( hexRed.c_str(), NULL, 16 );
     long int green = strtol( hexGreen.c_str(), NULL, 16 );
     long int blue  = strtol( hexBlue.c_str(), NULL, 16 );
 
     return ColorProperty::New( (float)red/ 255.0, (float)green/ 255.0, (float)blue/ 255.0 );
   }
   else
   {
     // a default color (green)
     return ColorProperty::New( 0.0, 1.0, 0.0 );
   }
 
 }
 
 void mitk::DataNodeFactory::SetDefaultCommonProperties(mitk::DataNode::Pointer &node)
 {
   // path
   mitk::StringProperty::Pointer pathProp = mitk::StringProperty::New( itksys::SystemTools::GetFilenamePath( m_FileName ) );
   node->SetProperty( StringProperty::PATH, pathProp );
 
 
   // name already defined?
   mitk::StringProperty::Pointer nameProp = dynamic_cast<mitk::StringProperty*>(node->GetProperty("name"));
   if(nameProp.IsNull() || (strcmp(nameProp->GetValue(),"No Name!")==0))
   {
     // name already defined in BaseData
     mitk::StringProperty::Pointer baseDataNameProp = dynamic_cast<mitk::StringProperty*>(node->GetData()->GetProperty("name").GetPointer() );
     if(baseDataNameProp.IsNull() || (strcmp(baseDataNameProp->GetValue(),"No Name!")==0))
     {
       // name neither defined in node, nor in BaseData -> name = filename
       if (FileNameEndsWith( ".gz" ))
         m_FileName = m_FileName.substr( 0, m_FileName.length()-3 );
 
       nameProp = mitk::StringProperty::New( itksys::SystemTools::GetFilenameWithoutLastExtension( m_FileName ) );
 
       node->SetProperty( "name", nameProp );
     }
     else
     {
       // name defined in BaseData!
       nameProp = mitk::StringProperty::New( baseDataNameProp->GetValue() );
       node->SetProperty( "name", nameProp );
     }
   }
 
   // visibility
   if(!node->GetProperty("visible"))
     node->SetVisibility(true);
 }
 
diff --git a/Core/Code/IO/mitkPixelType.h b/Core/Code/IO/mitkPixelType.h
index fb50a3feb8..e82d3bd08c 100644
--- a/Core/Code/IO/mitkPixelType.h
+++ b/Core/Code/IO/mitkPixelType.h
@@ -1,233 +1,231 @@
 /*===================================================================
 
 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 PIXELTYPE_H_HEADER_INCLUDED_C1EBF565
 #define PIXELTYPE_H_HEADER_INCLUDED_C1EBF565
 
 #include <MitkExports.h>
 #include "mitkCommon.h"
 #include "mitkPixelTypeTraits.h"
 
 #include <typeinfo>
 #include <string>
 
 #include <itkImageIOBase.h>
 #include <itkImage.h>
 
 namespace mitk {
 
 template<typename T>
 std::string PixelComponentTypeToString()
 {
   return itk::ImageIOBase::GetComponentTypeAsString(itk::ImageIOBase::MapPixelType<T>::CType);
 }
 
 template<typename PixelT>
 std::string PixelTypeToString()
 {
   return std::string();
 }
 
 
 //##Documentation
 //## @brief Class for defining the data type of pixels
 //##
 //## To obtain additional type information not provided by this class
 //## itk::ImageIOBase can be used by passing the return value of
 //## PixelType::GetItkTypeId() to itk::ImageIOBase::SetPixelTypeInfo
 //## and using the itk::ImageIOBase methods GetComponentType,
 //## GetComponentTypeAsString, GetPixelType, GetPixelTypeAsString.
 //## @ingroup Data
 class MITK_CORE_EXPORT PixelType
 {
 public:
 
   typedef itk::ImageIOBase::IOPixelType ItkIOPixelType;
   typedef itk::ImageIOBase::IOComponentType ItkIOComponentType;
 
   PixelType(const mitk::PixelType & aPixelType);
 
   itk::ImageIOBase::IOPixelType GetPixelType() const;
 
   /**
    * \brief Get the \a component type (the scalar (!) type). Each element
    * may contain m_NumberOfComponents (more than one) of these scalars.
    *
    */
   int GetComponentType() const;
 
   /**
    * \brief Returns a string containing the ITK pixel type name.
    */
   std::string GetPixelTypeAsString() const;
 
   /**
    * \brief Returns a string containing the name of the component.
    */
   std::string GetComponentTypeAsString() const;
 
   /**
    * \brief Returns a string representing the pixel type and pixel components.
    */
   std::string GetTypeAsString() const;
 
   /**
    * \brief Get size of the PixelType in bytes
    *
    * A RGBA PixelType of floats will return 4 * sizeof(float)
    */
   size_t GetSize() const;
 
   /**
    * \brief Get the number of bits per element (of an
    * element)
    *
    * A vector of double with three components will return
    * 8*sizeof(double)*3.
    * \sa GetBitsPerComponent
    * \sa GetItkTypeId
    * \sa GetTypeId
    */
   size_t GetBpe() const;
 
   /**
    * \brief Get the number of components of which each element consists
    *
    * Each pixel can consist of multiple components, e.g. RGB.
    */
   size_t GetNumberOfComponents() const;
 
   /**
    * \brief Get the number of bits per components
    * \sa GetBitsPerComponent
    */
   size_t GetBitsPerComponent() const;
 
   bool operator==(const PixelType& rhs) const;
   bool operator!=(const PixelType& rhs) const;
 
   ~PixelType();
 
 private:
 
   friend PixelType MakePixelType(const itk::ImageIOBase* imageIO);
 
   template< typename ComponentT, typename PixelT, std::size_t numberOfComponents >
     friend PixelType MakePixelType();
 
   template< typename ItkImageType >
     friend PixelType MakePixelType();
 
   PixelType( const int componentType,
              const ItkIOPixelType pixelType,
              std::size_t bytesPerComponent,
              std::size_t numberOfComponents,
              const std::string& componentTypeName,
              const std::string& pixelTypeName);
 
   // default constructor is disabled on purpose
   PixelType(void);
 
   // assignment operator declared private on purpose
   PixelType& operator=(const PixelType& other);
 
   /** \brief the \a type_info of the scalar (!) component type. Each element
     may contain m_NumberOfComponents (more than one) of these scalars.
   */
   const int m_ComponentType;
 
   const ItkIOPixelType m_PixelType;
 
   const std::string m_ComponentTypeName;
 
   const std::string m_PixelTypeName;
 
   std::size_t m_NumberOfComponents;
 
   std::size_t m_BytesPerComponent;
 
 };
 
 /** \brief A template method for creating a pixel type.
   */
 template< typename ComponentT, typename PixelT, std::size_t numOfComponents >
 PixelType MakePixelType()
 {
-  typedef itk::Image< PixelT, numOfComponents> ItkImageType;
-
   return PixelType( MapPixelType<PixelT, isPrimitiveType<PixelT>::value >::IOComponentType,
                     MapPixelType<PixelT, isPrimitiveType<PixelT>::value >::IOPixelType,
                     sizeof(ComponentT), numOfComponents,
                     PixelComponentTypeToString<ComponentT>(),
                     PixelTypeToString<PixelT>()
                    );
 }
 
 /** \brief A template method for creating a pixel type from an ItkImageType
   *
   * For fixed size vector images ( i.e. images of type itk::FixedArray<3,float> ) also the number of components
   * is propagated to the constructor
   */
 template< typename ItkImageType >
 PixelType MakePixelType()
 {
   // define new type, since the ::PixelType is used to distinguish between simple and compound types
   typedef typename ItkImageType::PixelType ImportPixelType;
 
   // get the component type ( is either directly ImportPixelType or ImportPixelType::ValueType for compound types )
   typedef typename GetComponentType<ImportPixelType>::ComponentType ComponentT;
 
   // The PixelType is the same as the ComponentT for simple types
   typedef typename ItkImageType::PixelType PixelT;
 
   // Get the length of compound type ( initialized to 1 for simple types and variable-length vector images)
   size_t numComp = ComponentsTrait<
     (isPrimitiveType<PixelT>::value || isVectorImage<PixelT, ComponentT>::value), ItkImageType >::Size;
 
   // call the constructor
   return PixelType(
             MapPixelType<PixelT, isPrimitiveType<PixelT>::value >::IOComponentType,
             MapPixelType<PixelT, isPrimitiveType<PixelT>::value >::IOPixelType,
             sizeof(ComponentT), numComp,
             PixelComponentTypeToString<ComponentT>(),
             PixelTypeToString<PixelT>()
          );
 }
 
 inline PixelType MakePixelType(const itk::ImageIOBase* imageIO)
 {
   return mitk::PixelType(imageIO->GetComponentType(), imageIO->GetPixelType(),
                          imageIO->GetComponentSize(), imageIO->GetNumberOfComponents(),
                          imageIO->GetComponentTypeAsString(imageIO->GetComponentType()),
                          imageIO->GetPixelTypeAsString(imageIO->GetPixelType()));
 }
 
 /** \brief An interface to the MakePixelType method for creating scalar pixel types.
   *
   * Usage: for example MakeScalarPixelType<short>() for a scalar short image
   */
 template< typename T>
 PixelType MakeScalarPixelType()
 {
     return MakePixelType<T,T,1>();
 }
 
 } // namespace mitk
 
 
 
 #endif /* PIXELTYPE_H_HEADER_INCLUDED_C1EBF565 */