diff --git a/Core/Code/DataManagement/mitkGeometry3D.cpp b/Core/Code/DataManagement/mitkGeometry3D.cpp
index fea5c250d7..9bf1db25a6 100644
--- a/Core/Code/DataManagement/mitkGeometry3D.cpp
+++ b/Core/Code/DataManagement/mitkGeometry3D.cpp
@@ -1,817 +1,817 @@
 /*===================================================================
 
 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 <sstream>
 
 #include "mitkGeometry3D.h"
 #include "mitkMatrixConvert.h"
 #include "mitkRotationOperation.h"
 #include "mitkRestorePlanePositionOperation.h"
 #include "mitkPointOperation.h"
 #include "mitkInteractionConst.h"
 //#include "mitkStatusBar.h"
 
 #include <vtkMatrixToLinearTransform.h>
 #include <vtkMatrix4x4.h>
 
 // Standard constructor for the New() macro. Sets the geometry to 3 dimensions
 mitk::Geometry3D::Geometry3D()
   : m_ParametricBoundingBox(NULL),
     m_ImageGeometry(false), m_Valid(true), m_FrameOfReferenceID(0), m_IndexToWorldTransformLastModified(0)
 {
   FillVector3D(m_FloatSpacing, 1,1,1);
   m_VtkMatrix = vtkMatrix4x4::New();
   m_VtkIndexToWorldTransform = vtkMatrixToLinearTransform::New();
   m_VtkIndexToWorldTransform->SetInput(m_VtkMatrix);
   Initialize();
 }
 mitk::Geometry3D::Geometry3D(const Geometry3D& other) : Superclass(), mitk::OperationActor(), m_ParametricBoundingBox(other.m_ParametricBoundingBox),m_TimeBounds(other.m_TimeBounds),
   m_ImageGeometry(other.m_ImageGeometry), m_Valid(other.m_Valid), m_FrameOfReferenceID(other.m_FrameOfReferenceID), m_IndexToWorldTransformLastModified(other.m_IndexToWorldTransformLastModified), m_RotationQuaternion( other.m_RotationQuaternion ) , m_Origin(other.m_Origin)
 {
   // AffineGeometryFrame
   SetBounds(other.GetBounds());
   //SetIndexToObjectTransform(other.GetIndexToObjectTransform());
   //SetObjectToNodeTransform(other.GetObjectToNodeTransform());
   //SetIndexToWorldTransform(other.GetIndexToWorldTransform());
   // this is not used in AffineGeometryFrame of ITK, thus there are not Get and Set methods
   // m_IndexToNodeTransform = other.m_IndexToNodeTransform;
   // m_InvertedTransform = TransformType::New();
   // m_InvertedTransform = TransformType::New();
   // m_InvertedTransform->DeepCopy(other.m_InvertedTransform);
   m_VtkMatrix = vtkMatrix4x4::New();
   m_VtkMatrix->DeepCopy(other.m_VtkMatrix);
   if (other.m_ParametricBoundingBox.IsNotNull())
   {
     m_ParametricBoundingBox = other.m_ParametricBoundingBox->DeepCopy();
   }
   FillVector3D(m_FloatSpacing,other.m_FloatSpacing[0],other.m_FloatSpacing[1],other.m_FloatSpacing[2]);
   m_VtkIndexToWorldTransform = vtkMatrixToLinearTransform::New();
   m_VtkIndexToWorldTransform->DeepCopy(other.m_VtkIndexToWorldTransform);
   m_VtkIndexToWorldTransform->SetInput(m_VtkMatrix);
   other.InitializeGeometry(this);
 }
 
 mitk::Geometry3D::~Geometry3D()
 {
   m_VtkMatrix->Delete();
   m_VtkIndexToWorldTransform->Delete();
 }
 
 
 static void CopySpacingFromTransform(mitk::AffineTransform3D* transform, mitk::Vector3D& spacing, float floatSpacing[3])
 {
   mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
   vnlmatrix = transform->GetMatrix().GetVnlMatrix();
 
   spacing[0]=vnlmatrix.get_column(0).magnitude();
   spacing[1]=vnlmatrix.get_column(1).magnitude();
   spacing[2]=vnlmatrix.get_column(2).magnitude();
   floatSpacing[0]=spacing[0];
   floatSpacing[1]=spacing[1];
   floatSpacing[2]=spacing[2];
 }
 
 
 void mitk::Geometry3D::Initialize()
 {
   float b[6] = {0,1,0,1,0,1};
   SetFloatBounds(b);
 
   if(m_IndexToWorldTransform.IsNull())
     m_IndexToWorldTransform = TransformType::New();
   else
     m_IndexToWorldTransform->SetIdentity();
   CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing);
   vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
 
   m_VtkMatrix->Identity();
 
   m_TimeBounds[0]=ScalarTypeNumericTraits::NonpositiveMin(); m_TimeBounds[1]=ScalarTypeNumericTraits::max();
 
   m_FrameOfReferenceID = 0;
 
   m_ImageGeometry = false;
 }
 
 void mitk::Geometry3D::TransferItkToVtkTransform()
 {
   // copy m_IndexToWorldTransform into m_VtkIndexToWorldTransform
   TransferItkTransformToVtkMatrix(m_IndexToWorldTransform.GetPointer(), m_VtkMatrix);
   m_VtkIndexToWorldTransform->Modified();
 }
 
 void mitk::Geometry3D::TransferVtkToItkTransform()
 {
   TransferVtkMatrixToItkTransform(m_VtkMatrix, m_IndexToWorldTransform.GetPointer());
   CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing);
   vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
 }
 
 void mitk::Geometry3D::SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4* vtkmatrix)
 {
   m_VtkMatrix->DeepCopy(vtkmatrix);
   TransferVtkToItkTransform();
 }
 
 void mitk::Geometry3D::SetTimeBounds(const TimeBounds& timebounds)
 {
   if(m_TimeBounds != timebounds)
   {
     m_TimeBounds = timebounds;
     Modified();
   }
 }
 
 void mitk::Geometry3D::SetFloatBounds(const float bounds[6])
 {
   mitk::BoundingBox::BoundsArrayType b;
   const float *input = bounds;
   int i=0;
   for(mitk::BoundingBox::BoundsArrayType::Iterator it = b.Begin(); i < 6 ;++i) *it++ = (mitk::ScalarType)*input++;
   SetBoundsArray(b, m_BoundingBox);
 }
 
 void mitk::Geometry3D::SetFloatBounds(const double bounds[6])
 {
   mitk::BoundingBox::BoundsArrayType b;
   const double *input = bounds;
   int i=0;
   for(mitk::BoundingBox::BoundsArrayType::Iterator it = b.Begin(); i < 6 ;++i) *it++ = (mitk::ScalarType)*input++;
   SetBoundsArray(b, m_BoundingBox);
 }
 
 void mitk::Geometry3D::SetParametricBounds(const BoundingBox::BoundsArrayType& bounds)
 {
   SetBoundsArray(bounds, m_ParametricBoundingBox);
 }
 
 void mitk::Geometry3D::WorldToIndex(const mitk::Point3D &pt_mm, mitk::Point3D &pt_units) const
 {
   BackTransform(pt_mm, pt_units);
 }
 
 void mitk::Geometry3D::IndexToWorld(const mitk::Point3D &pt_units, mitk::Point3D &pt_mm) const
 {
   pt_mm = m_IndexToWorldTransform->TransformPoint(pt_units);
 }
 
 void mitk::Geometry3D::WorldToIndex(const mitk::Point3D & /*atPt3d_mm*/, const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const
 {
   MITK_WARN<<"Warning! Call of the deprecated function Geometry3D::WorldToIndex(point, vec, vec). Use Geometry3D::WorldToIndex(vec, vec) instead!";
   //BackTransform(atPt3d_mm, vec_mm, vec_units);
   this->WorldToIndex(vec_mm, vec_units);
 }
 
 void mitk::Geometry3D::WorldToIndex( const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const
 {
   BackTransform( vec_mm, vec_units);
 }
 
 void mitk::Geometry3D::IndexToWorld(const mitk::Point3D &/*atPt3d_units*/, const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const
 {
   MITK_WARN<<"Warning! Call of the deprecated function Geometry3D::IndexToWorld(point, vec, vec). Use Geometry3D::IndexToWorld(vec, vec) instead!";
   //vec_mm = m_IndexToWorldTransform->TransformVector(vec_units);
   this->IndexToWorld(vec_units, vec_mm);
 }
 
 void mitk::Geometry3D::IndexToWorld(const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const
 {
   vec_mm = m_IndexToWorldTransform->TransformVector(vec_units);
 }
 
 void mitk::Geometry3D::SetIndexToWorldTransform(mitk::AffineTransform3D* transform)
 {
   if(m_IndexToWorldTransform.GetPointer() != transform)
   {
     m_IndexToWorldTransform = transform;
     CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing);
     vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
     TransferItkToVtkTransform();
     Modified();
   }
 }
 
 mitk::Geometry3D::Pointer mitk::Geometry3D::Clone() const
 {
   Self::Pointer newGeometry = new Self(*this);
   newGeometry->UnRegister();
   return newGeometry.GetPointer();
 }
 /*
 void mitk::Geometry3D::InitializeGeometry(Geometry3D * newGeometry) const
 {
   Superclass::InitializeGeometry(newGeometry);
 
   newGeometry->SetTimeBounds(m_TimeBounds);
 
   //newGeometry->GetVtkTransform()->SetMatrix(m_VtkIndexToWorldTransform->GetMatrix()); IW
   //newGeometry->TransferVtkToItkTransform(); //MH
 
   newGeometry->SetFrameOfReferenceID(GetFrameOfReferenceID());
   newGeometry->m_ImageGeometry = m_ImageGeometry;
 }
 */
 void mitk::Geometry3D::SetExtentInMM(int direction, ScalarType extentInMM)
 {
   ScalarType len = GetExtentInMM(direction);
   if(fabs(len - extentInMM)>=mitk::eps)
   {
     AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
     vnlmatrix = m_IndexToWorldTransform->GetMatrix().GetVnlMatrix();
     if(len>extentInMM)
       vnlmatrix.set_column(direction, vnlmatrix.get_column(direction)/len*extentInMM);
     else
       vnlmatrix.set_column(direction, vnlmatrix.get_column(direction)*extentInMM/len);
     Matrix3D matrix;
     matrix = vnlmatrix;
     m_IndexToWorldTransform->SetMatrix(matrix);
     Modified();
   }
 }
 
 mitk::BoundingBox::Pointer mitk::Geometry3D::CalculateBoundingBoxRelativeToTransform(const mitk::AffineTransform3D* transform) const
 {
   mitk::BoundingBox::PointsContainer::Pointer pointscontainer=mitk::BoundingBox::PointsContainer::New();
 
   mitk::BoundingBox::PointIdentifier pointid=0;
 
   unsigned char i;
   if(transform!=NULL)
   {
     mitk::AffineTransform3D::Pointer inverse = mitk::AffineTransform3D::New();
     transform->GetInverse(inverse);
     for(i=0; i<8; ++i)
       pointscontainer->InsertElement( pointid++, inverse->TransformPoint( GetCornerPoint(i) ));
   }
   else
   {
     for(i=0; i<8; ++i)
       pointscontainer->InsertElement( pointid++, GetCornerPoint(i) );
   }
 
   mitk::BoundingBox::Pointer result = mitk::BoundingBox::New();
   result->SetPoints(pointscontainer);
   result->ComputeBoundingBox();
 
   return result;
 }
 
 #include <vtkTransform.h>
 void mitk::Geometry3D::ExecuteOperation(Operation* operation)
 {
   vtkTransform *vtktransform = vtkTransform::New();
   vtktransform->SetMatrix(m_VtkMatrix);
   switch (operation->GetOperationType())
   {
   case OpNOTHING:
     break;
   case OpMOVE:
     {
       mitk::PointOperation *pointOp = dynamic_cast<mitk::PointOperation *>(operation);
       if (pointOp == NULL)
       {
         //mitk::StatusBar::GetInstance()->DisplayText("received wrong type of operation!See mitkAffineInteractor.cpp", 10000);
         return;
       }
       mitk::Point3D newPos = pointOp->GetPoint();
       ScalarType data[3];
       vtktransform->GetPosition(data);
       vtktransform->PostMultiply();
       vtktransform->Translate(newPos[0], newPos[1], newPos[2]);
       vtktransform->PreMultiply();
       break;
     }
   case OpSCALE:
     {
       mitk::PointOperation *pointOp = dynamic_cast<mitk::PointOperation *>(operation);
       if (pointOp == NULL)
       {
         //mitk::StatusBar::GetInstance()->DisplayText("received wrong type of operation!See mitkAffineInteractor.cpp", 10000);
         return;
       }
       mitk::Point3D newScale = pointOp->GetPoint();
       ScalarType data[3];
       /* calculate new scale: newscale = oldscale * (oldscale + scaletoadd)/oldscale */
       data[0] = 1 + (newScale[0] / GetMatrixColumn(0).magnitude());
       data[1] = 1 + (newScale[1] / GetMatrixColumn(1).magnitude());
       data[2] = 1 + (newScale[2] / GetMatrixColumn(2).magnitude());
 
       mitk::Point3D center = const_cast<mitk::BoundingBox*>(m_BoundingBox.GetPointer())->GetCenter();
       ScalarType pos[3];
       vtktransform->GetPosition(pos);
       vtktransform->PostMultiply();
       vtktransform->Translate(-pos[0], -pos[1], -pos[2]);
       vtktransform->Translate(-center[0], -center[1], -center[2]);
       vtktransform->PreMultiply();
       vtktransform->Scale(data[0], data[1], data[2]);
       vtktransform->PostMultiply();
       vtktransform->Translate(+center[0], +center[1], +center[2]);
       vtktransform->Translate(pos[0], pos[1], pos[2]);
       vtktransform->PreMultiply();
       break;
     }
   case OpROTATE:
     {
       mitk::RotationOperation *rotateOp = dynamic_cast<mitk::RotationOperation *>(operation);
       if (rotateOp == NULL)
       {
         //mitk::StatusBar::GetInstance()->DisplayText("received wrong type of operation!See mitkAffineInteractor.cpp", 10000);
         return;
       }
       Vector3D rotationVector = rotateOp->GetVectorOfRotation();
       Point3D center = rotateOp->GetCenterOfRotation();
       ScalarType angle = rotateOp->GetAngleOfRotation();
       vtktransform->PostMultiply();
       vtktransform->Translate(-center[0], -center[1], -center[2]);
       vtktransform->RotateWXYZ(angle, rotationVector[0], rotationVector[1], rotationVector[2]);
       vtktransform->Translate(center[0], center[1], center[2]);
       vtktransform->PreMultiply();
       break;
     }
   case OpRESTOREPLANEPOSITION:
   {
       //Copy necessary to avoid vtk warning
       vtkMatrix4x4* matrix = vtkMatrix4x4::New();
       TransferItkTransformToVtkMatrix(dynamic_cast<mitk::RestorePlanePositionOperation*>(operation)->GetTransform().GetPointer(), matrix);
       vtktransform->SetMatrix(matrix);
       break;
   }
 
   default:
     vtktransform->Delete();
     return;
   }
   m_VtkMatrix->DeepCopy(vtktransform->GetMatrix());
   TransferVtkToItkTransform();
   Modified();
   vtktransform->Delete();
 }
 
 void mitk::Geometry3D::BackTransform(const mitk::Point3D &in, mitk::Point3D& out) const
 {
   ScalarType temp[3];
   unsigned int i, j;
   const TransformType::OffsetType& offset = m_IndexToWorldTransform->GetOffset();
 
   // Remove offset
   for (j = 0; j < 3; j++)
   {
     temp[j] = in[j] - offset[j];
   }
 
   // Get WorldToIndex transform
   if (m_IndexToWorldTransformLastModified != m_IndexToWorldTransform->GetMTime())
   {
     m_InvertedTransform = TransformType::New();
     if (!m_IndexToWorldTransform->GetInverse( m_InvertedTransform.GetPointer() ))
     {
       itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed." );
     }
     m_IndexToWorldTransformLastModified = m_IndexToWorldTransform->GetMTime();
   }
 
   // Check for valid matrix inversion
   const TransformType::MatrixType& inverse = m_InvertedTransform->GetMatrix();
   if(inverse.GetVnlMatrix().has_nans())
   {
     itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed. Matrix was: " << std::endl
       << m_IndexToWorldTransform->GetMatrix() << "Suggested inverted matrix is:" << std::endl
       << inverse );
   }
 
   // Transform point
   for (i = 0; i < 3; i++)
   {
     out[i] = 0.0;
     for (j = 0; j < 3; j++)
     {
       out[i] += inverse[i][j]*temp[j];
     }
   }
 }
 
 void mitk::Geometry3D::BackTransform(const mitk::Point3D &/*at*/, const mitk::Vector3D &in, mitk::Vector3D& out) const
 {
   MITK_INFO<<"Warning! Call of the deprecated function Geometry3D::BackTransform(point, vec, vec). Use Geometry3D::BackTransform(vec, vec) instead!";
   //// Get WorldToIndex transform
   //if (m_IndexToWorldTransformLastModified != m_IndexToWorldTransform->GetMTime())
   //{
   //  m_InvertedTransform = TransformType::New();
   //  if (!m_IndexToWorldTransform->GetInverse( m_InvertedTransform.GetPointer() ))
   //  {
   //    itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed." );
   //  }
   //  m_IndexToWorldTransformLastModified = m_IndexToWorldTransform->GetMTime();
   //}
 
   //// Check for valid matrix inversion
   //const TransformType::MatrixType& inverse = m_InvertedTransform->GetMatrix();
   //if(inverse.GetVnlMatrix().has_nans())
   //{
   //  itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed. Matrix was: " << std::endl
   //    << m_IndexToWorldTransform->GetMatrix() << "Suggested inverted matrix is:" << std::endl
   //    << inverse );
   //}
 
   //// Transform vector
   //for (unsigned int i = 0; i < 3; i++)
   //{
   //  out[i] = 0.0;
   //  for (unsigned int j = 0; j < 3; j++)
   //  {
   //    out[i] += inverse[i][j]*in[j];
   //  }
   //}
   this->BackTransform(in, out);
 }
 
 void mitk::Geometry3D::BackTransform(const mitk::Vector3D& in, mitk::Vector3D& out) const
 {
   // Get WorldToIndex transform
   if (m_IndexToWorldTransformLastModified != m_IndexToWorldTransform->GetMTime())
   {
     m_InvertedTransform = TransformType::New();
     if (!m_IndexToWorldTransform->GetInverse( m_InvertedTransform.GetPointer() ))
     {
       itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed." );
     }
     m_IndexToWorldTransformLastModified = m_IndexToWorldTransform->GetMTime();
   }
 
   // Check for valid matrix inversion
   const TransformType::MatrixType& inverse = m_InvertedTransform->GetMatrix();
   if(inverse.GetVnlMatrix().has_nans())
   {
     itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed. Matrix was: " << std::endl
       << m_IndexToWorldTransform->GetMatrix() << "Suggested inverted matrix is:" << std::endl
       << inverse );
   }
 
   // Transform vector
   for (unsigned int i = 0; i < 3; i++)
   {
     out[i] = 0.0;
     for (unsigned int j = 0; j < 3; j++)
     {
       out[i] += inverse[i][j]*in[j];
     }
   }
 }
 
 const float* mitk::Geometry3D::GetFloatSpacing() const
 {
   return m_FloatSpacing;
 }
 
 void mitk::Geometry3D::SetSpacing(const mitk::Vector3D& aSpacing)
 {
   if(mitk::Equal(m_Spacing, aSpacing) == false)
   {
     assert(aSpacing[0]>0 && aSpacing[1]>0 && aSpacing[2]>0);
 
     m_Spacing = aSpacing;
 
     AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
 
     vnlmatrix = m_IndexToWorldTransform->GetMatrix().GetVnlMatrix();
 
     mitk::VnlVector col;
     col = vnlmatrix.get_column(0); col.normalize(); col*=aSpacing[0]; vnlmatrix.set_column(0, col);
     col = vnlmatrix.get_column(1); col.normalize(); col*=aSpacing[1]; vnlmatrix.set_column(1, col);
     col = vnlmatrix.get_column(2); col.normalize(); col*=aSpacing[2]; vnlmatrix.set_column(2, col);
 
     Matrix3D matrix;
     matrix = vnlmatrix;
 
     AffineTransform3D::Pointer transform = AffineTransform3D::New();
     transform->SetMatrix(matrix);
     transform->SetOffset(m_IndexToWorldTransform->GetOffset());
 
     SetIndexToWorldTransform(transform.GetPointer());
 
     itk2vtk(m_Spacing, m_FloatSpacing);
   }
 }
 
 void mitk::Geometry3D::SetOrigin(const Point3D & origin)
 {
   if(origin!=GetOrigin())
   {
     m_Origin = origin;
     m_IndexToWorldTransform->SetOffset(m_Origin.GetVectorFromOrigin());
     Modified();
     TransferItkToVtkTransform();
   }
 }
 
 void mitk::Geometry3D::Translate(const Vector3D & vector)
 {
     if((vector[0] != 0) || (vector[1] != 0) || (vector[2] != 0))
     {
         this->SetOrigin(m_Origin + vector);
 //        m_IndexToWorldTransform->SetOffset(m_IndexToWorldTransform->GetOffset()+vector);
 //        TransferItkToVtkTransform();
 //        Modified();
     }
 }
 
 void mitk::Geometry3D::SetIdentity()
 {
   m_IndexToWorldTransform->SetIdentity();
   m_Origin.Fill(0);
   Modified();
   TransferItkToVtkTransform();
 }
 
