diff --git a/Modules/CameraCalibration/CMakeLists.txt b/Modules/CameraCalibration/CMakeLists.txt
index 825c7cbcc7..660bc72afb 100644
--- a/Modules/CameraCalibration/CMakeLists.txt
+++ b/Modules/CameraCalibration/CMakeLists.txt
@@ -1,5 +1,8 @@
 MITK_CREATE_MODULE(mitkCameraCalibration
   DEPENDS MitkIGT
   PACKAGE_DEPENDS OpenCV
   PROVIDES mitkCameraCalibration
 )
+
+# add testing dir
+ADD_SUBDIRECTORY(Testing)
\ No newline at end of file
diff --git a/Modules/CameraCalibration/Testing/CMakeLists.txt b/Modules/CameraCalibration/Testing/CMakeLists.txt
new file mode 100644
index 0000000000..d45daf111d
--- /dev/null
+++ b/Modules/CameraCalibration/Testing/CMakeLists.txt
@@ -0,0 +1 @@
+MITK_CREATE_MODULE_TESTS()
\ No newline at end of file
diff --git a/Modules/CameraCalibration/Testing/files.cmake b/Modules/CameraCalibration/Testing/files.cmake
new file mode 100644
index 0000000000..f41bedbac5
--- /dev/null
+++ b/Modules/CameraCalibration/Testing/files.cmake
@@ -0,0 +1,4 @@
+SET(MODULE_TESTS
+  mitkCameraIntrinsicsTest.cpp
+  mitkTransformTest.cpp
+)
\ No newline at end of file
diff --git a/Modules/CameraCalibration/Testing/mitkCameraIntrinsicsTest.cpp b/Modules/CameraCalibration/Testing/mitkCameraIntrinsicsTest.cpp
new file mode 100644
index 0000000000..82f4439492
--- /dev/null
+++ b/Modules/CameraCalibration/Testing/mitkCameraIntrinsicsTest.cpp
@@ -0,0 +1,129 @@
+/*=========================================================================
+
+Program:   Medical Imaging & Interaction Toolkit
+Language:  C++
+Date:      $Date$
+Version:   $Revision: 16010 $
+
+Copyright (c) German Cancer Research Center, Division of Medical and
+Biological Informatics. All rights reserved.
+See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
+
+This software is distributed WITHOUT ANY WARRANTY; without even
+the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+
+#include <mitkCameraIntrinsics.h>
+#include <mitkTestingMacros.h>
+#include <mitkCvMatCompare.h>
+#include <itksys/SystemTools.hxx>
+
+/**Documentation
+ *  test for the class "CameraIntrinsics".
+ */
+int mitkCameraIntrinsicsTest(int argc, char* argv[])
+{
+  MITK_TEST_BEGIN("CameraIntrinsics")
+
+  cv::Mat _CameraMatrix = cv::Mat::zeros(3, 3, cv::DataType<double>::type);
+  _CameraMatrix.at<double>(2,2) = 1.0;
+  _CameraMatrix.at<double>(0,0) = 1662.54;
+  _CameraMatrix.at<double>(1,1) = 1678.23;
+  _CameraMatrix.at<double>(0,2) = 1030.23;
+  _CameraMatrix.at<double>(1,2) = 632.32;
+
+  cv::Mat _DistorsionCoeffs = cv::Mat::zeros(1, 5, cv::DataType<double>::type);
+  _DistorsionCoeffs.at<double>(0,0) = -0.443212;
+  _DistorsionCoeffs.at<double>(0,1) = 0.231012;
+  _DistorsionCoeffs.at<double>(0,2) = -0.013612;
+  _DistorsionCoeffs.at<double>(0,3) = -0.005312;
+  _DistorsionCoeffs.at<double>(0,4) = 0;
+
+  mitk::CameraIntrinsics::Pointer intrinsics
+      = mitk::CameraIntrinsics::New();
+
+  intrinsics->SetIntrinsics(_CameraMatrix, _DistorsionCoeffs);
+
+  double epsilon = 0.001;
+  bool equals = false;
+  mitk::CvMatCompare _CvMatCompare( &epsilon, &equals );
+
+  {    
+    cv::Mat _CameraMatrixResult = intrinsics->GetCameraMatrix();
+    _CvMatCompare.SetMatrices( &_CameraMatrix, &_CameraMatrixResult );
+    _CvMatCompare.Update();
+    MITK_TEST_CONDITION_REQUIRED( equals,
+                       "Testing CameraIntrinsics::GetCameraMatrix()");
+  }
+
+  {
+    cv::Mat _DistorsionCoeffsResult = intrinsics->GetDistorsionCoeffs();
+    _CvMatCompare.SetMatrices( &_DistorsionCoeffs, &_DistorsionCoeffsResult );
+    _CvMatCompare.Update();
+    MITK_TEST_CONDITION_REQUIRED( equals,
+                       "Testing CameraIntrinsics::GetDistorsionCoeffs()");
+  }
+
+
+  {
+    mitk::CameraIntrinsics::Pointer copy
+        = intrinsics->Clone();
+
+    cv::Mat _CameraMatrixResult = copy->GetCameraMatrix();
+    cv::Mat _DistorsionCoeffsResult = copy->GetDistorsionCoeffs();
+
+    bool distCoeffsEquals = false;
+    _CvMatCompare.SetMatrices( &_DistorsionCoeffs, &_DistorsionCoeffsResult );
+    _CvMatCompare.Update();
+    distCoeffsEquals = equals;
+    _CvMatCompare.SetMatrices( &_CameraMatrix, &_CameraMatrixResult );
+    _CvMatCompare.Update();
+    MITK_TEST_CONDITION( distCoeffsEquals && equals,
+                       "Testing CameraIntrinsics::Clone()");
+  }
+
+
+  {
+    std::string filename = "mitkCameraIntrinsicsTest.xml";
+    intrinsics->ToXMLFile(filename);
+    intrinsics->SetValid(true);
+
+    mitk::CameraIntrinsics::Pointer copy
+        = mitk::CameraIntrinsics::New();
+    copy->FromXMLFile(filename);
+
+    cv::Mat _CameraMatrixResult = copy->GetCameraMatrix();
+    cv::Mat _DistorsionCoeffsResult = copy->GetDistorsionCoeffs();
+
+//    MITK_INFO << "_CameraMatrix:" << std::endl
+//        << mitk::ToString(_CameraMatrix);
+//    MITK_INFO << "_CameraMatrixResult:" << std::endl
+//        << mitk::ToString(_CameraMatrixResult);
+//    MITK_INFO << "_DistorsionCoeffs:" << std::endl
+//        << mitk::ToString(_DistorsionCoeffs);
+//    MITK_INFO << "_DistorsionCoeffsResult:" << std::endl
+//        << mitk::ToString(_DistorsionCoeffsResult);
+
+    bool distCoeffsEquals = false;
+    _CvMatCompare.SetMatrices( &_DistorsionCoeffs, &_DistorsionCoeffsResult );
+    _CvMatCompare.Update();
+    distCoeffsEquals = equals;
+    _CvMatCompare.SetMatrices( &_CameraMatrix, &_CameraMatrixResult );
+    _CvMatCompare.Update();
+    MITK_TEST_CONDITION( distCoeffsEquals && equals
+                         && copy->IsValid(),
+                       "Testing CameraIntrinsics::ToXMLFile() and"
+                       " CameraIntrinsics::FromXMLFile()");
+
+    if(itksys::SystemTools::FileExists(filename.c_str() , true))
+      itksys::SystemTools::RemoveFile(filename.c_str());
+  }
+
+
+  // TODO
+
+  // always end with this!
+  MITK_TEST_END();
+}
diff --git a/Modules/CameraCalibration/Testing/mitkTransformTest.cpp b/Modules/CameraCalibration/Testing/mitkTransformTest.cpp
new file mode 100644
index 0000000000..a4482e5894
--- /dev/null
+++ b/Modules/CameraCalibration/Testing/mitkTransformTest.cpp
@@ -0,0 +1,107 @@
+/*=========================================================================
+
+Program:   Medical Imaging & Interaction Toolkit
+Language:  C++
+Date:      $Date$
+Version:   $Revision: 16010 $
+
+Copyright (c) German Cancer Research Center, Division of Medical and
+Biological Informatics. All rights reserved.
+See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
+
+This software is distributed WITHOUT ANY WARRANTY; without even
+the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+
+#include <mitkTransform.h>
+#include <mitkTestingMacros.h>
+#include <mitkStringFromCvMat.h>
+#include <mitkCvMatCompare.h>
+#include <mitkCvMatFromVnlMatrix.h>
+
+/**Documentation
+ *  test for the class "Transform".
+ */
+int mitkTransformTest(int argc, char* argv[])
+{
+  MITK_TEST_BEGIN("Transform")
+
+  mitk::Transform::Pointer transform = mitk::Transform::New();
+  mitk::Transform* t =  transform;
+
+  // test with homogeneous matrixes
+  vnl_matrix_fixed<mitk::ScalarType, 4, 4> I;
+  I.set_identity();
+
+  std::cout << "vnl I: " << std::endl << I << std::endl;
+  t->SetMatrix( I );
+
+  cv::Mat cvI = t->GetCvMatrix();
+  std::string matAsString;
+  mitk::StringFromCvMat _StringFromCvMat( &cvI, &matAsString );
+  _StringFromCvMat.Update();
+  std::cout << "cv identity matrix: " << matAsString << std::endl;
+
+  MITK_TEST_CONDITION_REQUIRED( trace(cvI)
+                                == cv::Scalar(4)
+                  , "trace(t->GetCvMatrix()) == cv::Scalar(4)" );
+  MITK_TEST_CONDITION_REQUIRED( countNonZero(t->GetCvMatrix()) == 4
+                  , "countNonZero(t->GetCvMatrix()) == 4" );
+
+  // test 2: 1. create a rotation matrix,convert to quaternion
+  // set as rotation vector
+  // get it back as vnl rotation matrix
+  // convert to cv matrix
+  // convert to quaternion (cv::Rodrigues)
+  // compare received quaternion with original one (created from rotation matrix)
+  cv::Mat cvRotMat = cv::Mat::ones( 3, 3, cv::DataType<mitk::ScalarType>::type );
+  cvRotMat.at<mitk::ScalarType>(0,1) = 2;
+  cvRotMat.at<mitk::ScalarType>(0,2) = 3;
+
+  cv::Mat cvRotVec;
+  cv::Rodrigues( cvRotMat, cvRotVec );
+  t->SetRotationVector( cvRotVec );
+
+  vnl_matrix_fixed<mitk::ScalarType, 3, 3> vnlRotMat
+      = t->GetVnlRotationMatrix();
+  std::cout << "vnl rotation matrix: "
+      << vnlRotMat << std::endl;
+
+  vnl_matrix<mitk::ScalarType> rotMat = vnlRotMat.as_matrix();
+  cv::Mat cvRotMatReturned;
+  mitk::CvMatFromVnlMatrix<mitk::ScalarType>
+      _CvMatFromVnlMatrix( &rotMat, &cvRotMatReturned );
+  _CvMatFromVnlMatrix.Update();
+
+  _StringFromCvMat.SetMatrix( &cvRotMatReturned );
+  _StringFromCvMat.Update();
+  std::cout << "cvRotMatReturned: " << matAsString << std::endl;
+
+  cv::Mat cvRotVecReturned;
+  cv::Rodrigues( cvRotMatReturned, cvRotVecReturned );
+
+  _StringFromCvMat.SetMatrix( &cvRotVec );
+  _StringFromCvMat.Update();
+  std::cout << "cvRotVec: " << matAsString << std::endl;
+  _StringFromCvMat.SetMatrix( &cvRotVecReturned );
+  _StringFromCvMat.Update();
+  std::cout << "cvRotVecReturned: " << matAsString << std::endl;
+
+  double epsilon = 0.001;
+  bool equals = false;
+  mitk::CvMatCompare _CvMatCompare( &cvRotVec, &cvRotVecReturned, &epsilon, &equals );
+  _CvMatCompare.Update();
+  MITK_TEST_CONDITION( equals,
+                         "testing returned rotation vector");
+
+  std::cout << "Transform as string: " << transform << std::endl;
+
+  // always end with this!
+  MITK_TEST_END();
+}
+
+
+
+
diff --git a/Modules/CameraCalibration/mitkCvMatCompare.h b/Modules/CameraCalibration/mitkCvMatCompare.h
new file mode 100644
index 0000000000..a29f6e87da
--- /dev/null
+++ b/Modules/CameraCalibration/mitkCvMatCompare.h
@@ -0,0 +1,96 @@
+#ifndef mitkCvMatCompare_h
+#define mitkCvMatCompare_h
+
+#include <mitkEpsilon.h>
+#include <mitkEndoTrackingExports.h>
+#include <mitkObservable.h>
+#include <mitkAlgorithm.h>
+#include <mitkEndoDebug.h>
+
+namespace mitk
+{
+  ///
+  /// compare two matrices with a given epsilon
+  ///
+  class CvMatCompare:
+    virtual public Algorithm
+  {
+  public:
+    ///
+    /// init default values and save references
+    ///
+    CvMatCompare(
+      const Epsilon* _Epsilon,
+      bool* _Equals):
+        m_CvMat1(0),
+        m_CvMat2(0),
+        m_Epsilon(_Epsilon),
+        m_Equals(_Equals)
+    {
+    }
+    ///
+    /// init default values and save references
+    ///
+    CvMatCompare(
+      const cv::Mat* _CvMat1, 
+      const cv::Mat* _CvMat2, 
+      const Epsilon* _Epsilon, 
+      bool* _Equals): 
+        m_CvMat1(_CvMat1), 
+        m_CvMat2(_CvMat2), 
+        m_Epsilon(_Epsilon), 
+        m_Equals(_Equals)
+    {
+    }
+
+    void SetMatrices( const cv::Mat* _CvMat1, const cv::Mat* _CvMat2 )
+    {
+      m_CvMat1 = _CvMat1;
+      m_CvMat2 = _CvMat2;
+    }
+
+    void SetMatrix1( const cv::Mat* _CvMat1 )
+    {
+      m_CvMat1 = _CvMat1;
+    }
+    void SetMatrix2( const cv::Mat* _CvMat2 )
+    {
+      m_CvMat2 = _CvMat2;
+    }
+
+    ///
+    /// executes the Algorithm 
+    ///
+    void Update()
+    {
+      assert( m_CvMat1 && m_CvMat2 );
+      cv::Mat dst;
+      cv::absdiff( (*m_CvMat1), (*m_CvMat2), dst);
+      double max = 0;
+      cv::minMaxLoc( dst, 0, &max );
+
+      endodebugvar( max )
+
+      (*m_Equals) = max <= *m_Epsilon;
+    }
+  private:
+    ///
+    /// CvMatCompare input member variable
+    ///
+    const cv::Mat* m_CvMat1;
+    ///
+    /// CvMatCompare input member variable
+    ///
+    const cv::Mat* m_CvMat2;
+    ///
+    /// CvMatCompare input member variable
+    ///
+    const Epsilon* m_Epsilon;
+    ///
+    /// CvMatCompare output member variable
+    ///
+    bool* m_Equals;
+  };
+} // namespace mitk
+
+#endif // mitkCvMatCompare_h
diff --git a/Modules/CameraCalibration/mitkEpsilon.h b/Modules/CameraCalibration/mitkEpsilon.h
new file mode 100644
index 0000000000..e8012b19e0
--- /dev/null
+++ b/Modules/CameraCalibration/mitkEpsilon.h
@@ -0,0 +1,13 @@
+#ifndef mitkEpsilon_h
+#define mitkEpsilon_h
+
+namespace mitk
+{
+  ///
+  /// typdef for Epsilon
+  ///
+  typedef double Epsilon;
+
+} // namespace mitk
+
+#endif // mitkEpsilon_h
diff --git a/Modules/CameraCalibration/mitkStringFromCvMat.h b/Modules/CameraCalibration/mitkStringFromCvMat.h
new file mode 100644
index 0000000000..53959f694c
--- /dev/null
+++ b/Modules/CameraCalibration/mitkStringFromCvMat.h
@@ -0,0 +1,77 @@
+#ifndef mitkStringFromCvMat_h
+#define mitkStringFromCvMat_h
+
+#include <cv.h>
+#include <string>
+#include <mitkObservable.h>
+#include <mitkAlgorithm.h>
+#include <mitkEndoMacros.h>
+#include <sstream>
+
+namespace mitk
+{
+  ///
+  /// create a vnl_matrix from a cv mat
+  ///
+  class StringFromCvMat:
+    virtual public Algorithm
+  {
+  public:
+    ///
+    /// init default values and save references
+    ///
+    StringFromCvMat(
+      const cv::Mat* _CvMat,
+      std::string* _String):
+        m_CvMat(_CvMat), 
+        m_String(_String)
+    {
+    }
+
+
+    ///
+    /// cv mat to vnl matrix with known cv type
+    ///
+    template <typename TCvMat, char T_Delim>
+    void ToString( std::string& string, const cv::Mat& mat )
+    {
+      std::ostringstream s;
+
+
+      for(int i=0; i<mat.rows; ++i)
+      {
+        for(int j=0; j<mat.cols; ++j)
+        {
+          s << mat.at<TCvMat>(i,j) << " ";
+        }
+        s << T_Delim;
+      }
+      string = s.str();
+    }
+
+    void SetMatrix(
+      const cv::Mat* _CvMat )
+    {
+      m_CvMat = _CvMat;
+    }
+
+    ///
+    /// executes the Algorithm 
+    ///
+    void Update()
+    {
+      endoAccessCvMat( ToString, '\n', (*m_String), (*m_CvMat) );
+    }
+  private:
+    ///
+    /// StringFromCvMat input member variable
+    ///
+    const cv::Mat* m_CvMat;
+    ///
+    /// StringFromCvMat output member variable
+    ///
+    std::string* m_String;
+  };
+} // namespace mitk
+
+#endif // mitkStringFromCvMat_h
diff --git a/Modules/CameraCalibration/mitkTransform.cpp b/Modules/CameraCalibration/mitkTransform.cpp
index e3a8e9ffad..856e58d2c9 100644
--- a/Modules/CameraCalibration/mitkTransform.cpp
+++ b/Modules/CameraCalibration/mitkTransform.cpp
@@ -1,688 +1,688 @@
 #include "mitkTransform.h"
 #include <fstream>
 #include <vnl/vnl_inverse.h>
