diff --git a/Modules/Core/include/mitkCameraRotationController.h b/Modules/Core/include/mitkCameraRotationController.h
index 94910dfd38..06622fadfd 100644
--- a/Modules/Core/include/mitkCameraRotationController.h
+++ b/Modules/Core/include/mitkCameraRotationController.h
@@ -1,50 +1,61 @@
 /*===================================================================
 
 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 CAMERAROTATIONCONTROLLER_H_HEADER_INCLUDED_NXYCBIU
 #define CAMERAROTATIONCONTROLLER_H_HEADER_INCLUDED_NXYCBIU
 
 #include "mitkBaseController.h"
 #include <MitkCoreExports.h>
+#include <vtkMatrix4x4.h>
+#include <vtkSmartPointer.h>
 
 class vtkCamera;
 class vtkRenderWindow;
 
 namespace mitk
 {
   class MITKCORE_EXPORT CameraRotationController : public BaseController
   {
   public:
     mitkClassMacro(CameraRotationController, BaseController);
     itkFactorylessNewMacro(Self) itkCloneMacro(Self)
       // mitkNewMacro1Param(Self, const char *);
 
       void RotateCamera();
     void AcquireCamera();
 
     void SetRenderWindow(vtkRenderWindow *renWin) { m_RenderWindow = renWin; }
+
+    /** Sets a new camera to world transformation */
+    void SetCameraTransformation(mitk::AffineTransform3D::Pointer newTransform);
+
+    /** Returns the current camera transformation */
+    mitk::AffineTransform3D::Pointer GetCameraTransformation();
+
   protected:
     CameraRotationController();
     ~CameraRotationController() override;
 
   private:
     int m_LastStepperValue;
     vtkCamera *m_Camera;
     vtkRenderWindow *m_RenderWindow;
+    mitk::AffineTransform3D::Pointer VtkToItkTransform(vtkSmartPointer <vtkMatrix4x4> vtkMatrix);
+    vtkSmartPointer <vtkMatrix4x4> ItkToVtkTransform(mitk::AffineTransform3D::Pointer itkTransform);
   };
 }
 
 #endif
diff --git a/Modules/Core/src/Controllers/mitkCameraRotationController.cpp b/Modules/Core/src/Controllers/mitkCameraRotationController.cpp
index d55b454240..1d609ab958 100644
--- a/Modules/Core/src/Controllers/mitkCameraRotationController.cpp
+++ b/Modules/Core/src/Controllers/mitkCameraRotationController.cpp
@@ -1,93 +1,142 @@
 /*===================================================================
 
 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 "mitkCameraRotationController.h"
 
 #include <itkCommand.h>
 #include <vtkCamera.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderer.h>
 
 #include "mitkRenderingManager.h"
 #include "mitkVtkPropRenderer.h"
 
 mitk::CameraRotationController::CameraRotationController()
   : BaseController(), m_LastStepperValue(180), m_Camera(nullptr), m_RenderWindow(nullptr)
 {
   m_Slice->SetAutoRepeat(true);
   m_Slice->SetSteps(360);
   m_Slice->SetPos(180);
 
   itk::SimpleMemberCommand<CameraRotationController>::Pointer sliceStepperChangedCommand, timeStepperChangedCommand;
   sliceStepperChangedCommand = itk::SimpleMemberCommand<CameraRotationController>::New();
   sliceStepperChangedCommand->SetCallbackFunction(this, &CameraRotationController::RotateCamera);
 
   m_Slice->AddObserver(itk::ModifiedEvent(), sliceStepperChangedCommand);
 }
 
-mitk::CameraRotationController::~CameraRotationController()
-{
-}
+mitk::CameraRotationController::~CameraRotationController() {}
 
 void mitk::CameraRotationController::RotateCamera()
 {
   if (!m_Camera)
   {
     this->AcquireCamera();
   }
 
   if (m_Camera)
   {
     int newStepperValue = m_Slice->GetPos();
     m_Camera->Azimuth(m_LastStepperValue - newStepperValue);
     m_LastStepperValue = newStepperValue;
     // const_cast< RenderWindow* >(m_RenderWindow)->RequestUpdate(); // TODO does not work with movie generator!
     mitk::RenderingManager::GetInstance()->RequestUpdate(m_RenderWindow);
     // m_MultiWidget->RequestUpdate();
   }
 }
 
+void mitk::CameraRotationController::SetCameraTransformation(mitk::AffineTransform3D::Pointer newTransform) {
+  if (!m_Camera) {this->AcquireCamera();}
+  m_Camera->SetEyeTransformMatrix(ItkToVtkTransform(newTransform));
+}
+
+mitk::AffineTransform3D::Pointer mitk::CameraRotationController::GetCameraTransformation()
+{
+  if (!m_Camera) {this->AcquireCamera();}
+  return VtkToItkTransform(m_Camera->GetEyeTransformMatrix());
+}
+
+mitk::AffineTransform3D::Pointer mitk::CameraRotationController::VtkToItkTransform(vtkSmartPointer <vtkMatrix4x4> vtkMatrix)
+{
+  mitk::AffineTransform3D::Pointer returnValue = mitk::AffineTransform3D::New();
+  itk::Matrix<mitk::ScalarType> rotationMatrix;
+  rotationMatrix[0][0] = vtkMatrix->GetElement(0, 0);
+  rotationMatrix[0][1] = vtkMatrix->GetElement(0, 1);
+  rotationMatrix[0][2] = vtkMatrix->GetElement(0, 2);
+  rotationMatrix[1][0] = vtkMatrix->GetElement(1, 0);
+  rotationMatrix[1][1] = vtkMatrix->GetElement(1, 1);
+  rotationMatrix[1][2] = vtkMatrix->GetElement(1, 2);
+  rotationMatrix[2][0] = vtkMatrix->GetElement(2, 0);
+  rotationMatrix[2][1] = vtkMatrix->GetElement(2, 1);
+  rotationMatrix[2][2] = vtkMatrix->GetElement(2, 2);
+  returnValue->SetMatrix(rotationMatrix);
+  mitk::Vector3D offset;
+  offset[0] = vtkMatrix->GetElement(0, 3);
+  offset[1] = vtkMatrix->GetElement(1, 3);
+  offset[2] = vtkMatrix->GetElement(2, 3);
+  returnValue->SetOffset(offset);
+  return returnValue;
+}
+vtkSmartPointer<vtkMatrix4x4> mitk::CameraRotationController::ItkToVtkTransform(
+  mitk::AffineTransform3D::Pointer itkTransform)
+{
+  vtkSmartPointer <vtkMatrix4x4> returnValue = vtkMatrix4x4::New();
+  returnValue->SetElement(0, 0,itkTransform->GetMatrix()[0][0]);
+  returnValue->SetElement(0, 1, itkTransform->GetMatrix()[0][1]);
+  returnValue->SetElement(0, 2, itkTransform->GetMatrix()[0][2]);
+  returnValue->SetElement(1, 0, itkTransform->GetMatrix()[1][0]);
+  returnValue->SetElement(1, 1, itkTransform->GetMatrix()[1][1]);
+  returnValue->SetElement(1, 2, itkTransform->GetMatrix()[1][2]);
+  returnValue->SetElement(2, 0, itkTransform->GetMatrix()[2][0]);
+  returnValue->SetElement(2, 1, itkTransform->GetMatrix()[2][1]);
+  returnValue->SetElement(2, 2, itkTransform->GetMatrix()[2][2]);
+  returnValue->SetElement(0, 3, itkTransform->GetOffset()[0]);
+  returnValue->SetElement(1, 3, itkTransform->GetOffset()[1]);
+  returnValue->SetElement(2, 3, itkTransform->GetOffset()[2]);
+  return returnValue;
+}
+
 void mitk::CameraRotationController::AcquireCamera()
 {
   BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(m_RenderWindow);
 
   const auto *propRenderer = dynamic_cast<const mitk::VtkPropRenderer *>(renderer);
   if (propRenderer)
   {
     // get vtk renderer
     vtkRenderer *vtkrenderer = propRenderer->GetVtkRenderer();
     if (vtkrenderer)
     {
       // get vtk camera
       vtkCamera *vtkcam = vtkrenderer->GetActiveCamera();
       if (vtkcam)
       {
         // vtk smart pointer handling
         if (!m_Camera)
         {
           m_Camera = vtkcam;
           m_Camera->Register(nullptr);
         }
         else
         {
           m_Camera->UnRegister(nullptr);
           m_Camera = vtkcam;
           m_Camera->Register(nullptr);
         }
       }
     }
   }
 }