-void mitk::Geometry3D::Compose( const mitk::AffineGeometryFrame3D::TransformType * other, bool pre )
+void mitk::Geometry3D::Compose( const mitk::Geometry3D::TransformType * other, bool pre )
 {
   m_IndexToWorldTransform->Compose(other, pre);
   CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing);
   vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
   Modified();
   TransferItkToVtkTransform();
 }
 
 void mitk::Geometry3D::Compose( const vtkMatrix4x4 * vtkmatrix, bool pre )
 {
-  mitk::AffineGeometryFrame3D::TransformType::Pointer itkTransform = mitk::AffineGeometryFrame3D::TransformType::New();
+  mitk::Geometry3D::TransformType::Pointer itkTransform = mitk::Geometry3D::TransformType::New();
   TransferVtkMatrixToItkTransform(vtkmatrix, itkTransform.GetPointer());
   Compose(itkTransform, pre);
 }
 
 const std::string mitk::Geometry3D::GetTransformAsString( TransformType* transformType )
 {
   std::ostringstream out;
 
   out << '[';
 
   for( int i=0; i<3; ++i )
   {
     out << '[';
     for( int j=0; j<3; ++j )
       out << transformType->GetMatrix().GetVnlMatrix().get(i, j) << ' ';
     out << ']';
   }
 
   out << "][";
 
   for( int i=0; i<3; ++i )
     out << transformType->GetOffset()[i] << ' ';
 
   out << "]\0";
 
   return out.str();
 }
 
 void mitk::Geometry3D::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   os << indent << " IndexToWorldTransform: ";
   if(m_IndexToWorldTransform.IsNull())
     os << "NULL" << std::endl;
   else
   {
     // from itk::MatrixOffsetTransformBase
     unsigned int i, j;
     os << std::endl;
     os << indent << "Matrix: " << std::endl;
     for (i = 0; i < 3; i++)
     {
       os << indent.GetNextIndent();
       for (j = 0; j < 3; j++)
       {
         os << m_IndexToWorldTransform->GetMatrix()[i][j] << " ";
       }
       os << std::endl;
     }
 
     os << indent << "Offset: " << m_IndexToWorldTransform->GetOffset() << std::endl;
     os << indent << "Center: " << m_IndexToWorldTransform->GetCenter() << std::endl;
     os << indent << "Translation: " << m_IndexToWorldTransform->GetTranslation() << std::endl;
 
     os << indent << "Inverse: " << std::endl;
     for (i = 0; i < 3; i++)
     {
       os << indent.GetNextIndent();
       for (j = 0; j < 3; j++)
       {
         os << m_IndexToWorldTransform->GetInverseMatrix()[i][j] << " ";
       }
       os << std::endl;
     }
 
     // from itk::ScalableAffineTransform
     os << indent << "Scale : ";
     for (i = 0; i < 3; i++)
     {
       os << m_IndexToWorldTransform->GetScale()[i] << " ";
     }
     os << std::endl;
   }
 
   os << indent << " BoundingBox: ";
   if(m_BoundingBox.IsNull())
     os << "NULL" << std::endl;
   else
   {
     os << indent << "( ";
     for (unsigned int i=0; i<3; i++)
     {
       os << m_BoundingBox->GetBounds()[2*i] << "," << m_BoundingBox->GetBounds()[2*i+1] << " ";
     }
     os << " )" << std::endl;
   }
 
   os << indent << " Origin: " << m_Origin << std::endl;
   os << indent << " ImageGeometry: " << m_ImageGeometry << std::endl;
   os << indent << " Spacing: " << m_Spacing << std::endl;
   os << indent << " TimeBounds: " << m_TimeBounds << std::endl;
 }
 
 mitk::Point3D mitk::Geometry3D::GetCornerPoint(int id) const
 {
   assert(id >= 0);
   assert(m_BoundingBox.IsNotNull());
 
   BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds();
 
   Point3D cornerpoint;
   switch(id)
   {
   case 0: FillVector3D(cornerpoint, bounds[0],bounds[2],bounds[4]); break;
   case 1: FillVector3D(cornerpoint, bounds[0],bounds[2],bounds[5]); break;
   case 2: FillVector3D(cornerpoint, bounds[0],bounds[3],bounds[4]); break;
   case 3: FillVector3D(cornerpoint, bounds[0],bounds[3],bounds[5]); break;
   case 4: FillVector3D(cornerpoint, bounds[1],bounds[2],bounds[4]); break;
   case 5: FillVector3D(cornerpoint, bounds[1],bounds[2],bounds[5]); break;
   case 6: FillVector3D(cornerpoint, bounds[1],bounds[3],bounds[4]); break;
   case 7: FillVector3D(cornerpoint, bounds[1],bounds[3],bounds[5]); break;
   default:
     {
       itkExceptionMacro(<<"A cube only has 8 corners. These are labeled 0-7.");
       return NULL;
     }
   }
   if(m_ImageGeometry)
   {
     // Here i have to adjust the 0.5 offset manually, because the cornerpoint is the corner of the
     // bounding box. The bounding box itself is no image, so it is corner-based
     FillVector3D(cornerpoint, cornerpoint[0]-0.5, cornerpoint[1]-0.5, cornerpoint[2]-0.5);
   }
   return m_IndexToWorldTransform->TransformPoint(cornerpoint);
 }
 
 mitk::Point3D mitk::Geometry3D::GetCornerPoint(bool xFront, bool yFront, bool zFront) const
 {
   assert(m_BoundingBox.IsNotNull());
   BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds();
 
   Point3D cornerpoint;
   cornerpoint[0] = (xFront ? bounds[0] : bounds[1]);
   cornerpoint[1] = (yFront ? bounds[2] : bounds[3]);
   cornerpoint[2] = (zFront ? bounds[4] : bounds[5]);
   if(m_ImageGeometry)
   {
     // Here i have to adjust the 0.5 offset manually, because the cornerpoint is the corner of the
     // bounding box. The bounding box itself is no image, so it is corner-based
     FillVector3D(cornerpoint, cornerpoint[0]-0.5, cornerpoint[1]-0.5, cornerpoint[2]-0.5);
   }
 
   return m_IndexToWorldTransform->TransformPoint(cornerpoint);
 }
 
 void
 mitk::Geometry3D::ResetSubTransforms()
 {
 }
 
 void
 mitk::Geometry3D::ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry )
 {
   // If Geometry is switched to ImageGeometry, you have to put an offset to the origin, because
   // imageGeometries origins are pixel-center-based
   // ... and remove the offset, if you switch an imageGeometry back to a normal geometry
   // For more information please see the Geometry documentation page
 
   if(m_ImageGeometry == isAnImageGeometry)
     return;
 
   const BoundingBox::BoundsArrayType& boundsarray =
     this->GetBoundingBox()->GetBounds();
 
   Point3D  originIndex;
   FillVector3D(originIndex,  boundsarray[0], boundsarray[2], boundsarray[4]);
 
   if(isAnImageGeometry == true)
     FillVector3D( originIndex,
       originIndex[0] + 0.5,
       originIndex[1] + 0.5,
       originIndex[2] + 0.5 );
   else
     FillVector3D( originIndex,
       originIndex[0] - 0.5,
       originIndex[1] - 0.5,
       originIndex[2] - 0.5 );
 
   Point3D originWorld;
 
   originWorld = GetIndexToWorldTransform()
     ->TransformPoint( originIndex );
   // instead could as well call  IndexToWorld(originIndex,originWorld);
 
   SetOrigin(originWorld);
 
   this->SetImageGeometry(isAnImageGeometry);
 }
 
 
 bool mitk::Geometry3D::Is2DConvertable()
 {
    bool isConvertableWithoutLoss = true;
    do
    {
       if (this->GetSpacing()[2] != 1)
       {
          isConvertableWithoutLoss = false;
          break;
       }
       if (this->GetOrigin()[2] != 0)
       {
          isConvertableWithoutLoss = false;
          break;
       }
       mitk::Vector3D col0, col1, col2;
       col0.Set_vnl_vector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0));
       col1.Set_vnl_vector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1));
       col2.Set_vnl_vector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2));
 
       if ((col0[2] != 0) || (col1[2] != 0) || (col2[0] != 0) || (col2[1] != 0) || (col2[2] != 1))
       {
          isConvertableWithoutLoss = false;
          break;
       }
    } while (0);
 
    return isConvertableWithoutLoss;
 }
 
 /** Initialize the geometry */
 void
 mitk::Geometry3D::InitializeGeometry(Geometry3D* newGeometry) const
 {
   newGeometry->SetBounds(m_BoundingBox->GetBounds());
   // we have to create a new transform!!
 
   if(m_IndexToWorldTransform)
   {
     TransformType::Pointer indexToWorldTransform = TransformType::New();
     indexToWorldTransform->SetCenter( m_IndexToWorldTransform->GetCenter() );
     indexToWorldTransform->SetMatrix( m_IndexToWorldTransform->GetMatrix() );
     indexToWorldTransform->SetOffset( m_IndexToWorldTransform->GetOffset() );
     newGeometry->SetIndexToWorldTransform(indexToWorldTransform);
   }
 }
 
 void mitk::Geometry3D::SetBoundsArray(const BoundsArrayType& bounds, BoundingBoxPointer& boundingBox)
 {
   boundingBox = BoundingBoxType::New();
 
   BoundingBoxType::PointsContainer::Pointer pointscontainer =
            BoundingBoxType::PointsContainer::New();
   BoundingBoxType::PointType p;
   BoundingBoxType::PointIdentifier pointid;
 
   for(pointid=0; pointid<2;++pointid)
     {
     unsigned int i;
     for(i=0; i<NDimensions; ++i)
       {
       p[i] = bounds[2*i+pointid];
       }
     pointscontainer->InsertElement(pointid, p);
     }
 
   boundingBox->SetPoints(pointscontainer);
   boundingBox->ComputeBoundingBox();
   this->Modified();
 }
 
 
 /** Set the bounds */
 void mitk::Geometry3D::SetBounds(const BoundsArrayType& bounds)
 {
   SetBoundsArray(bounds, m_BoundingBox);
 }