-#include <mitkVnlVectorCaster.h>
+#include <mitkVnlVectorFixedCaster.h>
 #include <mitkVnlVectorFromCvMat.h>
 #include <mitkVnlMatrixFromCvMat.h>
 #include <mitkCvMatFromVnlVector.h>
 namespace mitk
 {
 
   Transform::Transform()
     : m_NavData(mitk::NavigationData::New())
   {
     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_NavData->Graft(nd);
   }
 
   void Transform::Copy(const mitk::NavigationData* nd)
   {
     (const_cast<mitk::NavigationData*>(m_NavData.GetPointer()))->Graft(nd);
   }
 
   void Transform::Concatenate( mitk::Transform* transform )
   {
     vnl_matrix_fixed<mitk::ScalarType, 4, 4> mat = transform->GetMatrix();
     mat = mat * this->GetMatrix(); //
     this->SetMatrix( mat );
   }
 
   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::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;
-    VnlVectorCaster<double, mitk::ScalarType, 4> caster( &orientation, &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;
-    VnlVectorCaster<mitk::ScalarType, double, 3> caster( &vecFloat, &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;
-    VnlVectorCaster<double, mitk::ScalarType, 3> caster( &dTransl, &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;
-    VnlVectorCaster<mitk::ScalarType, double, 4> caster( &fOrientation, &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());
   }
 
   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()
   {
     vnl_matrix_fixed<mitk::ScalarType, 4, 4> tmp(this->GetMatrix());
     this->SetMatrix( vnl_inverse( tmp ) );
   }
 
   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::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);
   }
 
   //# 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->GetVnlRotationMatrix().as_matrix();
+    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 m_NavData->GetOrientation().rotation_matrix_transpose();
   }
 
   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->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();
 
     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;
     this->Modified();
   }
 
 } // namespace mitk
 
 std::ostream& operator<< (std::ostream& os, mitk::Transform::Pointer p)
 {
   os << p->ToString();
   return os;
 }
