diff --git a/Modules/Core/src/Rendering/mitkManufacturerLogo.cpp b/Modules/Core/src/Rendering/mitkManufacturerLogo.cpp
index 8f76cf2b22..bf1ab0d228 100644
--- a/Modules/Core/src/Rendering/mitkManufacturerLogo.cpp
+++ b/Modules/Core/src/Rendering/mitkManufacturerLogo.cpp
@@ -1,380 +1,380 @@
 /*===================================================================
 
 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 "mitkManufacturerLogo.h"
 
 #include "mitkVtkLayerController.h"
 
 #include <mitkStandardFileLocations.h>
 #include <mitkConfig.h>
 #include <itkObject.h>
 #include <itkMacro.h>
 #include <itksys/SystemTools.hxx>
 
 #include <vtkImageImport.h>
 #include <vtkRenderer.h>
 #include <vtkRenderWindow.h>
 #include <vtkMapper.h>
 #include <vtkImageActor.h>
 #include <vtkImageMapper.h>
 #include <vtkPolyData.h>
 #include <vtkCamera.h>
 #include <vtkObjectFactory.h>
 #include <vtkRendererCollection.h>
 #include <vtkPNGReader.h>
 #include <vtkImageData.h>
 #include <vtkConfigure.h>
 #include <vtkImageFlip.h>
 
 #include <mbilogo.h>
 
 #include <algorithm>
 
 
 mitk::ManufacturerLogo::ManufacturerLogo()
 :m_ImageData(NULL)
 {
   m_RenderWindow      = NULL;
   m_Renderer          = vtkRenderer::New();
   m_Actor             = vtkImageActor::New();
   m_Mapper            = vtkImageMapper::New();
   m_PngReader         = vtkPNGReader::New();
   m_VtkImageImport    = vtkImageImport::New();
 
   m_LogoPosition  = mitk::ManufacturerLogo::LowerRight;
 
   m_IsEnabled                  = false;
   m_ForceShowMBIDepartmentLogo = false;
 
   m_ZoomFactor = 1.15;
   m_Opacity    = 0.5;
 
   m_FileName  = "";
   m_PngReader->SetFileName(m_FileName.c_str());
 }
 
 mitk::ManufacturerLogo::~ManufacturerLogo()
 {
   if ( m_RenderWindow != NULL )
     if ( this->IsEnabled() )
       this->Disable();
 
   if ( m_Mapper != NULL )
     m_Mapper->Delete();
 
   if ( m_Actor!=NULL )
     m_Actor->Delete();
 
   if ( m_Renderer != NULL )
     m_Renderer->Delete();
 
   if ( m_PngReader != NULL )
     m_PngReader->Delete();
 
   if ( m_VtkImageImport != NULL )
     m_VtkImageImport->Delete();
 
   if ( m_ImageData != NULL)
     delete[] m_ImageData;
 }
 
 /**
  * Sets the renderwindow, in which the logo
  * will be shown. Make sure, you have called this function
  * before calling Enable()
  */
 void mitk::ManufacturerLogo::SetRenderWindow( vtkRenderWindow* renderWindow )
 {
   m_RenderWindow = renderWindow;
 }
 
 /**
  * Returns the vtkRenderWindow, which is used
  * for displaying the logo
  */
 vtkRenderWindow* mitk::ManufacturerLogo::GetRenderWindow()
 {
   return m_RenderWindow;
 }
 
 /**
  * Returns the renderer responsible for
  * rendering the  logo into the
  * vtkRenderWindow
  */
 vtkRenderer* mitk::ManufacturerLogo::GetVtkRenderer()
 {
   return m_Renderer;
 }
 
 /**
  * Returns the actor associated with the  logo
  */
 vtkImageActor* mitk::ManufacturerLogo::GetActor()
 {
   return m_Actor;
 }
 
 /**
  * Returns the mapper associated with the
  * logo.
  */
 vtkImageMapper* mitk::ManufacturerLogo::GetMapper()
 {
   return m_Mapper;
 }
 
 void mitk::ManufacturerLogo::SetLogoSource(const char* filename)
 {
   std::string file = filename;
   if(file.length() != 0)
   {
     m_FileName  = filename;
     m_PngReader->SetFileName(m_FileName.c_str());
   }
 }
 
 /**
  * Enables drawing of the logo.
  * If you want to disable it, call the Disable() function.
  */
 void mitk::ManufacturerLogo::Enable()
 {
   if(m_IsEnabled)
     return;
 
   if(m_RenderWindow != NULL)
   {
     if(itksys::SystemTools::FileExists(m_FileName.c_str()) && !m_ForceShowMBIDepartmentLogo)
     {
       m_PngReader->Update();
       m_Actor->SetInputData(m_PngReader->GetOutput());
     }
     else // either logo file not found or logo renderer is forced to show the MBI logo
     {
       m_VtkImageImport->SetDataScalarTypeToUnsignedChar();
       m_VtkImageImport->SetNumberOfScalarComponents(mbiLogo_NumberOfScalars);
       m_VtkImageImport->SetWholeExtent(0,mbiLogo_Width-1,0,mbiLogo_Height-1,0,1-1);
       m_VtkImageImport->SetDataExtentToWholeExtent();
 
       // flip mbi logo around y axis and change color order
       m_ImageData = new char[mbiLogo_Height*mbiLogo_Width*mbiLogo_NumberOfScalars];
 
       unsigned int column, row;
       char * dest   = m_ImageData;
       char * source = (char*) &mbiLogo_Data[0];;
       char r, g, b, a;
       for (column = 0; column < mbiLogo_Height; column++)
         for (row = 0; row < mbiLogo_Width; row++)
         {   //change r with b
             b = *source++;
             g = *source++;
             r = *source++;
             a = *source++;
 
             *dest++ = r;
             *dest++ = g;
             *dest++ = b;
             *dest++ = a;
           }
 
       m_VtkImageImport->SetImportVoidPointer(m_ImageData);
       m_VtkImageImport->Modified();
       m_VtkImageImport->Update();
 
       m_Actor->SetInputData(m_VtkImageImport->GetOutput());
     }
 
     m_Actor->SetOpacity(m_Opacity);
 
     m_Renderer->AddActor( m_Actor );
     m_Renderer->InteractiveOff();
 
     SetupCamera();
     SetupPosition();
 
     mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertForegroundRenderer(m_Renderer,false);
 
     m_IsEnabled = true;
   }
 }
 
 
 void mitk::ManufacturerLogo::SetupCamera()
 {
   // set the vtk camera in way that stretches the logo all over the renderwindow
 
   vtkImageData * image = m_Actor->GetInput();
   m_Camera = m_Renderer->GetActiveCamera();
   m_Camera->SetClippingRange(1,100000);
 
   if ( !image )
     return;
 
   double spacing[3];
   double origin[3];
   int   dimensions[3];
 
   image->GetSpacing(spacing);
   image->GetOrigin(origin);
   image->GetDimensions(dimensions);
 
   double focalPoint[3];
   double position[3];
 
   for ( unsigned int cc = 0; cc < 3; cc++)
   {
     focalPoint[cc] = origin[cc] + ( spacing[cc] * dimensions[cc] ) / 2.0;
     position[cc]   = focalPoint[cc];
   }
 
 
   m_Camera->SetViewUp (0,1,0);
   int idx = 2;
   const double distanceToFocalPoint = 1000;
   position[idx] = distanceToFocalPoint;
 
   m_Camera->ParallelProjectionOn();
   m_Camera->SetPosition (position);
   m_Camera->SetFocalPoint (focalPoint);
 
   int d1 = (idx + 1) % 3;
   int d2 = (idx + 2) % 3;
 
   double max = std::max(dimensions[d1],dimensions[d2]);
 
   m_Camera->SetParallelScale( max / 2 );
 }
 
 void mitk::ManufacturerLogo::SetupPosition()
 { // Position and Scale of the logo
 
   double newPos[4];
   int dimensions[3];
   vtkImageData * image = m_Actor->GetInput();
   image->GetDimensions(dimensions);
   // normalize image dimensions
   double max = std::max(dimensions[0],dimensions[1]);
   double normX = dimensions[0] / max;
   double normY = dimensions[1] / max;
 
   double buffer = 0; // buffer to the boarder of the renderwindow
 
   switch(m_LogoPosition)
   {
     case mitk::ManufacturerLogo::LowerLeft:
     {
       newPos[0] = (0 + buffer);
       newPos[1] = (0 + buffer);
       newPos[2] = 0.2 * normX * m_ZoomFactor;
       newPos[3] = 0.2 * normY * m_ZoomFactor;
       break;
     }
     case mitk::ManufacturerLogo::LowerRight:
     {
       newPos[0] = (1 - buffer) - 0.2 * normX * m_ZoomFactor;
       newPos[1] = 0.0;
       newPos[2] = (1 - buffer);
       newPos[3] = 0.2 * normY * m_ZoomFactor;
       break;
     }
     case mitk::ManufacturerLogo::UpperLeft:
     {
       newPos[0] = (0 + buffer);
       newPos[1] = (1 - buffer) - 0.2 * normY * m_ZoomFactor;
       newPos[2] = 0.2 * normX * m_ZoomFactor;
       newPos[3] = (1 - buffer);
       break;
     }
     case mitk::ManufacturerLogo::UpperRight:
     {
       newPos[0] = (1 - buffer) - 0.2 * normX * m_ZoomFactor;
       newPos[1] = (1 - buffer) - 0.2 * normY * m_ZoomFactor;
       newPos[2] = (1 - buffer);
       newPos[3] = (1 - buffer);
       break;
     }
     case mitk::ManufacturerLogo::Middle:
     default:
     {
-      newPos[0] = 0.5 - 0.2 * normX * m_ZoomFactor;
-      newPos[1] = 0.5 + 0.2 * normY * m_ZoomFactor;
-      newPos[2] = 0.5 - 0.2 * normX * m_ZoomFactor;
-      newPos[3] = 0.5 + 0.2 * normY * m_ZoomFactor;
+      newPos[0] = 0.5 - 0.1 * normX * m_ZoomFactor;
+      newPos[1] = 0.5 - 0.1 * normY * m_ZoomFactor;
+      newPos[2] = 0.5 + 0.1 * normX * m_ZoomFactor;
+      newPos[3] = 0.5 + 0.1 * normY * m_ZoomFactor;
       break;
     }
   }
 
   m_Renderer->SetViewport(newPos);
 }
 
 void mitk::ManufacturerLogo::ForceMBILogoVisible(bool visible)
 {
   m_ForceShowMBIDepartmentLogo = visible;
 }
 
 void mitk::ManufacturerLogo::SetZoomFactor( double factor )
 {
   m_ZoomFactor = factor;
 }
 void mitk::ManufacturerLogo::SetOpacity(double opacity)
 {
   m_Opacity = opacity;
 }
 
 /**
  * Disables drawing of the logo.
  * If you want to enable it, call the Enable() function.
  */
 void mitk::ManufacturerLogo::Disable()
 {
   if ( this->IsEnabled() && !m_ForceShowMBIDepartmentLogo )
   {
     mitk::VtkLayerController::GetInstance(m_RenderWindow)->RemoveRenderer(m_Renderer);
     m_IsEnabled = false;
   }
 }
 
 /**
  * Checks, if the logo is currently
  * enabled (visible)
  */
 bool mitk::ManufacturerLogo::IsEnabled()
 {
   return  m_IsEnabled;
 }
 
 
 void mitk::ManufacturerLogo::SetRequestedRegionToLargestPossibleRegion()
 {
     //nothing to do
 }
 
 bool mitk::ManufacturerLogo::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
     return false;
 }
 
 bool mitk::ManufacturerLogo::VerifyRequestedRegion()
 {
     return true;
 }
 
 void mitk::ManufacturerLogo::SetRequestedRegion( const itk::DataObject*)
 {
     //nothing to do
 }
 