\ No newline at end of file
diff --git a/Core/Code/DataManagement/mitkGeometry3D.h b/Core/Code/DataManagement/mitkGeometry3D.h
index 51d9b05443..37fad8be90 100644
--- a/Core/Code/DataManagement/mitkGeometry3D.h
+++ b/Core/Code/DataManagement/mitkGeometry3D.h
@@ -1,710 +1,710 @@
 /*===================================================================
 
 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 GEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD
 #define GEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD
 
 #include <MitkExports.h>
 #include <mitkCommon.h>
 #include "mitkVector.h"
 #include "mitkOperationActor.h"
 
 #include <itkIndex.h>
 #include <itkBoundingBox.h>
 #include <itkQuaternionRigidTransform.h>
 #include <itkAffineGeometryFrame.h>
 #include "itkScalableAffineTransform.h"
 #include "itkBoundingBox.h"
 
 class vtkLinearTransform;
 class vtkMatrixToLinearTransform;
 class vtkMatrix4x4;
 
 namespace mitk {
 
 //##Documentation
 //## @brief Standard 3D-BoundingBox typedef
 //##
 //## Standard 3D-BoundingBox typedef to get rid of template arguments (3D, type).
 typedef itk::BoundingBox<unsigned long, 3, ScalarType>   BoundingBox;
 
 //##Documentation
 //## @brief Standard typedef for time-bounds
 typedef itk::FixedArray<ScalarType,2>  TimeBounds;
 typedef itk::FixedArray<ScalarType, 3> FixedArrayType;
 
 typedef itk::AffineGeometryFrame<ScalarType, 3>        AffineGeometryFrame3D;
 
 
 //##Documentation
 //## @brief Describes the geometry of a data object
 //##
 //## At least, it can return the bounding box of the data object.
 //##
 //## The class holds
 //## \li a bounding box which is axes-parallel in intrinsic coordinates
 //## (often integer indices of pixels), to be accessed by
 //## GetBoundingBox()
 //## \li a transform to convert intrinsic coordinates into a
 //## world-coordinate system with coordinates in millimeters
 //## and milliseconds (all are floating point values), to
 //## be accessed by GetIndexToWorldTransform()
 //## \li a life span, i.e. a bounding box in time in ms (with
 //## start and end time), to be accessed by GetTimeBounds().
 //## The default is minus infinity to plus infinity.
 //##
 //## Geometry3D and its sub-classes allow converting between
 //## intrinsic coordinates (called index or unit coordinates)
 //## and world-coordinates (called world or mm coordinates),
 //## e.g. WorldToIndex.
 //## In case you need integer index coordinates, provide an
 //## mitk::Index3D (or itk::Index) as target variable to
 //## WorldToIndex, otherwise you will get a continuous index
 //## (floating point values).
 //##
 //## An important sub-class is SlicedGeometry3D, which descibes
 //## data objects consisting of slices, e.g., objects of type Image.
 //## Conversions between world coordinates (in mm) and unit coordinates
 //## (e.g., pixels in the case of an Image) can be performed.
 //##
 //## For more information on related classes, see \ref Geometry.
 //##
 //## Geometry3D instances referring to an Image need a slightly
 //## different definition of corners, see SetImageGeometry. This
 //## is usualy automatically called by Image.
 //##
 //## Geometry3D have to be initialized in the method GenerateOutputInformation()
 //## of BaseProcess (or CopyInformation/ UpdateOutputInformation of BaseData,
 //## if possible, e.g., by analyzing pic tags in Image) subclasses. See also
 //## itk::ProcessObject::GenerateOutputInformation(),
 //## itk::DataObject::CopyInformation() and
 //## itk::DataObject::UpdateOutputInformation().
 //##
 //## Rule: everything is in mm (ms) if not stated otherwise.
 //## @ingroup Geometry
 class MITK_CORE_EXPORT Geometry3D : public itk::Object, public OperationActor
 {
 public:
   mitkClassMacro(Geometry3D, itk::Object);
 
   typedef itk::QuaternionRigidTransform< ScalarType > QuaternionTransformType;
   typedef QuaternionTransformType::VnlQuaternionType VnlQuaternionType;
 
   /** Method for creation through the object factory. */
   itkNewMacro(Self);
 
 typedef itk::ScalableAffineTransform<ScalarType, 3>    TransformType;
 typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBoxType;
 typedef BoundingBoxType::BoundsArrayType               BoundsArrayType;
 typedef BoundingBoxType::Pointer                       BoundingBoxPointer;
 
   // a bit of a misuse, but we want only doxygen to see the following:
 #ifdef DOXYGEN_SKIP
   //##Documentation
   //## @brief Get the transformation used to convert from index
   //## to world coordinates
   itkGetObjectMacro(IndexToWorldTransform, AffineTransform3D);
 #endif
   //## @brief Set the transformation used to convert from index
   //## to world coordinates
   virtual void SetIndexToWorldTransform(mitk::AffineTransform3D* transform);
   //##Documentation
   //## @brief Convenience method for setting the ITK transform
   //## (m_IndexToWorldTransform) via an vtkMatrix4x4
   //## \sa SetIndexToWorldTransform
   virtual void SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4* vtkmatrix);
 
 #ifdef DOXYGEN_SKIP
   //##Documentation
   //## @brief Get bounding box (in index/unit coordinates)
   itkGetConstObjectMacro(BoundingBox, BoundingBoxType);
   //##Documentation
   //## @brief Get bounding box (in index/unit coordinates) as a BoundsArrayType
   const BoundsArrayType GetBounds() const
   {
     assert(m_BoundingBox.IsNotNull());
     return m_BoundingBox->GetBounds();
   }
 #endif
   //##Documentation
   //## \brief Set the bounding box (in index/unit coordinates)
   //##
   //## Only possible via the BoundsArray to make clear that a
   //## copy of the bounding-box is stored, not a reference to it.
   virtual void SetBounds(const BoundsArrayType& bounds);
   //##Documentation
   //## @brief Set the bounding box (in index/unit coordinates) via a float array
   virtual void SetFloatBounds(const float bounds[6]);
   //##Documentation
   //## @brief Set the bounding box (in index/unit coordinates) via a double array
   virtual void SetFloatBounds(const double bounds[6]);
 
 
   //##Documentation
   //## @brief When switching from an Image Geometry to a normal Geometry (and the other way around), you have to change the origin as well (See Geometry Documentation)! This function will change the "isImageGeometry" bool flag and changes the origin respectively.
   virtual void ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry );
 
 
   //##Documentation
   //## @brief Checks, if the given geometry can be converted to 2D without information loss
   //## e.g. when a 2D image is saved, the matrix is usually cropped to 2x2, and when you load it back to MITK
   //## it will be filled with standard values. This function checks, if information would be lost during this
   //## procedure
   virtual bool Is2DConvertable();
 
 
   //##Documentation
   //## @brief Get the time bounds (in ms)
   itkGetConstReferenceMacro(TimeBounds, TimeBounds);
   //##Documentation
   //## @brief Set the time bounds (in ms)
   virtual void SetTimeBounds(const TimeBounds& timebounds);
 
   //##Documentation
   //## @brief Get the position of the corner number \a id (in world coordinates)
   //##
   //## See SetImageGeometry for how a corner is defined on images.
   Point3D GetCornerPoint(int id) const;
 
   //##Documentation
   //## @brief Get the position of a corner (in world coordinates)
   //##
   //## See SetImageGeometry for how a corner is defined on images.
   Point3D GetCornerPoint(bool xFront=true, bool yFront=true, bool zFront=true) const;
 
   //##Documentation
   //## @brief Get vector along bounding-box in the specified @a direction in mm
   //##
   //## The length of the vector is the size of the bounding-box in the
   //## specified @a direction in mm
   //## \sa GetMatrixColumn
   Vector3D GetAxisVector(unsigned int direction) const
   {
     Vector3D frontToBack;
     frontToBack.Set_vnl_vector(m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction));
     frontToBack *= GetExtent(direction);
     return frontToBack;
   }
 
   //##Documentation
   //## @brief Get the center of the bounding-box in mm
   //##
   Point3D GetCenter() const
   {
     assert(m_BoundingBox.IsNotNull());
     return m_IndexToWorldTransform->TransformPoint(m_BoundingBox->GetCenter());
   }
 
   //##Documentation
   //## @brief Get the squared length of the diagonal of the bounding-box in mm
   //##
   double GetDiagonalLength2() const
   {
     Vector3D diagonalvector = GetCornerPoint()-GetCornerPoint(false, false, false);
     return diagonalvector.GetSquaredNorm();
   }
 
   //##Documentation
   //## @brief Get the length of the diagonal of the bounding-box in mm
   //##
   double GetDiagonalLength() const
   {
     return sqrt(GetDiagonalLength2());
   }
 
   //##Documentation
   //## @brief Get a VnlVector along bounding-box in the specified
   //## @a direction, length is spacing
   //##
   //## \sa GetAxisVector
   VnlVector GetMatrixColumn(unsigned int direction) const
   {
     return m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction);
   }
 
 #ifdef DOXYGEN_SKIP
   //##Documentation
   //## @brief Get the extent of the bounding box (in index/unit coordinates)
   //##
   //## To access the extent in mm use GetExtentInMM
   ScalarType GetExtent(unsigned int direction) const;
 #endif
 
   //##Documentation
   //## @brief Get the extent of the bounding-box in the specified @a direction in mm
   //##
   //## Equals length of GetAxisVector(direction).
   ScalarType GetExtentInMM(int direction) const
   {
     return m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction).magnitude()*GetExtent(direction);
   }
 
   //##Documentation
   //## @brief Set the extent of the bounding-box in the specified @a direction in mm
   //##
   //## @note This changes the matrix in the transform, @a not the bounds, which are given in units!
   virtual void SetExtentInMM(int direction, ScalarType extentInMM);
 
   //##Documentation
   //## @brief Get the m_IndexToWorldTransform as a vtkLinearTransform
   vtkLinearTransform* GetVtkTransform() const
   {
     return (vtkLinearTransform*)m_VtkIndexToWorldTransform;
   }
 
   //##Documentation
   //## @brief Set the origin, i.e. the upper-left corner of the plane
   //##
   virtual void SetOrigin(const Point3D& origin);
 
   //##Documentation
   //## @brief Translate the origin by a vector
   //##
   virtual void Translate(const Vector3D&  vector);
 
   //##Documentation
   //## @brief Set the transform to identity
   //##
   virtual void SetIdentity();
 
   //##Documentation
   //## @brief Compose new IndexToWorldTransform with a given transform.
   //##
   //## This method composes m_IndexToWorldTransform with another transform,
   //## modifying self to be the composition of self and other.
   //## If the argument pre is true, then other is precomposed with self;
   //## that is, the resulting transformation consists of first applying
   //## other to the source, followed by self. If pre is false or omitted,
   //## then other is post-composed with self; that is the resulting
   //## transformation consists of first applying self to the source,
   //## followed by other.