diff --git a/Modules/CameraCalibration/mitkVnlVectorCaster.h b/Modules/CameraCalibration/mitkVnlVectorCaster.h
index 2e620ec000..39849334c0 100644
--- a/Modules/CameraCalibration/mitkVnlVectorCaster.h
+++ b/Modules/CameraCalibration/mitkVnlVectorCaster.h
@@ -1,50 +1,60 @@
 #ifndef mitkVnlVectorCaster_h
 #define mitkVnlVectorCaster_h
 
-#include <vnl/vnl_vector_fixed.h>
+#include <vnl/vnl_vector.h>
 #include <mitkObservable.h>
 #include <mitkAlgorithm.h>
 
 namespace mitk
 {
   ///
   /// class for casting vnl vectors to another basic type
   /// by means of static cast
   ///
-  template <class T, class R, unsigned int n>
+  template <class T, class R>
   class VnlVectorCaster:
     virtual public Algorithm
   {
   public:
     ///
     /// init default values and save references
     ///
     VnlVectorCaster(
-      const vnl_vector_fixed<T, n>* _InputVector,
-      vnl_vector_fixed<R, n>* _OutputVector):
+      const vnl_vector<T>* _InputVector,
+      vnl_vector<R>* _OutputVector):
         m_InputVector(_InputVector), 
         m_OutputVector(_OutputVector)
     {
     }
+
+    ///
+    /// static update
+    ///
+    static void Update(
+      const vnl_vector<T>& _InputVector,
+      vnl_vector<R>& _OutputVector)
+    {
+      for( size_t i=0; i<_InputVector.size(); ++i )
+        _OutputVector[i] = static_cast<R>( _InputVector[i] );
+    }
+
     ///
     /// executes the Algorithm 
     ///
     void Update()
     {
-      for( size_t i=0; i<m_InputVector->size(); ++i )
-        (*m_OutputVector)[i] = static_cast<R>( (*m_InputVector)[i] );
-
+      Update( *m_InputVector, *m_OutputVector );
     }
   private:
     ///
     /// VnlVectorCaster input member variable
     ///
-    const vnl_vector_fixed<T, n>* m_InputVector;
+    const vnl_vector<T>* m_InputVector;
     ///
     /// VnlVectorCaster output member variable
     ///
-    vnl_vector_fixed<R, n>* m_OutputVector;
+    vnl_vector<R>* m_OutputVector;
   };
 } // namespace mitk
 
 #endif // mitkVnlVectorCaster_h
diff --git a/Modules/CameraCalibration/mitkVnlVectorCaster.h b/Modules/CameraCalibration/mitkVnlVectorFixedCaster.h
similarity index 77%
copy from Modules/CameraCalibration/mitkVnlVectorCaster.h
copy to Modules/CameraCalibration/mitkVnlVectorFixedCaster.h
index 2e620ec000..514afd6dd6 100644
--- a/Modules/CameraCalibration/mitkVnlVectorCaster.h
+++ b/Modules/CameraCalibration/mitkVnlVectorFixedCaster.h
@@ -1,50 +1,50 @@
-#ifndef mitkVnlVectorCaster_h
-#define mitkVnlVectorCaster_h
+#ifndef mitkVnlVectorFixedCaster_h
+#define mitkVnlVectorFixedCaster_h
 
 #include <vnl/vnl_vector_fixed.h>
 #include <mitkObservable.h>
 #include <mitkAlgorithm.h>
 
 namespace mitk
 {
   ///
   /// class for casting vnl vectors to another basic type
   /// by means of static cast
   ///
   template <class T, class R, unsigned int n>
-  class VnlVectorCaster:
+  class VnlVectorFixedCaster:
     virtual public Algorithm
   {
   public:
     ///
     /// init default values and save references
     ///
-    VnlVectorCaster(
+    VnlVectorFixedCaster(
       const vnl_vector_fixed<T, n>* _InputVector,
       vnl_vector_fixed<R, n>* _OutputVector):
         m_InputVector(_InputVector), 
         m_OutputVector(_OutputVector)
     {
     }
     ///
     /// executes the Algorithm 
     ///
     void Update()
     {
       for( size_t i=0; i<m_InputVector->size(); ++i )
         (*m_OutputVector)[i] = static_cast<R>( (*m_InputVector)[i] );
 
     }
   private:
     ///
-    /// VnlVectorCaster input member variable
+    /// VnlVectorFixedCaster input member variable
     ///
     const vnl_vector_fixed<T, n>* m_InputVector;
     ///
-    /// VnlVectorCaster output member variable
+    /// VnlVectorFixedCaster output member variable
     ///
     vnl_vector_fixed<R, n>* m_OutputVector;
   };
 } // namespace mitk
 
-#endif // mitkVnlVectorCaster_h
+#endif // mitkVnlVectorFixedCaster_h