diff --git a/Modules/Overlays/mitkLogoOverlay.cpp b/Modules/Overlays/mitkLogoOverlay.cpp
index 24eb89ecbf..03586be757 100644
--- a/Modules/Overlays/mitkLogoOverlay.cpp
+++ b/Modules/Overlays/mitkLogoOverlay.cpp
@@ -1,196 +1,193 @@
 /*===================================================================
 
 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 "mitkLogoOverlay.h"
 #include <vtkTextProperty.h>
 #include "vtkUnicodeString.h"
 #include <vtkImageMapper.h>
 #include <vtkTextRendererStringToImage.h>
 #include <vtkTextActor.h>
 #include <vtkImageData.h>
 #include <vtkImageMapper.h>
 #include <vtkTextRenderer.h>
 #include <vtkImageData.h>
 #include <vtkImageReader2Factory.h>
 #include <vtkImageReader2.h>
 
 #include <mitkVtkLogoRepresentation.h>
-#include <vtkLogoWidget.h>
 #include <vtkProperty2D.h>
 #include <vtkImageImport.h>
 #include <mbilogo.h>
 
 mitk::LogoOverlay::LogoOverlay()
 {
   m_readerFactory = vtkSmartPointer<vtkImageReader2Factory>::New();
   mitk::Point2D offset;
   offset.Fill(0.03);
   SetOffsetVector(offset);
   SetRelativeSize(0.2);
   SetCornerPosition(4);
   m_VtkImageImport = vtkSmartPointer<vtkImageImport>::New();
 }
 
 
 mitk::LogoOverlay::~LogoOverlay()
 {
 }
 
 mitk::LogoOverlay::LocalStorage::~LocalStorage()
 {
 }
 
 mitk::LogoOverlay::LocalStorage::LocalStorage()
 {
   m_LogoRep = vtkSmartPointer<mitkVtkLogoRepresentation>::New();
-  m_LogoWidget = vtkSmartPointer<vtkLogoWidget>::New();
-  m_LogoWidget->SetRepresentation(m_LogoRep);
 }
 
 void mitk::LogoOverlay::UpdateVtkOverlay(mitk::BaseRenderer *renderer)
 {
   LocalStorage* ls = this->m_LSH.GetLocalStorage(renderer);
   if(ls->IsGenerateDataRequired(renderer,this))
   {
 
     vtkImageReader2* imageReader = m_readerFactory->CreateImageReader2(GetLogoImagePath().c_str());
     if(imageReader)
     {
       imageReader->SetFileName(GetLogoImagePath().c_str());
       imageReader->Update();
       ls->m_LogoImage = imageReader->GetOutput();
       imageReader->Delete();
     }
     else
     {
       ls->m_LogoImage = CreateMbiLogo();
     }
 
     ls->m_LogoRep->SetImage(ls->m_LogoImage);
     ls->m_LogoRep->SetDragable(false);
     ls->m_LogoRep->SetMoving(false);
     ls->m_LogoRep->SetPickable(false);
     ls->m_LogoRep->SetShowBorder(true);
     ls->m_LogoRep->SetRenderer(renderer->GetVtkRenderer());
     float size = GetRelativeSize(renderer);
     ls->m_LogoRep->SetPosition2(size,size);
     int corner = GetCornerPosition(renderer);
     ls->m_LogoRep->SetCornerPosition(corner);
     mitk::Point2D offset = GetOffsetVector(renderer);
     ls->m_LogoRep->SetPosition(offset[0],offset[1]);
     float opacity = 1.0;
     GetOpacity(opacity,renderer);
     ls->m_LogoRep->GetImageProperty()->SetOpacity(opacity);
     ls->m_LogoRep->BuildRepresentation();
     ls->UpdateGenerateDataTime();
   }
 
 }
 
 vtkImageData *mitk::LogoOverlay::CreateMbiLogo()
 {
   m_VtkImageImport->SetDataScalarTypeToUnsignedChar();
   m_VtkImageImport->SetNumberOfScalarComponents(mbiLogo_NumberOfScalars);
   m_VtkImageImport->SetWholeExtent(0,mbiLogo_Width-1,0,mbiLogo_Height-1,0,1-1);
   m_VtkImageImport->SetDataExtentToWholeExtent();
 
   char *              ImageData;
   // flip mbi logo around y axis and change color order
   ImageData = new char[mbiLogo_Height*mbiLogo_Width*mbiLogo_NumberOfScalars];
 
   unsigned int column, row;
   char * dest   = ImageData;
   char * source = (char*) &mbiLogo_Data[0];;
   char r, g, b, a;
   for (column = 0; column < mbiLogo_Height; column++)
     for (row = 0; row < mbiLogo_Width; row++)
     {   //change r with b
         b = *source++;
         g = *source++;
         r = *source++;
         a = *source++;
 
         *dest++ = r;
         *dest++ = g;
         *dest++ = b;
         *dest++ = a;
       }
 
   m_VtkImageImport->SetImportVoidPointer(ImageData);
   m_VtkImageImport->Modified();
   m_VtkImageImport->Update();
   return m_VtkImageImport->GetOutput();
 }
 
 void mitk::LogoOverlay::SetLogoImagePath(std::string path)
 {
   SetStringProperty("Overlay.LogoImagePath", path.c_str());
   Modified();
 }
 
 std::string mitk::LogoOverlay::GetLogoImagePath() const
 {
   std::string path;
   GetPropertyList()->GetStringProperty("Overlay.LogoImagePath", path);
   return path;
 }
 
 void mitk::LogoOverlay::SetOffsetVector(const Point2D& OffsetVector, mitk::BaseRenderer *renderer)
 {
   mitk::Point2dProperty::Pointer OffsetVectorProperty = mitk::Point2dProperty::New(OffsetVector);
   SetProperty("Overlay.OffsetVector", OffsetVectorProperty.GetPointer(),renderer);
     Modified();
 }
 
 mitk::Point2D mitk::LogoOverlay::GetOffsetVector(mitk::BaseRenderer *renderer) const
 {
   mitk::Point2D OffsetVector;
   OffsetVector.Fill(0);
   GetPropertyValue<mitk::Point2D>("Overlay.OffsetVector", OffsetVector, renderer);
   return OffsetVector;
 }
 
 void mitk::LogoOverlay::SetCornerPosition(const int &corner, mitk::BaseRenderer *renderer)
 {
   SetIntProperty("Overlay.CornerPosition", corner, renderer);
   Modified();
 }
 
 int mitk::LogoOverlay::GetCornerPosition(mitk::BaseRenderer *renderer) const
 {
   int corner = 0;
   GetIntProperty("Overlay.CornerPosition",corner,renderer);
   return corner;
 }
 
 void mitk::LogoOverlay::SetRelativeSize(const float &size, mitk::BaseRenderer *renderer)
 {
   SetFloatProperty("Overlay.RelativeSize", size, renderer);
   Modified();
 }
 
 float mitk::LogoOverlay::GetRelativeSize(mitk::BaseRenderer *renderer) const
 {
   float size = 0;
   GetFloatProperty("Overlay.RelativeSize",size,renderer);
   return size;
 }
 
 vtkProp* mitk::LogoOverlay::GetVtkProp(BaseRenderer *renderer) const
 {
   LocalStorage* ls = this->m_LSH.GetLocalStorage(renderer);
   return ls->m_LogoRep;
 }
diff --git a/Modules/Overlays/mitkLogoOverlay.h b/Modules/Overlays/mitkLogoOverlay.h
index 4c591d67ba..e6b9504cad 100644
--- a/Modules/Overlays/mitkLogoOverlay.h
+++ b/Modules/Overlays/mitkLogoOverlay.h
@@ -1,108 +1,106 @@
 /*===================================================================
 
   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 LOGOOVERLAY_H
 #define LOGOOVERLAY_H
 
 #include <mitkVtkOverlay.h>
 #include <mitkLocalStorageHandler.h>
 #include <vtkSmartPointer.h>
 #include "MitkOverlaysExports.h"
 
 class mitkVtkLogoRepresentation;
-class vtkLogoWidget;
 class vtkImageData;
 class vtkImageReader2Factory;
 class vtkImageImport;
 
 namespace mitk {
 
 /** \brief Displays a logo on the renderwindow */
 class MITKOVERLAYS_EXPORT LogoOverlay : public mitk::VtkOverlay {
 public:
 
   class LocalStorage : public mitk::Overlay::BaseLocalStorage
   {
   public:
     /** \brief Actor of a 2D render window. */
     vtkSmartPointer<vtkImageData> m_LogoImage;
     vtkSmartPointer<mitkVtkLogoRepresentation> m_LogoRep;
-    vtkSmartPointer<vtkLogoWidget> m_LogoWidget;
 
     /** \brief Timestamp of last update of stored data. */
     itk::TimeStamp m_LastUpdateTime;
 
     /** \brief Default constructor of the local storage. */
     LocalStorage();
     /** \brief Default deconstructor of the local storage. */
     ~LocalStorage();
   };
 
   mitkClassMacro(LogoOverlay, mitk::VtkOverlay);
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   vtkSmartPointer<vtkImageReader2Factory> m_readerFactory;
 
   void SetLogoImagePath(std::string text);
   std::string GetLogoImagePath() const;
 
   /** \brief The relative offset to the corner position */
   void SetOffsetVector(const Point2D& OffsetVector, BaseRenderer* renderer = NULL);
   Point2D GetOffsetVector(mitk::BaseRenderer* renderer = NULL) const;
 
   /** \brief The corner where the logo is displayed.
  0 = Bottom left
  1 = Bottom right
  2 = Top right
  3 = Top left*/
   void SetCornerPosition(const int& corner, BaseRenderer* renderer = NULL);
   int GetCornerPosition(mitk::BaseRenderer* renderer = NULL) const;
 
   void SetRelativeSize(const float &size, BaseRenderer* renderer = NULL);
   float GetRelativeSize(mitk::BaseRenderer* renderer = NULL) const;
 
 protected:
 
   /** \brief The LocalStorageHandler holds all LocalStorages for the render windows. */
   mutable mitk::LocalStorageHandler<LocalStorage> m_LSH;
 
   virtual vtkProp *GetVtkProp(BaseRenderer *renderer) const;
   void UpdateVtkOverlay(mitk::BaseRenderer *renderer);
 
   vtkImageData* CreateMbiLogo();
 
   /** \brief explicit constructor which disallows implicit conversions */
   explicit LogoOverlay();
 
   /** \brief virtual destructor in order to derive from this class */
   virtual ~LogoOverlay();
 
 private:
 
   vtkSmartPointer <vtkImageImport> m_VtkImageImport;
 
   /** \brief copy constructor */
   LogoOverlay( const LogoOverlay &);
 
   /** \brief assignment operator */
   LogoOverlay &operator=(const LogoOverlay &);
 
 };
 
 } // namespace mitk
 #endif // LOGOOVERLAY_H