diff --git a/Modules/CameraCalibration/mitkTransform.cpp b/Modules/CameraCalibration/mitkTransform.cpp
index 4ea2f98bfa..835dfc6916 100644
--- a/Modules/CameraCalibration/mitkTransform.cpp
+++ b/Modules/CameraCalibration/mitkTransform.cpp
@@ -1,931 +1,933 @@
 /*===================================================================
 
 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 "mitkTransform.h"
 #include <fstream>
 #include <vnl/vnl_inverse.h>
 #include <itkQuaternionRigidTransform.h>
 #include <mitkVnlVectorFixedCaster.h>
 #include <mitkVnlVectorFromCvMat.h>
 #include <mitkVnlMatrixFromCvMat.h>
 #include <mitkCvMatFromVnlVector.h>
 namespace mitk
 {
   // DO NOT CHANGE THE VALUES OF THESE CONSTANTS!!
   const std::string Transform::UNKNOWN_TYPE = "Unknown type";
   const std::string Transform::ENDOSCOPE_SCOPE_TOOL = "Endoscope scope tool";
   const std::string Transform::ENDOSCOPE_CAM_TOOL = "Endoscope camera tool";
   const std::string Transform::CHESSBOARD_TOOL = "Chessboard tool";
   const std::string Transform::POINTER_TOOL = "Pointer tool";
   const std::string Transform::POINTER_TO_CHESSBOARD_ORIGIN = "Pointer to chessboard origin";
   const std::string Transform::POINTER_TO_CHESSBOARD_X_SUPPORT_POINT = "Pointer to chessboard X support origin";
   const std::string Transform::POINTER_TO_CHESSBOARD_Y_SUPPORT_POINT = "Pointer to chessboard Y support origin";
   const std::string Transform::BOARD_TO_BOARD_TOOL = "Board to board tool";
   const std::string Transform::REFERENCE_CAMERA_TRANSFORM = "Reference camera transform";
   const std::string Transform::REFERENCE_SCOPE_TRANSFORM = "Reference scope transform";
   const std::string Transform::EYE_TO_HAND_TRANSFORM = "Eye to hand transform";
   const std::string Transform::CAMERA_EXTRINSICS = "Camera extrinsics";
 
   Transform::Transform()
     : m_NavData(mitk::NavigationData::New()), m_Type( UNKNOWN_TYPE )
   {
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> rot;
     rot.set_identity();
     this->SetRotation( rot );
   }
 
   Transform::Transform(const mitk::NavigationData* nd)
     : m_NavData(mitk::NavigationData::New()), m_Type( UNKNOWN_TYPE )
   {
         m_NavData->Graft(nd);
   }
 
   Transform::Transform(const mitk::AffineTransform3D* transform)
     : m_NavData(mitk::NavigationData::New()), m_Type( UNKNOWN_TYPE )
   {
-    vnl_matrix_fixed<float,3,3> rotation = vnl_matrix_fixed<float,3,3>();
+    vnl_matrix_fixed<mitk::ScalarType, 3, 3> rotation = vnl_matrix_fixed<mitk::ScalarType,3,3>();
     rotation[0][0] = transform->GetMatrix().GetVnlMatrix()[0][0];
     rotation[0][1] = transform->GetMatrix().GetVnlMatrix()[0][1];
     rotation[0][2] = transform->GetMatrix().GetVnlMatrix()[0][2];
     rotation[1][0] = transform->GetMatrix().GetVnlMatrix()[1][0];
     rotation[1][1] = transform->GetMatrix().GetVnlMatrix()[1][1];
     rotation[1][2] = transform->GetMatrix().GetVnlMatrix()[1][2];
     rotation[2][0] = transform->GetMatrix().GetVnlMatrix()[2][0];
     rotation[2][1] = transform->GetMatrix().GetVnlMatrix()[2][1];
     rotation[2][2] = transform->GetMatrix().GetVnlMatrix()[2][2];
-    rotation.transpose();
+
+    //rotation.transpose();
     this->SetRotation(rotation);
     mitk::Point3D translation;
     translation[0] = transform->GetOffset()[0];
     translation[1] = transform->GetOffset()[1];
     translation[2] = transform->GetOffset()[2];
     this->SetPosition(translation);
+
   }
 
 
   Transform::Transform(const std::string& s)
     : m_NavData(mitk::NavigationData::New()), m_Type( s )
   {
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> rot;
     rot.set_identity();
     this->SetRotation( rot );
   }
 
   void Transform::Copy(const mitk::NavigationData* nd)
   {
     (const_cast<mitk::NavigationData*>(m_NavData.GetPointer()))->Graft(nd);
   }
 
   void Transform::Concatenate( mitk::Transform* transform )
   {
     //do calculation with double precision for better results:
 
     //convert to double
     vnl_matrix_fixed<double, 4, 4> thisMatrix = vnl_matrix_fixed<double, 4, 4>();
     thisMatrix[0][0] = this->GetMatrix()[0][0];
     thisMatrix[0][1] = this->GetMatrix()[0][1];
     thisMatrix[0][2] = this->GetMatrix()[0][2];
     thisMatrix[0][3] = this->GetMatrix()[0][3];
     thisMatrix[1][0] = this->GetMatrix()[1][0];
     thisMatrix[1][1] = this->GetMatrix()[1][1];
     thisMatrix[1][2] = this->GetMatrix()[1][2];
     thisMatrix[1][3] = this->GetMatrix()[1][3];
     thisMatrix[2][0] = this->GetMatrix()[2][0];
     thisMatrix[2][1] = this->GetMatrix()[2][1];
     thisMatrix[2][2] = this->GetMatrix()[2][2];
     thisMatrix[2][3] = this->GetMatrix()[2][3];
     thisMatrix[3][0] = this->GetMatrix()[3][0];
     thisMatrix[3][1] = this->GetMatrix()[3][1];
     thisMatrix[3][2] = this->GetMatrix()[3][2];
     thisMatrix[3][3] = this->GetMatrix()[3][3];
 
     vnl_matrix_fixed<double, 4, 4> secondMatrix = vnl_matrix_fixed<double, 4, 4>();
     secondMatrix[0][0] = transform->GetMatrix()[0][0];
     secondMatrix[0][1] = transform->GetMatrix()[0][1];
     secondMatrix[0][2] = transform->GetMatrix()[0][2];
     secondMatrix[0][3] = transform->GetMatrix()[0][3];
     secondMatrix[1][0] = transform->GetMatrix()[1][0];
     secondMatrix[1][1] = transform->GetMatrix()[1][1];
     secondMatrix[1][2] = transform->GetMatrix()[1][2];
     secondMatrix[1][3] = transform->GetMatrix()[1][3];
     secondMatrix[2][0] = transform->GetMatrix()[2][0];
     secondMatrix[2][1] = transform->GetMatrix()[2][1];
     secondMatrix[2][2] = transform->GetMatrix()[2][2];
     secondMatrix[2][3] = transform->GetMatrix()[2][3];
     secondMatrix[3][0] = transform->GetMatrix()[3][0];
     secondMatrix[3][1] = transform->GetMatrix()[3][1];
     secondMatrix[3][2] = transform->GetMatrix()[3][2];
     secondMatrix[3][3] = transform->GetMatrix()[3][3];
 
     //concatenate
     vnl_matrix_fixed<double, 4, 4> resultMatrix =  secondMatrix * thisMatrix;
 
     //convert back to float
     vnl_matrix_fixed<mitk::ScalarType, 4, 4> finalMatrix = vnl_matrix_fixed<mitk::ScalarType, 4, 4>();
     finalMatrix[0][0] = resultMatrix[0][0];
     finalMatrix[0][1] = resultMatrix[0][1];
     finalMatrix[0][2] = resultMatrix[0][2];
     finalMatrix[0][3] = resultMatrix[0][3];
     finalMatrix[1][0] = resultMatrix[1][0];
     finalMatrix[1][1] = resultMatrix[1][1];
     finalMatrix[1][2] = resultMatrix[1][2];
     finalMatrix[1][3] = resultMatrix[1][3];
     finalMatrix[2][0] = resultMatrix[2][0];
     finalMatrix[2][1] = resultMatrix[2][1];
     finalMatrix[2][2] = resultMatrix[2][2];
     finalMatrix[2][3] = resultMatrix[2][3];
     finalMatrix[3][0] = resultMatrix[3][0];
     finalMatrix[3][1] = resultMatrix[3][1];
     finalMatrix[3][2] = resultMatrix[3][2];
     finalMatrix[3][3] = resultMatrix[3][3];
 
     this->SetMatrix( finalMatrix );
 
   }
 
   void Transform::Concatenate( const vnl_matrix_fixed<mitk::ScalarType, 4, 4>&
                                transform )
   {
     Transform::Pointer t = Transform::New();
     t->SetMatrix( transform );
     this->Concatenate( t );
   }
 
   void Transform::Concatenate( const vtkMatrix4x4* transform )
   {
     Transform::Pointer t = Transform::New();
     t->SetMatrix( transform );
     this->Concatenate( t );
   }
 
   void Transform::Reset()
   {
     mitk::NavigationData::Pointer nd
       = NavigationData::New();
     this->Copy( nd );
   }
   void  Transform::SetOrientation(
       const vnl_quaternion<mitk::ScalarType>& orientation)
   {
     m_NavData->SetOrientation(orientation);
     this->Modified();
   }
 
   void Transform::SetTranslation( const vnl_vector_fixed<mitk::ScalarType, 3>&
                                   transl)
   {
     mitk::Point3D p;
     for(unsigned int i=0; i<3; ++i)
       p[i] = transl[i];
 
     m_NavData->SetPosition(p);
     this->Modified();
   }
 
   void Transform::SetTranslation( float* array )
   {
     vnl_vector_fixed<mitk::ScalarType, 3> vec;
     for(unsigned int i=0; i<vec.size(); i++)
       vec(i) = array[i];
     this->SetTranslation( vec );
   }
 
   void Transform::SetRotation( float* array )
   {
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> mat;
 
     unsigned int row = 0;
     unsigned int col = 0;
     for(unsigned int i=0; i<mat.rows()*mat.cols(); i++)
     {
       if( i > 0 && i % 3 == 0 )
       {
         ++row;
         col = 0;
       }
 
       mat(row,col) = array[i];
       ++col;
     }
 
     this->SetRotation( mat );
   }
 
   void Transform::SetOrientation( const vnl_quaternion<double>& orientation)
   {
     vnl_vector_fixed<mitk::ScalarType, 4> qvec;
     VnlVectorFixedCaster<double, mitk::ScalarType, 4> caster( &orientation, &qvec );
     caster.Update();
 
     mitk::Quaternion p( qvec );
 
     this->SetOrientation( p );
   }
 
   vnl_vector_fixed<double, 3> Transform::GetVnlDoubleTranslation() const
   {
     vnl_vector_fixed<mitk::ScalarType, 3> vecFloat = this->GetVnlTranslation();
     vnl_vector_fixed<double, 3> vecDouble;
     VnlVectorFixedCaster<mitk::ScalarType, double, 3> caster( &vecFloat, &vecDouble );
     caster.Update();
 
     return vecDouble;
   }
 
   void Transform::SetTranslation( const vnl_vector<double>& transl)
   {
     vnl_vector_fixed<double, 3> dTransl(transl);
     vnl_vector_fixed<mitk::ScalarType, 3> fTransl;
     VnlVectorFixedCaster<double, mitk::ScalarType, 3> caster( &dTransl, &fTransl );
     caster.Update();
 
     this->SetTranslation( fTransl );
   }
 
   vnl_quaternion<double> Transform::GetVnlDoubleQuaternion() const
   {
     mitk::Quaternion fOrientation = this->GetOrientation();
     vnl_quaternion<double> dOrientation;
     VnlVectorFixedCaster<mitk::ScalarType, double, 4> caster( &fOrientation, &dOrientation );
     caster.Update();
 
     return dOrientation;
   }
 
   void Transform::FromCSVFile(const std::string& file)
   {
     std::ifstream csvFile (file.c_str());
     endoAssert ( csvFile.fail() == false );
 
     mitk::Transform::Pointer transform = mitk::Transform::New();
     vnl_matrix_fixed<mitk::ScalarType, 4, 4> mat;
     std::string line;
     mitk::ScalarType d = 0.0f;
     int row=0,column = 0;
 
     while (std::getline (csvFile, line))
     {
       std::istringstream linestream(line);
       std::string item;
       column = 0;
       while (std::getline (linestream, item, ','))
       {
         std::istringstream number;
         number.str(item);
         number >> d;
         mat(row, column) = d;
         ++column;
       }
       ++row;
     }
     endoAssert( row == 4 && column == 4 );
     transform->SetMatrix( mat );
 
     this->SetNavigationData( transform->GetNavigationData() );
     // modified is called in SetNavigationData
   }
 
   std::string Transform::ToCSVString() const
   {
     std::ostringstream s; s.precision(12);
 
     vnl_matrix_fixed<mitk::ScalarType, 4, 4> mat
       = this->GetMatrix();
 
     for( unsigned int j=0; j<mat.rows(); ++j )
     {
       for( unsigned int k=0; k<mat.cols(); ++k )
       {
         s << mat(j,k);
         if(k+1<mat.cols())
           s  << ",";
       }
       if(j+1<mat.rows())
         s << std::endl;
     }
 
     return s.str();
 
   }
 
   std::string Transform::ToMatlabString(const std::string& varname
                                         , bool printLastRow) const
   {
     std::ostringstream s; s.precision(12);
 
     vnl_matrix_fixed<mitk::ScalarType, 4, 4> mat
       = this->GetMatrix();
 
     s << varname << " = [";
     for( unsigned int j=0; j<mat.rows(); ++j )
     {
       if( !printLastRow && j+1 == mat.rows() )
         break;
       for( unsigned int k=0; k<mat.cols(); ++k )
       {
         s << mat(j,k) << " ";
       }
       s << ";";
     }
     s << "];" << std::endl;
 
     return s.str();
   }
 
   void Transform::Copy( const mitk::Transform* transform )
   {
     m_NavData->Graft(transform->GetNavigationData());
     m_Type = transform->GetType();
   }
 
   mitk::Transform::Pointer Transform::Clone() const
   {
     Transform::Pointer copy = Transform::New();
     copy->Copy( this );
     return copy;
   }
 
   void Transform::SetMatrix( const vtkMatrix4x4* mat)
   {
     vnl_matrix_fixed<mitk::ScalarType, 4, 4> vnlMat;
     for(unsigned int i=0; i<4; ++i)
       for(unsigned int j=0; j<4; ++j)
         vnlMat(i,j) = mat->GetElement(i, j);
 
     this->SetMatrix( vnlMat );
   }
 
   void Transform::ToCSVFile(const std::string& file) const
   {
     std::ofstream csvFile;
     csvFile.open(file.c_str());
     endoAssert ( csvFile.fail() == false );
     csvFile << this->ToCSVString();
     csvFile.close();
   }
 
   void Transform::ToMatlabFile(const std::string& file
                                , const std::string& varname) const
   {
     std::ofstream csvFile;
     csvFile.open(file.c_str());
     endoAssert ( csvFile.fail() == false );
     csvFile << this->ToMatlabString(varname);
     csvFile.close();
   }
 
   void Transform::SetNavigationData( const mitk::NavigationData* naviData )
   {
     endoAssert( naviData != 0 );
     m_NavData->Graft( naviData );
     this->Modified();
   }
 
   void Transform::SetRotation( vnl_matrix_fixed<mitk::ScalarType, 3, 3>& mat)
   {
     this->m_NavData->SetOrientation( mitk::Quaternion(mat) );
     this->Modified();
   }
 
   void Transform::SetRotation( vnl_matrix<mitk::ScalarType>& mat)
   {
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> tmp(mat);
     this->SetRotation( tmp );
   }
 
   void Transform::SetPosition( const mitk::Point3D& transl)
   {
     this->SetTranslation( transl.GetVnlVector() );
   }
 
   void Transform::SetTranslation( double array[3] )
   {
     mitk::Point3D p;
     for(unsigned int i = 0; i < 3; ++i)
       p.SetElement(i, array[i]);
     this->SetTranslation( p.GetVnlVector() );
   }
 
 
   void Transform::SetRotation( double array[3][3] )
   {
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> mat;
 
     for(unsigned int i = 0; i < 3; ++i)
       for(unsigned int j = 0; j < 3; ++j)
         mat(i, j) = array[i][j];
     this->SetRotation( mat );
   }
 
   void Transform::Invert()
   { //do calculation with double precision for better results:
 
     //convert to double
     vnl_matrix_fixed<double, 4, 4> originMatrix = vnl_matrix_fixed<double, 4, 4>();
     originMatrix[0][0] = this->GetMatrix()[0][0];
     originMatrix[0][1] = this->GetMatrix()[0][1];
     originMatrix[0][2] = this->GetMatrix()[0][2];
     originMatrix[0][3] = this->GetMatrix()[0][3];
     originMatrix[1][0] = this->GetMatrix()[1][0];
     originMatrix[1][1] = this->GetMatrix()[1][1];
     originMatrix[1][2] = this->GetMatrix()[1][2];
     originMatrix[1][3] = this->GetMatrix()[1][3];
     originMatrix[2][0] = this->GetMatrix()[2][0];
     originMatrix[2][1] = this->GetMatrix()[2][1];
     originMatrix[2][2] = this->GetMatrix()[2][2];
     originMatrix[2][3] = this->GetMatrix()[2][3];
     originMatrix[3][0] = this->GetMatrix()[3][0];
     originMatrix[3][1] = this->GetMatrix()[3][1];
     originMatrix[3][2] = this->GetMatrix()[3][2];
     originMatrix[3][3] = this->GetMatrix()[3][3];
 
     //invert
     vnl_matrix_fixed<double, 4, 4> invertedMatrix = vnl_inverse(originMatrix);
 
 
     //convert back to float
     vnl_matrix_fixed<mitk::ScalarType, 4, 4> finalMatrix = vnl_matrix_fixed<mitk::ScalarType, 4, 4>();
     finalMatrix[0][0] = invertedMatrix[0][0];
     finalMatrix[0][1] = invertedMatrix[0][1];
     finalMatrix[0][2] = invertedMatrix[0][2];
     finalMatrix[0][3] = invertedMatrix[0][3];
     finalMatrix[1][0] = invertedMatrix[1][0];
     finalMatrix[1][1] = invertedMatrix[1][1];
     finalMatrix[1][2] = invertedMatrix[1][2];
     finalMatrix[1][3] = invertedMatrix[1][3];
     finalMatrix[2][0] = invertedMatrix[2][0];
     finalMatrix[2][1] = invertedMatrix[2][1];
     finalMatrix[2][2] = invertedMatrix[2][2];
     finalMatrix[2][3] = invertedMatrix[2][3];
     finalMatrix[3][0] = invertedMatrix[3][0];
     finalMatrix[3][1] = invertedMatrix[3][1];
     finalMatrix[3][2] = invertedMatrix[3][2];
     finalMatrix[3][3] = invertedMatrix[3][3];
 
     this->SetMatrix(finalMatrix);
   }
 
   void Transform::SetMatrix(
      const vnl_matrix_fixed<mitk::ScalarType, 4, 4>& mat)
   {
     // set translation first
     vnl_vector<mitk::ScalarType> transl = mat.get_column(3);
     mitk::Point3D p;
     for(unsigned int i=0; i<3; ++i)
       p[i] = transl[i];
 
     m_NavData->SetPosition(p);
 
     // set rotation
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> rotMatFixed(
       mat.extract(3,3));
     this->SetRotation(rotMatFixed);
   }
 
   bool Transform::IsValid() const
   {
     return m_NavData->IsDataValid();
   }
 
   void Transform::SetTranslation( const cv::Mat& transl)
   {
     vnl_vector<mitk::ScalarType> vec(3);
     VnlVectorFromCvMat<mitk::ScalarType> _VnlVectorFromCvMat( &transl, &vec );
     _VnlVectorFromCvMat.Update();
     this->SetTranslation( vnl_vector_fixed<mitk::ScalarType, 3>( vec ) );
   }
 
   void Transform::SetRotation( const cv::Mat& mat )
   {
     vnl_matrix<mitk::ScalarType> vnlMat(3, 3);
     VnlMatrixFromCvMat<mitk::ScalarType> _VnlMatrixFromCvMat( &mat, &vnlMat );
     _VnlMatrixFromCvMat.Update();
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> vnlMatFixed(vnlMat);
 
     this->SetRotation(vnlMatFixed);
   }
 
   void Transform::SetRotationVector( const cv::Mat& rotVec )
   {
     cv::Mat rotMat;
     cv::Rodrigues( rotVec, rotMat );
 
     vnl_matrix<mitk::ScalarType> vnlMat(3, 3);
     VnlMatrixFromCvMat<mitk::ScalarType> _VnlMatrixFromCvMat( &rotMat, &vnlMat );
     _VnlMatrixFromCvMat.Update();
 
 
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> vnlMatFixed(vnlMat);
 
     this->SetRotation( vnlMatFixed );
   }
 
   //# getter
   mitk::NavigationData::Pointer Transform::GetNavigationData() const
   {
     return m_NavData;
   }
 
   mitk::AffineTransform3D::Pointer Transform::GetAffineTransform3D()
   {
     mitk::AffineTransform3D::Pointer returnValue = mitk::AffineTransform3D::New();
     itk::Matrix<float,3,3> rotation = itk::Matrix<float,3,3>();
     rotation[0][0] = GetRotationMatrixFromQuaternion(m_NavData->GetOrientation())[0][0];
     rotation[0][1] = GetRotationMatrixFromQuaternion(m_NavData->GetOrientation())[0][1];
     rotation[0][2] = GetRotationMatrixFromQuaternion(m_NavData->GetOrientation())[0][2];
     rotation[1][0] = GetRotationMatrixFromQuaternion(m_NavData->GetOrientation())[1][0];
     rotation[1][1] = GetRotationMatrixFromQuaternion(m_NavData->GetOrientation())[1][1];
     rotation[1][2] = GetRotationMatrixFromQuaternion(m_NavData->GetOrientation())[1][2];
     rotation[2][0] = GetRotationMatrixFromQuaternion(m_NavData->GetOrientation())[2][0];
     rotation[2][1] = GetRotationMatrixFromQuaternion(m_NavData->GetOrientation())[2][1];
     rotation[2][2] = GetRotationMatrixFromQuaternion(m_NavData->GetOrientation())[2][2];
     itk::Vector<float,3> translation = itk::Vector<float,3>();
     translation[0] = m_NavData->GetPosition()[0];
     translation[1] = m_NavData->GetPosition()[1];
     translation[2] = m_NavData->GetPosition()[2];
     returnValue->SetMatrix(rotation);
     returnValue->SetOffset(translation);
     return returnValue;
   }
 
   mitk::Point3D Transform::GetTranslation() const
   {
     return m_NavData->GetPosition();
   }
 
   mitk::Point3D Transform::GetPosition() const
   {
     return m_NavData->GetPosition();
   }
 
   mitk::Quaternion Transform::GetOrientation() const
   {
     return m_NavData->GetOrientation();
   }
 
   void Transform::GetMatrix(vtkMatrix4x4* matrix) const
   {
     vnl_matrix_fixed<mitk::ScalarType, 4, 4> vnlMat = this->GetMatrix();
     for(unsigned int i=0; i<vnlMat.rows(); ++i)
       for(unsigned int j=0; j<vnlMat.cols(); ++j)
         matrix->SetElement(i,j, vnlMat(i,j));
   }
 
   void Transform::GetVtkOpenGlMatrix(vtkMatrix4x4* matrix) const
   {
     vnl_matrix<mitk::ScalarType> vnlRotation
         = this->GetVnlRotationMatrix().as_matrix();
 
     // normalize rows of rotation matrix
     vnlRotation.normalize_rows();
 
     vnl_matrix<mitk::ScalarType> vnlInverseRotation(3,3);
     // invert rotation
     vnlInverseRotation = vnl_matrix_inverse<mitk::ScalarType>(vnlRotation);
 
     vnl_vector<mitk::ScalarType> vnlTranslation
         = this->GetPosition().GetVnlVector();
     // rotate translation vector by inverse rotation P = P'
     vnlTranslation = vnlInverseRotation * vnlTranslation;
     vnlTranslation *= -1;  // save -P'
 
     // set position
     mitk::Transform::Pointer tmp = mitk::Transform::New();
 
     tmp->SetTranslation( vnlTranslation );
     tmp->SetRotation( vnlRotation );
     tmp->GetMatrix(matrix);
   }
 
   mitk::Point3D Transform::TransformPoint(mitk::Point3D point) const
   {
       itk::Matrix<mitk::ScalarType,3,3> R(GetVnlRotationMatrix());
       itk::Point<mitk::ScalarType,3> pointR = (R * point);
       mitk::Point3D retPoint = pointR;
       retPoint[0] = pointR[0] + GetPosition()[0];
       retPoint[1] = pointR[1] + GetPosition()[1];
       retPoint[2] = pointR[2] + GetPosition()[2];
       return retPoint;
   }
 
   //# cv getter
   cv::Mat Transform::GetCvTranslation() const
   {
     cv::Mat mat;
     vnl_vector<mitk::ScalarType> vec = this->GetVnlTranslation().as_vector();
     endodebugvar( vec )
     CvMatFromVnlVector<mitk::ScalarType> _CvMatFromVnlVector(&vec, &mat);
     _CvMatFromVnlVector.Update();
     return mat;
   }
 
   cv::Mat Transform::GetCvRotationMatrix() const
   {
     cv::Mat mat;
     vnl_matrix<mitk::ScalarType> vec = this->GetVnlRotationMatrix().as_matrix();
     endodebugvar( vec )
     CvMatFromVnlMatrix<mitk::ScalarType> _CvMatFromVnlMatrix(&vec, &mat);
     _CvMatFromVnlMatrix.Update();
     return mat;
   }
 
   cv::Mat Transform::GetCvMatrix() const
   {
     cv::Mat mat;
     vnl_matrix<mitk::ScalarType> vec = this->GetMatrix().as_matrix();
     CvMatFromVnlMatrix<mitk::ScalarType> _CvMatFromVnlMatrix(&vec, &mat);
     _CvMatFromVnlMatrix.Update();
     return mat;
   }
 
   cv::Mat Transform::GetCvRotationVector() const
   {
     cv::Mat rotVec(3,1,cv::DataType<mitk::ScalarType>::type);
     cv::Rodrigues( this->GetCvRotationMatrix(), rotVec );
     return rotVec;
   }
 
   //# vnl getter
   vnl_vector_fixed<mitk::ScalarType, 3> Transform::GetVnlTranslation() const
   {
     vnl_vector_fixed<mitk::ScalarType, 3> vec(m_NavData->GetPosition()
                                               .GetVnlVector());
     return vec;
   }
 
   vnl_matrix_fixed<mitk::ScalarType, 3, 3> Transform::GetVnlRotationMatrix() const
   {
     return GetRotationMatrixFromQuaternion(m_NavData->GetOrientation());
   }
 
   vnl_matrix_fixed<mitk::ScalarType, 3, 3> Transform::GetRotationMatrixFromQuaternion(mitk::Quaternion orientation) const
   {
   vnl_matrix_fixed<mitk::ScalarType, 3, 3> returnValue;
   //variant 1:
     returnValue = orientation.rotation_matrix_transpose();
 
   //variant 2:
 
     //itk::QuaternionRigidTransform<double>::Pointer quatTransform = itk::QuaternionRigidTransform<double>::New();
 
     //// convert mitk::ScalarType quaternion to double quaternion because of itk bug
     //vnl_quaternion<double> doubleQuaternion(orientation.x(), orientation.y(), orientation.z(), orientation.r());
     //quatTransform->SetIdentity();
     //quatTransform->SetRotation(doubleQuaternion);
     //quatTransform->Modified();
 
     ///* because of an itk bug, the transform can not be calculated with float data type.
     //To use it in the mitk geometry classes, it has to be transfered to mitk::ScalarType which is float*/
     //mitk::AffineTransform3D::MatrixType m;
     //mitk::TransferMatrix(quatTransform->GetMatrix(), m);
     //returnValue[0][0] = m[0][0];
     //returnValue[0][1] = m[0][1];
     //returnValue[0][2] = m[0][2];
     //returnValue[1][0] = m[1][0];
     //returnValue[1][1] = m[1][1];
     //returnValue[1][2] = m[1][2];
     //returnValue[2][0] = m[2][0];
     //returnValue[2][1] = m[2][1];
     //returnValue[2][2] = m[2][2];
 
     return returnValue;
 
 
   }
 
   vnl_matrix_fixed<double, 4, 4> Transform::GetVnlDoubleMatrix() const
   {
     vnl_matrix_fixed<mitk::ScalarType, 4, 4> mat = this->GetMatrix();
 
     vnl_matrix_fixed<double, 4, 4> doubleMat;
 
     for(unsigned int i=0; i<mat.rows(); ++i)
       for(unsigned int j=0; j<mat.cols(); ++j)
         doubleMat(i,j) = static_cast<double>( mat(i,j) );
 
     return doubleMat;
   }
 
   vnl_matrix_fixed<mitk::ScalarType, 4, 4> Transform::GetMatrix()
       const
   {
     vnl_vector_fixed<mitk::ScalarType, 3> transl = this->GetVnlTranslation();
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> rot = this->GetVnlRotationMatrix();
 
     vnl_matrix_fixed<mitk::ScalarType, 4, 4> homMat;
     homMat.set_identity();
     //std::cout << homMat << std::endl;
     for(unsigned int i=0; i<rot.rows(); ++i)
       for(unsigned int j=0; j<rot.cols(); ++j)
         homMat(i,j) = rot(i,j);
     for(unsigned int i=0; i<transl.size(); ++i)
       homMat(i,3) = transl[i];
 
     return homMat;
   }
 
   void Transform::TransposeRotation()
   {
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> rotMat = this->GetVnlRotationMatrix().transpose();
     this->SetRotation( rotMat );
   }
 
   void Transform::SetValid( bool valid )
   {
     if( m_NavData->IsDataValid() == valid )
       return;
 
     m_NavData->SetDataValid( valid );
     this->Modified();
   }
 
   std::string mitk::Transform::ToString() const
   {
     std::ostringstream s; s.precision(12);
 
     mitk::NavigationData::PositionType position;
     position.Fill(0.0);
     position = m_NavData->GetPosition();
 
     mitk::NavigationData::OrientationType orientation(0.0, 0.0, 0.0, 0.0);
     orientation = m_NavData->GetOrientation();
 
     s << "Translation: [" << position[0] << ", " << position[1] << ", "
         << position[2] << "]";
     s << ", orientation: [" << orientation[0] << ", " << orientation[1] << ", "
         << orientation[2] << ", " << orientation[3] << "]";
     s << ", valid: [" << (this->IsValid()? "true": "false") << "]";
 
     return s.str();
   }
 
   void mitk::Transform::ToXML(TiXmlElement* elem) const
   {
     std::string value = elem->ValueStr();
     if(value.empty())
       elem->SetValue(this->GetNameOfClass());
 
     mitk::NavigationData::PositionType position;
     position.Fill(0.0);
     position = m_NavData->GetPosition();
 
     mitk::NavigationData::OrientationType orientation(0.0, 0.0, 0.0, 0.0);
     orientation = m_NavData->GetOrientation();
 
     mitk::NavigationData::CovarianceMatrixType matrix;
     matrix.SetIdentity();
     matrix = m_NavData->GetCovErrorMatrix();
 
     bool hasPosition = true;
     hasPosition = m_NavData->GetHasPosition();
     bool hasOrientation = true;
     hasOrientation = m_NavData->GetHasOrientation();
     bool dataValid = false;
     dataValid = m_NavData->IsDataValid();
     mitk::NavigationData::TimeStampType timestamp=0.0;
 
     elem->SetAttribute("Type", m_Type);
     elem->SetDoubleAttribute("Time", timestamp);
     elem->SetDoubleAttribute("X", position[0]);
     elem->SetDoubleAttribute("Y", position[1]);
     elem->SetDoubleAttribute("Z", position[2]);
 
     elem->SetDoubleAttribute("QX", orientation[0]);
     elem->SetDoubleAttribute("QY", orientation[1]);
     elem->SetDoubleAttribute("QZ", orientation[2]);
     elem->SetDoubleAttribute("QR", orientation[3]);
 
     elem->SetDoubleAttribute("C00", matrix[0][0]);
     elem->SetDoubleAttribute("C01", matrix[0][1]);
     elem->SetDoubleAttribute("C02", matrix[0][2]);
     elem->SetDoubleAttribute("C03", matrix[0][3]);
     elem->SetDoubleAttribute("C04", matrix[0][4]);
     elem->SetDoubleAttribute("C05", matrix[0][5]);
     elem->SetDoubleAttribute("C10", matrix[1][0]);
     elem->SetDoubleAttribute("C11", matrix[1][1]);
     elem->SetDoubleAttribute("C12", matrix[1][2]);
     elem->SetDoubleAttribute("C13", matrix[1][3]);
     elem->SetDoubleAttribute("C14", matrix[1][4]);
     elem->SetDoubleAttribute("C15", matrix[1][5]);
 
     if (dataValid)
       elem->SetAttribute("Valid",1);
     else
       elem->SetAttribute("Valid",0);
 
     if (hasOrientation)
       elem->SetAttribute("hO",1);
     else
       elem->SetAttribute("hO",0);
 
     if (hasPosition)
       elem->SetAttribute("hP",1);
     else
       elem->SetAttribute("hP",0);
   }
 
   void mitk::Transform::FromXML(TiXmlElement* elem)
   {
     assert(elem);
 
     mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
     mitk::NavigationData::PositionType position;
     mitk::NavigationData::OrientationType orientation(0.0,0.0,0.0,0.0);
     mitk::NavigationData::TimeStampType timestamp = -1;
     mitk::NavigationData::CovarianceMatrixType matrix;
 
     bool hasPosition = true;
     bool hasOrientation = true;
     bool dataValid = false;
 
     position.Fill(0.0);
     matrix.SetIdentity();
 
     std::string type = Transform::UNKNOWN_TYPE;
     elem->QueryStringAttribute("Type", &type);
     elem->QueryDoubleAttribute("Time",&timestamp);
 
     // position and orientation is mandatory!
     if(elem->QueryFloatAttribute("X", &position[0]) != TIXML_SUCCESS)
       throw std::invalid_argument("No X position found in xml");
     if(elem->QueryFloatAttribute("Y", &position[1]) != TIXML_SUCCESS)
       throw std::invalid_argument("No Y position found in xml");
     if(elem->QueryFloatAttribute("Z", &position[2]) != TIXML_SUCCESS)
       throw std::invalid_argument("No Z position found in xml");
 
     if(elem->QueryFloatAttribute("QX", &orientation[0]) != TIXML_SUCCESS)
       throw std::invalid_argument("No QX orientation found in xml");
     if(elem->QueryFloatAttribute("QY", &orientation[1]) != TIXML_SUCCESS)
       throw std::invalid_argument("No QY orientation found in xml");
     if(elem->QueryFloatAttribute("QZ", &orientation[2]) != TIXML_SUCCESS)
       throw std::invalid_argument("No QZ orientation found in xml");
     if(elem->QueryFloatAttribute("QR", &orientation[3]) != TIXML_SUCCESS)
       throw std::invalid_argument("No QR orientation found in xml");
 
     elem->QueryFloatAttribute("C00", &matrix[0][0]);
     elem->QueryFloatAttribute("C01", &matrix[0][1]);
     elem->QueryFloatAttribute("C02", &matrix[0][2]);
     elem->QueryFloatAttribute("C03", &matrix[0][3]);
     elem->QueryFloatAttribute("C04", &matrix[0][4]);
     elem->QueryFloatAttribute("C05", &matrix[0][5]);
     elem->QueryFloatAttribute("C10", &matrix[1][0]);
     elem->QueryFloatAttribute("C11", &matrix[1][1]);
     elem->QueryFloatAttribute("C12", &matrix[1][2]);
     elem->QueryFloatAttribute("C13", &matrix[1][3]);
     elem->QueryFloatAttribute("C14", &matrix[1][4]);
     elem->QueryFloatAttribute("C15", &matrix[1][5]);
 
     int tmpval = 0;
     elem->QueryIntAttribute("Valid", &tmpval);
     if (tmpval == 0)
       dataValid = false;
     else
       dataValid = true;
 
     tmpval = 0;
     elem->QueryIntAttribute("hO", &tmpval);
     if (tmpval == 0)
       hasOrientation = false;
     else
       hasOrientation = true;
 
     tmpval = 0;
     elem->QueryIntAttribute("hP", &tmpval);
     if (tmpval == 0)
       hasPosition = false;
     else
       hasPosition = true;
 
     nd->SetTimeStamp(timestamp);
     nd->SetPosition(position);
     nd->SetOrientation(orientation);
     nd->SetCovErrorMatrix(matrix);
     nd->SetDataValid(dataValid);
     nd->SetHasOrientation(hasOrientation);
     nd->SetHasPosition(hasPosition);
 
     m_NavData = nd;
     m_Type = type;
 
     this->Modified();
   }
 
 } // namespace mitk
 
 std::ostream& operator<< (std::ostream& os, mitk::Transform::Pointer p)
 {
   os << p->ToString();
   return os;
 }
diff --git a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp
index f6280ea369..b88a11c72c 100644
--- a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp
+++ b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp
@@ -1,757 +1,784 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkIGTTrackingLabView.h"
 #include "QmitkStdMultiWidget.h"
 
 #include <QmitkNDIConfigurationWidget.h>
 #include <QmitkFiducialRegistrationWidget.h>
 #include <QmitkUpdateTimerWidget.h>
 #include <QmitkToolSelectionWidget.h>
 #include <QmitkToolTrackingStatusWidget.h>
 
 
 #include <mitkCone.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkTransform.h>
 
 #include <vtkConeSource.h>
 #include <vtkTransform.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkAppendPolyData.h>
 #include <vtkLandmarkTransform.h>
 #include <vtkSmartPointer.h>
 #include <vtkPoints.h>
 
 // Qt
 #include <QMessageBox>
 #include <QIcon>
 
 
 const std::string QmitkIGTTrackingLabView::VIEW_ID = "org.mitk.views.igttrackinglab";
 
 QmitkIGTTrackingLabView::QmitkIGTTrackingLabView()
 : QmitkFunctionality()
 ,m_Source(NULL)
 ,m_PermanentRegistrationFilter(NULL)
 ,m_Visualizer(NULL)
 ,m_VirtualView(NULL)
 ,m_PSRecordingPointSet(NULL)
 ,m_RegistrationTrackingFiducialsName("Tracking Fiducials")
 ,m_RegistrationImageFiducialsName("Image Fiducials")
 ,m_PointSetRecordingDataNodeName("Recorded Points")
 ,m_PointSetRecording(false)
 ,m_PermanentRegistration(false)
 ,m_CameraView(false)
 ,m_ImageFiducialsDataNode(NULL)
 ,m_TrackerFiducialsDataNode(NULL)
 ,m_PermanentRegistrationSourcePoints(NULL)
 {
 
   //[-1;0;0] for WOLF_6D bronchoscope
   m_DirectionOfProjectionVector[0]=0;
   m_DirectionOfProjectionVector[1]=0;
   m_DirectionOfProjectionVector[2]=-1;}
 
 QmitkIGTTrackingLabView::~QmitkIGTTrackingLabView()
 {
   if (m_Timer->isActive()) m_Timer->stop();
 }
 
 void QmitkIGTTrackingLabView::CreateQtPartControl( QWidget *parent )
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi( parent );
 
   m_ToolBox = m_Controls.m_ToolBox;
 
   this->CreateBundleWidgets( parent );
   this->CreateConnections();
 }
 
 
 void QmitkIGTTrackingLabView::CreateBundleWidgets( QWidget* parent )
 {
   //initialize registration widget
   m_RegistrationWidget = m_Controls.m_RegistrationWidget;
   m_RegistrationWidget->HideStaticRegistrationRadioButton(true);
   m_RegistrationWidget->HideContinousRegistrationRadioButton(true);
   m_RegistrationWidget->HideUseICPRegistrationCheckbox(true);
 }
 
 
 void QmitkIGTTrackingLabView::CreateConnections()
 {
   m_Timer = new QTimer(this);
   connect(m_Timer, SIGNAL(timeout()), this, SLOT(UpdateTimer()));
   connect( m_ToolBox, SIGNAL(currentChanged(int)), this, SLOT(OnToolBoxCurrentChanged(int)) );
   connect( m_Controls.m_UsePermanentRegistrationToggle, SIGNAL(toggled(bool)), this, SLOT(OnPermanentRegistration(bool)) );
   connect( m_Controls.m_TrackingDeviceSelectionWidget, SIGNAL(NavigationDataSourceSelected(mitk::NavigationDataSource::Pointer)), this, SLOT(OnSetupNavigation()) );
   connect( m_Controls.m_UseAsPointerButton, SIGNAL(clicked()), this, SLOT(OnInstrumentSelected()) );
   connect( m_Controls.m_UseAsObjectmarkerButton, SIGNAL(clicked()), this, SLOT(OnObjectmarkerSelected()) );
   connect( m_RegistrationWidget, SIGNAL(AddedTrackingFiducial()), this, SLOT(OnAddRegistrationTrackingFiducial()) );
   connect( m_RegistrationWidget, SIGNAL(PerformFiducialRegistration()), this, SLOT(OnRegisterFiducials()) );
   connect( m_Controls.m_PointSetRecordCheckBox, SIGNAL(toggled(bool)), this, SLOT(OnPointSetRecording(bool)) );
   connect( m_Controls.m_ActivateNeedleView, SIGNAL(toggled(bool)), this, SLOT(OnVirtualCamera(bool)) );
 
   //start timer
   m_Timer->start(30);
 
   //initialize Combo Boxes
   m_Controls.m_ObjectComboBox->SetDataStorage(this->GetDataStorage());
   m_Controls.m_ObjectComboBox->SetAutoSelectNewItems(false);
   m_Controls.m_ObjectComboBox->SetPredicate(mitk::NodePredicateDataType::New("Surface"));
 
   m_Controls.m_ImageComboBox->SetDataStorage(this->GetDataStorage());
   m_Controls.m_ImageComboBox->SetAutoSelectNewItems(false);
   m_Controls.m_ImageComboBox->SetPredicate(mitk::NodePredicateDataType::New("Image"));
 }
 
 void QmitkIGTTrackingLabView::UpdateTimer()
   {
   if (m_PermanentRegistration && m_PermanentRegistrationFilter.IsNotNull())
     {
-      mitk::Transform::Pointer newTransform = mitk::Transform::New();
-      newTransform->Concatenate(m_T_MarkerRel);
-      newTransform->Concatenate(mitk::Transform::New(m_ObjectmarkerNavigationData));
-      this->m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(newTransform->GetAffineTransform3D());
+
+      if(m_Controls.m_SurfaceActive->isChecked())
+        {
+        mitk::Transform::Pointer newTransform = mitk::Transform::New();
+        newTransform->Concatenate(m_T_MarkerRel);
+        newTransform->Concatenate(mitk::Transform::New(m_ObjectmarkerNavigationData));
+        this->m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(newTransform->GetAffineTransform3D());
+        }
+      if(m_Controls.m_ImageActive->isChecked())
+        {
+        /*
+        mitk::AffineTransform3D::Pointer imageTransform = m_T_ImageGeo;
+        imageTransform->Compose(newTransform->GetAffineTransform3D());
+        mitk::AffineTransform3D::Pointer newImageTransform = mitk::AffineTransform3D::New(); //create new image transform... setting the composed directly leads to an error
+        itk::Matrix<float,3,3> rotationFloatNew = imageTransform->GetMatrix();
+        itk::Vector<float,3> translationFloatNew = imageTransform->GetOffset();
+        newImageTransform->SetMatrix(rotationFloatNew);
+        newImageTransform->SetOffset(translationFloatNew);
+        m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(newImageTransform);
+        */
+
+        mitk::AffineTransform3D::Pointer newTransform = mitk::AffineTransform3D::New();
+        newTransform->SetIdentity();
+        newTransform->Compose(m_T_ImageGeo);
+        newTransform->Compose(m_T_MarkerRel->GetAffineTransform3D());
+        newTransform->Compose(mitk::Transform::New(m_ObjectmarkerNavigationData)->GetAffineTransform3D());
+        this->m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(newTransform);
+
+        }
     }
 
   if (m_CameraView && m_VirtualView.IsNotNull()) {m_VirtualView->Update();}
 
   if(m_PointSetRecording && m_PSRecordingPointSet.IsNotNull())
     {
       int size = m_PSRecordingPointSet->GetSize();
       mitk::NavigationData::Pointer nd = m_PointSetRecordingNavigationData;
 
       if(size > 0)
       {
         mitk::Point3D p = m_PSRecordingPointSet->GetPoint(size-1);
         if(p.EuclideanDistanceTo(nd->GetPosition()) > (double) m_Controls.m_PSRecordingSpinBox->value())
           m_PSRecordingPointSet->InsertPoint(size, nd->GetPosition());
       }
       else
         m_PSRecordingPointSet->InsertPoint(size, nd->GetPosition());
     }
   }
 
 
 void QmitkIGTTrackingLabView::OnAddRegistrationTrackingFiducial()
 {
   mitk::NavigationData::Pointer nd = m_InstrumentNavigationData;
 
   if( nd.IsNull() || !nd->IsDataValid())
   {
     QMessageBox::warning( 0, "Invalid tracking data", "Navigation data is not available or invalid!", QMessageBox::Ok );
     return;
   }
 
   if(m_TrackerFiducialsDataNode.IsNotNull() && m_TrackerFiducialsDataNode->GetData() != NULL)
   {
     mitk::PointSet::Pointer ps = dynamic_cast<mitk::PointSet*>(m_TrackerFiducialsDataNode->GetData());
     ps->InsertPoint(ps->GetSize(), nd->GetPosition());
   }
   else
     QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "Can not access Tracker Fiducials. Adding fiducial not possible!");
 }
 
 void QmitkIGTTrackingLabView::OnInstrumentSelected()
 {
   if (m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedNavigationDataSource().IsNotNull())
     {
     m_InstrumentNavigationData = m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedToolID());
     }
   else
     {
     m_Controls.m_PointerNameLabel->setText("<not available>");
     return;
     }
 
   if (m_InstrumentNavigationData.IsNotNull())
     {
     m_Controls.m_PointerNameLabel->setText(m_InstrumentNavigationData->GetName());
     }
   else
     {
     m_Controls.m_PointerNameLabel->setText("<not available>");
     }
 }
 
 void QmitkIGTTrackingLabView::OnObjectmarkerSelected()
 {
 
 if (m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedNavigationDataSource().IsNotNull())
     {
     m_ObjectmarkerNavigationData = m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_Controls.m_TrackingDeviceSelectionWidget->GetSelectedToolID());
     }
   else
     {
     m_Controls.m_ObjectmarkerNameLabel->setText("<not available>");
     return;
     }
 
   if (m_ObjectmarkerNavigationData.IsNotNull())
     {
     m_Controls.m_ObjectmarkerNameLabel->setText(m_ObjectmarkerNavigationData->GetName());
     }
   else
     {
     m_Controls.m_ObjectmarkerNameLabel->setText("<not available>");
     }
 }
 
 void QmitkIGTTrackingLabView::OnSetupNavigation()
 {
   MITK_INFO << "SetupNavigationCalled";
   if(m_Source.IsNotNull())
     if(m_Source->IsTracking())
       return;
 
   mitk::DataStorage* ds = this->GetDefaultDataStorage();
   if(ds == NULL)
   {
     QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "can not access DataStorage. Navigation not possible");
     return;
   }
 
   // Building up the filter pipeline
   try
   {
     this->SetupIGTPipeline();
 
   }
   catch(std::exception& e)
   {
     QMessageBox::warning(NULL, QString("IGTSurfaceTracker: Error"), QString("Error while building the IGT-Pipeline: %1").arg(e.what()));
     this->DestroyIGTPipeline(); // destroy the pipeline if building is incomplete
     return;
   }
   catch(...)
   {
     QMessageBox::warning(NULL, QString("IGTSurfaceTracker: Error"), QString("Error while building the IGT-Pipeline"));
     this->DestroyIGTPipeline();
     return;
   }
 }
 
 void QmitkIGTTrackingLabView::SetupIGTPipeline()
 {
   this->InitializeRegistration(); //initializes the registration widget
 }
 
 void QmitkIGTTrackingLabView::InitializeFilters()
 {
 
 }
 
 void QmitkIGTTrackingLabView::OnRegisterFiducials()
 {
   //Check for initialization
   if (!CheckRegistrationInitialization()) return;
 
   /* retrieve fiducials from data storage */
   mitk::DataStorage* ds = this->GetDefaultDataStorage();
   mitk::PointSet::Pointer imageFiducials = dynamic_cast<mitk::PointSet*>(m_ImageFiducialsDataNode->GetData());
   mitk::PointSet::Pointer trackerFiducials = dynamic_cast<mitk::PointSet*>(m_TrackerFiducialsDataNode->GetData());
 
   //convert point sets to vtk poly data
   vtkSmartPointer<vtkPoints> sourcePoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkPoints> targetPoints = vtkSmartPointer<vtkPoints>::New();
   for (int i=0; i<imageFiducials->GetSize(); i++)
     {
     double point[3] = {imageFiducials->GetPoint(i)[0],imageFiducials->GetPoint(i)[1],imageFiducials->GetPoint(i)[2]};
     sourcePoints->InsertNextPoint(point);
     double point_targets[3] = {trackerFiducials->GetPoint(i)[0],trackerFiducials->GetPoint(i)[1],trackerFiducials->GetPoint(i)[2]};
     targetPoints->InsertNextPoint(point_targets);
     }
 
   //compute transform
   vtkSmartPointer<vtkLandmarkTransform> transform = vtkSmartPointer<vtkLandmarkTransform>::New();
   transform->SetSourceLandmarks(sourcePoints);
   transform->SetTargetLandmarks(targetPoints);
   transform->SetModeToRigidBody();
   transform->Modified();
   transform->Update();
 
   //compute FRE
   double FRE = 0;
   for(unsigned int i = 0; i < imageFiducials->GetSize(); i++)
     {
     itk::Point<double> transformed = transform->TransformPoint(imageFiducials->GetPoint(i)[0],imageFiducials->GetPoint(i)[1],imageFiducials->GetPoint(i)[2]);
     double cur_error_squared = transformed.SquaredEuclideanDistanceTo(trackerFiducials->GetPoint(i));
     FRE += cur_error_squared;
     }
 
   FRE = sqrt(FRE/ (double) imageFiducials->GetSize());
   m_Controls.m_RegistrationWidget->SetQualityDisplayText("FRE: " + QString::number(FRE) + " mm");
 
   //convert from vtk to itk data types
   itk::Matrix<float,3,3> rotationFloat = itk::Matrix<float,3,3>();
   itk::Vector<float,3> translationFloat = itk::Vector<float,3>();
   itk::Matrix<double,3,3> rotationDouble = itk::Matrix<double,3,3>();
   itk::Vector<double,3> translationDouble = itk::Vector<double,3>();
 
   vtkSmartPointer<vtkMatrix4x4> m = transform->GetMatrix();
   for(int k=0; k<3; k++) for(int l=0; l<3; l++)
   {
     rotationFloat[k][l] = m->GetElement(k,l);
     rotationDouble[k][l] = m->GetElement(k,l);
 
   }
   for(int k=0; k<3; k++)
   {
     translationFloat[k] = m->GetElement(k,3);
     translationDouble[k] = m->GetElement(k,3);
   }
 
-  MITK_INFO << "MATRIX: ";
+  /*MITK_INFO << "MATRIX: ";
   for(int k=0; k<=3; k++)
     {
     MITK_INFO << m->GetElement(k,0) << " " << m->GetElement(k,1) << " " << m->GetElement(k,2) << " " << m->GetElement(k,3);
-    }
+    }*/
 
   //save transform
   m_T_ObjectReg = mitk::Transform::New();
   m_T_ObjectReg->SetMatrix(m);
 
   //transform surface
   mitk::AffineTransform3D::Pointer newTransform = mitk::AffineTransform3D::New();
   newTransform->SetMatrix(rotationFloat);
   newTransform->SetOffset(translationFloat);
 
   //transform surface
   if(m_Controls.m_SurfaceActive->isChecked() && m_Controls.m_ObjectComboBox->GetSelectedNode().IsNotNull())
   {
     m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(newTransform);
   }
 
   //transform ct image
   if(m_Controls.m_ImageActive->isChecked() && m_Controls.m_ImageComboBox->GetSelectedNode().IsNotNull())
   {
     mitk::AffineTransform3D::Pointer imageTransform = m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->GetIndexToWorldTransform();
+    m_T_ImageGeo = mitk::AffineTransform3D::New();
+    m_T_ImageGeo->Compose(imageTransform);
     imageTransform->Compose(newTransform);
     mitk::AffineTransform3D::Pointer newImageTransform = mitk::AffineTransform3D::New(); //create new image transform... setting the composed directly leads to an error
     itk::Matrix<float,3,3> rotationFloatNew = imageTransform->GetMatrix();
     itk::Vector<float,3> translationFloatNew = imageTransform->GetOffset();
     newImageTransform->SetMatrix(rotationFloatNew);
     newImageTransform->SetOffset(translationFloatNew);
     m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(newImageTransform);
+    m_T_ImageReg = m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->GetIndexToWorldTransform();
   }
 
 }
 
 void QmitkIGTTrackingLabView::DestroyIGTPipeline()
 {
   if(m_Source.IsNotNull())
   {
     m_Source->StopTracking();
     m_Source->Disconnect();
     m_Source = NULL;
   }
   m_PermanentRegistrationFilter = NULL;
   m_Visualizer = NULL;
   m_VirtualView = NULL;
 }
 
 void QmitkIGTTrackingLabView::InitializeRegistration()
 {
   mitk::DataStorage* ds = this->GetDefaultDataStorage();
   if( ds == NULL )
     return;
 
 
   m_RegistrationWidget->SetMultiWidget(this->GetActiveStdMultiWidget()); // passing multiwidget to pointsetwidget
 
   if(m_ImageFiducialsDataNode.IsNull())
   {
     m_ImageFiducialsDataNode = mitk::DataNode::New();
     mitk::PointSet::Pointer ifPS = mitk::PointSet::New();
 
     m_ImageFiducialsDataNode->SetData(ifPS);
 
     mitk::Color color;
     color.Set(1.0f, 0.0f, 0.0f);
     m_ImageFiducialsDataNode->SetName(m_RegistrationImageFiducialsName);
     m_ImageFiducialsDataNode->SetColor(color);
     m_ImageFiducialsDataNode->SetBoolProperty( "updateDataOnRender", false );
 
     ds->Add(m_ImageFiducialsDataNode);
   }
   m_RegistrationWidget->SetMultiWidget(this->GetActiveStdMultiWidget());
   m_RegistrationWidget->SetImageFiducialsNode(m_ImageFiducialsDataNode);
 
   if(m_TrackerFiducialsDataNode.IsNull())
   {
     m_TrackerFiducialsDataNode = mitk::DataNode::New();
     mitk::PointSet::Pointer tfPS = mitk::PointSet::New();
     m_TrackerFiducialsDataNode->SetData(tfPS);
 
     mitk::Color color;
     color.Set(0.0f, 1.0f, 0.0f);
     m_TrackerFiducialsDataNode->SetName(m_RegistrationTrackingFiducialsName);
     m_TrackerFiducialsDataNode->SetColor(color);
     m_TrackerFiducialsDataNode->SetBoolProperty( "updateDataOnRender", false );
 
     ds->Add(m_TrackerFiducialsDataNode);
   }
 
   m_RegistrationWidget->SetTrackerFiducialsNode(m_TrackerFiducialsDataNode);
 }
 
 
 void QmitkIGTTrackingLabView::OnToolBoxCurrentChanged(const int index)
 {
   switch (index)
   {
   case RegistrationWidget:
     this->InitializeRegistration();
     break;
 
   default:
     break;
   }
 }
 
 
 mitk::DataNode::Pointer QmitkIGTTrackingLabView::CreateRegistrationFiducialsNode( const std::string& label, const mitk::Color& color)
 {
   mitk::DataNode::Pointer fiducialsNode = mitk::DataNode::New();
   mitk::PointSet::Pointer fiducialsPointSet = mitk::PointSet::New();
 
   fiducialsNode->SetData(fiducialsPointSet);
   fiducialsNode->SetName( label );
   fiducialsNode->SetColor( color );
   fiducialsNode->SetBoolProperty( "updateDataOnRender", false );
 
   return fiducialsNode;
 }
 
 
 void QmitkIGTTrackingLabView::ChangeToolRepresentation( int toolID , mitk::Surface::Pointer surface )
 {
   mitk::DataStorage* ds = this->GetDefaultDataStorage();
   if(ds == NULL)
   {
     QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "Can not access DataStorage. Changing tool representation not possible!");
     return;
   }
 
   mitk::TrackingDevice::Pointer tracker = m_NDIConfigWidget->GetTracker();
   if(tracker.IsNull())
   {
     QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "Can not access Tracker. Changing tool representation not possible!");
     return;
   }
 
   try
   {
     const char* name = tracker->GetTool(toolID)->GetToolName();   // get tool name by id
 
     mitk::DataNode::Pointer toolNode = ds->GetNamedNode(name);
 
     if(toolNode.IsNull())
       return;
 
     toolNode->SetData(surface); // change surface representation of node
     toolNode->SetColor(0.45,0.70,0.85); //light blue like old 5D sensors
     toolNode->Modified();
 
     m_Visualizer->SetRepresentationObject( toolID, toolNode->GetData()); // updating node with changed surface back in visualizer
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   catch(std::exception& e)
   {
     QMessageBox::warning(NULL, QString("IGTSurfaceTracker: Error"), QString("Can not change tool representation!").arg(e.what()));
     return;
   }
 }
 
 void QmitkIGTTrackingLabView::OnPointSetRecording(bool record)
 {
   mitk::DataStorage* ds = this->GetDefaultDataStorage();
 
   if(record)
   {
     if (m_Controls.m_PointSetRecordingToolSelectionWidget->GetSelectedToolID() == -1)
       {
       QMessageBox::warning(NULL, "Error", "No tool selected for point set recording!");
       m_Controls.m_PointSetRecordCheckBox->setChecked(false);
       return;
       }
     m_PointSetRecordingNavigationData = m_Controls.m_PointSetRecordingToolSelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_Controls.m_PointSetRecordingToolSelectionWidget->GetSelectedToolID());
 
     //initialize point set
     mitk::DataNode::Pointer psRecND = ds->GetNamedNode(m_PointSetRecordingDataNodeName);
     if(m_PSRecordingPointSet.IsNull() || psRecND.IsNull())
     {
       m_PSRecordingPointSet = NULL;
       m_PSRecordingPointSet = mitk::PointSet::New();
       mitk::DataNode::Pointer dn = mitk::DataNode::New();
       dn->SetName(m_PointSetRecordingDataNodeName);
       dn->SetColor(0.,1.,0.);
       dn->SetData(m_PSRecordingPointSet);
       ds->Add(dn);
     }
     else
     {
       m_PSRecordingPointSet->Clear();
     }
     m_PointSetRecording = true;
   }
 
   else
   {
     m_PointSetRecording = false;
   }
 }
 
 void QmitkIGTTrackingLabView::GlobalReinit()
 {
   // request global reiinit
   mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
 
   // calculate bounding geometry of these nodes
   mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
 
   // initialize the views to the bounding geometry
   mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
 
   //global reinit end
 }
 
 void QmitkIGTTrackingLabView::OnVirtualCamera(bool on)
 {
 if (m_Controls.m_CameraViewSelection->GetSelectedToolID() == -1)
     {
     m_Controls.m_ActivateNeedleView->setChecked(false);
     QMessageBox::warning(NULL, "Error", "No tool selected for camera view!");
     return;
     }
 
 if(on)
   {
   m_VirtualView = mitk::CameraVisualization::New();
   m_VirtualView->SetInput(m_Controls.m_CameraViewSelection->GetSelectedNavigationDataSource()->GetOutput(m_Controls.m_CameraViewSelection->GetSelectedToolID()));
 
   mitk::Vector3D viewDirection;
   viewDirection[0] = (int)(m_Controls.m_NeedleViewX->isChecked());
   viewDirection[1] = (int)(m_Controls.m_NeedleViewY->isChecked());
   viewDirection[2] = (int)(m_Controls.m_NeedleViewZ->isChecked());
   if (m_Controls.m_NeedleViewInvert->isChecked()) viewDirection *= -1;
   m_VirtualView->SetDirectionOfProjectionInToolCoordinates(viewDirection);
 
   mitk::Vector3D viewUpVector;
   viewUpVector[0] = (int)(m_Controls.m_NeedleUpX->isChecked());
   viewUpVector[1] = (int)(m_Controls.m_NeedleUpY->isChecked());
   viewUpVector[2] = (int)(m_Controls.m_NeedleUpZ->isChecked());
   if (m_Controls.m_NeedleUpInvert->isChecked()) viewUpVector *= -1;
   m_VirtualView->SetViewUpInToolCoordinates(viewUpVector);
 
   m_VirtualView->SetRenderer(this->GetActiveStdMultiWidget()->GetRenderWindow4()->GetRenderer());
   //next line: better code when this plugin is migrated to mitk::abstractview
   //m_VirtualView->SetRenderer(mitk::BaseRenderer::GetInstance(this->GetRenderWindowPart()->GetRenderWindow("3d")->GetRenderWindow()));
   m_CameraView = true;
 
   //make pointer itself invisible
   m_Controls.m_CameraViewSelection->GetSelectedNavigationTool()->GetDataNode()->SetBoolProperty("visible",false);
 
   //disable UI elements
   m_Controls.m_ViewDirectionBox->setEnabled(false);
   m_Controls.m_ViewUpBox->setEnabled(false);
   }
 else
   {
   m_VirtualView = NULL;
   m_CameraView = false;
   m_Controls.m_CameraViewSelection->GetSelectedNavigationTool()->GetDataNode()->SetBoolProperty("visible",true);
 
   m_Controls.m_ViewDirectionBox->setEnabled(true);
   m_Controls.m_ViewUpBox->setEnabled(true);
   }
 
 }
 
 bool QmitkIGTTrackingLabView::CheckRegistrationInitialization()
 {
   mitk::DataStorage* ds = this->GetDefaultDataStorage();
   mitk::PointSet::Pointer imageFiducials = dynamic_cast<mitk::PointSet*>(m_ImageFiducialsDataNode->GetData());
   mitk::PointSet::Pointer trackerFiducials = dynamic_cast<mitk::PointSet*>(m_TrackerFiducialsDataNode->GetData());
 
   if (m_Controls.m_SurfaceActive->isChecked() && m_Controls.m_ObjectComboBox->GetSelectedNode().IsNull())
   {
     std::string warningMessage = "No surface selected for registration.\nRegistration is not possible";
     MITK_WARN << warningMessage;
     QMessageBox::warning(NULL, "Registration not possible", warningMessage.c_str());
     return false;
   }
 
   if (m_Controls.m_ImageActive->isChecked() && m_Controls.m_ImageComboBox->GetSelectedNode().IsNull())
   {
     std::string warningMessage = "No image selected for registration.\nRegistration is not possible";
     MITK_WARN << warningMessage;
     QMessageBox::warning(NULL, "Registration not possible", warningMessage.c_str());
     return false;
   }
 
   if (imageFiducials.IsNull() || trackerFiducials.IsNull())
   {
     std::string warningMessage = "Fiducial data objects not found. \n"
       "Please set 3 or more fiducials in the image and with the tracking system.\n\n"
       "Registration is not possible";
     MITK_WARN << warningMessage;
     QMessageBox::warning(NULL, "Registration not possible", warningMessage.c_str());
     return false;
   }
 
   unsigned int minFiducialCount = 3; // \Todo: move to view option
   if ((imageFiducials->GetSize() < minFiducialCount) || (trackerFiducials->GetSize() < minFiducialCount) || (imageFiducials->GetSize() != trackerFiducials->GetSize()))
   {
     QMessageBox::warning(NULL, "Registration not possible", QString("Not enough fiducial pairs found. At least %1 fiducial must "
       "exist for the image and the tracking system respectively.\n"
       "Currently, %2 fiducials exist for the image, %3 fiducials exist for the tracking system").arg(minFiducialCount).arg(imageFiducials->GetSize()).arg(trackerFiducials->GetSize()));
     return false;
   }
 
   return true;
 }
 
 
 void QmitkIGTTrackingLabView::OnPermanentRegistration(bool on)
 {
   MITK_INFO << "Permanent registration: " << on;
   if(on)
     {
 
     if(!CheckRegistrationInitialization())
     {
       m_Controls.m_UsePermanentRegistrationToggle->setChecked(false);
       return;
     }
 
     //remember initial object transform to calculate the object to marker transform later on
     mitk::Transform::Pointer T_Object = mitk::Transform::New(this->m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData()->GetGeometry()->GetIndexToWorldTransform());
 
     //then reset the transform because we will now start to calculate the permenent registration
     this->m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIdentity();
 
+    this->m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(m_T_ImageGeo);
+
     //create the permanent registration filter
     m_PermanentRegistrationFilter = mitk::NavigationDataObjectVisualizationFilter::New();
 
     //connect filter to source
     m_PermanentRegistrationFilter->SetInput(this->m_ObjectmarkerNavigationData);
 
     //set representation object
     m_PermanentRegistrationFilter->SetRepresentationObject(0,this->m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData());
 
-
-
     //TODO: add image when bug is fixed
 
-
     //get the marker transform out of the navigation data
     mitk::Transform::Pointer T_Marker = mitk::Transform::New(this->m_ObjectmarkerNavigationData);
 
 
     mitk::Transform::Pointer T_MarkerRel = mitk::Transform::New();
     T_MarkerRel->Concatenate(T_Object);
     T_Marker->Invert();
     T_MarkerRel->Concatenate(T_Marker);
 
     //m_PermanentRegistrationFilter->SetOffset(0,T_MarkerRel->GetAffineTransform3D());
     m_T_MarkerRel = T_MarkerRel;
 
     m_PermanentRegistration = true;
     }
   else
     {
     //stop permanent registration
     m_PermanentRegistration = false;
 
     //restore old registration
     if(m_T_ObjectReg.IsNotNull()) this->m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(m_T_ObjectReg->GetAffineTransform3D());
-    //if(m_T_ObjectReg2.IsNotNull()) this->m_Controls.m_ObjectComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(m_T_ObjectReg2);
+    if(m_T_ImageReg.IsNotNull()) this->m_Controls.m_ImageComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(m_T_ImageReg);
 
     //delete filter
     m_PermanentRegistrationFilter = NULL;
     }
 
 
 }
 
 mitk::PointSet::Pointer QmitkIGTTrackingLabView::GetVirtualPointSetFromPosition(mitk::NavigationData::Pointer navigationData)
 {
   typedef itk::QuaternionRigidTransform<double> QuaternionTransformType;
 
   mitk::NavigationData::PositionType pointA;
   mitk::NavigationData::PositionType pointB;
   mitk::NavigationData::PositionType pointC;
 
   //initializing three points with position(0|0|0)
   pointA.Fill(0);
   pointB.Fill(0);
   pointC.Fill(0);
 
   // changing position off all points in order to make them orthogonal
   pointA[0] = 1;
   pointB[1] = 1;
   pointC[2] = 1;
 
   QuaternionTransformType::Pointer quatTransform = QuaternionTransformType::New();
 
   // orientation of NavigationData from parameter
   mitk::NavigationData::OrientationType quatIn = navigationData->GetOrientation();
 
   // set orientation to quaternion transform
   vnl_quaternion<double> const vnlQuatIn(quatIn.x(), quatIn.y(), quatIn.z(), quatIn.r());
   quatTransform->SetRotation(vnlQuatIn);
 
   // transform each point
   pointA = quatTransform->TransformPoint(pointA);
   pointB = quatTransform->TransformPoint(pointB);
   pointC = quatTransform->TransformPoint(pointC);
 
   // add position data from NavigationData parameter to each point
   pointA[0] += navigationData->GetPosition()[0];
   pointA[1] += navigationData->GetPosition()[1];
   pointA[2] += navigationData->GetPosition()[2];
 
   pointB[0] += navigationData->GetPosition()[0];
   pointB[1] += navigationData->GetPosition()[1];
   pointB[2] += navigationData->GetPosition()[2];
 
   pointC[0] += navigationData->GetPosition()[0];
   pointC[1] += navigationData->GetPosition()[1];
   pointC[2] += navigationData->GetPosition()[2];
 
   // insert points in source points pointset for the permanent registration landmark transform
   m_PermanentRegistrationSourcePoints->InsertPoint(0,pointA);
   m_PermanentRegistrationSourcePoints->InsertPoint(1,pointB);
   m_PermanentRegistrationSourcePoints->InsertPoint(2,pointC);
 
 
   return m_PermanentRegistrationSourcePoints;
 }
 
diff --git a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.h b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.h
index 2724062e2a..880384086d 100644
--- a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.h
+++ b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.h
@@ -1,234 +1,235 @@
 /*===================================================================
 
 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 QmitkIGTTrackingLabView_h
 #define QmitkIGTTrackingLabView_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkFunctionality.h>
 
 #include "ui_QmitkIGTTrackingLabViewControls.h"
 
 #include <mitkNavigationDataToPointSetFilter.h>
 #include <mitkNavigationDataLandmarkTransformFilter.h>
 #include <mitkNavigationDataReferenceTransformFilter.h>
 #include <mitkNavigationDataObjectVisualizationFilter.h>
 #include <mitkNavigationDataToPointSetFilter.h>
 #include <mitkTrackingDeviceSource.h>
 #include <mitkSurface.h>
 #include <mitkCameraVisualization.h>
 #include <mitkTransform.h>
 
 #include <QToolBox>
 #include <QCheckBox>
 #include <QComboBox>
 #include <QPushButton>
 #include <QLabel>
 #include <QSpinBox>
 #include <QTimer>
 
 class QmitkNDIConfigurationWidget;
 class QmitkFiducialRegistrationWidget;
 class QmitkUpdateTimerWidget;
 class QmitkToolSelectionWidget;
 class QmitkToolTrackingStatusWidget;
 
 
 /*!
   \brief QmitkIGTTrackingLabView
 
   \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
   \sa QmitkFunctionality
   \ingroup ${plugin_target}_internal
 */
 class QmitkIGTTrackingLabView : public QmitkFunctionality
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     /**
     \brief default constructor
     */
     QmitkIGTTrackingLabView();
 
     /**
     \brief default destructor
     */
     virtual ~QmitkIGTTrackingLabView();
 
     virtual void CreateQtPartControl(QWidget *parent);
 
   protected slots:
 
     void UpdateTimer();
 
     /**
     \brief This method adds a new fiducial to the tracker fiducials PointSet.
     */
     void OnAddRegistrationTrackingFiducial();
     /**
     \brief This method calls the fiducial registration.
     */
     void OnRegisterFiducials();
     /**
     \brief This method sets up the navigation pipeline before tracking is started.
     */
     void OnSetupNavigation();
     /**
     \brief This method reacts on toolbox item changes.
     */
     void OnToolBoxCurrentChanged(int index);
     /**
     \brief This method initializes the registration for the FiducialRegistrationWidget.
     */
     void InitializeRegistration();
     /**
     \brief This method reacts on tool surface changes.
     */
     void ChangeToolRepresentation( int toolID , mitk::Surface::Pointer surface );
     /**
     \brief This method starts the PointSet recording.
     */
     void OnPointSetRecording(bool record);
     /**
     \brief This method activates the virtual camera.
     */
     void OnVirtualCamera(bool on);
     /**
     \brief This method activates the permanent registration based on one tool's position.
     */
     void OnPermanentRegistration(bool on);
 
     void OnInstrumentSelected();
 
     void OnObjectmarkerSelected();
 
 
 
   protected:
 
 
     enum ToolBoxElement  // enums for the different ToolBox item tabs.
     {
       NDIConfigurationWidget = 0,
       RegistrationWidget = 1,
       PermanentRecording = 2,
       PointSetRecording = 3,
       VirtualCamera = 4
     };
 
 
     Ui::QmitkIGTTrackingLabViewControls m_Controls;
     /**
     \brief This method creates all widgets this bundle needs.
     */
     void CreateBundleWidgets( QWidget* parent );
     /**
     \brief This method creates the SIGNAL SLOT connections.
     */
     void CreateConnections();
     /**
     \brief This method sets up the filter pipeline.
     */
     void SetupIGTPipeline();
     /**
     \brief This method initializes all needed filters.
     */
     void InitializeFilters();
     /**
     \brief This method destroys the filter pipeline.
     */
     void DestroyIGTPipeline();
 
 
     /**
     \brief This method creates a DataNode for fiducial PointSets.
     */
     mitk::DataNode::Pointer CreateRegistrationFiducialsNode( const std::string& label, const mitk::Color& color);
 
     /**
     \brief This method returns a PointSet with three vritual points transformed from the position and orientation of the given NavigationData. This method is needed to calculate the source points for permanent registration from one tool's position.
     */
     mitk::PointSet::Pointer GetVirtualPointSetFromPosition(mitk::NavigationData::Pointer navigationData);
 
 
     mitk::TrackingDeviceSource::Pointer m_Source; ///< source that connects to the tracking device
 
     mitk::NavigationDataObjectVisualizationFilter::Pointer m_PermanentRegistrationFilter; ///< this filter transforms from tracking coordinates into mitk world coordinates if needed it is interconnected before the FiducialEegistrationFilter
     mitk::NavigationDataObjectVisualizationFilter::Pointer m_Visualizer; ///< visualization filter
     mitk::CameraVisualization::Pointer m_VirtualView; ///< filter to update the vtk camera according to the reference navigation data
 
     mitk::Vector3D  m_DirectionOfProjectionVector;///< vector for direction of projection of instruments
 
     bool CheckRegistrationInitialization();///< Checks if everything is initialized for registration. Gives error messages and returns false if not.
 
 
 
 private:
 
   QTimer* m_Timer;
 
   QToolBox* m_ToolBox;
 
   mitk::PointSet::Pointer m_PSRecordingPointSet;
 
   QmitkNDIConfigurationWidget* m_NDIConfigWidget;  // tracking device configuration widget
   QmitkFiducialRegistrationWidget* m_RegistrationWidget; // landmark registration widget
 
   std::string m_RegistrationTrackingFiducialsName;
   std::string m_RegistrationImageFiducialsName;
 
   std::string m_PointSetRecordingDataNodeName;
   bool m_PointSetRecording;
   bool m_PermanentRegistration;
   bool m_CameraView;
 
   mitk::DataNode::Pointer m_ImageFiducialsDataNode;
   mitk::DataNode::Pointer m_TrackerFiducialsDataNode;
 
   QmitkToolSelectionWidget* m_PermanentRegistrationToolSelectionWidget;
   QmitkToolSelectionWidget* m_VirtualViewToolSelectionWidget;
 
   mitk::NavigationData::PositionType m_TargetPosition;
   mitk::NavigationData::OrientationType m_PermanentRegistrationInitialOrientation;
 
   mitk::PointSet::Pointer m_PermanentRegistrationSourcePoints;
 
   mitk::NavigationData::Pointer m_InstrumentNavigationData;
   mitk::NavigationData::Pointer m_ObjectmarkerNavigationData;
   mitk::NavigationData::Pointer m_PointSetRecordingNavigationData;
 
   mitk::Transform::Pointer m_T_MarkerRel;
   mitk::Transform::Pointer m_T_ObjectReg;
-  mitk::AffineTransform3D::Pointer m_T_ObjectReg2;
+  mitk::AffineTransform3D::Pointer m_T_ImageReg;
+  mitk::AffineTransform3D::Pointer m_T_ImageGeo;
 
   /**
     \brief This method performs GlobalReinit() for the rendering widgets.
     */
   void GlobalReinit();
 
 };
 
 #endif // QmitkIGTTrackingLabView_h