-  virtual void Compose( const AffineGeometryFrame3D::TransformType * other, bool pre = 0 );
+  virtual void Compose( const Geometry3D::TransformType * other, bool pre = 0 );
 
   //##Documentation
   //## @brief Compose new IndexToWorldTransform with a given vtkMatrix4x4.
   //##
   //## Converts the vtkMatrix4x4 into a itk-transform and calls the previous method.
   virtual void Compose( const vtkMatrix4x4 * vtkmatrix, bool pre = 0 );
 
   //##Documentation
   //## @brief Get the origin, e.g. the upper-left corner of the plane
   const Point3D& GetOrigin() const
   {
     return m_Origin;
   }
 
   //##Documentation
   //## @brief Get the origin as VnlVector
   //##
   //## \sa GetOrigin
   VnlVector GetOriginVnl() const
   {
     return const_cast<Self*>(this)->m_Origin.Get_vnl_vector();
   }
 
   //##Documentation
   //## @brief Convert world coordinates (in mm) of a \em point to (continuous!) index coordinates
   //## \warning If you need (discrete) integer index coordinates (e.g., for iterating easily over an image),
   //## use WorldToIndex(const mitk::Point3D& pt_mm, itk::Index<VIndexDimension> &index).
   //## For further information about coordinates types, please see the Geometry documentation
   void WorldToIndex(const mitk::Point3D& pt_mm, mitk::Point3D& pt_units) const;
 
   //##Documentation
   //## @brief Convert (continuous or discrete) index coordinates of a \em point to world coordinates (in mm)
   //## For further information about coordinates types, please see the Geometry documentation
   void IndexToWorld(const mitk::Point3D& pt_units, mitk::Point3D& pt_mm) const;
 
   //##Documentation
   //## @brief Convert world coordinates (in mm) of a \em vector
   //## \a vec_mm to (continuous!) index coordinates.
   //## @deprecated First parameter (Point3D) is not used. If possible, please use void WorldToIndex(const mitk::Vector3D& vec_mm, mitk::Vector3D& vec_units) const.
   //## For further information about coordinates types, please see the Geometry documentation
   void WorldToIndex(const mitk::Point3D& atPt3d_mm, const mitk::Vector3D& vec_mm, mitk::Vector3D& vec_units) const;
 
   //##Documentation
   //## @brief Convert world coordinates (in mm) of a \em vector
   //## \a vec_mm to (continuous!) index coordinates.
   //## For further information about coordinates types, please see the Geometry documentation
   void WorldToIndex(const mitk::Vector3D& vec_mm, mitk::Vector3D& vec_units) const;
 
   //##Documentation
   //## @brief Convert (continuous or discrete) index coordinates of a \em vector
   //## \a vec_units to world coordinates (in mm)
   //## @deprecated First parameter (Point3D) is not used. If possible, please use void IndexToWorld(const mitk::Vector3D& vec_units, mitk::Vector3D& vec_mm) const.
   //## For further information about coordinates types, please see the Geometry documentation
   void IndexToWorld(const mitk::Point3D& atPt3d_units, const mitk::Vector3D& vec_units, mitk::Vector3D& vec_mm) const;
 
   //##Documentation
   //## @brief Convert (continuous or discrete) index coordinates of a \em vector
   //## \a vec_units to world coordinates (in mm)
   //## For further information about coordinates types, please see the Geometry documentation
   void IndexToWorld(const mitk::Vector3D& vec_units, mitk::Vector3D& vec_mm) const;
 
   //##Documentation
   //## @brief Convert world coordinates (in mm) of a \em point to (discrete!) index coordinates.
   //## This method rounds to integer indices!
   //## For further information about coordinates types, please see the Geometry documentation
   template <unsigned int VIndexDimension>
   void WorldToIndex(const mitk::Point3D& pt_mm, itk::Index<VIndexDimension> &index) const
   {
     typedef itk::Index<VIndexDimension> IndexType;
     mitk::Point3D pt_units;
     this->WorldToIndex(pt_mm, pt_units);
     int i, dim=index.GetIndexDimension();
     if(dim>3)
     {
       index.Fill(0);
       dim=3;
     }
     for(i=0;i<dim;++i){
       //index[i]=itk::Math::RoundHalfIntegerUp<typename IndexType::IndexValueType >( pt_units[i] );
       index[i]=itk::Math::RoundHalfIntegerUp( pt_units[i] );
     }
   }
 
   //##Documentation
   //## @brief Deprecated for use with ITK version 3.10 or newer.
   //## Convert world coordinates (in mm) of a \em point to
   //## ITK physical coordinates (in mm, but without a possible rotation)
   //##
   //## This method is useful if you have want to access an mitk::Image
   //## via an itk::Image. ITK v3.8 and older did not support rotated (tilted)
   //## images, i.e., ITK images are always parallel to the coordinate axes.
   //## When accessing a (possibly rotated) mitk::Image via an itk::Image
   //## the rotational part of the transformation in the Geometry3D is
   //## simply discarded; in other word: only the origin and spacing is
   //## used by ITK, not the complete matrix available in MITK.
   //## With WorldToItkPhysicalPoint you can convert an MITK world
   //## coordinate (including the rotation) into a coordinate that
   //## can be used with the ITK image as a ITK physical coordinate
   //## (excluding the rotation).
   template<class TCoordRep>
   void WorldToItkPhysicalPoint(const mitk::Point3D& pt_mm,
             itk::Point<TCoordRep, 3>& itkPhysicalPoint) const
   {
       mitk::vtk2itk(pt_mm, itkPhysicalPoint);
   }
 
   //##Documentation
   //## @brief Deprecated for use with ITK version 3.10 or newer.
   //## Convert ITK physical coordinates of a \em point (in mm,
   //## but without a rotation) into MITK world coordinates (in mm)
   //##
   //## For more information, see WorldToItkPhysicalPoint.
   template<class TCoordRep>
   void ItkPhysicalPointToWorld(const itk::Point<TCoordRep, 3>& itkPhysicalPoint,
             mitk::Point3D& pt_mm) const
   {
       mitk::vtk2itk(itkPhysicalPoint, pt_mm);
    }
 
   //##Documentation
   //## @brief Initialize the Geometry3D
   virtual void Initialize();
 
   //##Documentation
   //## @brief Is this an ImageGeometry?
   //##
   //## For more information, see SetImageGeometry
   itkGetConstMacro(ImageGeometry, bool);
   //##Documentation
   //## @brief Define that this Geometry3D is refering to an Image
   //##
   //## A geometry referring to an Image needs a slightly different
   //## definition of the position of the corners (see GetCornerPoint).
   //## The position of a voxel is defined by the position of its center.
   //## If we would use the origin (position of the (center of) the first
   //## voxel) as a corner and display this point, it would seem to be
   //## \em not at the corner but a bit within the image. Even worse for
   //## the opposite corner of the image: here the corner would appear
   //## outside the image (by half of the voxel diameter). Thus, we have
   //## to correct for this and to be able to do that, we need to know
   //## that the Geometry3D is referring to an Image.
   itkSetMacro(ImageGeometry, bool);
   itkBooleanMacro(ImageGeometry);
 
   //##Documentation
   //## @brief Is this Geometry3D in a state that is valid?
   virtual bool IsValid() const
   {
     return m_Valid;
   }
 
   //##Documentation
   //## @brief Test whether the point \a p (world coordinates in mm) is
   //## inside the bounding box
   bool IsInside(const mitk::Point3D& p) const
   {
     mitk::Point3D index;
     WorldToIndex(p, index);
     return IsIndexInside(index);
   }
 
   //##Documentation
   //## @brief Test whether the point \a p ((continous!)index coordinates in units) is
   //## inside the bounding box
   bool IsIndexInside(const mitk::Point3D& index) const
   {
     bool inside = false;
      //if it is an image geometry, we need to convert the index to discrete values
     //this is done by applying the rounding function also used in WorldToIndex (see line 323)
     if (m_ImageGeometry)
     {
       mitk::Point3D discretIndex;
       discretIndex[0]=itk::Math::RoundHalfIntegerUp( index[0] );
       discretIndex[1]=itk::Math::RoundHalfIntegerUp( index[1] );
       discretIndex[2]=itk::Math::RoundHalfIntegerUp( index[2] );
 
       inside = m_BoundingBox->IsInside(discretIndex);
       //we have to check if the index is at the upper border of each dimension,
       // because the boundingbox is not centerbased
       if (inside)
       {
         const BoundingBox::BoundsArrayType& bounds = m_BoundingBox->GetBounds();
         if((discretIndex[0] == bounds[1]) ||
            (discretIndex[1] == bounds[3]) ||
            (discretIndex[2] == bounds[5]))
          inside = false;
       }
     }
     else
       inside = m_BoundingBox->IsInside(index);
 
     return inside;
   }
 
   //##Documentation
   //## @brief Convenience method for working with ITK indices
   template <unsigned int VIndexDimension>
     bool IsIndexInside(const itk::Index<VIndexDimension> &index) const
   {
     int i, dim=index.GetIndexDimension();
     Point3D pt_index;
     pt_index.Fill(0);
     for ( i = 0; i < dim; ++i )
     {
       pt_index[i] = index[i];
     }
     return IsIndexInside(pt_index);
   }
 
 
   //##Documentation
   //## @brief Get the spacing (size of a pixel).
   //##
   itkGetConstReferenceMacro(Spacing, mitk::Vector3D);
 
   //##Documentation
   //## @brief Get the spacing as a float[3] array.
   const float* GetFloatSpacing() const;
 
   //##Documentation
   //## @brief Set the spacing (m_Spacing)
   virtual void SetSpacing(const mitk::Vector3D& aSpacing);
 
   //##Documentation
   //## @brief Get the DICOM FrameOfReferenceID referring to the
   //## used world coordinate system
   itkGetConstMacro(FrameOfReferenceID, unsigned int);
   //##Documentation
   //## @brief Set the DICOM FrameOfReferenceID referring to the
   //## used world coordinate system
   itkSetMacro(FrameOfReferenceID, unsigned int);
 
   //##Documentation
   //## @brief Copy the ITK transform
   //## (m_IndexToWorldTransform) to the VTK transform
   //## \sa SetIndexToWorldTransform
   void TransferItkToVtkTransform();
 
   //##Documentation
   //## @brief Copy the VTK transform
   //## to the ITK transform (m_IndexToWorldTransform)
   //## \sa SetIndexToWorldTransform
   void TransferVtkToItkTransform();
 
   //##Documentation
   //## @brief Get the parametric bounding-box
   //##
   //## See AbstractTransformGeometry for an example usage of this.
   itkGetConstObjectMacro(ParametricBoundingBox, BoundingBox);
   //##Documentation
   //## @brief Get the parametric bounds
   //##
   //## See AbstractTransformGeometry for an example usage of this.
   const BoundingBox::BoundsArrayType& GetParametricBounds() const
   {
     assert(m_ParametricBoundingBox.IsNotNull());
     return m_ParametricBoundingBox->GetBounds();
   }
 
   //##Documentation
   //## @brief Get the parametric extent
   //##
   //## See AbstractTransformGeometry for an example usage of this.
   mitk::ScalarType GetParametricExtent(int direction) const
   {
     assert(direction>=0 && direction<3);
     assert(m_ParametricBoundingBox.IsNotNull());
 
     BoundingBoxType::BoundsArrayType bounds = m_ParametricBoundingBox->GetBounds();
     return bounds[direction*2+1]-bounds[direction*2];
   }
 
   //##Documentation
   //## @brief Get the parametric extent in mm
   //##
   //## See AbstractTransformGeometry for an example usage of this.
   virtual mitk::ScalarType GetParametricExtentInMM(int direction) const
   {
     return GetExtentInMM(direction);
   }
 
   //##Documentation
   //## @brief Get the parametric transform
   //##
   //## See AbstractTransformGeometry for an example usage of this.
   virtual const Transform3D* GetParametricTransform() const
   {
     return m_IndexToWorldTransform;
   }
 
   //##Documentation
   //## @brief Calculates a bounding-box around the geometry relative
   //## to a coordinate system defined by a transform
   //##
   mitk::BoundingBox::Pointer CalculateBoundingBoxRelativeToTransform(const mitk::AffineTransform3D* transform) const;
 
   //##Documentation
   //## @brief clones the geometry
   //##
   //## Overwrite in all sub-classes.
   //## Normally looks like:
   //## \code
   //##  Self::Pointer newGeometry = new Self(*this);
   //##  newGeometry->UnRegister();
   //##  return newGeometry.GetPointer();
   //## \endcode
   virtual Geometry3D::Pointer Clone() const;
 
   //##Documentation
   //##@brief executes affine operations (translate, rotate, scale)
   virtual void ExecuteOperation(Operation* operation);
 
 
 
   /** Set/Get the IndexToWorldTransform */
   itkGetConstObjectMacro(IndexToWorldTransform, AffineTransform3D);
   itkGetObjectMacro(IndexToWorldTransform, AffineTransform3D);
   /** Get the bounding box */
   itkGetConstObjectMacro(BoundingBox, BoundingBoxType);
 
   const BoundsArrayType GetBounds() const
     {
     assert(m_BoundingBox.IsNotNull());
     return m_BoundingBox->GetBounds();
     }
 
   /** Get the extent of the bounding box */
   ScalarType GetExtent(unsigned int direction) const
     {
     assert(direction<NDimensions);
     assert(m_BoundingBox.IsNotNull());
     BoundsArrayType bounds = m_BoundingBox->GetBounds();
     return bounds[direction*2+1]-bounds[direction*2];
     }
 protected:
   Geometry3D();
   Geometry3D(const Geometry3D& other);
 
 
   virtual void InitializeGeometry(Self * newGeometry) const;
   void SetBoundsArray(const BoundsArrayType& bounds,
                       BoundingBoxPointer& boundingBox);
 
 
   static const std::string GetTransformAsString( TransformType* transformType );
   static const unsigned int NDimensions = 3;
 
   virtual ~Geometry3D();
 
   virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
 
   virtual void BackTransform(const mitk::Point3D& in, mitk::Point3D& out) const;
   //##Documentation
   //## @brief Deprecated
   virtual void BackTransform(const mitk::Point3D& at, const mitk::Vector3D& in, mitk::Vector3D& out) const;
 
   //Without redundant parameter Point3D
   virtual void BackTransform(const mitk::Vector3D& in, mitk::Vector3D& out) const;
 
   //##Documentation
   //## @brief Set the parametric bounds
   //##
   //## Protected in this class, made public in some sub-classes, e.g.,
   //## ExternAbstractTransformGeometry.
   virtual void SetParametricBounds(const BoundingBox::BoundsArrayType& bounds);
 
   /** Resets sub-transforms that compose m_IndexToWorldTransform, by using
    * the current value of m_IndexToWorldTransform and setting the rotation
    * component to zero. */
   virtual void ResetSubTransforms();
 
   mutable mitk::BoundingBox::Pointer m_ParametricBoundingBox;
 
   mutable mitk::TimeBounds m_TimeBounds;
 
   vtkMatrix4x4* m_VtkMatrix;
 
   bool m_ImageGeometry;
 
   AffineTransform3D::Pointer m_IndexToWorldTransform;
   mutable BoundingBoxPointer m_BoundingBox;
 
   //##Documentation
   //## @brief Spacing of the data. Only significant if the geometry describes
   //## an Image (m_ImageGeometry==true).
   mitk::Vector3D m_Spacing;
 
   bool m_Valid;
 
   unsigned int m_FrameOfReferenceID;
 
   static const std::string INDEX_TO_OBJECT_TRANSFORM;
   static const std::string OBJECT_TO_NODE_TRANSFORM;
   static const std::string INDEX_TO_NODE_TRANSFORM;
   static const std::string INDEX_TO_WORLD_TRANSFORM;
 
 private:
   mutable TransformType::Pointer m_InvertedTransform;
   mutable unsigned long m_IndexToWorldTransformLastModified;
 
   VnlQuaternionType m_RotationQuaternion;
 
 
   float m_FloatSpacing[3];
   vtkMatrixToLinearTransform* m_VtkIndexToWorldTransform;
 
   //##Documentation
   //## @brief Origin, i.e. upper-left corner of the plane
   //##
   Point3D m_Origin;
 };
 
 } // namespace mitk
 
 #endif /* GEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD */