diff --git a/Core/Code/DataManagement/mitkImage.cpp b/Core/Code/DataManagement/mitkImage.cpp
index 8746b2ec51..a5af6e9c04 100644
--- a/Core/Code/DataManagement/mitkImage.cpp
+++ b/Core/Code/DataManagement/mitkImage.cpp
@@ -1,1285 +1,1285 @@
 /*===================================================================
 
 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 "mitkImage.h"
 
 #include "mitkImageStatisticsHolder.h"
 #include "mitkPixelTypeMultiplex.h"
 
 #include <vtkImageData.h>
 
 #include <cmath>
 
 #define FILL_C_ARRAY( _arr, _size, _value) for(unsigned int i=0u; i<_size; i++) \
 { _arr[i] = _value; }
 
 
 mitk::Image::Image() :
 m_Dimension(0), m_Dimensions(NULL), m_ImageDescriptor(NULL), m_OffsetTable(NULL), m_CompleteData(NULL),
   m_ImageStatistics(NULL)
 {
    m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
    FILL_C_ARRAY( m_Dimensions, MAX_IMAGE_DIMENSIONS, 0u);
 
    m_Initialized = false;
 }
 
 mitk::Image::Image(const Image &other) : SlicedData(other), m_Dimension(0), m_Dimensions(NULL),
 m_ImageDescriptor(NULL), m_OffsetTable(NULL), m_CompleteData(NULL), m_ImageStatistics(NULL)
 {
   m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
   FILL_C_ARRAY( m_Dimensions, MAX_IMAGE_DIMENSIONS, 0u);
 
   this->Initialize( other.GetPixelType(), other.GetDimension(), other.GetDimensions());
 
   //Since the above called "Initialize" method doesn't take the geometry into account we need to set it
   //here manually
   this->SetGeometry(dynamic_cast<mitk::TimeSlicedGeometry*>(other.GetTimeSlicedGeometry()->Clone().GetPointer()));
 
   if (this->GetDimension() > 3)
   {
     const unsigned int time_steps = this->GetDimension(3);
 
     for (unsigned int i = 0u; i < time_steps; ++i)
     {
       ImageDataItemPointer volume = const_cast<Image&>(other).GetVolumeData(i);
 
       this->SetVolume(volume->GetData(), i);
     }
   }
   else
   {
     ImageDataItemPointer volume = const_cast<Image&>(other).GetVolumeData(0);
 
     this->SetVolume(volume->GetData(), 0);
   }
 }
 
 mitk::Image::~Image()
 {
   Clear();
   m_ReferenceCountLock.Lock();
   m_ReferenceCount = 3;
   m_ReferenceCountLock.Unlock();
   m_ReferenceCountLock.Lock();
   m_ReferenceCount = 0;
   m_ReferenceCountLock.Unlock();
   if(m_OffsetTable != NULL)
     delete [] m_OffsetTable;
 
   if(m_ImageStatistics != NULL)
     delete m_ImageStatistics;
 }
 
 const mitk::PixelType mitk::Image::GetPixelType(int n) const
 {
   return this->m_ImageDescriptor->GetChannelTypeById(n);
 }
 
 unsigned int mitk::Image::GetDimension() const
 {
   return m_Dimension;
 }
 
 unsigned int mitk::Image::GetDimension(int i) const
 {
   if((i>=0) && (i<(int)m_Dimension))
     return m_Dimensions[i];
   return 1;
 }
 
 void* mitk::Image::GetData()
 {
   if(m_Initialized==false)
   {
     if(GetSource().IsNull())
       return NULL;
     if(GetSource()->Updating()==false)
       GetSource()->UpdateOutputInformation();
   }
   m_CompleteData=GetChannelData();
 
   // update channel's data
   // if data was not available at creation point, the m_Data of channel descriptor is NULL
   // if data present, it won't be overwritten
   m_ImageDescriptor->GetChannelDescriptor(0).SetData(m_CompleteData->GetData());
 
   return m_CompleteData->GetData();
 }
 
 
 template <class T>
 void AccessPixel( const mitk::PixelType ptype, void* data, const unsigned int offset, double& value )
 {
   value = 0.0;
   if( data == NULL ) return;
 
   if(ptype.GetBpe() != 24)
   {
     value = (double) (((T*) data)[ offset ]);
  }
   else
   {
     const unsigned int rgboffset = 3 * offset;
 
     double returnvalue = (((T*) data)[rgboffset ]);
     returnvalue += (((T*) data)[rgboffset + 1]);
     returnvalue += (((T*) data)[rgboffset + 2]);
     value = returnvalue;
   }
 
 }
 
 double mitk::Image::GetPixelValueByIndex(const mitk::Index3D &position, unsigned int timestep)
 {
   double value = 0;
   if (this->GetTimeSteps() < timestep)
   {
     timestep = this->GetTimeSteps();
   }
 
   value = 0.0;
 
   const unsigned int* imageDims = this->m_ImageDescriptor->GetDimensions();
   const mitk::PixelType ptype = this->m_ImageDescriptor->GetChannelTypeById(0);
 
   // Comparison ?>=0 not needed since all position[i] and timestep are unsigned int
   // (position[0]>=0 && position[1] >=0 && position[2]>=0 && timestep>=0)
   // bug-11978 : we still need to catch index with negative values
   if ( position[0] < 0 ||
        position[1] < 0 ||
        position[2] < 0 )
   {
     MITK_WARN << "Given position ("<< position << ") is out of image range, returning 0." ;
   }
   // check if the given position is inside the index range of the image, the 3rd dimension needs to be compared only if the dimension is not 0
   else if ( (unsigned int)position[0] >= imageDims[0] ||
             (unsigned int)position[1] >= imageDims[1] ||
             ( imageDims[2] && (unsigned int)position[2] >= imageDims[2] ))
   {
     MITK_WARN << "Given position ("<< position << ") is out of image range, returning 0." ;
   }
   else
   {
     const unsigned int offset = position[0] + position[1]*imageDims[0] + position[2]*imageDims[0]*imageDims[1] + timestep*imageDims[0]*imageDims[1]*imageDims[2];
 
     mitkPixelTypeMultiplex3( AccessPixel, ptype, this->GetData(), offset, value );
   }
 
   return value;
 }
 
 double mitk::Image::GetPixelValueByWorldCoordinate(const mitk::Point3D& position, unsigned int timestep)
 {
   double value = 0.0;
   if (this->GetTimeSteps() < timestep)
   {
     timestep = this->GetTimeSteps();
   }
 
   Index3D itkIndex;
   this->GetGeometry()->WorldToIndex(position, itkIndex);
 
   value = this->GetPixelValueByIndex( itkIndex, timestep);
 
   return value;
 }
 
 mitk::ImageVtkAccessor* mitk::Image::GetVtkImageData(int t, int n)
 {
   if(m_Initialized==false)
   {
     if(GetSource().IsNull())
       return NULL;
     if(GetSource()->Updating()==false)
       GetSource()->UpdateOutputInformation();
   }
   ImageDataItemPointer volume=GetVolumeData(t, n);
   if(volume.GetPointer()==NULL || volume->GetVtkImageData(this) == NULL)
     return NULL;
 
 
   float *fspacing = const_cast<float *>(GetSlicedGeometry(t)->GetFloatSpacing());
   double dspacing[3] = {fspacing[0],fspacing[1],fspacing[2]};
   volume->GetVtkImageData(this)->SetSpacing( dspacing );
 
   return volume->GetVtkImageData(this);
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::GetSliceData(int s, int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidSlice(s,t,n)==false) return NULL;
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   // slice directly available?
   int pos=GetSliceIndex(s,t,n);
   if(m_Slices[pos].GetPointer()!=NULL)
     return m_Slices[pos];
 
   // is slice available as part of a volume that is available?
   ImageDataItemPointer sl, ch, vol;
   vol=m_Volumes[GetVolumeIndex(t,n)];
   if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
   {
     sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
     sl->SetComplete(true);
     return m_Slices[pos]=sl;
   }
 
   // is slice available as part of a channel that is available?
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
   {
     sl=new ImageDataItem(*ch, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, (((size_t) s)*m_OffsetTable[2]+((size_t) t)*m_OffsetTable[3])*(ptypeSize));
     sl->SetComplete(true);
     return m_Slices[pos]=sl;
   }
 
   // slice is unavailable. Can we calculate it?
   if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
   {
     // ... wir mussen rechnen!!! ....
     m_RequestedRegion.SetIndex(0, 0);
     m_RequestedRegion.SetIndex(1, 0);
     m_RequestedRegion.SetIndex(2, s);
     m_RequestedRegion.SetIndex(3, t);
     m_RequestedRegion.SetIndex(4, n);
     m_RequestedRegion.SetSize(0, m_Dimensions[0]);
     m_RequestedRegion.SetSize(1, m_Dimensions[1]);
     m_RequestedRegion.SetSize(2, 1);
     m_RequestedRegion.SetSize(3, 1);
     m_RequestedRegion.SetSize(4, 1);
     m_RequestedRegionInitialized=true;
     GetSource()->Update();
     if(IsSliceSet(s,t,n))
       //yes: now we can call ourselves without the risk of a endless loop (see "if" above)
       return GetSliceData(s,t,n,data,importMemoryManagement);
     else
       return NULL;
   }
   else
   {
     ImageDataItemPointer item = AllocateSliceData(s,t,n,data,importMemoryManagement);
     item->SetComplete(true);
     return item;
   }
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::GetVolumeData(int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidVolume(t,n)==false) return NULL;
 
   ImageDataItemPointer ch, vol;
 
   // volume directly available?
   int pos=GetVolumeIndex(t,n);
   vol=m_Volumes[pos];
   if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
     return vol;
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   // is volume available as part of a channel that is available?
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
   {
     vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory, (((size_t) t)*m_OffsetTable[3])*(ptypeSize));
     vol->SetComplete(true);
     return m_Volumes[pos]=vol;
   }
 
   // let's see if all slices of the volume are set, so that we can (could) combine them to a volume
   bool complete=true;
   unsigned int s;
   for(s=0;s<m_Dimensions[2];++s)
   {
     if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()==NULL)
     {
       complete=false;
       break;
     }
   }
   if(complete)
   {
     // if there is only single slice we do not need to combine anything
     if(m_Dimensions[2]<=1)
     {
       ImageDataItemPointer sl;
       sl=GetSliceData(0,t,n,data,importMemoryManagement);
       vol=new ImageDataItem(*sl, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory);
       vol->SetComplete(true);
     }
     else
     {
       mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(n);
 
       vol=m_Volumes[pos];
       // ok, let's combine the slices!
       if(vol.GetPointer()==NULL)
         vol=new ImageDataItem( chPixelType, 3, m_Dimensions, NULL, true);
       vol->SetComplete(true);
       size_t size=m_OffsetTable[2]*(ptypeSize);
       for(s=0;s<m_Dimensions[2];++s)
       {
         int posSl;
         ImageDataItemPointer sl;
         posSl=GetSliceIndex(s,t,n);
 
         sl=m_Slices[posSl];
         if(sl->GetParent()!=vol)
         {
           // copy data of slices in volume
           size_t offset = ((size_t) s)*size;
           std::memcpy(static_cast<char*>(vol->GetData())+offset, sl->GetData(), size);
 
           // FIXME mitkIpPicDescriptor * pic = sl->GetPicDescriptor();
 
           // replace old slice with reference to volume
           sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*size);
           sl->SetComplete(true);
           //mitkIpFuncCopyTags(sl->GetPicDescriptor(), pic);
           m_Slices[posSl]=sl;
         }
       }
       //if(vol->GetPicDescriptor()->info->tags_head==NULL)
       //  mitkIpFuncCopyTags(vol->GetPicDescriptor(), m_Slices[GetSliceIndex(0,t,n)]->GetPicDescriptor());
     }
     return m_Volumes[pos]=vol;
   }
 
   // volume is unavailable. Can we calculate it?
   if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
   {
     // ... wir muessen rechnen!!! ....
     m_RequestedRegion.SetIndex(0, 0);
     m_RequestedRegion.SetIndex(1, 0);
     m_RequestedRegion.SetIndex(2, 0);
     m_RequestedRegion.SetIndex(3, t);
     m_RequestedRegion.SetIndex(4, n);
     m_RequestedRegion.SetSize(0, m_Dimensions[0]);
     m_RequestedRegion.SetSize(1, m_Dimensions[1]);
     m_RequestedRegion.SetSize(2, m_Dimensions[2]);
     m_RequestedRegion.SetSize(3, 1);
     m_RequestedRegion.SetSize(4, 1);
     m_RequestedRegionInitialized=true;
     GetSource()->Update();
     if(IsVolumeSet(t,n))
       //yes: now we can call ourselves without the risk of a endless loop (see "if" above)
       return GetVolumeData(t,n,data,importMemoryManagement);
     else
       return NULL;
   }
   else
   {
     ImageDataItemPointer item = AllocateVolumeData(t,n,data,importMemoryManagement);
     item->SetComplete(true);
     return item;
   }
 
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::GetChannelData(int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidChannel(n)==false) return NULL;
   ImageDataItemPointer ch, vol;
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
     return ch;
 
   // let's see if all volumes are set, so that we can (could) combine them to a channel
   if(IsChannelSet(n))
   {
     // if there is only one time frame we do not need to combine anything
     if(m_Dimensions[3]<=1)
     {
       vol=GetVolumeData(0,n,data,importMemoryManagement);
       ch=new ImageDataItem(*vol, m_ImageDescriptor, m_ImageDescriptor->GetNumberOfDimensions(), data, importMemoryManagement == ManageMemory);
       ch->SetComplete(true);
     }
     else
     {
       const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
       ch=m_Channels[n];
       // ok, let's combine the volumes!
       if(ch.GetPointer()==NULL)
         ch=new ImageDataItem(this->m_ImageDescriptor, NULL, true);
       ch->SetComplete(true);
       size_t size=m_OffsetTable[m_Dimension-1]*(ptypeSize);
       unsigned int t;
       ImageDataItemPointerArray::iterator slicesIt = m_Slices.begin()+n*m_Dimensions[2]*m_Dimensions[3];
       for(t=0;t<m_Dimensions[3];++t)
       {
         int posVol;
         ImageDataItemPointer vol;
 
         posVol=GetVolumeIndex(t,n);
         vol=GetVolumeData(t,n,data,importMemoryManagement);
 
         if(vol->GetParent()!=ch)
         {
           // copy data of volume in channel
           size_t offset = ((size_t) t)*m_OffsetTable[3]*(ptypeSize);
           std::memcpy(static_cast<char*>(ch->GetData())+offset, vol->GetData(), size);
 
           // REVEIW FIX mitkIpPicDescriptor * pic = vol->GetPicDescriptor();
 
           // replace old volume with reference to channel
           vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory, offset);
           vol->SetComplete(true);
           //mitkIpFuncCopyTags(vol->GetPicDescriptor(), pic);
 
           m_Volumes[posVol]=vol;
 
           // get rid of slices - they may point to old volume
           ImageDataItemPointer dnull=NULL;
           for(unsigned int i = 0; i < m_Dimensions[2]; ++i, ++slicesIt)
           {
             assert(slicesIt != m_Slices.end());
             *slicesIt = dnull;
           }
         }
       }
    // REVIEW FIX
    //   if(ch->GetPicDescriptor()->info->tags_head==NULL)
    //     mitkIpFuncCopyTags(ch->GetPicDescriptor(), m_Volumes[GetVolumeIndex(0,n)]->GetPicDescriptor());
     }
     return m_Channels[n]=ch;
   }
 
   // channel is unavailable. Can we calculate it?
   if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
   {
     // ... wir muessen rechnen!!! ....
     m_RequestedRegion.SetIndex(0, 0);
     m_RequestedRegion.SetIndex(1, 0);
     m_RequestedRegion.SetIndex(2, 0);
     m_RequestedRegion.SetIndex(3, 0);
     m_RequestedRegion.SetIndex(4, n);
     m_RequestedRegion.SetSize(0, m_Dimensions[0]);
     m_RequestedRegion.SetSize(1, m_Dimensions[1]);
     m_RequestedRegion.SetSize(2, m_Dimensions[2]);
     m_RequestedRegion.SetSize(3, m_Dimensions[3]);
     m_RequestedRegion.SetSize(4, 1);
     m_RequestedRegionInitialized=true;
     GetSource()->Update();
     // did it work?
     if(IsChannelSet(n))
       //yes: now we can call ourselves without the risk of a endless loop (see "if" above)
       return GetChannelData(n,data,importMemoryManagement);
     else
       return NULL;
   }
   else
   {
     ImageDataItemPointer item = AllocateChannelData(n,data,importMemoryManagement);
     item->SetComplete(true);
     return item;
   }
 }
 
 bool mitk::Image::IsSliceSet(int s, int t, int n) const
 {
   if(IsValidSlice(s,t,n)==false) return false;
 
   if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()!=NULL)
     return true;
 
   ImageDataItemPointer ch, vol;
   vol=m_Volumes[GetVolumeIndex(t,n)];
   if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
     return true;
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
     return true;
   return false;
 }
 
 bool mitk::Image::IsVolumeSet(int t, int n) const
 {
   if(IsValidVolume(t,n)==false) return false;
   ImageDataItemPointer ch, vol;
 
   // volume directly available?
   vol=m_Volumes[GetVolumeIndex(t,n)];
   if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
     return true;
 
   // is volume available as part of a channel that is available?
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
     return true;
 
   // let's see if all slices of the volume are set, so that we can (could) combine them to a volume
   unsigned int s;
   for(s=0;s<m_Dimensions[2];++s)
     if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()==NULL)
       return false;
   return true;
 }
 
 bool mitk::Image::IsChannelSet(int n) const
 {
   if(IsValidChannel(n)==false) return false;
   ImageDataItemPointer ch, vol;
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
 
     return true;
   // let's see if all volumes are set, so that we can (could) combine them to a channel
   unsigned int t;
   for(t=0;t<m_Dimensions[3];++t)
     if(IsVolumeSet(t,n)==false)
       return false;
   return true;
 }
 
 bool mitk::Image::SetSlice(const void *data, int s, int t, int n)
 {
   // const_cast is no risk for ImportMemoryManagementType == CopyMemory
   return SetImportSlice(const_cast<void*>(data), s, t, n, CopyMemory);
 }
 
 bool mitk::Image::SetVolume(const void *data, int t, int n)
 {
   // const_cast is no risk for ImportMemoryManagementType == CopyMemory
   return SetImportVolume(const_cast<void*>(data), t, n, CopyMemory);
 }
 
 bool mitk::Image::SetChannel(const void *data, int n)
 {
   // const_cast is no risk for ImportMemoryManagementType == CopyMemory
   return SetImportChannel(const_cast<void*>(data), n, CopyMemory);
 }
 
 bool mitk::Image::SetImportSlice(void *data, int s, int t, int n, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidSlice(s,t,n)==false) return false;
   ImageDataItemPointer sl;
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   if(IsSliceSet(s,t,n))
   {
     sl=GetSliceData(s,t,n,data,importMemoryManagement);
     if(sl->GetManageMemory()==false)
     {
       sl=AllocateSliceData(s,t,n,data,importMemoryManagement);
       if(sl.GetPointer()==NULL) return false;
     }
     if ( sl->GetData() != data )
       std::memcpy(sl->GetData(), data, m_OffsetTable[2]*(ptypeSize));
     sl->Modified();
     //we have changed the data: call Modified()!
     Modified();
   }
   else
   {
     sl=AllocateSliceData(s,t,n,data,importMemoryManagement);
     if(sl.GetPointer()==NULL) return false;
     if ( sl->GetData() != data )
       std::memcpy(sl->GetData(), data, m_OffsetTable[2]*(ptypeSize));
     //we just added a missing slice, which is not regarded as modification.
     //Therefore, we do not call Modified()!
   }
   return true;
 }
 
 bool mitk::Image::SetImportVolume(void *data, int t, int n, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidVolume(t,n)==false) return false;
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
   ImageDataItemPointer vol;
   if(IsVolumeSet(t,n))
   {
     vol=GetVolumeData(t,n,data,importMemoryManagement);
     if(vol->GetManageMemory()==false)
     {
       vol=AllocateVolumeData(t,n,data,importMemoryManagement);
       if(vol.GetPointer()==NULL) return false;
     }
     if ( vol->GetData() != data )
       std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
     vol->Modified();
     vol->SetComplete(true);
     //we have changed the data: call Modified()!
     Modified();
   }
   else
   {
     vol=AllocateVolumeData(t,n,data,importMemoryManagement);
     if(vol.GetPointer()==NULL) return false;
     if ( vol->GetData() != data )
     {
       std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
     }
     vol->SetComplete(true);
     this->m_ImageDescriptor->GetChannelDescriptor(n).SetData( vol->GetData() );
     //we just added a missing Volume, which is not regarded as modification.
     //Therefore, we do not call Modified()!
   }
   return true;
 }
 
 bool mitk::Image::SetImportChannel(void *data, int n, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidChannel(n)==false) return false;
 
   // channel descriptor
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   ImageDataItemPointer ch;
   if(IsChannelSet(n))
   {
     ch=GetChannelData(n,data,importMemoryManagement);
     if(ch->GetManageMemory()==false)
     {
       ch=AllocateChannelData(n,data,importMemoryManagement);
       if(ch.GetPointer()==NULL) return false;
     }
     if ( ch->GetData() != data )
       std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
     ch->Modified();
     ch->SetComplete(true);
     //we have changed the data: call Modified()!
     Modified();
   }
   else
   {
     ch=AllocateChannelData(n,data,importMemoryManagement);
     if(ch.GetPointer()==NULL) return false;
     if ( ch->GetData() != data )
       std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
     ch->SetComplete(true);
 
     this->m_ImageDescriptor->GetChannelDescriptor(n).SetData( ch->GetData() );
     //we just added a missing Channel, which is not regarded as modification.
     //Therefore, we do not call Modified()!
   }
   return true;
 }
 
 void mitk::Image::Initialize()
 {
   ImageDataItemPointerArray::iterator it, end;
   for( it=m_Slices.begin(), end=m_Slices.end(); it!=end; ++it )
   {
     (*it)=NULL;
   }
   for( it=m_Volumes.begin(), end=m_Volumes.end(); it!=end; ++it )
   {
     (*it)=NULL;
   }
   for( it=m_Channels.begin(), end=m_Channels.end(); it!=end; ++it )
   {
     (*it)=NULL;
   }
   m_CompleteData = NULL;
 
   if( m_ImageStatistics == NULL)
   {
     m_ImageStatistics = new mitk::ImageStatisticsHolder( this );
   }
 
   SetRequestedRegionToLargestPossibleRegion();
 }
 
 void mitk::Image::Initialize(const mitk::ImageDescriptor::Pointer inDesc)
 {
   // store the descriptor
   this->m_ImageDescriptor = inDesc;
 
   // initialize image
   this->Initialize( inDesc->GetChannelDescriptor(0).GetPixelType(), inDesc->GetNumberOfDimensions(), inDesc->GetDimensions(), 1 );
 }
 
 void mitk::Image::Initialize(const mitk::PixelType& type, unsigned int dimension, const unsigned int *dimensions, unsigned int channels)
 {
   Clear();
 
   m_Dimension=dimension;
 
   if(!dimensions)
     itkExceptionMacro(<< "invalid zero dimension image");
 
   unsigned int i;
   for(i=0;i<dimension;++i)
   {
     if(dimensions[i]<1)
       itkExceptionMacro(<< "invalid dimension[" << i << "]: " << dimensions[i]);
   }
 
   // create new array since the old was deleted
   m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
 
   // initialize the first four dimensions to 1, the remaining 4 to 0
   FILL_C_ARRAY(m_Dimensions, 4, 1u);
   FILL_C_ARRAY((m_Dimensions+4), 4, 0u);
 
   // copy in the passed dimension information
   std::memcpy(m_Dimensions, dimensions, sizeof(unsigned int)*m_Dimension);
 
   this->m_ImageDescriptor = mitk::ImageDescriptor::New();
   this->m_ImageDescriptor->Initialize( this->m_Dimensions, this->m_Dimension );
 
   for(i=0;i<4;++i)
   {
     m_LargestPossibleRegion.SetIndex(i, 0);
     m_LargestPossibleRegion.SetSize (i, m_Dimensions[i]);
   }
   m_LargestPossibleRegion.SetIndex(i, 0);
   m_LargestPossibleRegion.SetSize(i, channels);
 
   if(m_LargestPossibleRegion.GetNumberOfPixels()==0)
   {
     delete [] m_Dimensions;
     m_Dimensions = NULL;
     return;
   }
 
   for( unsigned int i=0u; i<channels; i++)
   {
     this->m_ImageDescriptor->AddNewChannel( type );
   }
 
   PlaneGeometry::Pointer planegeometry = PlaneGeometry::New();
   planegeometry->InitializeStandardPlane(m_Dimensions[0], m_Dimensions[1]);
 
   SlicedGeometry3D::Pointer slicedGeometry = SlicedGeometry3D::New();
   slicedGeometry->InitializeEvenlySpaced(planegeometry, m_Dimensions[2]);
 
   if(dimension>=4)
   {
     TimeBounds timebounds;
     timebounds[0] = 0.0;
     timebounds[1] = 1.0;
     slicedGeometry->SetTimeBounds(timebounds);
   }
 
   TimeSlicedGeometry::Pointer timeSliceGeometry = TimeSlicedGeometry::New();
   timeSliceGeometry->InitializeEvenlyTimed(slicedGeometry, m_Dimensions[3]);
   timeSliceGeometry->ImageGeometryOn();
 
   SetGeometry(timeSliceGeometry);
 
   ImageDataItemPointer dnull=NULL;
 
   m_Channels.assign(GetNumberOfChannels(), dnull);
 
   m_Volumes.assign(GetNumberOfChannels()*m_Dimensions[3], dnull);
 
   m_Slices.assign(GetNumberOfChannels()*m_Dimensions[3]*m_Dimensions[2], dnull);
 
   ComputeOffsetTable();
 
   Initialize();
 
   m_Initialized = true;
 }
 
 void mitk::Image::Initialize(const mitk::PixelType& type, const mitk::Geometry3D& geometry, unsigned int channels, int tDim )
 {
   unsigned int dimensions[5];
   dimensions[0] = (unsigned int)(geometry.GetExtent(0)+0.5);
   dimensions[1] = (unsigned int)(geometry.GetExtent(1)+0.5);
   dimensions[2] = (unsigned int)(geometry.GetExtent(2)+0.5);
   dimensions[3] = 0;
   dimensions[4] = 0;
 
   unsigned int dimension = 2;
   if ( dimensions[2] > 1 )
     dimension = 3;
 
   if ( tDim > 0)
   {
     dimensions[3] = tDim;
   }
   else
   {
     const mitk::TimeSlicedGeometry* timeGeometry = dynamic_cast<const mitk::TimeSlicedGeometry*>(&geometry);
     if ( timeGeometry != NULL )
     {
       dimensions[3] = timeGeometry->GetTimeSteps();
     }
   }
 
   if ( dimensions[3] > 1 )
     dimension = 4;
 
   Initialize( type, dimension, dimensions, channels );
 
   SetGeometry(static_cast<Geometry3D*>(geometry.Clone().GetPointer()));
 
   mitk::BoundingBox::BoundsArrayType bounds = geometry.GetBoundingBox()->GetBounds();
   if( (bounds[0] != 0.0) || (bounds[2] != 0.0) || (bounds[4] != 0.0) )
   {
     SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
 
     mitk::Point3D origin; origin.Fill(0.0);
     slicedGeometry->IndexToWorld(origin, origin);
 
     bounds[1]-=bounds[0]; bounds[3]-=bounds[2]; bounds[5]-=bounds[4];
     bounds[0] = 0.0;      bounds[2] = 0.0;      bounds[4] = 0.0;
 this->m_ImageDescriptor->Initialize( this->m_Dimensions, this->m_Dimension );
     slicedGeometry->SetBounds(bounds);
     slicedGeometry->GetIndexToWorldTransform()->SetOffset(origin.GetVnlVector().data_block());
 
     GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, m_Dimensions[3]);
   }
 }
 
 void mitk::Image::Initialize(const mitk::PixelType& type, int sDim, const mitk::Geometry2D& geometry2d, bool flipped, unsigned int channels, int tDim )
 {
   SlicedGeometry3D::Pointer slicedGeometry = SlicedGeometry3D::New();
   slicedGeometry->InitializeEvenlySpaced(static_cast<Geometry2D*>(geometry2d.Clone().GetPointer()), sDim, flipped);
   Initialize(type, *slicedGeometry, channels, tDim);
 }
 
 void mitk::Image::Initialize(const mitk::Image* image)
 {
   Initialize(image->GetPixelType(), *image->GetTimeSlicedGeometry());
 }
 
 void mitk::Image::Initialize(vtkImageData* vtkimagedata, int channels, int tDim, int sDim, int pDim)
 {
   if(vtkimagedata==NULL) return;
 
   m_Dimension=vtkimagedata->GetDataDimension();
   unsigned int i, *tmpDimensions=new unsigned int[m_Dimension>4?m_Dimension:4];
   for(i=0;i<m_Dimension;++i) tmpDimensions[i]=vtkimagedata->GetDimensions()[i];
   if(m_Dimension<4)
   {
     unsigned int *p;
     for(i=0,p=tmpDimensions+m_Dimension;i<4-m_Dimension;++i, ++p)
       *p=1;
   }
 
   if(pDim>=0)
   {
      tmpDimensions[1]=pDim;
      if(m_Dimension < 2)
         m_Dimension = 2;
   }
   if(sDim>=0)
   {
     tmpDimensions[2]=sDim;
     if(m_Dimension < 3)
       m_Dimension = 3;
   }
   if(tDim>=0)
   {
     tmpDimensions[3]=tDim;
     if(m_Dimension < 4)
       m_Dimension = 4;
   }
 
 
   switch ( vtkimagedata->GetScalarType() )
   {
   case VTK_BIT:
   case VTK_CHAR:
     //pixelType.Initialize(typeid(char), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<char>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_UNSIGNED_CHAR:
     //pixelType.Initialize(typeid(unsigned char), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<unsigned char>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_SHORT:
     //pixelType.Initialize(typeid(short), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<short>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_UNSIGNED_SHORT:
     //pixelType.Initialize(typeid(unsigned short), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<unsigned short>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_INT:
     //pixelType.Initialize(typeid(int), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<int>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_UNSIGNED_INT:
     //pixelType.Initialize(typeid(unsigned int), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<unsigned int>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_LONG:
     //pixelType.Initialize(typeid(long), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<long>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_UNSIGNED_LONG:
     //pixelType.Initialize(typeid(unsigned long), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<unsigned long>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_FLOAT:
     //pixelType.Initialize(typeid(float), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<float>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_DOUBLE:
     //pixelType.Initialize(typeid(double), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<double>(), m_Dimension, tmpDimensions, channels);
     break;
   default:
     break;
   }
   /*
   Initialize(pixelType,
     m_Dimension,
     tmpDimensions,
     channels);
 */
 
   const double *spacinglist = vtkimagedata->GetSpacing();
   Vector3D spacing;
   FillVector3D(spacing, spacinglist[0], 1.0, 1.0);
   if(m_Dimension>=2)
     spacing[1]=spacinglist[1];
   if(m_Dimension>=3)
     spacing[2]=spacinglist[2];
 
   // access origin of vtkImage
     Point3D origin;
   vtkFloatingPointType vtkorigin[3];
   vtkimagedata->GetOrigin(vtkorigin);
   FillVector3D(origin, vtkorigin[0], 0.0, 0.0);
   if(m_Dimension>=2)
     origin[1]=vtkorigin[1];
   if(m_Dimension>=3)
     origin[2]=vtkorigin[2];
 
   SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
 
   // re-initialize PlaneGeometry with origin and direction
   PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(slicedGeometry->GetGeometry2D(0));
   planeGeometry->SetOrigin(origin);
 
   // re-initialize SlicedGeometry3D
   slicedGeometry->SetOrigin(origin);
   slicedGeometry->SetSpacing(spacing);
   GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, m_Dimensions[3]);
 
   delete [] tmpDimensions;
 }
 
 bool mitk::Image::IsValidSlice(int s, int t, int n) const
 {
   if(m_Initialized)
     return ((s>=0) && (s<(int)m_Dimensions[2]) && (t>=0) && (t< (int) m_Dimensions[3]) && (n>=0) && (n< (int)GetNumberOfChannels()));
   else
     return false;
 }
 
 bool mitk::Image::IsValidVolume(int t, int n) const
 {
   if(m_Initialized)
     return IsValidSlice(0, t, n);
   else
     return false;
 }
 
 bool mitk::Image::IsValidChannel(int n) const
 {
   if(m_Initialized)
     return IsValidSlice(0, 0, n);
   else
     return false;
 }
 
 void mitk::Image::ComputeOffsetTable()
 {
   if(m_OffsetTable!=NULL)
     delete [] m_OffsetTable;
 
   m_OffsetTable=new size_t[m_Dimension>4 ? m_Dimension+1 : 4+1];
 
   unsigned int i;
   size_t num=1;
   m_OffsetTable[0] = 1;
   for (i=0; i < m_Dimension; ++i)
   {
     num *= m_Dimensions[i];
     m_OffsetTable[i+1] = num;
   }
   for (;i < 4; ++i)
     m_OffsetTable[i+1] = num;
 }
 
 bool mitk::Image::IsValidTimeStep(int t) const
 {
   return ( ( m_Dimension >= 4 && t <= (int)m_Dimensions[3] && t > 0 ) || (t == 0) );
 }
 
 void mitk::Image::Expand(unsigned int timeSteps)
 {
   if(timeSteps < 1) itkExceptionMacro(<< "Invalid timestep in Image!");
   Superclass::Expand(timeSteps);
 }
 
 int mitk::Image::GetSliceIndex(int s, int t, int n) const
 {
   if(IsValidSlice(s,t,n)==false) return false;
   return ((size_t)s)+((size_t) t)*m_Dimensions[2]+((size_t) n)*m_Dimensions[3]*m_Dimensions[2]; //??
 }
 
 int mitk::Image::GetVolumeIndex(int t, int n) const
 {
   if(IsValidVolume(t,n)==false) return false;
   return ((size_t)t)+((size_t) n)*m_Dimensions[3]; //??
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::AllocateSliceData(int s, int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   int pos;
   pos=GetSliceIndex(s,t,n);
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   // is slice available as part of a volume that is available?
   ImageDataItemPointer sl, ch, vol;
   vol=m_Volumes[GetVolumeIndex(t,n)];
   if(vol.GetPointer()!=NULL)
   {
     sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
     sl->SetComplete(true);
     return m_Slices[pos]=sl;
   }
 
   // is slice available as part of a channel that is available?
   ch=m_Channels[n];
   if(ch.GetPointer()!=NULL)
   {
     sl=new ImageDataItem(*ch, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, (((size_t) s)*m_OffsetTable[2]+((size_t) t)*m_OffsetTable[3])*(ptypeSize));
     sl->SetComplete(true);
     return m_Slices[pos]=sl;
   }
 
   // allocate new volume (instead of a single slice to keep data together!)
   m_Volumes[GetVolumeIndex(t,n)]=vol=AllocateVolumeData(t,n,NULL,importMemoryManagement);
   sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
   sl->SetComplete(true);
   return m_Slices[pos]=sl;
 
   ////ALTERNATIVE:
   //// allocate new slice
   //sl=new ImageDataItem(*m_PixelType, 2, m_Dimensions);
   //m_Slices[pos]=sl;
   //return vol;
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::AllocateVolumeData(int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   int pos;
   pos=GetVolumeIndex(t,n);
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   // is volume available as part of a channel that is available?
   ImageDataItemPointer ch, vol;
   ch=m_Channels[n];
   if(ch.GetPointer()!=NULL)
   {
     vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data,importMemoryManagement == ManageMemory, (((size_t) t)*m_OffsetTable[3])*(ptypeSize));
     return m_Volumes[pos]=vol;
   }
 
   mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(n);
 
   // allocate new volume
   if(importMemoryManagement == CopyMemory)
   {
     vol=new ImageDataItem( chPixelType, 3, m_Dimensions, NULL, true);
     if(data != NULL)
       std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
   }
   else
   {
     vol=new ImageDataItem( chPixelType, 3, m_Dimensions, data, importMemoryManagement == ManageMemory);
   }
   m_Volumes[pos]=vol;
   return vol;
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::AllocateChannelData(int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   ImageDataItemPointer ch;
   // allocate new channel
   if(importMemoryManagement == CopyMemory)
   {
     const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
     ch=new ImageDataItem(this->m_ImageDescriptor, NULL, true);
     if(data != NULL)
       std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
   }
   else
   {
     ch=new ImageDataItem(this->m_ImageDescriptor, data, importMemoryManagement == ManageMemory);
   }
   m_Channels[n]=ch;
   return ch;
 }
 
 unsigned int* mitk::Image::GetDimensions() const
 {
   return m_Dimensions;
 }
 
 void mitk::Image::Clear()
 {
   Superclass::Clear();
   delete [] m_Dimensions;
   m_Dimensions = NULL;
 }
 
 void mitk::Image::SetGeometry(Geometry3D* aGeometry3D)
 {
   // Please be aware of the 0.5 offset/pixel-center issue! See Geometry documentation for further information
 
   if(aGeometry3D->GetImageGeometry()==false)
   {
     MITK_INFO << "WARNING: Applied a non-image geometry onto an image. Please be SURE that this geometry is pixel-center-based! If it is not, you need to call Geometry3D->ChangeImageGeometryConsideringOriginOffset(true) before calling image->setGeometry(..)\n";
   }
   Superclass::SetGeometry(aGeometry3D);
   GetTimeSlicedGeometry()->ImageGeometryOn();
 }
 
 void mitk::Image::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   unsigned char i;
   if(m_Initialized)
   {
     os << indent << " Dimension: " << m_Dimension << std::endl;
     os << indent << " Dimensions: ";
     for(i=0; i < m_Dimension; ++i)
       os << GetDimension(i) << " ";
     os << std::endl;
 
     for(unsigned int ch=0; ch < this->m_ImageDescriptor->GetNumberOfChannels(); ch++)
     {
       mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(ch);
 
       os << indent << " Channel: " << this->m_ImageDescriptor->GetChannelName(ch) << std::endl;
       os << indent << " PixelType: " << chPixelType.GetPixelTypeAsString() << std::endl;
       os << indent << " BitsPerElement: " << chPixelType.GetSize() << std::endl;
       os << indent << " ComponentType: " << chPixelType.GetComponentTypeAsString() << std::endl;
       os << indent << " NumberOfComponents: " << chPixelType.GetNumberOfComponents() << std::endl;
       os << indent << " BitsPerComponent: " << chPixelType.GetBitsPerComponent() << std::endl;
     }
 
   }
   else
   {
     os << indent << " Image not initialized: m_Initialized: false" << std::endl;
   }
 
   Superclass::PrintSelf(os,indent);
 }
 
 bool mitk::Image::IsRotated() const
 {
   const mitk::Geometry3D* geo = this->GetGeometry();
   bool ret = false;
 
   if(geo)
   {
-    const vnl_matrix_fixed<float, 3, 3> & mx = geo->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
+    const vnl_matrix_fixed<ScalarType, 3, 3> & mx = geo->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
     float ref = 0;
     for(short k = 0; k < 3; ++k)
       ref += mx[k][k];
     ref/=1000;  // Arbitrary value; if a non-diagonal (nd) element is bigger then this, matrix is considered nd.
 
     for(short i = 0; i < 3; ++i)
     {
       for(short j = 0; j < 3; ++j)
       {
         if(i != j)
         {
           if(std::abs(mx[i][j]) > ref) // matrix is nd
             ret = true;
         }
       }
     }
   }
   return ret;
 }
 
 #include "mitkImageStatisticsHolder.h"
 
 //##Documentation
 mitk::ScalarType mitk::Image::GetScalarValueMin(int t) const
 {
   return m_ImageStatistics->GetScalarValueMin(t);
 }
 
 //##Documentation
 //## \brief Get the maximum for scalar images
 mitk::ScalarType mitk::Image::GetScalarValueMax(int t) const
 {
   return m_ImageStatistics->GetScalarValueMax(t);
 }
 
 //##Documentation
 //## \brief Get the second smallest value for scalar images
 mitk::ScalarType mitk::Image::GetScalarValue2ndMin(int t) const
 {
   return m_ImageStatistics->GetScalarValue2ndMin(t);
 }
 
 mitk::ScalarType mitk::Image::GetScalarValueMinNoRecompute( unsigned int t ) const
 {
   return m_ImageStatistics->GetScalarValueMinNoRecompute(t);
 }
 
 mitk::ScalarType mitk::Image::GetScalarValue2ndMinNoRecompute( unsigned int t ) const
 {
   return m_ImageStatistics->GetScalarValue2ndMinNoRecompute(t);
 }
 
 mitk::ScalarType mitk::Image::GetScalarValue2ndMax(int t) const
 {
   return m_ImageStatistics->GetScalarValue2ndMax(t);
 }
 
 mitk::ScalarType mitk::Image::GetScalarValueMaxNoRecompute( unsigned int t) const
 {
   return m_ImageStatistics->GetScalarValueMaxNoRecompute(t);
 }
 
 mitk::ScalarType mitk::Image::GetScalarValue2ndMaxNoRecompute( unsigned int t ) const
 {
   return m_ImageStatistics->GetScalarValue2ndMaxNoRecompute(t);
 }
 
 mitk::ScalarType mitk::Image::GetCountOfMinValuedVoxels(int t ) const
 {
   return m_ImageStatistics->GetCountOfMinValuedVoxels(t);
 }
 
 mitk::ScalarType mitk::Image::GetCountOfMaxValuedVoxels(int t) const
 {
   return m_ImageStatistics->GetCountOfMaxValuedVoxels(t);
 }
 
 unsigned int mitk::Image::GetCountOfMaxValuedVoxelsNoRecompute( unsigned int t  ) const
 {
   return m_ImageStatistics->GetCountOfMaxValuedVoxelsNoRecompute(t);
 }
 
 unsigned int mitk::Image::GetCountOfMinValuedVoxelsNoRecompute( unsigned int t ) const
 {
   return m_ImageStatistics->GetCountOfMinValuedVoxelsNoRecompute(t);
 }
 
diff --git a/Core/Code/DataManagement/mitkSlicedData.cpp b/Core/Code/DataManagement/mitkSlicedData.cpp
index bfb5dcef8e..6f97ffb6a2 100644
--- a/Core/Code/DataManagement/mitkSlicedData.cpp
+++ b/Core/Code/DataManagement/mitkSlicedData.cpp
@@ -1,350 +1,350 @@
 /*===================================================================
 
 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 "mitkSlicedData.h"
 #include "mitkBaseProcess.h"
 
 
 mitk::SlicedData::SlicedData() : m_UseLargestPossibleRegion(false)
 {
   unsigned int i;
   for(i=0;i<4;++i)
   {
     m_LargestPossibleRegion.SetIndex(i, 0);
     m_LargestPossibleRegion.SetSize (i, 1);
   }
 }
 
 mitk::SlicedData::SlicedData( const SlicedData &other ): BaseData(other),
 m_LargestPossibleRegion(other.m_LargestPossibleRegion),
 m_RequestedRegion(other.m_RequestedRegion),
 m_BufferedRegion(other.m_BufferedRegion),
 m_UseLargestPossibleRegion(other.m_UseLargestPossibleRegion)
 {
 
 }
 mitk::SlicedData::~SlicedData()
 {
 }
 
 void mitk::SlicedData::UpdateOutputInformation()
 {
   Superclass::UpdateOutputInformation();
 
   if (this->GetSource().IsNull())
   // If we don't have a source, then let's make our Image
   // span our buffer
   {
     m_UseLargestPossibleRegion = true;
   }
 
   // Now we should know what our largest possible region is. If our
   // requested region was not set yet, (or has been set to something
   // invalid - with no data in it ) then set it to the largest possible
   // region.
   if ( ! m_RequestedRegionInitialized)
   {
     this->SetRequestedRegionToLargestPossibleRegion();
     m_RequestedRegionInitialized = true;
   }
 
   m_LastRequestedRegionWasOutsideOfTheBufferedRegion = 0;
 }
 
 void mitk::SlicedData::PrepareForNewData()
 {
   if ( GetUpdateMTime() < GetPipelineMTime() || GetDataReleased() )
   {
    ReleaseData();
   }
 }
 
 void mitk::SlicedData::SetRequestedRegionToLargestPossibleRegion()
 {
   m_UseLargestPossibleRegion = true;
   if(GetGeometry()==NULL)
     return;
   unsigned int i;
   const RegionType::IndexType & index = GetLargestPossibleRegion().GetIndex();
   const RegionType::SizeType & size = GetLargestPossibleRegion().GetSize();
   for(i=0;i<RegionDimension;++i)
   {
     m_RequestedRegion.SetIndex(i, index[i]);
     m_RequestedRegion.SetSize(i, size[i]);
   }
 }
 
 bool mitk::SlicedData::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   // Is the requested region within the currently buffered data?
   // SlicedData and subclasses store entire volumes or slices. The
   // methods IsVolumeSet() and IsSliceSet are provided to check,
   // a volume or slice, respectively, is available. Thus, these
   // methods used here.
   const IndexType &requestedRegionIndex = m_RequestedRegion.GetIndex();
 
   const SizeType& requestedRegionSize = m_RequestedRegion.GetSize();
   const SizeType& largestPossibleRegionSize
     = GetLargestPossibleRegion().GetSize();
 
   // are whole channels requested?
   int c, cEnd;
   c=requestedRegionIndex[4];
   cEnd=c+static_cast<long>(requestedRegionSize[4]);
   if(requestedRegionSize[3] == largestPossibleRegionSize[3])
   {
     for (; c< cEnd; ++c)
       if(IsChannelSet(c)==false) return true;
     return false;
   }
 
   // are whole volumes requested?
   int t, tEnd;
   t=requestedRegionIndex[3];
   tEnd=t+static_cast<long>(requestedRegionSize[3]);
   if(requestedRegionSize[2] == largestPossibleRegionSize[2])
   {
     for (; c< cEnd; ++c)
       for (; t< tEnd; ++t)
         if(IsVolumeSet(t, c)==false) return true;
     return false;
   }
 
   // ok, only slices are requested. Check if they are available.
   int s, sEnd;
   s=requestedRegionIndex[2];
   sEnd=s+static_cast<long>(requestedRegionSize[2]);
   for (; c< cEnd; ++c)
     for (; t< tEnd; ++t)
       for (; s< sEnd; ++s)
         if(IsSliceSet(s, t, c)==false) return true;
 
   return false;
 }
 
 bool mitk::SlicedData::VerifyRequestedRegion()
 {
   if(GetTimeSlicedGeometry() == NULL) return false;
 
   unsigned int i;
 
   // Is the requested region within the LargestPossibleRegion?
   // Note that the test is indeed against the largest possible region
   // rather than the buffered region; see DataObject::VerifyRequestedRegion.
   const IndexType &requestedRegionIndex = m_RequestedRegion.GetIndex();
   const IndexType &largestPossibleRegionIndex
     = GetLargestPossibleRegion().GetIndex();
 
   const SizeType& requestedRegionSize = m_RequestedRegion.GetSize();
   const SizeType& largestPossibleRegionSize
     = GetLargestPossibleRegion().GetSize();
 
   for (i=0; i< RegionDimension; ++i)
   {
     if ( (requestedRegionIndex[i] < largestPossibleRegionIndex[i]) ||
       ((requestedRegionIndex[i] + static_cast<long>(requestedRegionSize[i]))
     > (largestPossibleRegionIndex[i]+static_cast<long>(largestPossibleRegionSize[i]))))
     {
       return false;
     }
   }
 
   return true;
 }
 
 void mitk::SlicedData::SetRequestedRegion( const itk::DataObject *data)
 {
   m_UseLargestPossibleRegion=false;
 
   const mitk::SlicedData *slicedData = dynamic_cast<const mitk::SlicedData*>(data);
 
   if (slicedData)
   {
     m_RequestedRegion = slicedData->GetRequestedRegion();
     m_RequestedRegionInitialized = true;
   }
   else
   {
     // pointer could not be cast back down
     itkExceptionMacro( << "mitk::SlicedData::SetRequestedRegion(DataObject*) cannot cast " << typeid(data).name() << " to " << typeid(SlicedData*).name() );
   }
 }
 
 void mitk::SlicedData::SetRequestedRegion(SlicedData::RegionType *region)
 {
   m_UseLargestPossibleRegion=false;
 
   if(region!=NULL)
   {
     m_RequestedRegion = *region;
     m_RequestedRegionInitialized = true;
   }
   else
   {
     // pointer could not be cast back down
     itkExceptionMacro( << "mitk::SlicedData::SetRequestedRegion(SlicedData::RegionType*) cannot cast " << typeid(region).name() << " to " << typeid(SlicedData*).name() );
   }
 }
 
 void mitk::SlicedData::CopyInformation(const itk::DataObject *data)
 {
   // Standard call to the superclass' method
   Superclass::CopyInformation(data);
 
   const mitk::SlicedData *slicedData;
 
   slicedData = dynamic_cast<const mitk::SlicedData*>(data);
 
   if (slicedData)
   {
     m_LargestPossibleRegion = slicedData->GetLargestPossibleRegion();
   }
   else
   {
     // pointer could not be cast back down
     itkExceptionMacro( << "mitk::SlicedData::CopyInformation(const DataObject *data) cannot cast " << typeid(data).name() << " to " << typeid(SlicedData*).name() );
   }
 }
 
 //const mitk::Geometry2D* mitk::SlicedData::GetGeometry2D(int s, int t) const
 //{
 //  const_cast<SlicedData*>(this)->SetRequestedRegionToLargestPossibleRegion();
 //
 //  const_cast<SlicedData*>(this)->UpdateOutputInformation();
 //
 //  return GetSlicedGeometry(t)->GetGeometry2D(s);
 //}
 //
 mitk::SlicedGeometry3D* mitk::SlicedData::GetSlicedGeometry(unsigned int t) const
 {
   if(GetTimeSlicedGeometry() == NULL)
     return NULL;
   return dynamic_cast<SlicedGeometry3D*>(GetTimeSlicedGeometry()->GetGeometry3D(t));
 }
 
 const mitk::SlicedGeometry3D* mitk::SlicedData::GetUpdatedSlicedGeometry(unsigned int t)
 {
   SetRequestedRegionToLargestPossibleRegion();
 
   UpdateOutputInformation();
 
   return GetSlicedGeometry(t);
 }
 
 void mitk::SlicedData::SetGeometry(Geometry3D* aGeometry3D)
 {
   if(aGeometry3D!=NULL)
   {
     TimeSlicedGeometry::Pointer timeSlicedGeometry = dynamic_cast<TimeSlicedGeometry*>(aGeometry3D);
     if(timeSlicedGeometry.IsNull())
     {
       SlicedGeometry3D::Pointer slicedGeometry = dynamic_cast<SlicedGeometry3D*>(aGeometry3D);
       if(slicedGeometry.IsNull())
       {
         Geometry2D* geometry2d = dynamic_cast<Geometry2D*>(aGeometry3D);
         if(geometry2d!=NULL)
         {
           if((GetSlicedGeometry()->GetGeometry2D(0)==geometry2d) && (GetSlicedGeometry()->GetSlices()==1))
             return;
           slicedGeometry = SlicedGeometry3D::New();
           slicedGeometry->InitializeEvenlySpaced(geometry2d, 1);
         }
         else
         {
           slicedGeometry = SlicedGeometry3D::New();
           PlaneGeometry::Pointer planeGeometry = PlaneGeometry::New();
           planeGeometry->InitializeStandardPlane(aGeometry3D);
           slicedGeometry->InitializeEvenlySpaced(planeGeometry, (unsigned int)(aGeometry3D->GetExtent(2)));
         }
       }
       assert(slicedGeometry.IsNotNull());
 
       timeSlicedGeometry = TimeSlicedGeometry::New();
       timeSlicedGeometry->InitializeEvenlyTimed(slicedGeometry, 1);
     }
     Superclass::SetGeometry(timeSlicedGeometry);
   }
   else
   {
     if(GetGeometry()==NULL)
       return;
     Superclass::SetGeometry(NULL);
   }
 }
 
-void mitk::SlicedData::SetSpacing(const float aSpacing[3])
+void mitk::SlicedData::SetSpacing(const ScalarType aSpacing[3])
 {
   this->SetSpacing((mitk::Vector3D)aSpacing);
 }
 
 void mitk::SlicedData::SetOrigin(const mitk::Point3D& origin)
 {
   mitk::TimeSlicedGeometry* timeSlicedGeometry = GetTimeSlicedGeometry();
 
   assert(timeSlicedGeometry!=NULL);
 
   mitk::SlicedGeometry3D* slicedGeometry;
 
   unsigned int steps = timeSlicedGeometry->GetTimeSteps();
 
   for(unsigned int timestep = 0; timestep < steps; ++timestep)
   {
     slicedGeometry = GetSlicedGeometry(timestep);
     if(slicedGeometry != NULL)
     {
       slicedGeometry->SetOrigin(origin);
       if(slicedGeometry->GetEvenlySpaced())
       {
         mitk::Geometry2D* geometry2D = slicedGeometry->GetGeometry2D(0);
         geometry2D->SetOrigin(origin);
         slicedGeometry->InitializeEvenlySpaced(geometry2D, slicedGeometry->GetSlices());
       }
     }
     if(GetTimeSlicedGeometry()->GetEvenlyTimed())
     {
       GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, steps);
       break;
     }
   }
 }
 
 void mitk::SlicedData::SetSpacing(mitk::Vector3D aSpacing)
 {
   mitk::TimeSlicedGeometry* timeSlicedGeometry = GetTimeSlicedGeometry();
 
   assert(timeSlicedGeometry!=NULL);
 
   mitk::SlicedGeometry3D* slicedGeometry;
 
   unsigned int steps = timeSlicedGeometry->GetTimeSteps();
 
   for(unsigned int timestep = 0; timestep < steps; ++timestep)
   {
     slicedGeometry = GetSlicedGeometry(timestep);
     if(slicedGeometry != NULL)
     {
       slicedGeometry->SetSpacing(aSpacing);
     }
     if(GetTimeSlicedGeometry()->GetEvenlyTimed())
     {
       GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, steps);
       break;
     }
   }
 }
 
 
diff --git a/Core/Code/DataManagement/mitkSlicedData.h b/Core/Code/DataManagement/mitkSlicedData.h
index 0c26d36471..14af6e37a1 100644
--- a/Core/Code/DataManagement/mitkSlicedData.h
+++ b/Core/Code/DataManagement/mitkSlicedData.h
@@ -1,222 +1,222 @@
 /*===================================================================
 
 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 SLICEDDATA_H_HEADER_INCLUDED
 #define SLICEDDATA_H_HEADER_INCLUDED
 
 #include <MitkExports.h>
 #include "mitkBaseData.h"
 #include "mitkTimeSlicedGeometry.h"
 #include "mitkSlicedGeometry3D.h"
 #include "itkIndex.h"
 #include "itkOffset.h"
 #include "itkSize.h"
 #include "itkImageRegion.h"
 
 namespace mitk {
 
 class SlicedGeometry3D;
 
 //##Documentation
 //## @brief Super class of data objects consisting of slices
 //##
 //## Super class of data objects consisting of slices, e.g., images or a stack
 //## of contours. (GetGeometry will return a Geometry3D containing Geometry2D
 //## objects).
 //##
 //## SlicedData-objects have geometries of type SlicedGeometry3D or sub-classes.
 //## @ingroup Data
 class MITK_CORE_EXPORT SlicedData : public BaseData
 {
 public:
   mitkClassMacro(SlicedData, BaseData);
 
   itkStaticConstMacro(RegionDimension, unsigned int, 5);
 
   /** Region typedef support. A region is used to specify a subset of a @a SlicedData. */
   typedef itk::ImageRegion<RegionDimension>  RegionType;
 
   /** Index typedef support. An index is used to access pixel values. */
   typedef itk::Index<RegionDimension>  IndexType;
   typedef IndexType::IndexValueType  IndexValueType;
 
   /** Offset typedef support. An offset represent relative position
   * between indices. */
   typedef itk::Offset<RegionDimension>  OffsetType;
   typedef OffsetType::OffsetValueType OffsetValueType;
 
   /** Size typedef support. A size is used to define region bounds. */
   typedef itk::Size<RegionDimension>  SizeType;
   typedef SizeType::SizeValueType SizeValueType;
 
   //##Documentation
   //## Update the information for this DataObject so that it can be used as
   //## an output of a ProcessObject.  This method is used in the pipeline
   //## mechanism to propagate information and initialize the meta data
   //## associated with a itk::DataObject.  Any implementation of this method
   //## in a derived class of itk::DataObject is assumed to call its source's
   //## ProcessObject::UpdateOutputInformation() which determines modified
   //## times, LargestPossibleRegions, and any extra meta data like spacing,
   //## origin, etc.
   virtual void UpdateOutputInformation();
 
   virtual void PrepareForNewData();
 
   //##Documentation
   //## Set the RequestedRegion to the LargestPossibleRegion.  This forces a
   //## filter to produce all of the output in one execution (i.e. not
   //## streaming) on the next call to Update().
   virtual void SetRequestedRegionToLargestPossibleRegion();
 
   //##Documentation
   //## Determine whether the RequestedRegion is outside of the
   //## BufferedRegion. This method returns true if the RequestedRegion is
   //## outside the BufferedRegion (true if at least one pixel is outside).
   //## This is used by the pipeline mechanism to determine whether a filter
   //## needs to re-execute in order to satisfy the current request.  If the
   //## current RequestedRegion is already inside the BufferedRegion from the
   //## previous execution (and the current filter is up to date), then a
   //## given filter does not need to re-execute
   virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
 
   //##Documentation
   //## @brief Verify that the RequestedRegion is within the
   //## LargestPossibleRegion.
   //##
   //## Verify that the RequestedRegion is within the LargestPossibleRegion.
   //## If the RequestedRegion is not within the LargestPossibleRegion,
   //## then the filter cannot possibly satisfy the request. This method
   //## returns true if the request can be satisfied (even if it will be
   //## necessary to process the entire LargestPossibleRegion) and
   //## returns false otherwise.  This method is used by
   //## PropagateRequestedRegion().  PropagateRequestedRegion() throws a
   //## InvalidRequestedRegionError exception if the requested region is
   //## not within the LargestPossibleRegion.
   virtual bool VerifyRequestedRegion();
 
   //##Documentation
   //## Set the requested region from this data object to match the requested
   //## region of the data object passed in as a parameter.  This method is
   //## implemented in the concrete subclasses of DataObject.
   virtual void SetRequestedRegion( const itk::DataObject *data);
 
   //##Documentation
   //## Set the requested region from this data object to match the requested
   //## region of the data object passed in as a parameter.  This method is
   //## implemented in the concrete subclasses of DataObject.
   virtual void SetRequestedRegion(SlicedData::RegionType *region);
 
   const RegionType& GetLargestPossibleRegion() const
   {
     return m_LargestPossibleRegion;
   }
 
   //##Documentation
   //## Get the region object that defines the size and starting index
   //## for the region of the image requested (i.e., the region of the
   //## image to be operated on by a filter).
   virtual const RegionType& GetRequestedRegion() const
   {
     return m_RequestedRegion;
   }
 
   virtual bool IsSliceSet(int s = 0, int t = 0, int n = 0) const = 0;
   virtual bool IsVolumeSet(int t = 0, int n = 0) const = 0;
   virtual bool IsChannelSet(int n = 0) const = 0;
   virtual void CopyInformation(const itk::DataObject *data);
 
   //##Documentation
   //## @brief Get the number of channels
   unsigned int GetNumberOfChannels() const
   {
     return m_LargestPossibleRegion.GetSize(4);
   }
 
   ////##Documentation
   ////## @brief Return the Geometry2D of the slice (@a s, @a t).
   ////##
   ////## The method does not simply call GetGeometry()->GetGeometry2D(). Before doing this, it
   ////## makes sure that the Geometry2D is up-to-date before returning it (by
   ////## setting the update extent appropriately and calling
   ////## UpdateOutputInformation).
   ////##
   ////## @warning GetGeometry2D not yet completely implemented.
   ////## @todo Appropriate setting of the update extent is missing.
   //virtual const mitk::Geometry2D* GetGeometry2D(int s, int t=0) const;
 
   //##Documentation
   //## @brief Convenience access method for the geometry, which is of type SlicedGeometry3D (or a sub-class of it).
   //##
   //## @em No update will be called. Normally used in GenerateOutputInformation of
   //## subclasses of BaseProcess.
   SlicedGeometry3D* GetSlicedGeometry(unsigned int t=0) const;
 
   //##Documentation
   //## @brief Convenience access method for the geometry, which is of type SlicedGeometry3D (or a sub-class of it).
   //##
   //## The method does not simply return the value of the m_Geometry3D member.
   //## Before doing this, it makes sure that the Geometry3D is up-to-date before
   //## returning it (by setting the update extent appropriately and calling
   //## UpdateOutputInformation).
   //##
   //## @warning GetGeometry not yet completely implemented.
   //## @todo Appropriate setting of the update extent is missing.
   const SlicedGeometry3D* GetUpdatedSlicedGeometry(unsigned int t=0);
 
   //##Documentation
   //## @brief Set the Geometry3D of the data, which will be referenced (not copied!). It
   //## has to be a sub-class of SlicedGeometry3D.
   //##
   //## @warning This method will normally be called internally by the sub-class of SlicedData
   //## during initialization.
   virtual void SetGeometry(Geometry3D* aGeometry3D);
 
   //##Documentation
   //## @brief Convenience method for setting the origin of
   //## the SlicedGeometry3D instances of all time steps
   //##
   //## In case the SlicedGeometry3D is evenly spaced,
   //## the origin of the first slice is set to \a origin.
   //## \sa mitk::BaseData::SetOrigin
   virtual void SetOrigin(const Point3D& origin);
 
   //##Documentation
   //## @brief Convenience method for setting the spacing of
   //## the SlicedGeometry3D instances of all time steps
-  virtual void SetSpacing(const float aSpacing[3]);
+  virtual void SetSpacing(const ScalarType aSpacing[]);
 
   //##Documentation
   //## @brief Convenience method for setting the spacing of
   //## the SlicedGeometry3D instances of all time steps
   virtual void SetSpacing(mitk::Vector3D aSpacing);
 
 protected:
 
   SlicedData();
   SlicedData(const SlicedData &other);
   virtual ~SlicedData();
 
   RegionType m_LargestPossibleRegion;
 
   RegionType          m_RequestedRegion;
   RegionType          m_BufferedRegion;
   bool                m_UseLargestPossibleRegion;
 };
 
 } // namespace mitk
 
 #endif /* SLICEDDATA_H_HEADER_INCLUDED */
diff --git a/Core/Code/DataManagement/mitkVector.cpp b/Core/Code/DataManagement/mitkVector.cpp
index 8a75c8cc09..3a6f50b86b 100644
--- a/Core/Code/DataManagement/mitkVector.cpp
+++ b/Core/Code/DataManagement/mitkVector.cpp
@@ -1,23 +1,21 @@
 /*===================================================================
 
 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 "mitkVector.h"
-#include <vtkSystemIncludes.h>
-#include <vtkMatrix4x4.h>
 
-const mitk::ScalarType mitk::eps     = vnl_math::float_eps*100;
-const mitk::ScalarType mitk::sqrteps = vnl_math::float_sqrteps;
-extern const double mitk::large      = VTK_LARGE_FLOAT;
+const mitk::ScalarType mitk::eps     = vnl_math::eps*100;
+const mitk::ScalarType mitk::sqrteps = vnl_math::sqrteps;
+extern const mitk::ScalarType mitk::large = std::numeric_limits<mitk::ScalarType>::max();
diff --git a/Core/Code/DataManagement/mitkVector.h b/Core/Code/DataManagement/mitkVector.h
index 29883739ee..86cce50561 100644
--- a/Core/Code/DataManagement/mitkVector.h
+++ b/Core/Code/DataManagement/mitkVector.h
@@ -1,457 +1,463 @@
 /*===================================================================
 
 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 MITKVECTOR_H_HEADER_INCLUDED_C1EBD0AD
 #define MITKVECTOR_H_HEADER_INCLUDED_C1EBD0AD
 
 // this is needed for memcopy in ITK
 // can be removed when fixed in ITK
 #include <cstring>
 
 #include <itkPoint.h>
 #include <float.h>
 #include <itkIndex.h>
 #include <itkContinuousIndex.h>
 #include <itkVector.h>
 #include <itkMatrix.h>
 #include <itkTransform.h>
 #include <vnl/vnl_quaternion.h>
 #include <MitkExports.h>
 
 #ifndef DOXYGEN_SKIP
 
 namespace mitk {
-typedef float ScalarType;
+typedef double ScalarType;
 
 typedef itk::Matrix<ScalarType, 3, 3> Matrix3D;
 typedef itk::Matrix<ScalarType,4,4> Matrix4D;
 typedef vnl_matrix_fixed<ScalarType, 3, 3> VnlMatrix3D;
 typedef itk::Transform<ScalarType, 3, 3> Transform3D;
 typedef vnl_vector<ScalarType> VnlVector;
 typedef vnl_vector_ref<ScalarType> VnlVectorRef;
 
 typedef itk::Point<ScalarType,2> Point2D;
 typedef itk::Point<ScalarType,3> Point3D;
 typedef itk::Point<ScalarType,4> Point4D;
 typedef itk::Point<int,2> Point2I;
 typedef itk::Point<int,3> Point3I;
 typedef itk::Point<int,4> Point4I;
 typedef itk::Vector<ScalarType,2> Vector2D;
 typedef itk::Vector<ScalarType,3> Vector3D;
 typedef itk::Index<3> Index3D;
 typedef itk::ContinuousIndex<ScalarType, 3> ContinuousIndex3D;
 typedef vnl_quaternion<ScalarType> Quaternion;
 
 //##Documentation
 //##@brief enumeration of the type a point can be
 enum PointSpecificationType
 {
   PTUNDEFINED = 0,
   PTSTART,
   PTCORNER,
   PTEDGE,
   PTEND
 };
 
 typedef itk::NumericTraits<mitk::ScalarType> ScalarTypeNumericTraits;
 MITK_CORE_EXPORT extern const ScalarType eps;
 MITK_CORE_EXPORT extern const ScalarType sqrteps;
 MITK_CORE_EXPORT extern const double large;
 
 template <class T> class VectorTraits {
   public:
     typedef T ValueType;
 };
 
 template <> class VectorTraits<VnlVector> {
   public:
     typedef ScalarType ValueType;
 };
 
-template<> class VectorTraits<double[4]> {
+template<> class VectorTraits<float[4]> {
   public:
-    typedef double ValueType;
+    typedef float ValueType;
 };
+
 template<> class VectorTraits< itk::Index<5> > {
   public:
     typedef itk::Index<5>::IndexValueType ValueType;
 };
 
 template<> class VectorTraits< itk::Index<3> > {
   public:
     typedef itk::Index<3>::IndexValueType ValueType;
 };
 
 template<> class VectorTraits< long int [3]> {
   public:
     typedef long int ValueType;
 };
 template<> class VectorTraits< float [3]> {
   public:
     typedef float ValueType;
 };
 template<> class VectorTraits< double [3]> {
   public:
     typedef double ValueType;
 };
 
 template<> class VectorTraits< vnl_vector_fixed<ScalarType, 3> > {
   public:
     typedef ScalarType ValueType;
 };
 
 template<> class VectorTraits< long unsigned int[3]> {
   public:
     typedef long unsigned int ValueType;
 };
 
 template<> class VectorTraits< unsigned int *> {
   public:
     typedef unsigned int ValueType;
 };
 
 template<> class VectorTraits< ScalarType[4] > {
   public:
     typedef ScalarType ValueType;
 };
 
 template<> class VectorTraits< itk::Vector<float,3> > {
   public:
     typedef float ValueType;
 };
 
 template<> class VectorTraits< itk::Point<float,3> > {
   public:
     typedef float ValueType;
 };
 
 template<> class VectorTraits< itk::Point<float,4> > {
   public:
     typedef float ValueType;
 };
 
 template<> class VectorTraits< itk::Vector<double,3> > {
   public:
     typedef double ValueType;
 };
 
 template<> class VectorTraits< itk::Point<double,3> > {
   public:
     typedef double ValueType;
 };
 
+template<> class VectorTraits< itk::Point<double,4> > {
+public:
+    typedef double ValueType;
+};
+
 template<> class VectorTraits< itk::Vector<int,3> > {
   public:
     typedef int ValueType;
 };
 
 template<> class VectorTraits< itk::Point<int,3> > {
   public:
     typedef int ValueType;
 };
 
 template <class Tin, class Tout>
   inline void itk2vtk(const Tin& in, Tout& out)
 {
   out[0]=(typename VectorTraits<Tout>::ValueType)(in[0]);
   out[1]=(typename VectorTraits<Tout>::ValueType)(in[1]);
   out[2]=(typename VectorTraits<Tout>::ValueType)(in[2]);
 }
 
 template <class Tin, class Tout>
   inline void vtk2itk(const Tin& in, Tout& out)
 {
   out[0]=(typename VectorTraits<Tout>::ValueType)(in[0]);
   out[1]=(typename VectorTraits<Tout>::ValueType)(in[1]);
   out[2]=(typename VectorTraits<Tout>::ValueType)(in[2]);
 }
 template <class Tout>
   inline void FillVector3D(Tout& out, ScalarType x, ScalarType y, ScalarType z)
 {
   out[0] = (typename VectorTraits<Tout>::ValueType)x;
   out[1] = (typename VectorTraits<Tout>::ValueType)y;
   out[2] = (typename VectorTraits<Tout>::ValueType)z;
 }
 template <class Tout>
   inline void FillVector4D(Tout& out, ScalarType x, ScalarType y, ScalarType z, ScalarType t)
 {
   out[0] = (typename VectorTraits<Tout>::ValueType)x;
   out[1] = (typename VectorTraits<Tout>::ValueType)y;
   out[2] = (typename VectorTraits<Tout>::ValueType)z;
   out[3] = (typename VectorTraits<Tout>::ValueType)t;
 }
 
 
 template <class Tin, class Tout>
   inline void vnl2vtk(const vnl_vector<Tin>& in, Tout *out)
 {
   unsigned int i;
   for(i=0; i<in.size();++i)
     out[i]=(Tout) (in[i]);
 }
 
 template <class Tin, class Tout>
   inline void vtk2vnl(const Tin *in, vnl_vector<Tout>& out)
 {
   unsigned int i;
   for(i=0; i<out.size();++i)
     out[i]=(Tout) (in[i]);
 }
 
 template <class Tin, class Tout>
   inline void vtk2vnlref(const Tin *in, vnl_vector_ref<Tout>& out)
 {
   unsigned int i;
   for(i=0; i<out.size();++i)
     out[i]=(Tout) (in[i]);
 }
 
 template <class Tin, class Tout, unsigned int n>
   inline void vnl2vtk(const vnl_vector_fixed<Tin, n>& in, Tout *out)
 {
   unsigned int i;
   for(i=0; i<in.size();++i)
     out[i]=(Tout) (in[i]);
 }
 
 template <class Tin, class Tout, unsigned int n>
   inline void vtk2vnl(const Tin *in, vnl_vector_fixed<Tout, n>& out)
 {
   unsigned int i;
   for(i=0; i<out.size();++i)
     out[i]=(Tout) (in[i]);
 }
 
 template <class T, unsigned int NVectorDimension>
   itk::Vector<T, NVectorDimension> operator+(const itk::Vector<T, NVectorDimension> &vector, const itk::Point<T, NVectorDimension> &point)
 {
   itk::Vector<T, NVectorDimension> sub;
   for( unsigned int i=0; i<NVectorDimension; i++)
   {
     sub[i] = vector[i]+point[i];
   }
   return sub;
 }
 
 template <class T, unsigned int NVectorDimension>
   inline itk::Vector<T, NVectorDimension>& operator+=(itk::Vector<T, NVectorDimension> &vector, const itk::Point<T, NVectorDimension> &point)
 {
   for( unsigned int i=0; i<NVectorDimension; i++)
   {
     vector[i] += point[i];
   }
   return vector;
 }
 
 template <class T, unsigned int NVectorDimension>
   itk::Vector<T, NVectorDimension> operator-(const itk::Vector<T, NVectorDimension> &vector, const itk::Point<T, NVectorDimension> &point)
 {
   itk::Vector<T, NVectorDimension> sub;
   for( unsigned int i=0; i<NVectorDimension; i++)
   {
     sub[i] = vector[i]-point[i];
   }
   return sub;
 }
 
 template <class T, unsigned int NVectorDimension>
   inline itk::Vector<T, NVectorDimension>& operator-=(itk::Vector<T, NVectorDimension> &vector, const itk::Point<T, NVectorDimension> &point)
 {
   for( unsigned int i=0; i<NVectorDimension; i++)
   {
     vector[i] -= point[i];
   }
   return vector;
 }
 
 /*!
 \brief Check for matrix equality with a user defined accuracy. As an equality metric the root mean squared error (RMS) of all elements is calculated.
 \param matrix1 first vnl matrix
 \param matrix2 second vnl matrix
 \epsilon user defined accuracy bounds
 */
 template <typename TCoordRep, unsigned int NRows, unsigned int NCols>
 inline bool MatrixEqualRMS(const vnl_matrix_fixed<TCoordRep,NRows,NCols>& matrix1,const vnl_matrix_fixed<TCoordRep,NRows,NCols>& matrix2,mitk::ScalarType epsilon=mitk::eps)
 {
   if ( (matrix1.rows() == matrix2.rows()) && (matrix1.cols() == matrix2.cols()) )
   {
     vnl_matrix_fixed<TCoordRep,NRows,NCols> differenceMatrix = matrix1-matrix2;
     if (differenceMatrix.rms()<epsilon)
     {
       return true;
     }
     else
     {
       return false;
     }
   }
   else
   {
     return false;
   }
 }
 
 /*!
 \brief Check for matrix equality with a user defined accuracy. As an equality metric the root mean squared error (RMS) of all elements is calculated.
 \param matrix1 first itk matrix
 \param matrix2 second itk matrix
 \epsilon user defined accuracy bounds
 */
 template <typename TCoordRep, unsigned int NRows, unsigned int NCols>
 inline bool MatrixEqualRMS(const itk::Matrix<TCoordRep, NRows, NCols>& matrix1,const itk::Matrix<TCoordRep, NRows, NCols>& matrix2,mitk::ScalarType epsilon=mitk::eps)
 {
   return mitk::MatrixEqualRMS(matrix1.GetVnlMatrix(),matrix2.GetVnlMatrix(),epsilon);
 }
 
 /*!
 \brief Check for element-wise matrix equality with a user defined accuracy.
 \param matrix1 first vnl matrix
 \param matrix2 second vnl matrix
 \epsilon user defined accuracy bounds
 */
 template <typename TCoordRep, unsigned int NRows, unsigned int NCols>
 inline bool MatrixEqualElementWise(const vnl_matrix_fixed<TCoordRep,NRows,NCols>& matrix1,const vnl_matrix_fixed<TCoordRep,NRows,NCols>& matrix2,mitk::ScalarType epsilon=mitk::eps)
 {
   if ( (matrix1.rows() == matrix2.rows()) && (matrix1.cols() == matrix2.cols()) )
   {
     for( unsigned int r=0; r<NRows; r++)
     {
       for( unsigned int c=0; c<NCols; c++ )
       {
         TCoordRep difference =  fabs(matrix1(r,c)-matrix2(r,c));
         if (difference>epsilon)
         {
           return false;
         }
       }
     }
     return true;
   }
   else
   {
     return false;
   }
 }
 
 /*!
 \brief Check for element-wise matrix equality with a user defined accuracy.
 \param matrix1 first itk matrix
 \param matrix2 second itk matrix
 \epsilon user defined accuracy bounds
 */
 template <typename TCoordRep, unsigned int NRows, unsigned int NCols>
 inline bool MatrixEqualElementWise(const itk::Matrix<TCoordRep, NRows, NCols>& matrix1,const itk::Matrix<TCoordRep, NRows, NCols>& matrix2,mitk::ScalarType epsilon=mitk::eps)
 {
   return mitk::MatrixEqualElementWise(matrix1.GetVnlMatrix(),matrix2.GetVnlMatrix(),epsilon);
 }
 
 template <typename TCoordRep, unsigned int NPointDimension>
 inline bool Equal(const itk::Vector<TCoordRep, NPointDimension>& vector1, const itk::Vector<TCoordRep, NPointDimension>& vector2, TCoordRep eps=mitk::eps)
 {
   typename itk::Vector<TCoordRep, NPointDimension>::VectorType diff = vector1-vector2;
   for (unsigned int i=0; i<NPointDimension; i++)
       if (diff[i]>eps || diff[i]<-eps)
       return false;
   return true;
 }
 
 template <typename TCoordRep, unsigned int NPointDimension>
   inline bool Equal(const itk::Point<TCoordRep, NPointDimension>& vector1, const itk::Point<TCoordRep, NPointDimension>& vector2, TCoordRep eps=mitk::eps)
 {
   typename itk::Point<TCoordRep, NPointDimension>::VectorType diff = vector1-vector2;
   for (unsigned int i=0; i<NPointDimension; i++)
     if (diff[i]>eps || diff[i]<-eps)
       return false;
   return true;
 }
 
 inline bool Equal(const mitk::VnlVector& vector1, const mitk::VnlVector& vector2, ScalarType eps=mitk::eps)
 {
   mitk::VnlVector diff = vector1-vector2;
   for (unsigned int i=0; i<diff.size(); i++)
     if (diff[i]>eps || diff[i]<-eps)
       return false;
   return true;
 }
 
-inline bool Equal(double scalar1, double scalar2, ScalarType eps=mitk::eps)
+inline bool Equal(ScalarType scalar1, ScalarType scalar2, ScalarType eps=mitk::eps)
 {
   return fabs(scalar1-scalar2) < eps;
 }
 
 template <typename TCoordRep, unsigned int NPointDimension>
   inline bool Equal(const vnl_vector_fixed<TCoordRep, NPointDimension> & vector1, const vnl_vector_fixed<TCoordRep, NPointDimension>& vector2, TCoordRep eps=mitk::eps)
 {
   vnl_vector_fixed<TCoordRep, NPointDimension> diff = vector1-vector2;
   bool returnValue = true;
   for( unsigned int i=0; i<diff.size(); i++)
   {
     if(diff[i]>eps || diff[i]<-eps)
     {
      returnValue = false;
     }
   }
 
   return returnValue;
 }
 
 template <typename U, typename V, unsigned int NRows, unsigned int NColumns>
 inline void TransferMatrix(const itk::Matrix<U, NRows, NColumns>& in, itk::Matrix<V, NRows, NColumns>& out)
 {
   for (unsigned int i = 0; i < in.RowDimensions; ++i)
     for (unsigned int j = 0; j < in.ColumnDimensions; ++j)
       out[i][j] = in[i][j];
 }
 
 
 } // namespace mitk
 
 #endif //DOXYGEN_SKIP
 
 /*
  * This part of the code has been shifted here to avoid compiler clashes
  * caused by including <itkAffineGeometryFrame.h> before the declaration of
  * the Equal() methods above. This problem occurs when using MSVC and is
  * probably related to a compiler bug.
  */
 
 #include <itkAffineGeometryFrame.h>
 
 namespace mitk
 {
   typedef itk::AffineGeometryFrame<ScalarType, 3>::TransformType AffineTransform3D;
 }
 
 
 #define mitkSetConstReferenceMacro(name,type) \
   virtual void Set##name (const type & _arg) \
   { \
     itkDebugMacro("setting " << #name " to " << _arg ); \
     if (this->m_##name != _arg) \
       { \
       this->m_##name = _arg; \
       this->Modified(); \
       } \
   }
 
 #define mitkSetVectorMacro(name,type) \
   mitkSetConstReferenceMacro(name,type)
 
 #define mitkGetVectorMacro(name,type) \
   itkGetConstReferenceMacro(name,type)
 
 #endif /* MITKVECTOR_H_HEADER_INCLUDED_C1EBD0AD */
diff --git a/Core/Code/IO/mitkDicomSeriesReader.cpp b/Core/Code/IO/mitkDicomSeriesReader.cpp
index 4a0c865bf4..30b2d597a0 100644
--- a/Core/Code/IO/mitkDicomSeriesReader.cpp
+++ b/Core/Code/IO/mitkDicomSeriesReader.cpp
@@ -1,1974 +1,1974 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // uncomment for learning more about the internal sorting mechanisms
 //#define MBILOG_ENABLE_DEBUG
 
 #include <mitkDicomSeriesReader.h>
 
 #include <itkGDCMSeriesFileNames.h>
 
 #include <gdcmSorter.h>
 #include <gdcmRAWCodec.h>
 #include <gdcmAttribute.h>
 #include <gdcmPixmapReader.h>
 #include <gdcmStringFilter.h>
 #include <gdcmDirectory.h>
 #include <gdcmScanner.h>
 #include <gdcmUIDs.h>
 
 #include "mitkProperties.h"
 
 namespace mitk
 {
 
 typedef itk::GDCMSeriesFileNames DcmFileNamesGeneratorType;
 
 DicomSeriesReader::ImageBlockDescriptor::ImageBlockDescriptor()
 :m_HasGantryTiltCorrected(false)
 ,m_HasMultipleTimePoints(false)
 ,m_IsMultiFrameImage(false)
 {
 }
 
 DicomSeriesReader::ImageBlockDescriptor::~ImageBlockDescriptor()
 {
   // nothing
 }
 
 DicomSeriesReader::ImageBlockDescriptor::ImageBlockDescriptor(const StringContainer& files)
 :m_HasGantryTiltCorrected(false)
 ,m_HasMultipleTimePoints(false)
 ,m_IsMultiFrameImage(false)
 {
   m_Filenames = files;
 }
 
 
 void DicomSeriesReader::ImageBlockDescriptor::AddFile(const std::string& filename)
 {
   m_Filenames.push_back( filename );
 }
 
 void DicomSeriesReader::ImageBlockDescriptor::AddFiles(const StringContainer& files)
 {
   m_Filenames.insert( m_Filenames.end(), files.begin(), files.end() );
 }
 
 DicomSeriesReader::StringContainer DicomSeriesReader::ImageBlockDescriptor::GetFilenames() const
 {
   return m_Filenames;
 }
 
 std::string DicomSeriesReader::ImageBlockDescriptor::GetImageBlockUID() const
 {
   return m_ImageBlockUID;
 }
 
 std::string DicomSeriesReader::ImageBlockDescriptor::GetSeriesInstanceUID() const
 {
   return m_SeriesInstanceUID;
 }
 
 std::string DicomSeriesReader::ImageBlockDescriptor::GetModality() const
 {
   return m_Modality;
 }
 
 std::string DicomSeriesReader::ImageBlockDescriptor::GetSOPClassUIDAsString() const
 {
   gdcm::UIDs uidKnowledge;
   uidKnowledge.SetFromUID( m_SOPClassUID.c_str() );
   return uidKnowledge.GetName();
 }
 
 std::string DicomSeriesReader::ImageBlockDescriptor::GetSOPClassUID() const
 {
   return m_SOPClassUID;
 }
 
 bool DicomSeriesReader::ImageBlockDescriptor::IsMultiFrameImage() const
 {
   return m_IsMultiFrameImage;
 }
 
 DicomSeriesReader::ReaderImplementationLevel DicomSeriesReader::ImageBlockDescriptor::GetReaderImplementationLevel() const
 {
   if ( this->IsMultiFrameImage() )
     return ReaderImplementationLevel_Unsupported;
 
   gdcm::UIDs uidKnowledge;
   uidKnowledge.SetFromUID( m_SOPClassUID.c_str() );
 
   gdcm::UIDs::TSType uid = uidKnowledge;
 
   switch (uid)
   {
     case gdcm::UIDs::CTImageStorage:
     case gdcm::UIDs::MRImageStorage:
     case gdcm::UIDs::PositronEmissionTomographyImageStorage:
     case gdcm::UIDs::ComputedRadiographyImageStorage:
     case gdcm::UIDs::DigitalXRayImageStorageForPresentation:
     case gdcm::UIDs::DigitalXRayImageStorageForProcessing:
       return ReaderImplementationLevel_Supported;
 
     case gdcm::UIDs::NuclearMedicineImageStorage:
       return ReaderImplementationLevel_PartlySupported;
 
     case gdcm::UIDs::SecondaryCaptureImageStorage:
       return ReaderImplementationLevel_Implemented;
 
     default:
       return ReaderImplementationLevel_Unsupported;
   }
 }
 
 std::string DicomSeriesReader::ReaderImplementationLevelToString( const ReaderImplementationLevel& enumValue )
 {
   switch (enumValue)
   {
     case ReaderImplementationLevel_Supported: return "Supported";
     case ReaderImplementationLevel_PartlySupported: return "PartlySupported";
     case ReaderImplementationLevel_Implemented: return "Implemented";
     case ReaderImplementationLevel_Unsupported: return "Unsupported";
     default: return "<unknown value of enum ReaderImplementationLevel>";
   };
 }
 
 std::string DicomSeriesReader::PixelSpacingInterpretationToString( const PixelSpacingInterpretation& enumValue )
 {
   switch (enumValue)
   {
     case PixelSpacingInterpretation_SpacingInPatient: return "In Patient";
     case PixelSpacingInterpretation_SpacingAtDetector: return "At Detector";
     case PixelSpacingInterpretation_SpacingUnknown: return "Unknown spacing";
     default: return "<unknown value of enum PixelSpacingInterpretation>";
   };
 }
 
 
 bool DicomSeriesReader::ImageBlockDescriptor::HasGantryTiltCorrected() const
 {
   return m_HasGantryTiltCorrected;
 }
 
 /*
    PS defined      IPS defined     PS==IPS
         0               0                     --> UNKNOWN spacing, loader will invent
         0               1                     --> spacing as at detector surface
         1               0                     --> spacing as in patient
         1               1             0       --> detector surface spacing CORRECTED for geometrical magnifications: spacing as in patient
         1               1             1       --> detector surface spacing NOT corrected for geometrical magnifications: spacing as at detector
 */
 DicomSeriesReader::PixelSpacingInterpretation DicomSeriesReader::ImageBlockDescriptor::GetPixelSpacingType() const
 {
   if (m_PixelSpacing.empty())
   {
     if (m_ImagerPixelSpacing.empty())
     {
       return PixelSpacingInterpretation_SpacingUnknown;
     }
     else
     {
       return PixelSpacingInterpretation_SpacingAtDetector;
     }
   }
   else // Pixel Spacing defined
   {
     if (m_ImagerPixelSpacing.empty())
     {
       return PixelSpacingInterpretation_SpacingInPatient;
     }
     else if (m_PixelSpacing != m_ImagerPixelSpacing)
     {
       return PixelSpacingInterpretation_SpacingInPatient;
     }
     else
     {
       return PixelSpacingInterpretation_SpacingAtDetector;
     }
   }
 }
 
 bool DicomSeriesReader::ImageBlockDescriptor::PixelSpacingRelatesToPatient() const
 {
   return  GetPixelSpacingType() == PixelSpacingInterpretation_SpacingInPatient;
 }
 
 bool DicomSeriesReader::ImageBlockDescriptor::PixelSpacingRelatesToDetector() const
 {
   return  GetPixelSpacingType() == PixelSpacingInterpretation_SpacingAtDetector;
 }
 
 bool DicomSeriesReader::ImageBlockDescriptor::PixelSpacingIsUnknown() const
 {
   return GetPixelSpacingType() == PixelSpacingInterpretation_SpacingUnknown;
 }
 
 void DicomSeriesReader::ImageBlockDescriptor::SetPixelSpacingInformation(const std::string& pixelSpacing, const std::string& imagerPixelSpacing)
 {
   m_PixelSpacing = pixelSpacing;
   m_ImagerPixelSpacing = imagerPixelSpacing;
 }
 
-void DicomSeriesReader::ImageBlockDescriptor::GetDesiredMITKImagePixelSpacing( float& spacingX, float& spacingY) const
+void DicomSeriesReader::ImageBlockDescriptor::GetDesiredMITKImagePixelSpacing( ScalarType& spacingX, ScalarType& spacingY) const
 {
   // preference for "in patient" pixel spacing
   if ( !DICOMStringToSpacing( m_PixelSpacing, spacingX, spacingY ) )
   {
     // fallback to "on detector" spacing
     if ( !DICOMStringToSpacing( m_ImagerPixelSpacing, spacingX, spacingY ) )
     {
       // last resort: invent something
       spacingX = spacingY = 1.0;
     }
   }
 }
 
 bool DicomSeriesReader::ImageBlockDescriptor::HasMultipleTimePoints() const
 {
   return m_HasMultipleTimePoints;
 }
 
 void DicomSeriesReader::ImageBlockDescriptor::SetImageBlockUID(const std::string& uid)
 {
   m_ImageBlockUID = uid;
 }
 
 void DicomSeriesReader::ImageBlockDescriptor::SetSeriesInstanceUID(const std::string& uid)
 {
   m_SeriesInstanceUID = uid;
 }
 
 void DicomSeriesReader::ImageBlockDescriptor::SetModality(const std::string& modality)
 {
   m_Modality = modality;
 }
 
 void DicomSeriesReader::ImageBlockDescriptor::SetNumberOfFrames(const std::string& numberOfFrames)
 {
   m_IsMultiFrameImage = !numberOfFrames.empty();
 }
 
 void DicomSeriesReader::ImageBlockDescriptor::SetSOPClassUID(const std::string& sopClassUID)
 {
   m_SOPClassUID = sopClassUID;
 }
 
 
 void DicomSeriesReader::ImageBlockDescriptor::SetHasGantryTiltCorrected(bool on)
 {
   m_HasGantryTiltCorrected = on;
 }
 
 void DicomSeriesReader::ImageBlockDescriptor::SetHasMultipleTimePoints(bool on)
 {
   m_HasMultipleTimePoints = on;
 }
 
 
 
 DicomSeriesReader::SliceGroupingAnalysisResult::SliceGroupingAnalysisResult()
 :m_GantryTilt(false)
 {
 }
 
 DicomSeriesReader::StringContainer DicomSeriesReader::SliceGroupingAnalysisResult::GetBlockFilenames()
 {
   return m_GroupedFiles;
 }
 
 DicomSeriesReader::StringContainer DicomSeriesReader::SliceGroupingAnalysisResult::GetUnsortedFilenames()
 {
   return m_UnsortedFiles;
 }
 
 bool DicomSeriesReader::SliceGroupingAnalysisResult::ContainsGantryTilt()
 {
   return m_GantryTilt;
 }
 
 void DicomSeriesReader::SliceGroupingAnalysisResult::AddFileToSortedBlock(const std::string& filename)
 {
   m_GroupedFiles.push_back( filename );
 }
 
 void DicomSeriesReader::SliceGroupingAnalysisResult::AddFileToUnsortedBlock(const std::string& filename)
 {
   m_UnsortedFiles.push_back( filename );
 }
 
 void DicomSeriesReader::SliceGroupingAnalysisResult::AddFilesToUnsortedBlock(const StringContainer& filenames)
 {
   m_UnsortedFiles.insert( m_UnsortedFiles.end(), filenames.begin(), filenames.end() );
 }
 
 void DicomSeriesReader::SliceGroupingAnalysisResult::FlagGantryTilt()
 {
   m_GantryTilt = true;
 }
 
 void DicomSeriesReader::SliceGroupingAnalysisResult::UndoPrematureGrouping()
 {
   assert( !m_GroupedFiles.empty() );
   m_UnsortedFiles.insert( m_UnsortedFiles.begin(), m_GroupedFiles.back() );
   m_GroupedFiles.pop_back();
 }
 
 
 
 
 
 
 
 const DicomSeriesReader::TagToPropertyMapType& DicomSeriesReader::GetDICOMTagsToMITKPropertyMap()
 {
   static bool initialized = false;
   static TagToPropertyMapType dictionary;
   if (!initialized)
   {
     /*
        Selection criteria:
        - no sequences because we cannot represent that
        - nothing animal related (specied, breed registration number), MITK focusses on human medical image processing.
        - only general attributes so far
 
        When extending this, we should make use of a real dictionary (GDCM/DCMTK and lookup the tag names there)
     */
 
     // Patient module
     dictionary["0010|0010"] = "dicom.patient.PatientsName";
     dictionary["0010|0020"] = "dicom.patient.PatientID";
     dictionary["0010|0030"] = "dicom.patient.PatientsBirthDate";
     dictionary["0010|0040"] = "dicom.patient.PatientsSex";
     dictionary["0010|0032"] = "dicom.patient.PatientsBirthTime";
     dictionary["0010|1000"] = "dicom.patient.OtherPatientIDs";
     dictionary["0010|1001"] = "dicom.patient.OtherPatientNames";
     dictionary["0010|2160"] = "dicom.patient.EthnicGroup";
     dictionary["0010|4000"] = "dicom.patient.PatientComments";
     dictionary["0012|0062"] = "dicom.patient.PatientIdentityRemoved";
     dictionary["0012|0063"] = "dicom.patient.DeIdentificationMethod";
 
     // General Study module
     dictionary["0020|000d"] = "dicom.study.StudyInstanceUID";
     dictionary["0008|0020"] = "dicom.study.StudyDate";
     dictionary["0008|0030"] = "dicom.study.StudyTime";
     dictionary["0008|0090"] = "dicom.study.ReferringPhysiciansName";
     dictionary["0020|0010"] = "dicom.study.StudyID";
     dictionary["0008|0050"] = "dicom.study.AccessionNumber";
     dictionary["0008|1030"] = "dicom.study.StudyDescription";
     dictionary["0008|1048"] = "dicom.study.PhysiciansOfRecord";
     dictionary["0008|1060"] = "dicom.study.NameOfPhysicianReadingStudy";
 
     // General Series module
     dictionary["0008|0060"] = "dicom.series.Modality";
     dictionary["0020|000e"] = "dicom.series.SeriesInstanceUID";
     dictionary["0020|0011"] = "dicom.series.SeriesNumber";
     dictionary["0020|0060"] = "dicom.series.Laterality";
     dictionary["0008|0021"] = "dicom.series.SeriesDate";
     dictionary["0008|0031"] = "dicom.series.SeriesTime";
     dictionary["0008|1050"] = "dicom.series.PerformingPhysiciansName";
     dictionary["0018|1030"] = "dicom.series.ProtocolName";
     dictionary["0008|103e"] = "dicom.series.SeriesDescription";
     dictionary["0008|1070"] = "dicom.series.OperatorsName";
     dictionary["0018|0015"] = "dicom.series.BodyPartExamined";
     dictionary["0018|5100"] = "dicom.series.PatientPosition";
     dictionary["0028|0108"] = "dicom.series.SmallestPixelValueInSeries";
     dictionary["0028|0109"] = "dicom.series.LargestPixelValueInSeries";
 
     // VOI LUT module
     dictionary["0028|1050"] = "dicom.voilut.WindowCenter";
     dictionary["0028|1051"] = "dicom.voilut.WindowWidth";
     dictionary["0028|1055"] = "dicom.voilut.WindowCenterAndWidthExplanation";
 
     // Image Pixel module
     dictionary["0028|0004"] = "dicom.pixel.PhotometricInterpretation";
     dictionary["0028|0010"] = "dicom.pixel.Rows";
     dictionary["0028|0011"] = "dicom.pixel.Columns";
 
     // Image Plane module
     dictionary["0028|0030"] = "dicom.PixelSpacing";
     dictionary["0018|1164"] = "dicom.ImagerPixelSpacing";
 
     initialized = true;
   }
 
   return dictionary;
 }
 
 
 DataNode::Pointer
 DicomSeriesReader::LoadDicomSeries(const StringContainer &filenames, bool sort, bool check_4d, bool correctTilt, UpdateCallBackMethod callback, Image::Pointer preLoadedImageBlock)
 {
   DataNode::Pointer node = DataNode::New();
 
   if (DicomSeriesReader::LoadDicomSeries(filenames, *node, sort, check_4d, correctTilt, callback, preLoadedImageBlock))
   {
     if( filenames.empty() )
     {
       return NULL;
     }
 
     return node;
   }
   else
   {
     return NULL;
   }
 }
 
 bool
 DicomSeriesReader::LoadDicomSeries(
     const StringContainer &filenames,
     DataNode &node,
     bool sort,
     bool check_4d,
     bool correctTilt,
     UpdateCallBackMethod callback,
     Image::Pointer preLoadedImageBlock)
 {
   if( filenames.empty() )
   {
     MITK_DEBUG << "Calling LoadDicomSeries with empty filename string container. Probably invalid application logic.";
     node.SetData(NULL);
     return true; // this is not actually an error but the result is very simple
   }
 
   DcmIoType::Pointer io = DcmIoType::New();
 
   try
   {
     if (io->CanReadFile(filenames.front().c_str()))
     {
       io->SetFileName(filenames.front().c_str());
       io->ReadImageInformation();
 
       if (io->GetPixelType() == itk::ImageIOBase::SCALAR)
       {
         switch (io->GetComponentType())
         {
           case DcmIoType::UCHAR:
             DicomSeriesReader::LoadDicom<unsigned char>(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::CHAR:
             DicomSeriesReader::LoadDicom<char>(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::USHORT:
             DicomSeriesReader::LoadDicom<unsigned short>(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::SHORT:
             DicomSeriesReader::LoadDicom<short>(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::UINT:
             DicomSeriesReader::LoadDicom<unsigned int>(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::INT:
             DicomSeriesReader::LoadDicom<int>(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::ULONG:
             DicomSeriesReader::LoadDicom<long unsigned int>(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::LONG:
             DicomSeriesReader::LoadDicom<long int>(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::FLOAT:
             DicomSeriesReader::LoadDicom<float>(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::DOUBLE:
             DicomSeriesReader::LoadDicom<double>(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           default:
             MITK_ERROR << "Found unsupported DICOM scalar pixel type: (enum value) " << io->GetComponentType();
         }
       }
       else if (io->GetPixelType() == itk::ImageIOBase::RGB)
       {
         switch (io->GetComponentType())
         {
           case DcmIoType::UCHAR:
             DicomSeriesReader::LoadDicom< itk::RGBPixel<unsigned char> >(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::CHAR:
             DicomSeriesReader::LoadDicom<itk::RGBPixel<char> >(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::USHORT:
             DicomSeriesReader::LoadDicom<itk::RGBPixel<unsigned short> >(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::SHORT:
             DicomSeriesReader::LoadDicom<itk::RGBPixel<short> >(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::UINT:
             DicomSeriesReader::LoadDicom<itk::RGBPixel<unsigned int> >(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::INT:
             DicomSeriesReader::LoadDicom<itk::RGBPixel<int> >(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::ULONG:
             DicomSeriesReader::LoadDicom<itk::RGBPixel<long unsigned int> >(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::LONG:
             DicomSeriesReader::LoadDicom<itk::RGBPixel<long int> >(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::FLOAT:
             DicomSeriesReader::LoadDicom<itk::RGBPixel<float> >(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           case DcmIoType::DOUBLE:
             DicomSeriesReader::LoadDicom<itk::RGBPixel<double> >(filenames, node, sort, check_4d, correctTilt, callback, preLoadedImageBlock);
             break;
           default:
             MITK_ERROR << "Found unsupported DICOM scalar pixel type: (enum value) " << io->GetComponentType();
         }
       }
 
       if (node.GetData())
       {
         return true;
       }
     }
   }
   catch(itk::MemoryAllocationError& e)
   {
     MITK_ERROR << "Out of memory. Cannot load DICOM series: " << e.what();
   }
   catch(std::exception& e)
   {
     MITK_ERROR << "Error encountered when loading DICOM series:" << e.what();
   }
   catch(...)
   {
     MITK_ERROR << "Unspecified error encountered when loading DICOM series.";
   }
 
   return false;
 }
 
 
 bool
 DicomSeriesReader::IsDicom(const std::string &filename)
 {
   DcmIoType::Pointer io = DcmIoType::New();
 
   return io->CanReadFile(filename.c_str());
 }
 
 bool
 DicomSeriesReader::IsPhilips3DDicom(const std::string &filename)
 {
   DcmIoType::Pointer io = DcmIoType::New();
 
   if (io->CanReadFile(filename.c_str()))
   {
     //Look at header Tag 3001,0010 if it is "Philips3D"
     gdcm::Reader reader;
     reader.SetFileName(filename.c_str());
     reader.Read();
     gdcm::DataSet &data_set = reader.GetFile().GetDataSet();
     gdcm::StringFilter sf;
     sf.SetFile(reader.GetFile());
 
     if (data_set.FindDataElement(gdcm::Tag(0x3001, 0x0010)) &&
       (sf.ToString(gdcm::Tag(0x3001, 0x0010)) == "Philips3D "))
     {
       return true;
     }
   }
   return false;
 }
 
 bool
 DicomSeriesReader::ReadPhilips3DDicom(const std::string &filename, mitk::Image::Pointer output_image)
 {
   // Now get PhilipsSpecific Tags
 
   gdcm::PixmapReader reader;
   reader.SetFileName(filename.c_str());
   reader.Read();
   gdcm::DataSet &data_set = reader.GetFile().GetDataSet();
   gdcm::StringFilter sf;
   sf.SetFile(reader.GetFile());
 
   gdcm::Attribute<0x0028,0x0011> dimTagX; // coloumns || sagittal
   gdcm::Attribute<0x3001,0x1001, gdcm::VR::UL, gdcm::VM::VM1> dimTagZ; //I have no idea what is VM1. // (Philips specific) // axial
   gdcm::Attribute<0x0028,0x0010> dimTagY; // rows || coronal
   gdcm::Attribute<0x0028,0x0008> dimTagT; // how many frames
   gdcm::Attribute<0x0018,0x602c> spaceTagX; // Spacing in X , unit is "physicalTagx" (usually centimeter)
   gdcm::Attribute<0x0018,0x602e> spaceTagY;
   gdcm::Attribute<0x3001,0x1003, gdcm::VR::FD, gdcm::VM::VM1> spaceTagZ; // (Philips specific)
   gdcm::Attribute<0x0018,0x6024> physicalTagX; // if 3, then spacing params are centimeter
   gdcm::Attribute<0x0018,0x6026> physicalTagY;
   gdcm::Attribute<0x3001,0x1002, gdcm::VR::US, gdcm::VM::VM1> physicalTagZ; // (Philips specific)
 
   dimTagX.Set(data_set);
   dimTagY.Set(data_set);
   dimTagZ.Set(data_set);
   dimTagT.Set(data_set);
   spaceTagX.Set(data_set);
   spaceTagY.Set(data_set);
   spaceTagZ.Set(data_set);
   physicalTagX.Set(data_set);
   physicalTagY.Set(data_set);
   physicalTagZ.Set(data_set);
 
   unsigned int
     dimX = dimTagX.GetValue(),
     dimY = dimTagY.GetValue(),
     dimZ = dimTagZ.GetValue(),
     dimT = dimTagT.GetValue(),
     physicalX = physicalTagX.GetValue(),
     physicalY = physicalTagY.GetValue(),
     physicalZ = physicalTagZ.GetValue();
 
   float
     spaceX = spaceTagX.GetValue(),
     spaceY = spaceTagY.GetValue(),
     spaceZ = spaceTagZ.GetValue();
 
   if (physicalX == 3) // spacing parameter in cm, have to convert it to mm.
     spaceX = spaceX * 10;
 
   if (physicalY == 3) // spacing parameter in cm, have to convert it to mm.
     spaceY = spaceY * 10;
 
   if (physicalZ == 3) // spacing parameter in cm, have to convert it to mm.
     spaceZ = spaceZ * 10;
 
   // Ok, got all necessary Tags!
   // Now read Pixeldata (7fe0,0010) X x Y x Z x T Elements
 
   const gdcm::Pixmap &pixels = reader.GetPixmap();
   gdcm::RAWCodec codec;
 
   codec.SetPhotometricInterpretation(gdcm::PhotometricInterpretation::MONOCHROME2);
   codec.SetPixelFormat(pixels.GetPixelFormat());
   codec.SetPlanarConfiguration(0);
 
   gdcm::DataElement out;
   codec.Decode(data_set.GetDataElement(gdcm::Tag(0x7fe0, 0x0010)), out);
 
   const gdcm::ByteValue *bv = out.GetByteValue();
   const char *new_pixels = bv->GetPointer();
 
   // Create MITK Image + Geometry
   typedef itk::Image<unsigned char, 4> ImageType;   //Pixeltype might be different sometimes? Maybe read it out from header
   ImageType::RegionType myRegion;
   ImageType::SizeType mySize;
   ImageType::IndexType myIndex;
   ImageType::SpacingType mySpacing;
   ImageType::Pointer imageItk = ImageType::New();
 
   mySpacing[0] = spaceX;
   mySpacing[1] = spaceY;
   mySpacing[2] = spaceZ;
   mySpacing[3] = 1;
   myIndex[0] = 0;
   myIndex[1] = 0;
   myIndex[2] = 0;
   myIndex[3] = 0;
   mySize[0] = dimX;
   mySize[1] = dimY;
   mySize[2] = dimZ;
   mySize[3] = dimT;
   myRegion.SetSize( mySize);
   myRegion.SetIndex( myIndex );
   imageItk->SetSpacing(mySpacing);
   imageItk->SetRegions( myRegion);
   imageItk->Allocate();
   imageItk->FillBuffer(0);
 
   itk::ImageRegionIterator<ImageType>  iterator(imageItk, imageItk->GetLargestPossibleRegion());
   iterator.GoToBegin();
   unsigned long pixCount = 0;
   unsigned long planeSize = dimX*dimY;
   unsigned long planeCount = 0;
   unsigned long timeCount = 0;
   unsigned long numberOfSlices = dimZ;
 
   while (!iterator.IsAtEnd())
   {
     unsigned long adressedPixel =
       pixCount
       + (numberOfSlices-1-planeCount)*planeSize // add offset to adress the first pixel of current plane
       + timeCount*numberOfSlices*planeSize; // add time offset
 
     iterator.Set( new_pixels[ adressedPixel ] );
     pixCount++;
     ++iterator;
 
     if (pixCount == planeSize)
     {
       pixCount = 0;
       planeCount++;
     }
     if (planeCount == numberOfSlices)
     {
       planeCount = 0;
       timeCount++;
     }
     if (timeCount == dimT)
     {
       break;
     }
   }
   mitk::CastToMitkImage(imageItk, output_image);
   return true; // actually never returns false yet.. but exception possible
 }
 
 DicomSeriesReader::GantryTiltInformation::GantryTiltInformation()
 : m_ShiftUp(0.0)
 , m_ShiftRight(0.0)
 , m_ShiftNormal(0.0)
 , m_ITKAssumedSliceSpacing(0.0)
 , m_NumberOfSlicesApart(1)
 {
 }
 
 
 #define doublepoint(x) \
   Point3Dd x; \
   x[0] = x ## f[0]; \
   x[1] = x ## f[1]; \
   x[2] = x ## f[2];
 
 
 #define doublevector(x) \
   Vector3Dd x; \
   x[0] = x ## f[0]; \
   x[1] = x ## f[1]; \
   x[2] = x ## f[2];
 
 DicomSeriesReader::GantryTiltInformation::GantryTiltInformation(
     const Point3D& origin1f, const Point3D& origin2f,
     const Vector3D& rightf, const Vector3D& upf,
     unsigned int numberOfSlicesApart)
 : m_ShiftUp(0.0)
 , m_ShiftRight(0.0)
 , m_ShiftNormal(0.0)
 , m_NumberOfSlicesApart(numberOfSlicesApart)
 {
   assert(numberOfSlicesApart);
 
   doublepoint(origin1);
   doublepoint(origin2);
   doublevector(right);
   doublevector(up);
 
   // determine if slice 1 (imagePosition1 and imageOrientation1) and slice 2 can be in one orthogonal slice stack:
   // calculate a line from origin 1, directed along the normal of slice (calculated as the cross product of orientation 1)
   // check if this line passes through origin 2
 
   /*
      Determine if line (imagePosition2 + l * normal) contains imagePosition1.
      Done by calculating the distance of imagePosition1 from line (imagePosition2 + l *normal)
 
      E.g. http://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html
 
      squared distance = | (pointAlongNormal - origin2) x (origin2 - origin1) | ^ 2
      /
      |pointAlongNormal - origin2| ^ 2
 
      ( x meaning the cross product )
   */
 
   Vector3Dd normal = itk::CrossProduct(right, up);
   Point3Dd pointAlongNormal = origin2 + normal;
 
   double numerator = itk::CrossProduct( pointAlongNormal - origin2 , origin2 - origin1 ).GetSquaredNorm();
   double denominator = (pointAlongNormal - origin2).GetSquaredNorm();
 
   double distance = sqrt(numerator / denominator);
 
   if ( distance > 0.001 ) // mitk::eps is too small; 1/1000 of a mm should be enough to detect tilt
   {
     MITK_DEBUG << "  Series seems to contain a tilted (or sheared) geometry";
     MITK_DEBUG << "  Distance of expected slice origin from actual slice origin: " << distance;
     MITK_DEBUG << "    ==> storing this shift for later analysis:";
     MITK_DEBUG << "    v right: " << right;
     MITK_DEBUG << "    v up: " << up;
     MITK_DEBUG << "    v normal: " << normal;
 
     Point3Dd projectionRight = projectPointOnLine( origin1, origin2, right );
     Point3Dd projectionNormal = projectPointOnLine( origin1, origin2, normal );
 
     m_ShiftRight = (projectionRight - origin2).GetNorm();
     m_ShiftNormal = (projectionNormal - origin2).GetNorm();
 
     /*
        now also check to which side the image is shifted.
 
        Calculation e.g. from
        http://mathworld.wolfram.com/Point-PlaneDistance.html
     */
 
     Point3Dd  testPoint = origin1;
     Vector3Dd planeNormal = up;
 
     double signedDistance = (
                              planeNormal[0] * testPoint[0]
                            + planeNormal[1] * testPoint[1]
                            + planeNormal[2] * testPoint[2]
                            - (
                                planeNormal[0] * origin2[0]
                              + planeNormal[1] * origin2[1]
                              + planeNormal[2] * origin2[2]
                              )
                            )
                            /
                            sqrt( planeNormal[0] * planeNormal[0]
                                + planeNormal[1] * planeNormal[1]
                                + planeNormal[2] * planeNormal[2]
                                );
 
     m_ShiftUp = signedDistance;
 
     m_ITKAssumedSliceSpacing = (origin2 - origin1).GetNorm();
     // How do we now this is assumed? See header documentation for ITK code references
     //double itkAssumedSliceSpacing = sqrt( m_ShiftUp * m_ShiftUp + m_ShiftNormal * m_ShiftNormal );
 
     MITK_DEBUG << "    shift normal: " << m_ShiftNormal;
     MITK_DEBUG << "    shift normal assumed by ITK: " << m_ITKAssumedSliceSpacing;
     MITK_DEBUG << "    shift up: " << m_ShiftUp;
     MITK_DEBUG << "    shift right: " << m_ShiftRight;
 
     MITK_DEBUG << "    tilt angle (deg): " << atan( m_ShiftUp / m_ShiftNormal ) * 180.0 / 3.1415926535;
   }
 }
 
 Point3D
 DicomSeriesReader::GantryTiltInformation::projectPointOnLine( Point3Dd p, Point3Dd lineOrigin, Vector3Dd lineDirection )
 {
   /**
     See illustration at http://mo.mathematik.uni-stuttgart.de/inhalt/aussage/aussage472/
 
     vector(lineOrigin,p) = normal * ( innerproduct((p - lineOrigin),normal) / squared-length(normal) )
   */
 
   Vector3Dd lineOriginToP = p - lineOrigin;
   double innerProduct = lineOriginToP * lineDirection;
 
   double factor = innerProduct / lineDirection.GetSquaredNorm();
   Point3Dd projection = lineOrigin + factor * lineDirection;
 
   return projection;
 }
 
 double
 DicomSeriesReader::GantryTiltInformation::GetTiltCorrectedAdditionalSize() const
 {
   return fabs(m_ShiftUp);
 }
 
 double
 DicomSeriesReader::GantryTiltInformation::GetTiltAngleInDegrees() const
 {
   return atan( fabs(m_ShiftUp) / m_ShiftNormal ) * 180.0 / 3.1415926535;
 }
 
 double
 DicomSeriesReader::GantryTiltInformation::GetMatrixCoefficientForCorrectionInWorldCoordinates() const
 {
   // so many mm need to be shifted per slice!
   return m_ShiftUp / static_cast<double>(m_NumberOfSlicesApart);
 }
 
 double
 DicomSeriesReader::GantryTiltInformation::GetRealZSpacing() const
 {
   return m_ShiftNormal / static_cast<double>(m_NumberOfSlicesApart);
 }
 
 
 bool
 DicomSeriesReader::GantryTiltInformation::IsSheared() const
 {
   return (   fabs(m_ShiftRight) > 0.001
           ||    fabs(m_ShiftUp) > 0.001);
 }
 
 
 bool
 DicomSeriesReader::GantryTiltInformation::IsRegularGantryTilt() const
 {
   return (   fabs(m_ShiftRight) < 0.001
           &&    fabs(m_ShiftUp) > 0.001);
 }
 
 
 std::string
 DicomSeriesReader::ConstCharStarToString(const char* s)
 {
   return s ?  std::string(s) : std::string();
 }
 
 bool
-DicomSeriesReader::DICOMStringToSpacing(const std::string& s, float& spacingX, float& spacingY)
+DicomSeriesReader::DICOMStringToSpacing(const std::string& s, ScalarType& spacingX, ScalarType& spacingY)
 {
   bool successful = false;
 
   std::istringstream spacingReader(s);
   std::string spacing;
   if ( std::getline( spacingReader, spacing, '\\' ) )
   {
     spacingY = atof( spacing.c_str() );
 
     if ( std::getline( spacingReader, spacing, '\\' ) )
     {
       spacingX = atof( spacing.c_str() );
 
       successful = true;
     }
   }
 
   return successful;
 }
 
 Point3D
 DicomSeriesReader::DICOMStringToPoint3D(const std::string& s, bool& successful)
 {
   Point3D p;
   successful = true;
 
   std::istringstream originReader(s);
   std::string coordinate;
   unsigned int dim(0);
   while( std::getline( originReader, coordinate, '\\' ) && dim < 3)
   {
     p[dim++]= atof(coordinate.c_str());
   }
 
   if (dim && dim != 3)
   {
     successful = false;
     MITK_ERROR << "Reader implementation made wrong assumption on tag (0020,0032). Found " << dim << " instead of 3 values.";
   }
   else if (dim == 0)
   {
     successful = false;
     p.Fill(0.0); // assume default (0,0,0)
   }
 
   return p;
 }
 
 void
 DicomSeriesReader::DICOMStringToOrientationVectors(const std::string& s, Vector3D& right, Vector3D& up, bool& successful)
 {
   successful = true;
 
   std::istringstream orientationReader(s);
   std::string coordinate;
   unsigned int dim(0);
   while( std::getline( orientationReader, coordinate, '\\' ) && dim < 6 )
   {
     if (dim<3)
     {
       right[dim++] = atof(coordinate.c_str());
     }
     else
     {
       up[dim++ - 3] = atof(coordinate.c_str());
     }
   }
 
   if (dim && dim != 6)
   {
     successful = false;
     MITK_ERROR << "Reader implementation made wrong assumption on tag (0020,0037). Found " << dim << " instead of 6 values.";
   }
   else if (dim == 0)
   {
     // fill with defaults
     right.Fill(0.0);
     right[0] = 1.0;
 
     up.Fill(0.0);
     up[1] = 1.0;
 
     successful = false;
   }
 }
 
 
 DicomSeriesReader::SliceGroupingAnalysisResult
 DicomSeriesReader::AnalyzeFileForITKImageSeriesReaderSpacingAssumption(
     const StringContainer& files,
     bool groupImagesWithGantryTilt,
     const gdcm::Scanner::MappingType& tagValueMappings_)
 {
   // result.first = files that fit ITK's assumption
   // result.second = files that do not fit, should be run through AnalyzeFileForITKImageSeriesReaderSpacingAssumption() again
   SliceGroupingAnalysisResult result;
 
   // we const_cast here, because I could not use a map.at(), which would make the code much more readable
   gdcm::Scanner::MappingType& tagValueMappings = const_cast<gdcm::Scanner::MappingType&>(tagValueMappings_);
   const gdcm::Tag tagImagePositionPatient(0x0020,0x0032); // Image Position (Patient)
   const gdcm::Tag    tagImageOrientation(0x0020, 0x0037); // Image Orientation
   const gdcm::Tag          tagGantryTilt(0x0018, 0x1120); // gantry tilt
 
   Vector3D fromFirstToSecondOrigin; fromFirstToSecondOrigin.Fill(0.0);
   bool fromFirstToSecondOriginInitialized(false);
   Point3D thisOrigin;
   thisOrigin.Fill(0.0f);
   Point3D lastOrigin;
   lastOrigin.Fill(0.0f);
   Point3D lastDifferentOrigin;
   lastDifferentOrigin.Fill(0.0f);
 
   bool lastOriginInitialized(false);
 
   MITK_DEBUG << "--------------------------------------------------------------------------------";
   MITK_DEBUG << "Analyzing files for z-spacing assumption of ITK's ImageSeriesReader (group tilted: " << groupImagesWithGantryTilt << ")";
   unsigned int fileIndex(0);
   for (StringContainer::const_iterator fileIter = files.begin();
        fileIter != files.end();
        ++fileIter, ++fileIndex)
   {
     bool fileFitsIntoPattern(false);
     std::string thisOriginString;
     // Read tag value into point3D. PLEASE replace this by appropriate GDCM code if you figure out how to do that
     thisOriginString = ConstCharStarToString( tagValueMappings[fileIter->c_str()][tagImagePositionPatient] );
 
     if (thisOriginString.empty())
     {
       // don't let such files be in a common group. Everything without position information will be loaded as a single slice:
       // with standard DICOM files this can happen to: CR, DX, SC
       MITK_DEBUG << "    ==> Sort away " << *fileIter << " for later analysis (no position information)"; // we already have one occupying this position
 
       if ( result.GetBlockFilenames().empty() ) // nothing WITH position information yet
       {
         // ==> this is a group of its own, stop processing, come back later
         result.AddFileToSortedBlock( *fileIter );
 
         StringContainer remainingFiles;
         remainingFiles.insert( remainingFiles.end(), fileIter+1, files.end() );
         result.AddFilesToUnsortedBlock( remainingFiles );
 
         fileFitsIntoPattern = false;
         break; // no files anymore
       }
       else
       {
         // ==> this does not match, consider later
         result.AddFileToUnsortedBlock( *fileIter );
         fileFitsIntoPattern = false;
         continue; // next file
       }
     }
 
     bool ignoredConversionError(-42); // hard to get here, no graceful way to react
     thisOrigin = DICOMStringToPoint3D( thisOriginString, ignoredConversionError );
 
     MITK_DEBUG << "  " << fileIndex << " " << *fileIter
                        << " at "
                        /* << thisOriginString */ << "(" << thisOrigin[0] << "," << thisOrigin[1] << "," << thisOrigin[2] << ")";
 
     if ( lastOriginInitialized && (thisOrigin == lastOrigin) )
     {
       MITK_DEBUG << "    ==> Sort away " << *fileIter << " for separate time step"; // we already have one occupying this position
       result.AddFileToUnsortedBlock( *fileIter );
       fileFitsIntoPattern = false;
     }
     else
     {
       if (!fromFirstToSecondOriginInitialized && lastOriginInitialized) // calculate vector as soon as possible when we get a new position
       {
         fromFirstToSecondOrigin = thisOrigin - lastDifferentOrigin;
         fromFirstToSecondOriginInitialized = true;
 
         // Here we calculate if this slice and the previous one are well aligned,
         // i.e. we test if the previous origin is on a line through the current
         // origin, directed into the normal direction of the current slice.
 
         // If this is NOT the case, then we have a data set with a TILTED GANTRY geometry,
         // which cannot be simply loaded into a single mitk::Image at the moment.
         // For this case, we flag this finding in the result and DicomSeriesReader
         // can correct for that later.
 
         Vector3D right; right.Fill(0.0);
         Vector3D up; right.Fill(0.0); // might be down as well, but it is just a name at this point
         DICOMStringToOrientationVectors( tagValueMappings[fileIter->c_str()][tagImageOrientation], right, up, ignoredConversionError );
 
         GantryTiltInformation tiltInfo( lastDifferentOrigin, thisOrigin, right, up, 1 );
 
         if ( tiltInfo.IsSheared() ) // mitk::eps is too small; 1/1000 of a mm should be enough to detect tilt
         {
           /* optimistic approach, accepting gantry tilt: save file for later, check all further files */
 
           // at this point we have TWO slices analyzed! if they are the only two files, we still split, because there is no third to verify our tilting assumption.
           // later with a third being available, we must check if the initial tilting vector is still valid. if yes, continue.
           // if NO, we need to split the already sorted part (result.first) and the currently analyzed file (*fileIter)
 
           // tell apart gantry tilt from overall skewedness
           // sort out irregularly sheared slices, that IS NOT tilting
 
           if ( groupImagesWithGantryTilt && tiltInfo.IsRegularGantryTilt() )
           {
             // check if this is at least roughly the same angle as recorded in DICOM tags
             if ( tagValueMappings[fileIter->c_str()].find(tagGantryTilt) != tagValueMappings[fileIter->c_str()].end() )
             {
               // read value, compare to calculated angle
               std::string tiltStr = ConstCharStarToString( tagValueMappings[fileIter->c_str()][tagGantryTilt] );
               double angle = atof(tiltStr.c_str());
 
               MITK_DEBUG << "Comparing recorded tilt angle " << angle << " against calculated value " << tiltInfo.GetTiltAngleInDegrees();
               // TODO we probably want the signs correct, too (that depends: this is just a rough check, nothing serious)
               if ( fabs(angle) - tiltInfo.GetTiltAngleInDegrees() > 0.25)
               {
                 result.AddFileToUnsortedBlock( *fileIter ); // sort away for further analysis
                 fileFitsIntoPattern = false;
               }
               else  // tilt angle from header is less than 0.25 degrees different from what we calculated, assume this is fine
               {
                 result.FlagGantryTilt();
                 result.AddFileToSortedBlock(*fileIter); // this file is good for current block
                 fileFitsIntoPattern = true;
               }
             }
             else // we cannot check the calculated tilt angle against the one from the dicom header (so we assume we are right)
             {
               result.FlagGantryTilt();
               result.AddFileToSortedBlock(*fileIter); // this file is good for current block
               fileFitsIntoPattern = true;
             }
           }
           else // caller does not want tilt compensation OR shearing is more complicated than tilt
           {
             result.AddFileToUnsortedBlock( *fileIter ); // sort away for further analysis
             fileFitsIntoPattern = false;
           }
         }
         else // not sheared
         {
           result.AddFileToSortedBlock(*fileIter); // this file is good for current block
           fileFitsIntoPattern = true;
         }
       }
       else if (fromFirstToSecondOriginInitialized) // we already know the offset between slices
       {
         Point3D assumedOrigin = lastDifferentOrigin + fromFirstToSecondOrigin;
 
         Vector3D originError = assumedOrigin - thisOrigin;
         double norm = originError.GetNorm();
         double toleratedError(0.005); // max. 1/10mm error when measurement crosses 20 slices in z direction
 
         if (norm > toleratedError)
         {
           MITK_DEBUG << "  File does not fit into the inter-slice distance pattern (diff = "
                                << norm << ", allowed "
                                << toleratedError << ").";
           MITK_DEBUG << "  Expected position (" << assumedOrigin[0] << ","
                                             << assumedOrigin[1] << ","
                                             << assumedOrigin[2] << "), got position ("
                                             << thisOrigin[0] << ","
                                             << thisOrigin[1] << ","
                                             << thisOrigin[2] << ")";
           MITK_DEBUG  << "    ==> Sort away " << *fileIter << " for later analysis";
 
           // At this point we know we deviated from the expectation of ITK's ImageSeriesReader
           // We split the input file list at this point, i.e. all files up to this one (excluding it)
           // are returned as group 1, the remaining files (including the faulty one) are group 2
 
           /* Optimistic approach: check if any of the remaining slices fits in */
           result.AddFileToUnsortedBlock( *fileIter ); // sort away for further analysis
           fileFitsIntoPattern = false;
         }
         else
         {
           result.AddFileToSortedBlock(*fileIter); // this file is good for current block
           fileFitsIntoPattern = true;
         }
       }
       else // this should be the very first slice
       {
         result.AddFileToSortedBlock(*fileIter); // this file is good for current block
         fileFitsIntoPattern = true;
       }
     }
 
     // record current origin for reference in later iterations
     if ( !lastOriginInitialized || ( fileFitsIntoPattern && (thisOrigin != lastOrigin) ) )
     {
       lastDifferentOrigin = thisOrigin;
     }
 
     lastOrigin = thisOrigin;
     lastOriginInitialized = true;
   }
 
   if ( result.ContainsGantryTilt() )
   {
     // check here how many files were grouped.
     // IF it was only two files AND we assume tiltedness (e.g. save "distance")
     // THEN we would want to also split the two previous files (simple) because
     // we don't have any reason to assume they belong together
 
     if ( result.GetBlockFilenames().size() == 2 )
     {
       result.UndoPrematureGrouping();
     }
   }
 
   return result;
 }
 
 DicomSeriesReader::FileNamesGrouping
 DicomSeriesReader::GetSeries(const StringContainer& files, bool groupImagesWithGantryTilt, const StringContainer &restrictions)
 {
   return GetSeries(files, true, groupImagesWithGantryTilt, restrictions);
 }
 
 DicomSeriesReader::FileNamesGrouping
 DicomSeriesReader::GetSeries(const StringContainer& files, bool sortTo3DPlust, bool groupImagesWithGantryTilt, const StringContainer& /*restrictions*/)
 {
   /**
     assumption about this method:
       returns a map of uid-like-key --> list(filename)
       each entry should contain filenames that have images of same
         - series instance uid (automatically done by GDCMSeriesFileNames
         - 0020,0037 image orientation (patient)
         - 0028,0030 pixel spacing (x,y)
         - 0018,0050 slice thickness
   */
 
   // use GDCM directly, itk::GDCMSeriesFileNames does not work with GDCM 2
 
   // PART I: scan files for sorting relevant DICOM tags,
   //         separate images that differ in any of those
   //         attributes (they cannot possibly form a 3D block)
 
   // scan for relevant tags in dicom files
   gdcm::Scanner scanner;
   const gdcm::Tag tagSOPClassUID(0x0008, 0x0016); // SOP class UID
     scanner.AddTag( tagSOPClassUID );
 
   const gdcm::Tag tagSeriesInstanceUID(0x0020,0x000e); // Series Instance UID
     scanner.AddTag( tagSeriesInstanceUID );
 
   const gdcm::Tag tagImageOrientation(0x0020, 0x0037); // image orientation
     scanner.AddTag( tagImageOrientation );
 
   const gdcm::Tag tagPixelSpacing(0x0028, 0x0030); // pixel spacing
     scanner.AddTag( tagPixelSpacing );
 
   const gdcm::Tag tagImagerPixelSpacing(0x0018, 0x1164); // imager pixel spacing
     scanner.AddTag( tagImagerPixelSpacing );
 
   const gdcm::Tag tagSliceThickness(0x0018, 0x0050); // slice thickness
     scanner.AddTag( tagSliceThickness );
 
   const gdcm::Tag tagNumberOfRows(0x0028, 0x0010); // number rows
     scanner.AddTag( tagNumberOfRows );
 
   const gdcm::Tag tagNumberOfColumns(0x0028, 0x0011); // number cols
     scanner.AddTag( tagNumberOfColumns );
 
   const gdcm::Tag tagGantryTilt(0x0018, 0x1120); // gantry tilt
     scanner.AddTag( tagGantryTilt );
 
   const gdcm::Tag tagModality(0x0008, 0x0060); // modality
     scanner.AddTag( tagModality );
 
   const gdcm::Tag tagNumberOfFrames(0x0028, 0x0008); // number of frames
     scanner.AddTag( tagNumberOfFrames );
 
   // additional tags read in this scan to allow later analysis
   // THESE tag are not used for initial separating of files
   const gdcm::Tag tagImagePositionPatient(0x0020,0x0032); // Image Position (Patient)
     scanner.AddTag( tagImagePositionPatient );
 
   // TODO add further restrictions from arguments (when anybody asks for it)
 
   FileNamesGrouping result;
 
   // let GDCM scan files
   if ( !scanner.Scan( files ) )
   {
     MITK_ERROR << "gdcm::Scanner failed when scanning " << files.size() << " input files.";
     return result;
   }
 
   // assign files IDs that will separate them for loading into image blocks
   for (gdcm::Scanner::ConstIterator fileIter = scanner.Begin();
        fileIter != scanner.End();
        ++fileIter)
   {
     if ( std::string(fileIter->first).empty() ) continue; // TODO understand why Scanner has empty string entries
     if ( std::string(fileIter->first) == std::string("DICOMDIR") ) continue;
 
     /* sort out multi-frame
     if ( scanner.GetValue( fileIter->first , tagNumberOfFrames ) )
     {
       MITK_INFO << "Ignoring " << fileIter->first << " because we cannot handle multi-frame images.";
       continue;
     }
     */
 
     // we const_cast here, because I could not use a map.at() function in CreateMoreUniqueSeriesIdentifier.
     // doing the same thing with find would make the code less readable. Since we forget the Scanner results
     // anyway after this function, we can simply tolerate empty map entries introduced by bad operator[] access
     std::string moreUniqueSeriesId = CreateMoreUniqueSeriesIdentifier( const_cast<gdcm::Scanner::TagToValue&>(fileIter->second) );
     result[ moreUniqueSeriesId ].AddFile( fileIter->first );
   }
 
   // PART II: sort slices spatially (or at least consistently if this is NOT possible, see method)
 
   for ( FileNamesGrouping::const_iterator groupIter = result.begin();
         groupIter != result.end();
         ++groupIter )
   {
     try
     {
       result[ groupIter->first ] = ImageBlockDescriptor( SortSeriesSlices( groupIter->second.GetFilenames() ) ); // sort each slice group spatially
     } catch(...)
     {
        MITK_ERROR << "Caught something.";
     }
   }
 
   // PART III: analyze pre-sorted images for valid blocks (i.e. blocks of equal z-spacing),
   //          separate into multiple blocks if necessary.
   //
   //          Analysis performs the following steps:
   //            * imitate itk::ImageSeriesReader: use the distance between the first two images as z-spacing
   //            * check what images actually fulfill ITK's z-spacing assumption
   //            * separate all images that fail the test into new blocks, re-iterate analysis for these blocks
   //              * this includes images which DO NOT PROVIDE spatial information, i.e. all images w/o ImagePositionPatient will be loaded separately
 
   FileNamesGrouping groupsOf3DPlusTBlocks; // final result of this function
   for ( FileNamesGrouping::const_iterator groupIter = result.begin();
         groupIter != result.end();
         ++groupIter )
   {
     FileNamesGrouping groupsOf3DBlocks; // intermediate result for only this group(!)
     std::map<std::string, SliceGroupingAnalysisResult> mapOf3DBlockAnalysisResults;
     StringContainer filesStillToAnalyze = groupIter->second.GetFilenames();
     std::string groupUID = groupIter->first;
     unsigned int subgroup(0);
     MITK_DEBUG << "Analyze group " << groupUID;
 
     while (!filesStillToAnalyze.empty()) // repeat until all files are grouped somehow
     {
       SliceGroupingAnalysisResult analysisResult =
         AnalyzeFileForITKImageSeriesReaderSpacingAssumption( filesStillToAnalyze,
                                                              groupImagesWithGantryTilt,
                                                              scanner.GetMappings() );
 
       // enhance the UID for additional groups
       std::stringstream newGroupUID;
       newGroupUID << groupUID << '.' << subgroup;
 
       ImageBlockDescriptor thisBlock( analysisResult.GetBlockFilenames() );
 
       std::string firstFileInBlock = thisBlock.GetFilenames().front();
 
       thisBlock.SetImageBlockUID( newGroupUID.str() );
       thisBlock.SetSeriesInstanceUID( DicomSeriesReader::ConstCharStarToString( scanner.GetValue( firstFileInBlock.c_str(), tagSeriesInstanceUID ) ) );
       thisBlock.SetHasGantryTiltCorrected( analysisResult.ContainsGantryTilt() );
       thisBlock.SetSOPClassUID( DicomSeriesReader::ConstCharStarToString( scanner.GetValue( firstFileInBlock.c_str(), tagSOPClassUID ) ) );
       thisBlock.SetNumberOfFrames( ConstCharStarToString( scanner.GetValue( firstFileInBlock.c_str(), tagNumberOfFrames ) ) );
       thisBlock.SetModality( DicomSeriesReader::ConstCharStarToString( scanner.GetValue( firstFileInBlock.c_str(), tagModality ) ) );
       thisBlock.SetPixelSpacingInformation( DicomSeriesReader::ConstCharStarToString( scanner.GetValue( firstFileInBlock.c_str(), tagPixelSpacing ) ),
                                             DicomSeriesReader::ConstCharStarToString( scanner.GetValue( firstFileInBlock.c_str(), tagImagerPixelSpacing ) ) );
       thisBlock.SetHasMultipleTimePoints( false );
 
       groupsOf3DBlocks[ newGroupUID.str() ] = thisBlock;
 
       //MITK_DEBUG << "Result: sorted 3D group " << newGroupUID.str() << " with " << groupsOf3DBlocks[ newGroupUID.str() ].GetFilenames().size() << " files";
       MITK_DEBUG << "Result: sorted 3D group with " << groupsOf3DBlocks[ newGroupUID.str() ].GetFilenames().size() << " files";
       StringContainer debugOutputFiles = analysisResult.GetBlockFilenames();
       for (StringContainer::const_iterator siter = debugOutputFiles.begin(); siter != debugOutputFiles.end(); ++siter)
         MITK_DEBUG << "  IN  " << *siter;
 
       ++subgroup;
 
       filesStillToAnalyze = analysisResult.GetUnsortedFilenames(); // remember what needs further analysis
       for (StringContainer::const_iterator siter = filesStillToAnalyze.begin(); siter != filesStillToAnalyze.end(); ++siter)
         MITK_DEBUG << " OUT  " << *siter;
 
     }
 
     // end of grouping, now post-process groups
 
     // PART IV: attempt to group blocks to 3D+t blocks if requested
     //           inspect entries of groupsOf3DBlocks
     //            - if number of files is identical to previous entry, collect for 3D+t block
     //            - as soon as number of files changes from previous entry, record collected blocks as 3D+t block, start a new one, continue
 
     // decide whether or not to group 3D blocks into 3D+t blocks where possible
     if ( !sortTo3DPlust )
     {
       // copy 3D blocks to output
       groupsOf3DPlusTBlocks.insert( groupsOf3DBlocks.begin(), groupsOf3DBlocks.end() );
     }
     else
     {
       // sort 3D+t (as described in "PART IV")
 
       MITK_DEBUG << "================================================================================";
       MITK_DEBUG << "3D+t analysis:";
 
       unsigned int numberOfFilesInPreviousBlock(0);
       std::string previousBlockKey;
 
       for ( FileNamesGrouping::const_iterator block3DIter = groupsOf3DBlocks.begin();
             block3DIter != groupsOf3DBlocks.end();
             ++block3DIter )
       {
         unsigned int numberOfFilesInThisBlock = block3DIter->second.GetFilenames().size();
         std::string thisBlockKey = block3DIter->first;
 
         if (numberOfFilesInPreviousBlock == 0)
         {
           numberOfFilesInPreviousBlock = numberOfFilesInThisBlock;
           groupsOf3DPlusTBlocks[thisBlockKey] = block3DIter->second;
           MITK_DEBUG << "  3D+t group " << thisBlockKey;
           previousBlockKey = thisBlockKey;
         }
         else
         {
           bool identicalOrigins;
           try {
             // check whether this and the previous block share a comon origin
             // TODO should be safe, but a little try/catch or other error handling wouldn't hurt
 
             const char
                 *origin_value = scanner.GetValue( groupsOf3DBlocks[thisBlockKey].GetFilenames().front().c_str(), tagImagePositionPatient ),
                 *previous_origin_value = scanner.GetValue( groupsOf3DBlocks[previousBlockKey].GetFilenames().front().c_str(), tagImagePositionPatient ),
                 *destination_value = scanner.GetValue( groupsOf3DBlocks[thisBlockKey].GetFilenames().back().c_str(), tagImagePositionPatient ),
                 *previous_destination_value = scanner.GetValue( groupsOf3DBlocks[previousBlockKey].GetFilenames().back().c_str(), tagImagePositionPatient );
 
             if (!origin_value || !previous_origin_value || !destination_value || !previous_destination_value)
             {
               identicalOrigins = false;
             }
             else
             {
               std::string thisOriginString = ConstCharStarToString( origin_value );
               std::string previousOriginString = ConstCharStarToString( previous_origin_value );
 
               // also compare last origin, because this might differ if z-spacing is different
               std::string thisDestinationString = ConstCharStarToString( destination_value );
               std::string previousDestinationString = ConstCharStarToString( previous_destination_value );
 
               identicalOrigins =  ( (thisOriginString == previousOriginString) && (thisDestinationString == previousDestinationString) );
             }
 
           } catch(...)
           {
             identicalOrigins = false;
           }
 
           if (identicalOrigins && (numberOfFilesInPreviousBlock == numberOfFilesInThisBlock))
           {
             // group with previous block
             groupsOf3DPlusTBlocks[previousBlockKey].AddFiles( block3DIter->second.GetFilenames() );
             groupsOf3DPlusTBlocks[previousBlockKey].SetHasMultipleTimePoints(true);
             MITK_DEBUG << "  --> group enhanced with another timestep";
           }
           else
           {
             // start a new block
             groupsOf3DPlusTBlocks[thisBlockKey] = block3DIter->second;
             int numberOfTimeSteps = groupsOf3DPlusTBlocks[previousBlockKey].GetFilenames().size() / numberOfFilesInPreviousBlock;
             MITK_DEBUG << "  ==> group closed with " << numberOfTimeSteps << " time steps";
             previousBlockKey = thisBlockKey;
             MITK_DEBUG << "  3D+t group " << thisBlockKey << " started";
           }
         }
 
         numberOfFilesInPreviousBlock = numberOfFilesInThisBlock;
       }
     }
   }
 
   MITK_DEBUG << "================================================================================";
   MITK_DEBUG << "Summary: ";
   for ( FileNamesGrouping::const_iterator groupIter = groupsOf3DPlusTBlocks.begin(); groupIter != groupsOf3DPlusTBlocks.end(); ++groupIter )
   {
     ImageBlockDescriptor block = groupIter->second;
     MITK_DEBUG << "  " << block.GetFilenames().size() << " '" << block.GetModality() << "' images (" << block.GetSOPClassUIDAsString() << ") in volume " << block.GetImageBlockUID();
     MITK_DEBUG << "    (gantry tilt : " << (block.HasGantryTiltCorrected()?"Yes":"No") << "; "
                        "pixel spacing : " << PixelSpacingInterpretationToString( block.GetPixelSpacingType() ) << "; "
                        "3D+t: " << (block.HasMultipleTimePoints()?"Yes":"No") << "; "
                        "reader support: " << ReaderImplementationLevelToString( block.GetReaderImplementationLevel() ) << ")";
     StringContainer debugOutputFiles = block.GetFilenames();
     for (StringContainer::const_iterator siter = debugOutputFiles.begin(); siter != debugOutputFiles.end(); ++siter)
       MITK_DEBUG << "  F " << *siter;
   }
   MITK_DEBUG << "================================================================================";
 
   return groupsOf3DPlusTBlocks;
 }
 
 DicomSeriesReader::FileNamesGrouping
 DicomSeriesReader::GetSeries(const std::string &dir, bool groupImagesWithGantryTilt, const StringContainer &restrictions)
 {
   gdcm::Directory directoryLister;
   directoryLister.Load( dir.c_str(), false ); // non-recursive
   return GetSeries(directoryLister.GetFilenames(), groupImagesWithGantryTilt, restrictions);
 }
 
 std::string
 DicomSeriesReader::CreateSeriesIdentifierPart( gdcm::Scanner::TagToValue& tagValueMap, const gdcm::Tag& tag )
 {
   std::string result;
   try
   {
     result = IDifyTagValue( tagValueMap[ tag ] ? tagValueMap[ tag ] : std::string("") );
   }
   catch (std::exception&)
   {
     // we are happy with even nothing, this will just group images of a series
     //MITK_WARN << "Could not access tag " << tag << ": " << e.what();
   }
 
   return result;
 }
 
 std::string
 DicomSeriesReader::CreateMoreUniqueSeriesIdentifier( gdcm::Scanner::TagToValue& tagValueMap )
 {
   const gdcm::Tag tagSeriesInstanceUID(0x0020,0x000e); // Series Instance UID
   const gdcm::Tag tagImageOrientation(0x0020, 0x0037); // image orientation
   const gdcm::Tag tagPixelSpacing(0x0028, 0x0030); // pixel spacing
   const gdcm::Tag tagImagerPixelSpacing(0x0018, 0x1164); // imager pixel spacing
   const gdcm::Tag tagSliceThickness(0x0018, 0x0050); // slice thickness
   const gdcm::Tag tagNumberOfRows(0x0028, 0x0010); // number rows
   const gdcm::Tag tagNumberOfColumns(0x0028, 0x0011); // number cols
   const gdcm::Tag tagNumberOfFrames(0x0028, 0x0008); // number of frames
 
   const char* tagSeriesInstanceUid = tagValueMap[tagSeriesInstanceUID];
   if (!tagSeriesInstanceUid)
   {
     mitkThrow() << "CreateMoreUniqueSeriesIdentifier() could not access series instance UID. Something is seriously wrong with this image, so stopping here.";
   }
   std::string constructedID = tagSeriesInstanceUid;
 
   constructedID += CreateSeriesIdentifierPart( tagValueMap, tagNumberOfRows );
   constructedID += CreateSeriesIdentifierPart( tagValueMap, tagNumberOfColumns );
   constructedID += CreateSeriesIdentifierPart( tagValueMap, tagPixelSpacing );
   constructedID += CreateSeriesIdentifierPart( tagValueMap, tagImagerPixelSpacing );
   constructedID += CreateSeriesIdentifierPart( tagValueMap, tagSliceThickness );
   constructedID += CreateSeriesIdentifierPart( tagValueMap, tagNumberOfFrames );
 
   // be a bit tolerant for orienatation, let only the first few digits matter (http://bugs.mitk.org/show_bug.cgi?id=12263)
   // NOT constructedID += CreateSeriesIdentifierPart( tagValueMap, tagImageOrientation );
   if (tagValueMap.find(tagImageOrientation) != tagValueMap.end())
   {
     bool conversionError(false);
     Vector3D right; right.Fill(0.0);
     Vector3D up; right.Fill(0.0);
     DICOMStringToOrientationVectors( tagValueMap[tagImageOrientation], right, up, conversionError );
     //string  newstring sprintf(simplifiedOrientationString, "%.3f\\%.3f\\%.3f\\%.3f\\%.3f\\%.3f", right[0], right[1], right[2], up[0], up[1], up[2]);
     std::ostringstream ss;
     ss.setf(std::ios::fixed, std::ios::floatfield);
     ss.precision(5);
     ss << right[0] << "\\"
        << right[1] << "\\"
        << right[2] << "\\"
        << up[0] << "\\"
        << up[1] << "\\"
        << up[2];
     std::string simplifiedOrientationString(ss.str());
 
     constructedID += IDifyTagValue( simplifiedOrientationString );
   }
 
   constructedID.resize( constructedID.length() - 1 ); // cut of trailing '.'
 
   return constructedID;
 }
 
 std::string
 DicomSeriesReader::IDifyTagValue(const std::string& value)
 {
   std::string IDifiedValue( value );
   if (value.empty()) throw std::logic_error("IDifyTagValue() illegaly called with empty tag value");
 
   // Eliminate non-alnum characters, including whitespace...
   //   that may have been introduced by concats.
   for(std::size_t i=0; i<IDifiedValue.size(); i++)
   {
     while(i<IDifiedValue.size()
       && !( IDifiedValue[i] == '.'
         || (IDifiedValue[i] >= 'a' && IDifiedValue[i] <= 'z')
         || (IDifiedValue[i] >= '0' && IDifiedValue[i] <= '9')
         || (IDifiedValue[i] >= 'A' && IDifiedValue[i] <= 'Z')))
     {
       IDifiedValue.erase(i, 1);
     }
   }
 
 
   IDifiedValue += ".";
   return IDifiedValue;
 }
 
 DicomSeriesReader::StringContainer
 DicomSeriesReader::GetSeries(const std::string &dir, const std::string &series_uid, bool groupImagesWithGantryTilt, const StringContainer &restrictions)
 {
   FileNamesGrouping allSeries = GetSeries(dir, groupImagesWithGantryTilt, restrictions);
   StringContainer resultingFileList;
 
   for ( FileNamesGrouping::const_iterator idIter = allSeries.begin();
         idIter != allSeries.end();
         ++idIter )
   {
     if ( idIter->first.find( series_uid ) == 0 ) // this ID starts with given series_uid
     {
       return idIter->second.GetFilenames();
     }
   }
 
   return resultingFileList;
 }
 
 DicomSeriesReader::StringContainer
 DicomSeriesReader::SortSeriesSlices(const StringContainer &unsortedFilenames)
 {
   /* we CAN expect a group of equal
      - series instance uid
      - image orientation
      - pixel spacing
      - imager pixel spacing
      - slice thickness
      - number of rows/columns
 
      (each piece of information except the rows/columns might be missing)
 
      sorting with GdcmSortFunction tries its best by sorting by spatial position
      and more hints (acquisition number, acquisition time, trigger time) but will
      always produce a sorting by falling back to SOP Instance UID.
   */
   gdcm::Sorter sorter;
 
   sorter.SetSortFunction(DicomSeriesReader::GdcmSortFunction);
   try
   {
     sorter.Sort(unsortedFilenames);
     return sorter.GetFilenames();
   }
   catch(std::logic_error&)
   {
     MITK_WARN << "Sorting error. Leaving series unsorted.";
     return unsortedFilenames;
   }
 }
 
 bool
 DicomSeriesReader::GdcmSortFunction(const gdcm::DataSet &ds1, const gdcm::DataSet &ds2)
 {
   // This method MUST accept missing location and position information (and all else, too)
   // because we cannot rely on anything
   // (restriction on the sentence before: we have to provide consistent sorting, so we
   // rely on the minimum information all DICOM files need to provide: SOP Instance UID)
 
   /* we CAN expect a group of equal
      - series instance uid
      - image orientation
      - pixel spacing
      - imager pixel spacing
      - slice thickness
      - number of rows/columns
   */
   const gdcm::Tag tagImagePositionPatient(0x0020,0x0032); // Image Position (Patient)
   const gdcm::Tag    tagImageOrientation(0x0020, 0x0037); // Image Orientation
 
   // see if we have Image Position and Orientation
   if ( ds1.FindDataElement(tagImagePositionPatient) && ds1.FindDataElement(tagImageOrientation) &&
        ds2.FindDataElement(tagImagePositionPatient) && ds2.FindDataElement(tagImageOrientation) )
   {
     gdcm::Attribute<0x0020,0x0032> image_pos1; // Image Position (Patient)
     gdcm::Attribute<0x0020,0x0037> image_orientation1; // Image Orientation (Patient)
 
     image_pos1.Set(ds1);
     image_orientation1.Set(ds1);
 
     gdcm::Attribute<0x0020,0x0032> image_pos2;
     gdcm::Attribute<0x0020,0x0037> image_orientation2;
 
     image_pos2.Set(ds2);
     image_orientation2.Set(ds2);
 
     /*
        we tolerate very small differences in image orientation, since we got to know about
        acquisitions where these values change across a single series (7th decimal digit)
        (http://bugs.mitk.org/show_bug.cgi?id=12263)
 
        still, we want to check if our assumption of 'almost equal' orientations is valid
      */
     for (unsigned int dim = 0; dim < 6; ++dim)
     {
       if ( fabs(image_orientation2[dim] - image_orientation1[dim]) > 0.0001 )
       {
         MITK_ERROR << "Dicom images have different orientations.";
         throw std::logic_error("Dicom images have different orientations. Call GetSeries() first to separate images.");
       }
     }
 
     double normal[3];
 
     normal[0] = image_orientation1[1] * image_orientation1[5] - image_orientation1[2] * image_orientation1[4];
     normal[1] = image_orientation1[2] * image_orientation1[3] - image_orientation1[0] * image_orientation1[5];
     normal[2] = image_orientation1[0] * image_orientation1[4] - image_orientation1[1] * image_orientation1[3];
 
     double
       dist1 = 0.0,
       dist2 = 0.0;
 
     // this computes the distance from world origin (0,0,0) ALONG THE NORMAL of the image planes
     for (unsigned char i = 0u; i < 3u; ++i)
     {
       dist1 += normal[i] * image_pos1[i];
       dist2 += normal[i] * image_pos2[i];
     }
 
     // if we can sort by just comparing the distance, we do exactly that
     if ( fabs(dist1 - dist2) >= mitk::eps)
     {
       // default: compare position
       return dist1 < dist2;
     }
     else // we need to check more properties to distinguish slices
     {
       // try to sort by Acquisition Number
       const gdcm::Tag tagAcquisitionNumber(0x0020, 0x0012);
       if (ds1.FindDataElement(tagAcquisitionNumber) && ds2.FindDataElement(tagAcquisitionNumber))
       {
         gdcm::Attribute<0x0020,0x0012> acquisition_number1; // Acquisition number
         gdcm::Attribute<0x0020,0x0012> acquisition_number2;
 
         acquisition_number1.Set(ds1);
         acquisition_number2.Set(ds2);
 
         if (acquisition_number1 != acquisition_number2)
         {
           return acquisition_number1 < acquisition_number2;
         }
         else // neither position nor acquisition number are good for sorting, so check more
         {
           // try to sort by Acquisition Time
           const gdcm::Tag tagAcquisitionTime(0x0008, 0x0032);
           if (ds1.FindDataElement(tagAcquisitionTime) && ds2.FindDataElement(tagAcquisitionTime))
           {
             gdcm::Attribute<0x0008,0x0032> acquisition_time1; // Acquisition time
             gdcm::Attribute<0x0008,0x0032> acquisition_time2;
 
             acquisition_time1.Set(ds1);
             acquisition_time2.Set(ds2);
 
             if (acquisition_time1 != acquisition_time2)
             {
               return acquisition_time1 < acquisition_time2;
             }
             else // we gave up on image position, acquisition number and acquisition time now
             {
               // let's try trigger time
               const gdcm::Tag tagTriggerTime(0x0018, 0x1060);
               if (ds1.FindDataElement(tagTriggerTime) && ds2.FindDataElement(tagTriggerTime))
               {
                 gdcm::Attribute<0x0018,0x1060> trigger_time1; // Trigger time
                 gdcm::Attribute<0x0018,0x1060> trigger_time2;
 
                 trigger_time1.Set(ds1);
                 trigger_time2.Set(ds2);
 
                 if (trigger_time1 != trigger_time2)
                 {
                   return trigger_time1 < trigger_time2;
                 }
                 // ELSE!
                 // for this and many previous ifs we fall through if nothing lets us sort
               } // .
             }   // .
           }     // .
         }
       }
     }
   }             // .
 
   // LAST RESORT: all valuable information for sorting is missing.
   // Sort by some meaningless but unique identifiers to satisfy the sort function
   const gdcm::Tag tagSOPInstanceUID(0x0008, 0x0018);
   if (ds1.FindDataElement(tagSOPInstanceUID) && ds2.FindDataElement(tagSOPInstanceUID))
   {
     MITK_DEBUG << "Dicom images are missing attributes for a meaningful sorting, falling back to SOP instance UID comparison.";
     gdcm::Attribute<0x0008,0x0018> SOPInstanceUID1;   // SOP instance UID is mandatory and unique
     gdcm::Attribute<0x0008,0x0018> SOPInstanceUID2;
 
     SOPInstanceUID1.Set(ds1);
     SOPInstanceUID2.Set(ds2);
 
     return SOPInstanceUID1 < SOPInstanceUID2;
   }
   else
   {
     // no DICOM file should really come down here, this should only be reached with unskillful and unlucky manipulation of files
     std::string error_message("Malformed DICOM images, which do not even contain a SOP Instance UID.");
     MITK_ERROR << error_message;
     throw std::logic_error( error_message );
   }
 }
 
 std::string DicomSeriesReader::GetConfigurationString()
 {
   std::stringstream configuration;
   configuration << "MITK_USE_GDCMIO: ";
   configuration << "true";
   configuration << "\n";
 
   configuration << "GDCM_VERSION: ";
 #ifdef GDCM_MAJOR_VERSION
   configuration << GDCM_VERSION;
 #endif
   //configuration << "\n";
 
   return configuration.str();
 }
 
 void DicomSeriesReader::CopyMetaDataToImageProperties(StringContainer filenames, const gdcm::Scanner::MappingType &tagValueMappings_, DcmIoType *io, const ImageBlockDescriptor& blockInfo, Image *image)
 {
   std::list<StringContainer> imageBlock;
   imageBlock.push_back(filenames);
   CopyMetaDataToImageProperties(imageBlock, tagValueMappings_, io, blockInfo, image);
 }
 
 void DicomSeriesReader::CopyMetaDataToImageProperties( std::list<StringContainer> imageBlock, const gdcm::Scanner::MappingType& tagValueMappings_,  DcmIoType* io, const ImageBlockDescriptor& blockInfo, Image* image)
 {
   if (!io || !image) return;
 
   StringLookupTable filesForSlices;
   StringLookupTable sliceLocationForSlices;
   StringLookupTable instanceNumberForSlices;
   StringLookupTable SOPInstanceNumberForSlices;
 
   gdcm::Scanner::MappingType& tagValueMappings = const_cast<gdcm::Scanner::MappingType&>(tagValueMappings_);
 
   //DICOM tags which should be added to the image properties
   const gdcm::Tag tagSliceLocation(0x0020, 0x1041); // slice location
 
   const gdcm::Tag tagInstanceNumber(0x0020, 0x0013); // (image) instance number
 
   const gdcm::Tag tagSOPInstanceNumber(0x0008, 0x0018); // SOP instance number
   unsigned int timeStep(0);
 
   std::string propertyKeySliceLocation = "dicom.image.0020.1041";
   std::string propertyKeyInstanceNumber = "dicom.image.0020.0013";
   std::string propertyKeySOPInstanceNumber = "dicom.image.0008.0018";
 
   // tags for each image
   for ( std::list<StringContainer>::iterator i = imageBlock.begin(); i != imageBlock.end(); i++, timeStep++ )
   {
 
     const StringContainer& files = (*i);
     unsigned int slice(0);
     for ( StringContainer::const_iterator fIter = files.begin();
           fIter != files.end();
           ++fIter, ++slice )
     {
       filesForSlices.SetTableValue( slice, *fIter );
       gdcm::Scanner::TagToValue tagValueMapForFile = tagValueMappings[fIter->c_str()];
       if(tagValueMapForFile.find(tagSliceLocation) != tagValueMapForFile.end())
         sliceLocationForSlices.SetTableValue(slice, tagValueMapForFile[tagSliceLocation]);
       if(tagValueMapForFile.find(tagInstanceNumber) != tagValueMapForFile.end())
         instanceNumberForSlices.SetTableValue(slice, tagValueMapForFile[tagInstanceNumber]);
       if(tagValueMapForFile.find(tagSOPInstanceNumber) != tagValueMapForFile.end())
         SOPInstanceNumberForSlices.SetTableValue(slice, tagValueMapForFile[tagSOPInstanceNumber]);
     }
 
     image->SetProperty( "files", StringLookupTableProperty::New( filesForSlices ) );
 
     //If more than one time step add postfix ".t" + timestep
     if(timeStep != 0)
     {
       std::ostringstream postfix;
       postfix << ".t" << timeStep;
 
       propertyKeySliceLocation.append(postfix.str());
       propertyKeyInstanceNumber.append(postfix.str());
       propertyKeySOPInstanceNumber.append(postfix.str());
     }
     image->SetProperty( propertyKeySliceLocation.c_str(), StringLookupTableProperty::New( sliceLocationForSlices ) );
     image->SetProperty( propertyKeyInstanceNumber.c_str(), StringLookupTableProperty::New( instanceNumberForSlices ) );
     image->SetProperty( propertyKeySOPInstanceNumber.c_str(), StringLookupTableProperty::New( SOPInstanceNumberForSlices ) );
   }
 
   // Copy tags for series, study, patient level (leave interpretation to application).
   // These properties will be copied to the DataNode by DicomSeriesReader.
 
   // tags for the series (we just use the one that ITK copied to its dictionary (proably that of the last slice)
   const itk::MetaDataDictionary& dict = io->GetMetaDataDictionary();
   const TagToPropertyMapType& propertyLookup = DicomSeriesReader::GetDICOMTagsToMITKPropertyMap();
 
   itk::MetaDataDictionary::ConstIterator dictIter = dict.Begin();
   while ( dictIter != dict.End() )
   {
     //MITK_DEBUG << "Key " << dictIter->first;
     std::string value;
     if ( itk::ExposeMetaData<std::string>( dict, dictIter->first, value ) )
     {
       //MITK_DEBUG << "Value " << value;
 
       TagToPropertyMapType::const_iterator valuePosition = propertyLookup.find( dictIter->first );
       if ( valuePosition != propertyLookup.end() )
       {
         std::string propertyKey = valuePosition->second;
         //MITK_DEBUG << "--> " << propertyKey;
 
         image->SetProperty( propertyKey.c_str(), StringProperty::New(value) );
       }
     }
     else
     {
       MITK_WARN << "Tag " << dictIter->first << " not read as string as expected. Ignoring..." ;
     }
     ++dictIter;
   }
 
   // copy imageblockdescriptor as properties
   image->SetProperty("dicomseriesreader.SOPClass", StringProperty::New(blockInfo.GetSOPClassUIDAsString()));
   image->SetProperty("dicomseriesreader.ReaderImplementationLevelString", StringProperty::New(ReaderImplementationLevelToString( blockInfo.GetReaderImplementationLevel() )));
   image->SetProperty("dicomseriesreader.ReaderImplementationLevel", GenericProperty<ReaderImplementationLevel>::New( blockInfo.GetReaderImplementationLevel() ));
   image->SetProperty("dicomseriesreader.PixelSpacingInterpretationString", StringProperty::New(PixelSpacingInterpretationToString( blockInfo.GetPixelSpacingType() )));
   image->SetProperty("dicomseriesreader.PixelSpacingInterpretation", GenericProperty<PixelSpacingInterpretation>::New(blockInfo.GetPixelSpacingType()));
   image->SetProperty("dicomseriesreader.MultiFrameImage", BoolProperty::New(blockInfo.IsMultiFrameImage()));
   image->SetProperty("dicomseriesreader.GantyTiltCorrected", BoolProperty::New(blockInfo.HasGantryTiltCorrected()));
   image->SetProperty("dicomseriesreader.3D+t", BoolProperty::New(blockInfo.HasMultipleTimePoints()));
 }
 
 void DicomSeriesReader::FixSpacingInformation( mitk::Image* image, const ImageBlockDescriptor& imageBlockDescriptor )
 {
   // spacing provided by ITK/GDCM
   Vector3D imageSpacing = image->GetGeometry()->GetSpacing();
   ScalarType imageSpacingX = imageSpacing[0];
   ScalarType imageSpacingY = imageSpacing[1];
 
   // spacing as desired by MITK (preference for "in patient", else "on detector", or "1.0/1.0")
   ScalarType desiredSpacingX = imageSpacingX;
   ScalarType desiredSpacingY = imageSpacingY;
   imageBlockDescriptor.GetDesiredMITKImagePixelSpacing( desiredSpacingX, desiredSpacingY );
 
   MITK_DEBUG << "Loaded spacing: " << imageSpacingX << "/" << imageSpacingY;
   MITK_DEBUG << "Corrected spacing: " << desiredSpacingX << "/" << desiredSpacingY;
 
   imageSpacing[0] = desiredSpacingX;
   imageSpacing[1] = desiredSpacingY;
   image->GetGeometry()->SetSpacing( imageSpacing );
 }
 
 } // end namespace mitk
 
 #include <mitkDicomSeriesReader.txx>
 
diff --git a/Core/Code/IO/mitkDicomSeriesReader.h b/Core/Code/IO/mitkDicomSeriesReader.h
index d45f874438..ecf91aac24 100644
--- a/Core/Code/IO/mitkDicomSeriesReader.h
+++ b/Core/Code/IO/mitkDicomSeriesReader.h
@@ -1,939 +1,939 @@
 /*===================================================================
 
 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 mitkDicomSeriesReader_h
 #define mitkDicomSeriesReader_h
 
 #include "mitkDataNode.h"
 #include "mitkConfig.h"
 
 #include <itkGDCMImageIO.h>
 
 #include <itkImageSeriesReader.h>
 #include <itkCommand.h>
 
 #ifdef NOMINMAX
 #  define DEF_NOMINMAX
 #  undef NOMINMAX
 #endif
 
 #include <gdcmConfigure.h>
 
 #ifdef DEF_NOMINMAX
 #  ifndef NOMINMAX
 #    define NOMINMAX
 #  endif
 #  undef DEF_NOMINMAX
 #endif
 
 #include <gdcmDataSet.h>
 #include <gdcmScanner.h>
 
 namespace mitk
 {
 
 /**
  \brief Loading DICOM images as MITK images.
 
  - \ref DicomSeriesReader_purpose
  - \ref DicomSeriesReader_limitations
  - \ref DicomSeriesReader_usage
  - \ref DicomSeriesReader_sorting
    - \ref DicomSeriesReader_sorting1
    - \ref DicomSeriesReader_sorting2
    - \ref DicomSeriesReader_sorting3
    - \ref DicomSeriesReader_sorting4
  - \ref DicomSeriesReader_gantrytilt
  - \ref DicomSeriesReader_pixelspacing
  - \ref DicomSeriesReader_nextworkitems
  - \ref DicomSeriesReader_whynotinitk
  - \ref DicomSeriesReader_tests
 
  \section DicomSeriesReader_purpose Purpose
 
  DicomSeriesReader serves as a central class for loading DICOM images as mitk::Image.
 
  As the term "DICOM image" covers a huge variety of possible modalities and
  implementations, and since MITK assumes that 3D images are made up of continuous blocks
  of slices without any gaps or changes in orientation, the loading mechanism must
  implement a number of decisions and compromises.
 
  <b>The main intention of this implementation is not efficiency but correctness of generated slice positions and pixel spacings!</b>
 
  \section DicomSeriesReader_limitations Assumptions and limitations
 
  The class is working only with GDCM 2.0.14 (or possibly newer). This version is the
  default of an MITK super-build. Support for other versions or ITK's DicomIO was dropped
  because of the associated complexity of DicomSeriesReader.
 
  \b Assumptions
   - expected to work with certain SOP Classes (mostly CT Image Storage and MR Image Storage)
     - see ImageBlockDescriptor.GetReaderImplementationLevel() method for the details
   - special treatment for a certain type of Philips 3D ultrasound (recogized by tag 3001,0010 set to "Philips3D")
   - loader will always attempt to read multiple single slices as a single 3D image volume (i.e. mitk::Image)
     - slices will be grouped by basic properties such as orientation, rows, columns, spacing and grouped into as large blocks as possible
   - images which do NOT report a position or orientation in space (Image Position Patient, Image Orientation) will be assigned defaults
     - image position (0,0,0)
     - image orientation (1,0,0), (0,1,0)
     - such images will always be grouped separately since spatial grouping / sorting makes no sense for them
 
  \b Options
   - images that cover the same piece of space (i.e. position, orientation, and dimensions are equal)
     can be interpreted as time-steps of the same image, i.e. a series will be loaded as 3D+t
 
  \b Limitations
   - the 3D+t assumption only works if all time-steps have an equal number of slices and if all
     have the Acquisition Time attribute set to meaningful values
 
  \section DicomSeriesReader_usage Usage
 
  The starting point for an application is a set of DICOM files that should be loaded.
  For convenience, DicomSeriesReader can also parse a whole directory for DICOM files,
  but an application should better know exactly what to load.
 
  Loading is then done in two steps:
 
   1. <b>Group the files into spatial blocks</b> by calling GetSeries().
      This method will sort all passed files into meaningful blocks that
      could fit into an mitk::Image. Sorting for 3D+t loading is optional but default.
      The \b return value of this function is a list of descriptors, which
      describe a grouped list of files with its most basic properties:
      - SOP Class (CT Image Storage, Secondary Capture Image Storage, etc.)
      - Modality
      - What type of pixel spacing can be read from the provided DICOM tags
      - How well DicomSeriesReader is prepared to load this type of data
 
   2. <b>Load a sorted set of files</b> by calling LoadDicomSeries().
      This method expects go receive the sorting output of GetSeries().
      The method will then invoke ITK methods configured with GDCM-IO
      classes to actually load the files into memory and put them into
      mitk::Images. Again, loading as 3D+t is optional.
 
   Example:
 
 \code
 
  // only a directory is known at this point: /home/who/dicom
 
  DicomSeriesReader::FileNamesGrouping allImageBlocks = DicomSeriesReader::GetSeries("/home/who/dicom/");
 
  // file now divided into groups of identical image size, orientation, spacing, etc.
  // each of these lists should be loadable as an mitk::Image.
 
  DicomSeriesReader::StringContainer seriesToLoad = allImageBlocks[...]; // decide what to load
 
  // final step: load into DataNode (can result in 3D+t image)
  DataNode::Pointer node = DicomSeriesReader::LoadDicomSeries( oneBlockSorted );
 
  Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
 \endcode
 
  \section DicomSeriesReader_sorting Logic for sorting 2D slices from DICOM images into 3D+t blocks for mitk::Image
 
  The general sorting mechanism (implemented in GetSeries) groups and sorts a set of DICOM files, each assumed to contain a single CT/MR slice.
  In the following we refer to those file groups as "blocks", since this is what they are meant to become when loaded into an mitk::Image.
 
  \subsection DicomSeriesReader_sorting1 Step 1: Avoiding pure non-sense
 
  A first pass separates slices that cannot possibly be loaded together because of restrictions of mitk::Image.
  After this steps, each block contains only slices that match in all of the following DICOM tags:
 
    - (0020,000e) Series Instance UID
    - (0020,0037) Image Orientation
    - (0028,0030) Pixel Spacing
    - (0018,1164) Imager Pixel Spacing
    - (0018,0050) Slice Thickness
    - (0028,0010) Number Of Rows
    - (0028,0011) Number Of Columns
    - (0028,0008) Number Of Frames
 
  \subsection DicomSeriesReader_sorting2 Step 2: Sort slices spatially
 
  Before slices are further analyzed, they are sorted spatially. As implemented by GdcmSortFunction(),
  slices are sorted by
    1. distance from origin (calculated using (0020,0032) Image Position Patient and (0020,0037) Image Orientation)
    2. when distance is equal, (0020,0012) Aquisition Number, (0008,0032) Acquisition Time and (0018,1060) Trigger Time are
       used as a backup criterions (necessary for meaningful 3D+t sorting)
 
  \subsection DicomSeriesReader_sorting3 Step 3: Ensure equal z spacing
 
  Since inter-slice distance is not recorded in DICOM tags, we must ensure that blocks are made up of
  slices that have equal distances between neighboring slices. This is especially necessary because itk::ImageSeriesReader
  is later used for the actual loading, and this class expects (and does nocht verify) equal inter-slice distance (see \ref DicomSeriesReader_whatweknowaboutitk).
 
  To achieve such grouping, the inter-slice distance is calculated from the first two different slice positions of a block.
  Following slices are added to a block as long as they can be added by adding the calculated inter-slice distance to the
  last slice of the block. Slices that do not fit into the expected distance pattern, are set aside for further analysis.
  This grouping is done until each file has been assigned to a group.
 
  Slices that share a position in space are also sorted into separate blocks during this step.
  So the result of this step is a set of blocks that contain only slices with equal z spacing
  and uniqe slices at each position.
 
  \subsection DicomSeriesReader_sorting4 Step 4 (optional): group 3D blocks as 3D+t when possible
 
  This last step depends on an option of GetSeries(). When requested, image blocks from the previous step are merged again
  whenever two blocks occupy the same portion of space (i.e. same origin, number of slices and z-spacing).
 
  \section DicomSeriesReader_gantrytilt Handling of gantry tilt
 
  When CT gantry tilt is used, the gantry plane (= X-Ray source and detector ring) and the vertical plane do not align
  anymore. This scanner feature is used for example to reduce metal artifacs (e.g. <i>Lee C , Evaluation of Using CT
  Gantry Tilt Scan on Head and Neck Cancer Patients with Dental Structure: Scans Show Less Metal Artifacts. Presented
  at: Radiological Society of North America 2011 Scientific Assembly and Annual Meeting; November 27- December 2,
  2011 Chicago IL.</i>).
 
  The acquired planes of such CT series do not match the expectations of a orthogonal geometry in mitk::Image: if you
  stack the slices, they show a small shift along the Y axis:
 \verbatim
 
   without tilt       with tilt
 
     ||||||             //////
     ||||||            //////
 --  |||||| --------- ////// -------- table orientation
     ||||||          //////
     ||||||         //////
 
 Stacked slices:
 
   without tilt       with tilt
 
  --------------    --------------
  --------------     --------------
  --------------      --------------
  --------------       --------------
  --------------        --------------
 
 \endverbatim
 
 
  As such gemetries do not in conjunction with mitk::Image, DicomSeriesReader performs a correction for such series
  if the groupImagesWithGantryTilt or correctGantryTilt flag in GetSeries and LoadDicomSeries is set (default = on).
 
  The correction algorithms undoes two errors introduced by ITK's ImageSeriesReader:
   - the plane shift that is ignored by ITK's reader is recreated by applying a shearing transformation using itk::ResampleFilter.
   - the spacing is corrected (it is calculated by ITK's reader from the distance between two origins, which is NOT the slice distance in this special case)
 
  Both errors are introduced in
  itkImageSeriesReader.txx (ImageSeriesReader<TOutputImage>::GenerateOutputInformation(void)), lines 176 to 245 (as of ITK 3.20)
 
  For the correction, we examine two consecutive slices of a series, both described as a pair (origin/orientation):
   - we calculate if the first origin is on a line along the normal of the second slice
     - if this is not the case, the geometry will not fit a normal mitk::Image/mitk::Geometry3D
     - we then project the second origin into the first slice's coordinate system to quantify the shift
     - both is done in class GantryTiltInformation with quite some comments.
 
  The geometry of image stacks with tilted geometries is illustrated below:
   - green: the DICOM images as described by their tags: origin as a point with the line indicating the orientation
   - red: the output of ITK ImageSeriesReader: wrong, larger spacing, no tilt
   - blue: how much a shear must correct
 
   \image tilt-correction.jpg
 
  \section DicomSeriesReader_whatweknowaboutitk The actual image loading process
 
  When calling LoadDicomSeries(), this method "mainly" uses an instance of itk::ImageSeriesReader,
  configured with an itk::GDCMImageIO object. Because DicomSeriesReader works around some of the
  behaviors of these classes, the following is a list of features that we find in the code and need to work with:
 
   - itk::ImageSeriesReader::GenerateOutputInformation() does the z-spacing handling
     - spacing is directly determined by comparing (euclidean distance) the origins of the first two slices of a series
       - this is GOOD because there is no reliable z-spacing information in DICOM images
       - this is bad because it does not work with gantry tilt, in which case the slice distance is SMALLER than the distance between two origins (see section on tilt)
   - origin and spacing are calculated by GDCMImageIO and re-used in itk::ImageSeriesReader
       - the origins are read from appropriate tags, nothing special about that
       - the spacing is read by gdcm::ImageReader, gdcm::ImageHelper::GetSpacingValue() from a tag determined by gdcm::ImageHelper::GetSpacingTagFromMediaStorage(), which basically determines ONE appropriate pixel spacing tag for each media storage type (ct image, mr image, secondary capture image, etc.)
         - this is fine for modalities such as CT/MR where the "Pixel Spacing" tag is mandatory, but for other modalities such as CR or Secondary Capture, the tag "Imager Pixel Spacing" is taken, which is no only optional but also has a more complicated relation with the "Pixel Spacing" tag. For this reason we check/modify the pixel spacing reported by itk::ImageSeriesReader after loading the image (see \ref DicomSeriesReader_pixelspacing)
 
  AFTER loading, DicomSeriesReader marks some of its findings as mitk::Properties to the loaded Image and DataNode:
   - <b>dicomseriesreader.SOPClass</b> : DICOM SOP Class as readable string (instead of a UID)
   - <b>dicomseriesreader.ReaderImplementationLevelString</b> : Confidence /Support level of the reader for this image as readable string
   - <b>dicomseriesreader.ReaderImplementationLevel</b> : Confidence /Support level of the reader for this image as enum value of type ReaderImplementationLevel
   - <b>dicomseriesreader.PixelSpacingInterpretationString</b> : Appropriate interpreteation of pixel spacing for this Image as readable string
   - <b>dicomseriesreader.PixelSpacingInterpretation</b> : Appropriate interpreteation of pixel spacing for this Image as enum value of type PixelSpacingInterpretation
   - <b>dicomseriesreader.MultiFrameImage</b> : bool flag to mark multi-frame images
   - <b>dicomseriesreader.GantyTiltCorrected</b> : bool flag to mark images where a gantry tilt was corrected to fit slices into an mitk::Image
   - <b>dicomseriesreader.3D+t</b> : bool flag to mark images with a time dimension (multiple 3D blocks of the same size at the same position in space)
 
  \section DicomSeriesReader_pixelspacing Handling of pixel spacing
 
  The reader implementes what is described in DICOM Part 3, chapter 10.7 (Basic Pixel Spacing Calibration Macro): Both tags
   - (0028,0030) Pixel Spacing and
   - (0018,1164) Imager Pixel Spacing
 
  are evaluated and the pixel spacing is set to the spacing within the patient when tags allow that.
  The result of pixel spacing interpretation can be read from a property "dicomseriesreader.PixelSpacingInterpretation",
  which refers to one of the enumerated values of type PixelSpacingInterpretation;
 
  \section DicomSeriesReader_supportedmodalities Limitations for specific modalities
 
   - <b>Enhanced Computed Tomography / Magnetic Resonance Images</b> are currently NOT supported at all, because we lack general support for multi-frame images.
   - <b>Nuclear Medicine Images</b> are not supported fully supported, only the single-frame variants are loaded properly.
 
  \section DicomSeriesReader_nextworkitems Possible enhancements
 
   This is a short list of ideas for enhancement:
    - Class has historically grown and should be reviewed again. There is probably too many duplicated scanning code
    - Multi-frame images don't mix well with the curent assumption of "one file - one slice", which is assumed by our code
      - It should be checked how well GDCM and ITK support these files (some load, some don't)
    - Specializations such as the Philips 3D code should be handled in a more generic way. The current handling of Philips 3D images is not nice at all
 
  \section DicomSeriesReader_whynotinitk Why is this not in ITK?
 
   Some of this code would probably be better located in ITK. It is just a matter of resources that this is not the
   case yet. Any attempts into this direction are welcome and can be supported. At least the gantry tilt correction
   should be a simple addition to itk::ImageSeriesReader.
 
  \section DicomSeriesReader_tests Tests regarding DICOM loading
 
  A number of tests have been implemented to check our assumptions regarding DICOM loading. Please see \ref DICOMTesting
 
  \todo refactor all the protected helper objects/methods into a separate header so we compile faster
 */
 class MITK_CORE_EXPORT DicomSeriesReader
 {
 public:
 
   /**
     \brief Lists of filenames.
   */
   typedef std::vector<std::string> StringContainer;
 
   /**
     \brief Interface for the progress callback.
   */
   typedef void (*UpdateCallBackMethod)(float);
 
   /**
     \brief Describes how well the reader is tested for a certain file type.
 
     Applications should not rely on the outcome for images which are reported
     ReaderImplementationLevel_Implemented or ReaderImplementationLevel_Unsupported.
 
     Errors to load images which are reported as ReaderImplementationLevel_Supported
     are considered bugs. For ReaderImplementationLevel_PartlySupported please check the appropriate paragraph in \ref DicomSeriesReader_supportedmodalities
   */
   typedef enum
   {
     ReaderImplementationLevel_Supported,       /// loader code and tests are established
     ReaderImplementationLevel_PartlySupported, /// loader code and tests are establised for specific parts of a SOP Class
     ReaderImplementationLevel_Implemented,     /// loader code is implemented but not accompanied by tests
     ReaderImplementationLevel_Unsupported,     /// loader code is not working with this SOP Class
   } ReaderImplementationLevel;
 
   /**
     \brief How the mitk::Image spacing should be interpreted.
 
     Compare DICOM PS 3.3 10.7 (Basic Pixel Spacing Calibration Macro).
   */
   typedef enum
   {
     PixelSpacingInterpretation_SpacingInPatient,  /// distances are mm within a patient
     PixelSpacingInterpretation_SpacingAtDetector, /// distances are mm at detector surface
     PixelSpacingInterpretation_SpacingUnknown     /// NO spacing information is present, we use (1,1) as default
   } PixelSpacingInterpretation;
 
   /**
     \brief Return type of GetSeries, describes a logical group of files.
 
     Files grouped into a single 3D or 3D+t block are described by an instance
     of this class. Relevant descriptive properties can be used to provide
     the application user with meaningful choices.
   */
   class MITK_CORE_EXPORT ImageBlockDescriptor
   {
     public:
 
       /// List of files in this group
       StringContainer GetFilenames() const;
 
       /// A unique ID describing this bloc (enhanced Series Instance UID).
       std::string GetImageBlockUID() const;
 
       /// The Series Instance UID.
       std::string GetSeriesInstanceUID() const;
 
       /// Series Modality (CT, MR, etc.)
       std::string GetModality() const;
 
       /// SOP Class UID as readable string (Computed Tomography Image Storage, Secondary Capture Image Storage, etc.)
       std::string GetSOPClassUIDAsString() const;
 
       /// SOP Class UID as DICOM UID
       std::string GetSOPClassUID() const;
 
       /// Confidence of the reader that this block can be read successfully.
       ReaderImplementationLevel GetReaderImplementationLevel() const;
 
       /// Whether or not the block contains a gantry tilt which will be "corrected" during loading
       bool HasGantryTiltCorrected() const;
 
       /// Whether or not mitk::Image spacing relates to the patient
       bool PixelSpacingRelatesToPatient() const;
       /// Whether or not mitk::Image spacing relates to the detector surface
       bool PixelSpacingRelatesToDetector() const;
       /// Whether or not mitk::Image spacing is of unknown origin
       bool PixelSpacingIsUnknown() const;
 
       /// How the mitk::Image spacing can meaningfully be interpreted.
       PixelSpacingInterpretation GetPixelSpacingType() const;
 
       /// 3D+t or not
       bool HasMultipleTimePoints() const;
 
       /// Multi-frame image(s) or not
       bool IsMultiFrameImage() const;
 
       ImageBlockDescriptor();
       ~ImageBlockDescriptor();
 
     private:
 
       friend class DicomSeriesReader;
 
       ImageBlockDescriptor(const StringContainer& files);
 
       void AddFile(const std::string& file);
       void AddFiles(const StringContainer& files);
 
 
       void SetImageBlockUID(const std::string& uid);
 
       void SetSeriesInstanceUID(const std::string& uid);
 
       void SetModality(const std::string& modality);
 
       void SetNumberOfFrames(const std::string& );
 
       void SetSOPClassUID(const std::string& mediaStorageSOPClassUID);
 
       void SetHasGantryTiltCorrected(bool);
 
       void SetPixelSpacingInformation(const std::string& pixelSpacing, const std::string& imagerPixelSpacing);
 
       void SetHasMultipleTimePoints(bool);
 
-      void GetDesiredMITKImagePixelSpacing( float& spacingX, float& spacingY) const;
+      void GetDesiredMITKImagePixelSpacing(ScalarType& spacingX, ScalarType& spacingY) const;
 
       StringContainer m_Filenames;
       std::string m_ImageBlockUID;
       std::string m_SeriesInstanceUID;
       std::string m_Modality;
       std::string m_SOPClassUID;
       bool m_HasGantryTiltCorrected;
       std::string m_PixelSpacing;
       std::string m_ImagerPixelSpacing;
       bool m_HasMultipleTimePoints;
       bool m_IsMultiFrameImage;
   };
 
   typedef std::map<std::string, ImageBlockDescriptor> FileNamesGrouping;
 
   /**
     \brief Provide combination of preprocessor defines that was active during compilation.
 
     Since this class is a combination of several possible implementations, separated only
     by ifdef's, calling instances might want to know which flags were active at compile time.
   */
   static std::string GetConfigurationString();
 
   /**
    \brief Checks if a specific file contains DICOM data.
   */
   static
   bool
   IsDicom(const std::string &filename);
 
   /**
    \brief see other GetSeries().
 
    Find all series (and sub-series -- see details) in a particular directory.
   */
   static FileNamesGrouping GetSeries(const std::string &dir,
                                    bool groupImagesWithGantryTilt,
                                    const StringContainer &restrictions = StringContainer());
 
   /**
    \brief see other GetSeries().
 
    \warning Untested, could or could not work.
 
    This differs only by having an additional restriction to a single known DICOM series.
    Internally, it uses the other GetSeries() method.
   */
   static StringContainer GetSeries(const std::string &dir,
                                    const std::string &series_uid,
                                    bool groupImagesWithGantryTilt,
                                    const StringContainer &restrictions = StringContainer());
 
   /**
    \brief PREFERRED version of this method - scan and sort DICOM files.
 
    Parse a list of files for images of DICOM series.
    For each series, an enumeration of the files contained in it is created.
 
    \return The resulting maps UID-like keys (based on Series Instance UID and slice properties) to sorted lists of file names.
 
    SeriesInstanceUID will be enhanced to be unique for each set of file names
    that is later loadable as a single mitk::Image. This implies that
    Image orientation, slice thickness, pixel spacing, rows, and columns
    must be the same for each file (i.e. the image slice contained in the file).
 
    If this separation logic requires that a SeriesInstanceUID must be made more specialized,
    it will follow the same logic as itk::GDCMSeriesFileNames to enhance the UID with
    more digits and dots.
 
    Optionally, more tags can be used to separate files into different logical series by setting
    the restrictions parameter.
 
    \warning Adding restrictions is not yet implemented!
    */
   static
   FileNamesGrouping
   GetSeries(const StringContainer& files,
             bool sortTo3DPlust,
             bool groupImagesWithGantryTilt,
             const StringContainer &restrictions = StringContainer());
 
   /**
     \brief See other GetSeries().
 
     Use GetSeries(const StringContainer& files, bool sortTo3DPlust, const StringContainer &restrictions) instead.
   */
   static
   FileNamesGrouping
   GetSeries(const StringContainer& files,
             bool groupImagesWithGantryTilt,
             const StringContainer &restrictions = StringContainer());
 
   /**
    Loads a DICOM series composed by the file names enumerated in the file names container.
    If a callback method is supplied, it will be called after every progress update with a progress value in [0,1].
 
    \param filenames The filenames to load.
    \param sort Whether files should be sorted spatially (true) or not (false - maybe useful if presorted)
    \param load4D Whether to load the files as 3D+t (if possible)
   */
   static DataNode::Pointer LoadDicomSeries(const StringContainer &filenames,
                                            bool sort = true,
                                            bool load4D = true,
                                            bool correctGantryTilt = true,
                                            UpdateCallBackMethod callback = 0,
                                            Image::Pointer preLoadedImageBlock = 0);
 
   /**
     \brief See LoadDicomSeries! Just a slightly different interface.
 
     If \p preLoadedImageBlock is provided, the reader will only "fake" loading and create appropriate
     mitk::Properties.
   */
   static bool LoadDicomSeries(const StringContainer &filenames,
                               DataNode &node,
                               bool sort = true,
                               bool load4D = true,
                               bool correctGantryTilt = true,
                               UpdateCallBackMethod callback = 0,
                               Image::Pointer preLoadedImageBlock = 0);
 
 protected:
 
   /**
     \brief Return type of DicomSeriesReader::AnalyzeFileForITKImageSeriesReaderSpacingAssumption.
 
     Class contains the grouping result of method DicomSeriesReader::AnalyzeFileForITKImageSeriesReaderSpacingAssumption,
     which takes as input a number of images, which are all equally oriented and spatially sorted along their normal direction.
 
     The result contains of two blocks: a first one is the grouping result, all of those images can be loaded
     into one image block because they have an equal origin-to-origin distance without any gaps in-between.
   */
   class SliceGroupingAnalysisResult
   {
     public:
 
       SliceGroupingAnalysisResult();
 
       /**
         \brief Grouping result, all same origin-to-origin distance w/o gaps.
       */
       StringContainer GetBlockFilenames();
 
       /**
         \brief Remaining files, which could not be grouped.
       */
       StringContainer GetUnsortedFilenames();
 
       /**
         \brief Wheter or not the grouped result contain a gantry tilt.
       */
       bool ContainsGantryTilt();
 
       /**
         \brief Meant for internal use by AnalyzeFileForITKImageSeriesReaderSpacingAssumption only.
       */
       void AddFileToSortedBlock(const std::string& filename);
 
       /**
         \brief Meant for internal use by AnalyzeFileForITKImageSeriesReaderSpacingAssumption only.
       */
       void AddFileToUnsortedBlock(const std::string& filename);
       void AddFilesToUnsortedBlock(const StringContainer& filenames);
 
       /**
         \brief Meant for internal use by AnalyzeFileForITKImageSeriesReaderSpacingAssumption only.
         \todo Could make sense to enhance this with an instance of GantryTiltInformation to store the whole result!
       */
       void FlagGantryTilt();
 
       /**
         \brief Only meaningful for use by AnalyzeFileForITKImageSeriesReaderSpacingAssumption.
       */
       void UndoPrematureGrouping();
 
     protected:
 
       StringContainer m_GroupedFiles;
       StringContainer m_UnsortedFiles;
 
       bool m_GantryTilt;
   };
 
   /**
     \brief Gantry tilt analysis result.
 
     Takes geometry information for two slices of a DICOM series and
     calculates whether these fit into an orthogonal block or not.
     If NOT, they can either be the result of an acquisition with
     gantry tilt OR completly broken by some shearing transformation.
 
     Most calculations are done in the constructor, results can then
     be read via the remaining methods.
   */
   class GantryTiltInformation
   {
     public:
 
       // two types to avoid any rounding errors
       typedef  itk::Point<double,3> Point3Dd;
       typedef itk::Vector<double,3> Vector3Dd;
 
       /**
         \brief Just so we can create empty instances for assigning results later.
       */
       GantryTiltInformation();
 
       /**
         \brief THE constructor, which does all the calculations.
 
         Determining the amount of tilt is done by checking the distances
         of origin1 from planes through origin2. Two planes are considered:
          - normal vector along normal of slices (right x up): gives the slice distance
          - normal vector along orientation vector "up": gives the shift parallel to the plane orientation
 
         The tilt angle can then be calculated from these distances
 
         \param origin1 origin of the first slice
         \param origin2 origin of the second slice
         \param right right/up describe the orientatation of borth slices
         \param up right/up describe the orientatation of borth slices
         \param numberOfSlicesApart how many slices are the given origins apart (1 for neighboring slices)
       */
       GantryTiltInformation( const Point3D& origin1,
                              const Point3D& origin2,
                              const Vector3D& right,
                              const Vector3D& up,
                              unsigned int numberOfSlicesApart);
 
       /**
         \brief Whether the slices were sheared.
 
         True if any of the shifts along right or up vector are non-zero.
       */
       bool IsSheared() const;
 
       /**
         \brief Whether the shearing is a gantry tilt or more complicated.
 
         Gantry tilt will only produce shifts in ONE orientation, not in both.
 
         Since the correction code currently only coveres one tilt direction
         AND we don't know of medical images with two tilt directions, the
         loading code wants to check if our assumptions are true.
       */
       bool IsRegularGantryTilt() const;
 
       /**
         \brief The offset distance in Y direction for each slice in mm (describes the tilt result).
       */
       double GetMatrixCoefficientForCorrectionInWorldCoordinates() const;
 
 
       /**
         \brief The z / inter-slice spacing. Needed to correct ImageSeriesReader's result.
       */
       double GetRealZSpacing() const;
 
       /**
         \brief The shift between first and last slice in mm.
 
         Needed to resize an orthogonal image volume.
       */
       double GetTiltCorrectedAdditionalSize() const;
 
       /**
         \brief Calculated tilt angle in degrees.
       */
       double GetTiltAngleInDegrees() const;
 
     protected:
 
       /**
         \brief Projection of point p onto line through lineOrigin in direction of lineDirection.
       */
       Point3D projectPointOnLine( Point3Dd p, Point3Dd lineOrigin, Vector3Dd lineDirection );
 
       double m_ShiftUp;
       double m_ShiftRight;
       double m_ShiftNormal;
       double m_ITKAssumedSliceSpacing;
       unsigned int m_NumberOfSlicesApart;
   };
 
   /**
     \brief for internal sorting.
   */
   typedef std::pair<StringContainer, StringContainer> TwoStringContainers;
 
   /**
     \brief Maps DICOM tags to MITK properties.
   */
   typedef std::map<std::string, std::string> TagToPropertyMapType;
 
   /**
     \brief Ensure an equal z-spacing for a group of files.
 
     Takes as input a number of images, which are all equally oriented and spatially sorted along their normal direction.
 
     Internally used by GetSeries. Returns two lists: the first one contins slices of equal inter-slice spacing.
     The second list contains remaining files, which need to be run through AnalyzeFileForITKImageSeriesReaderSpacingAssumption again.
 
     Relevant code that is matched here is in
     itkImageSeriesReader.txx (ImageSeriesReader<TOutputImage>::GenerateOutputInformation(void)), lines 176 to 245 (as of ITK 3.20)
   */
   static
   SliceGroupingAnalysisResult
   AnalyzeFileForITKImageSeriesReaderSpacingAssumption(const StringContainer& files, bool groupsOfSimilarImages, const gdcm::Scanner::MappingType& tagValueMappings_);
 
   /**
     \brief Safely convert const char* to std::string.
   */
   static
   std::string
   ConstCharStarToString(const char* s);
 
   /**
     \brief Safely convert a string into pixel spacing x and y.
   */
   static
   bool
-  DICOMStringToSpacing(const std::string& s, float& spacingX, float& spacingY);
+  DICOMStringToSpacing(const std::string& s, ScalarType& spacingX, ScalarType& spacingY);
 
   /**
     \brief Convert DICOM string describing a point to Point3D.
 
     DICOM tags like ImagePositionPatient contain a position as float numbers separated by backslashes:
     \verbatim
     42.7131\13.77\0.7
     \endverbatim
   */
   static
   Point3D
   DICOMStringToPoint3D(const std::string& s, bool& successful);
 
   /**
     \brief Convert DICOM string describing a point two Vector3D.
 
     DICOM tags like ImageOrientationPatient contain two vectors as float numbers separated by backslashes:
     \verbatim
     42.7131\13.77\0.7\137.76\0.3
     \endverbatim
   */
   static
   void
   DICOMStringToOrientationVectors(const std::string& s, Vector3D& right, Vector3D& up, bool& successful);
 
   template <typename ImageType>
   static
   typename ImageType::Pointer
   // TODO this is NOT inplace!
   InPlaceFixUpTiltedGeometry( ImageType* input, const GantryTiltInformation& tiltInfo );
 
 
   /**
     \brief Sort a set of file names in an order that is meaningful for loading them into an mitk::Image.
 
     \warning This method assumes that input files are similar in basic properties such as
              slice thicknes, image orientation, pixel spacing, rows, columns.
              It should always be ok to put the result of a call to GetSeries(..) into this method.
 
     Sorting order is determined by
 
      1. image position along its normal (distance from world origin)
      2. acquisition time
 
     If P<n> denotes a position and T<n> denotes a time step, this method will order slices from three timesteps like this:
 \verbatim
   P1T1 P1T2 P1T3 P2T1 P2T2 P2T3 P3T1 P3T2 P3T3
 \endverbatim
 
    */
   static StringContainer SortSeriesSlices(const StringContainer &unsortedFilenames);
 
 public:
   /**
    \brief Checks if a specific file is a Philips3D ultrasound DICOM file.
   */
   static bool IsPhilips3DDicom(const std::string &filename);
 
   static std::string ReaderImplementationLevelToString( const ReaderImplementationLevel& enumValue );
   static std::string PixelSpacingInterpretationToString( const PixelSpacingInterpretation& enumValue );
 
 protected:
 
   /**
    \brief Read a Philips3D ultrasound DICOM file and put into an mitk::Image.
   */
   static bool ReadPhilips3DDicom(const std::string &filename, mitk::Image::Pointer output_image);
 
   /**
     \brief Construct a UID that takes into account sorting criteria from GetSeries().
   */
   static std::string CreateMoreUniqueSeriesIdentifier( gdcm::Scanner::TagToValue& tagValueMap );
 
   /**
     \brief Helper for CreateMoreUniqueSeriesIdentifier
   */
   static std::string CreateSeriesIdentifierPart( gdcm::Scanner::TagToValue& tagValueMap, const gdcm::Tag& tag );
 
   /**
     \brief Helper for CreateMoreUniqueSeriesIdentifier
   */
   static std::string IDifyTagValue(const std::string& value);
 
   typedef itk::GDCMImageIO DcmIoType;
 
   /**
     \brief Progress callback for DicomSeriesReader.
   */
   class CallbackCommand : public itk::Command
   {
   public:
     CallbackCommand(UpdateCallBackMethod callback)
       : m_Callback(callback)
     {
     }
 
     void Execute(const itk::Object *caller, const itk::EventObject&)
     {
       (*this->m_Callback)(static_cast<const itk::ProcessObject*>(caller)->GetProgress());
     }
 
     void Execute(itk::Object *caller, const itk::EventObject&)
     {
       (*this->m_Callback)(static_cast<itk::ProcessObject*>(caller)->GetProgress());
     }
 
   protected:
 
     UpdateCallBackMethod m_Callback;
   };
 
   static void FixSpacingInformation( Image* image, const ImageBlockDescriptor& imageBlockDescriptor );
 
   /**
    \brief Scan for slice image information
   */
   static void ScanForSliceInformation( const StringContainer &filenames, gdcm::Scanner& scanner );
 
   /**
    \brief Performs actual loading of a series and creates an image having the specified pixel type.
   */
   template <typename PixelType>
   static
   void
   LoadDicom(const StringContainer &filenames, DataNode &node, bool sort, bool check_4d, bool correctTilt, UpdateCallBackMethod callback, Image::Pointer preLoadedImageBlock);
 
   /**
     \brief Feed files into itk::ImageSeriesReader and retrieve a 3D MITK image.
 
     \param command can be used for progress reporting
   */
   template <typename PixelType>
   static
   Image::Pointer
   LoadDICOMByITK( const StringContainer&, bool correctTilt, const GantryTiltInformation& tiltInfo, DcmIoType::Pointer& io, CallbackCommand* command = NULL, Image::Pointer preLoadedImageBlock = NULL);
 
   /**
     \brief Sort files into time step blocks of a 3D+t image.
 
     Called by LoadDicom. Expects to be fed a single list of filenames that have been sorted by
     GetSeries previously (one map entry). This method will check how many timestep can be filled
     with given files.
 
     Assumption is that the number of time steps is determined by how often the first position in
     space repeats. I.e. if the first three files in the input parameter all describe the same
     location in space, we'll construct three lists of files. and sort the remaining files into them.
 
     \todo We can probably remove this method if we somehow transfer 3D+t information from GetSeries to LoadDicomSeries.
   */
   static
   std::list<StringContainer>
   SortIntoBlocksFor3DplusT( const StringContainer& presortedFilenames, const gdcm::Scanner::MappingType& tagValueMappings_, bool sort, bool& canLoadAs4D);
 
   /**
    \brief Defines spatial sorting for sorting by GDCM 2.
 
    Sorts by image position along image normal (distance from world origin).
    In cases of conflict, acquisition time is used as a secondary sort criterium.
   */
   static
   bool
   GdcmSortFunction(const gdcm::DataSet &ds1, const gdcm::DataSet &ds2);
 
 
   /**
     \brief Copy information about files and DICOM tags from ITK's MetaDataDictionary
            and from the list of input files to the PropertyList of mitk::Image.
     \todo Tag copy must follow; image level will cause some additional files parsing, probably.
   */
   static void CopyMetaDataToImageProperties( StringContainer filenames, const gdcm::Scanner::MappingType& tagValueMappings_, DcmIoType* io, const ImageBlockDescriptor& blockInfo, Image* image);
   static void CopyMetaDataToImageProperties( std::list<StringContainer> imageBlock, const gdcm::Scanner::MappingType& tagValueMappings_, DcmIoType* io, const ImageBlockDescriptor& blockInfo, Image* image);
 
   /**
     \brief Map between DICOM tags and MITK properties.
 
     Uses as a positive list for copying specified DICOM tags (from ITK's ImageIO)
     to MITK properties. ITK provides MetaDataDictionary entries of form
     "gggg|eeee" (g = group, e = element), e.g. "0028,0109" (Largest Pixel in Series),
     which we want to sort as dicom.series.largest_pixel_in_series".
   */
   static const TagToPropertyMapType& GetDICOMTagsToMITKPropertyMap();
 };
 
 }
 
 
 #endif /* mitkDicomSeriesReader_h */
diff --git a/Core/Code/IO/mitkItkImageFileReader.cpp b/Core/Code/IO/mitkItkImageFileReader.cpp
index 64844dd321..f59f600d1b 100644
--- a/Core/Code/IO/mitkItkImageFileReader.cpp
+++ b/Core/Code/IO/mitkItkImageFileReader.cpp
@@ -1,205 +1,205 @@
 /*===================================================================
 
 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 "mitkItkImageFileReader.h"
 #include "mitkConfig.h"
 #include "mitkException.h"
 
 #include <itkImageFileReader.h>
 #include <itksys/SystemTools.hxx>
 #include <itksys/Directory.hxx>
 #include <itkImage.h>
 //#include <itkImageSeriesReader.h>
 #include <itkImageFileReader.h>
 #include <itkImageIOFactory.h>
 #include <itkImageIORegion.h>
 //#include <itkImageSeriesReader.h>
 //#include <itkDICOMImageIO2.h>
 //#include <itkDICOMSeriesFileNames.h>
 //#include <itkGDCMImageIO.h>
 //#include <itkGDCMSeriesFileNames.h>
 //#include <itkNumericSeriesFileNames.h>
 
 
 void mitk::ItkImageFileReader::GenerateData()
 {
   const std::string& locale = "C";
   const std::string& currLocale = setlocale( LC_ALL, NULL );
 
   if ( locale.compare(currLocale)!=0 )
   {
     try
     {
       setlocale(LC_ALL, locale.c_str());
     }
     catch(...)
     {
       MITK_INFO << "Could not set locale " << locale;
     }
   }
 
   mitk::Image::Pointer image = this->GetOutput();
 
   const unsigned int MINDIM = 2;
   const unsigned int MAXDIM = 4;
 
   MITK_INFO << "loading " << m_FileName << " via itk::ImageIOFactory... " << std::endl;
 
   // Check to see if we can read the file given the name or prefix
   if ( m_FileName == "" )
   {
     mitkThrow() << "Empty filename in mitk::ItkImageFileReader ";
     return ;
   }
 
   itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( m_FileName.c_str(), itk::ImageIOFactory::ReadMode );
   if ( imageIO.IsNull() )
   {
     //itkWarningMacro( << "File Type not supported!" );
     mitkThrow() << "Could not create itk::ImageIOBase object for filename " << m_FileName;
     return ;
   }
 
   // Got to allocate space for the image. Determine the characteristics of
   // the image.
   imageIO->SetFileName( m_FileName.c_str() );
   imageIO->ReadImageInformation();
 
   unsigned int ndim = imageIO->GetNumberOfDimensions();
   if ( ndim < MINDIM || ndim > MAXDIM )
   {
     itkWarningMacro( << "Sorry, only dimensions 2, 3 and 4 are supported. The given file has " << ndim << " dimensions! Reading as 4D." );
     ndim = MAXDIM;
   }
 
   itk::ImageIORegion ioRegion( ndim );
   itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
   itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
 
   unsigned int dimensions[ MAXDIM ];
   dimensions[ 0 ] = 0;
   dimensions[ 1 ] = 0;
   dimensions[ 2 ] = 0;
   dimensions[ 3 ] = 0;
 
-  float spacing[ MAXDIM ];
+  ScalarType spacing[ MAXDIM ];
   spacing[ 0 ] = 1.0f;
   spacing[ 1 ] = 1.0f;
   spacing[ 2 ] = 1.0f;
   spacing[ 3 ] = 1.0f;
 
   Point3D origin;
   origin.Fill(0);
 
   unsigned int i;
   for ( i = 0; i < ndim ; ++i )
   {
     ioStart[ i ] = 0;
     ioSize[ i ] = imageIO->GetDimensions( i );
     if(i<MAXDIM)
     {
       dimensions[ i ] = imageIO->GetDimensions( i );
       spacing[ i ] = imageIO->GetSpacing( i );
       if(spacing[ i ] <= 0)
         spacing[ i ] = 1.0f;
     }
     if(i<3)
     {
       origin[ i ] = imageIO->GetOrigin( i );
     }
   }
 
   ioRegion.SetSize( ioSize );
   ioRegion.SetIndex( ioStart );
 
   MITK_INFO << "ioRegion: " << ioRegion << std::endl;
   imageIO->SetIORegion( ioRegion );
   void* buffer = new unsigned char[imageIO->GetImageSizeInBytes()];
   imageIO->Read( buffer );
 
   image->Initialize( MakePixelType(imageIO), ndim, dimensions );
   image->SetImportChannel( buffer, 0, Image::ManageMemory );
 
   // access direction of itk::Image and include spacing
   mitk::Matrix3D matrix;
   matrix.SetIdentity();
   unsigned int j, itkDimMax3 = (ndim >= 3? 3 : ndim);
   for ( i=0; i < itkDimMax3; ++i)
     for( j=0; j < itkDimMax3; ++j )
       matrix[i][j] = imageIO->GetDirection(j)[i];
 
   // re-initialize PlaneGeometry with origin and direction
   PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(image->GetSlicedGeometry(0)->GetGeometry2D(0));
   planeGeometry->SetOrigin(origin);
   planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
 
   // re-initialize SlicedGeometry3D
   SlicedGeometry3D* slicedGeometry = image->GetSlicedGeometry(0);
   slicedGeometry->InitializeEvenlySpaced(planeGeometry, image->GetDimension(2));
   slicedGeometry->SetSpacing(spacing);
 
   // re-initialize TimeSlicedGeometry
   image->GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, image->GetDimension(3));
 
   buffer = NULL;
   MITK_INFO << "number of image components: "<< image->GetPixelType().GetNumberOfComponents() << std::endl;
 //  mitk::DataNode::Pointer node = this->GetOutput();
 //  node->SetData( image );
 
   // add level-window property
   //if ( image->GetPixelType().GetNumberOfComponents() == 1 )
   //{
   //  SetDefaultImageProperties( node );
   //}
   MITK_INFO << "...finished!" << std::endl;
 
   try
   {
     setlocale(LC_ALL, currLocale.c_str());
   }
   catch(...)
   {
     MITK_INFO << "Could not reset locale " << currLocale;
   }
 }
 
 
 bool mitk::ItkImageFileReader::CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern)
 {
   // First check the extension
   if(  filename == "" )
     return false;
 
   // check if image is serie
   if( filePattern != "" && filePrefix != "" )
     return false;
 
   itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( filename.c_str(), itk::ImageIOFactory::ReadMode );
   if ( imageIO.IsNull() )
     return false;
 
   return true;
 }
 
 mitk::ItkImageFileReader::ItkImageFileReader()
     : m_FileName(""), m_FilePrefix(""), m_FilePattern("")
 {
 }
 
 mitk::ItkImageFileReader::~ItkImageFileReader()
 {
 }
diff --git a/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp b/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp
index e3664c35e8..3cfa92ee61 100644
--- a/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp
+++ b/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp
@@ -1,524 +1,524 @@
 /*===================================================================
 
 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 "mitkPointSetGLMapper2D.h"
 #include "mitkPointSet.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "vtkLinearTransform.h"
 #include "mitkStringProperty.h"
 #include "mitkPointSet.h"
 #include "mitkVtkPropRenderer.h"
 #include "mitkGL.h"
 
 //const float selectedColor[]={1.0,0.0,0.6}; //for selected!
 
 
 mitk::PointSetGLMapper2D::PointSetGLMapper2D()
 : m_Polygon(false),
   m_ShowPoints(true),
   m_ShowDistances(false),
   m_DistancesDecimalDigits(1),
   m_ShowAngles(false),
   m_ShowDistantLines(true),
   m_LineWidth(1)
 {
 }
 
 
 mitk::PointSetGLMapper2D::~PointSetGLMapper2D()
 {
 }
 
 
 const mitk::PointSet *mitk::PointSetGLMapper2D::GetInput(void)
 {
   return static_cast<const mitk::PointSet * > ( GetDataNode()->GetData() );
 }
 
 
 void mitk::PointSetGLMapper2D::ApplyAllProperties(mitk::BaseRenderer* renderer)
 {
   GLMapper::ApplyColorAndOpacityProperties( renderer );
 
   const mitk::DataNode* node=GetDataNode();
   if( node == NULL )
     return;
 
   node->GetBoolProperty("show contour",            m_Polygon);
   node->GetBoolProperty("close contour",            m_PolygonClosed);
   node->GetBoolProperty("show points",        m_ShowPoints);
   node->GetBoolProperty("show distances",     m_ShowDistances);
   node->GetIntProperty("distance decimal digits",     m_DistancesDecimalDigits);
   node->GetBoolProperty("show angles",        m_ShowAngles);
   node->GetBoolProperty("show distant lines", m_ShowDistantLines);
   node->GetIntProperty("line width",          m_LineWidth);
   node->GetIntProperty("point line width",    m_PointLineWidth);
   node->GetIntProperty("point 2D size",       m_Point2DSize);
 }
 
 
 
 static bool makePerpendicularVector2D(const mitk::Vector2D& in, mitk::Vector2D& out)
 {
   if((fabs(in[0])>0) && ( (fabs(in[0])>fabs(in[1])) || (in[1] == 0) ) )
   {
     out[0]=-in[1]/in[0];
     out[1]=1;
     out.Normalize();
     return true;
   }
   else
   if(fabs(in[1])>0)
   {
     out[0]=1;
     out[1]=-in[0]/in[1];
     out.Normalize();
     return true;
   }
   else
     return false;
 }
 
 
 void mitk::PointSetGLMapper2D::Paint( mitk::BaseRenderer *renderer )
 {
 
   const mitk::DataNode* node=GetDataNode();
   if( node == NULL )
     return;
 
   const int text2dDistance = 10;
 
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if ( !visible) return;
 
   // @FIXME: Logik fuer update
   bool updateNeccesary=true;
 
   if (updateNeccesary)
   {
     // ok, das ist aus GenerateData kopiert
     mitk::PointSet::Pointer input  = const_cast<mitk::PointSet*>(this->GetInput());
 
     // Get the TimeSlicedGeometry of the input object
     const TimeSlicedGeometry* inputTimeGeometry = input->GetTimeSlicedGeometry();
     if (( inputTimeGeometry == NULL ) || ( inputTimeGeometry->GetTimeSteps() == 0 ) )
     {
       return;
     }
 
     //
     // get the world time
     //
     const Geometry2D* worldGeometry = renderer->GetCurrentWorldGeometry2D();
     assert( worldGeometry != NULL );
     ScalarType time = worldGeometry->GetTimeBounds()[ 0 ];
 
     //
     // convert the world time in time steps of the input object
     //
     int timeStep=0;
     if ( time > ScalarTypeNumericTraits::NonpositiveMin() )
       timeStep = inputTimeGeometry->MSToTimeStep( time );
     if ( inputTimeGeometry->IsValidTime( timeStep ) == false )
     {
       return;
     }
 
 
     mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timeStep );
 
     if ( itkPointSet.GetPointer() == NULL)
     {
       return;
     }
 
 
     mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
 
     assert(displayGeometry.IsNotNull());
 
     //apply color and opacity read from the PropertyList
     this->ApplyAllProperties(renderer);
 
     vtkLinearTransform* transform = GetDataNode()->GetVtkTransform();
 
     //List of the Points
     PointSet::DataType::PointsContainerConstIterator it, end;
     it = itkPointSet->GetPoints()->Begin();
     end = itkPointSet->GetPoints()->End();
 
     //iterator on the additional data of each point
     PointSet::DataType::PointDataContainerIterator selIt, selEnd;
     bool pointDataBroken = (itkPointSet->GetPointData()->Size() != itkPointSet->GetPoints()->Size());
     selIt = itkPointSet->GetPointData()->Begin();
     selEnd = itkPointSet->GetPointData()->End();
 
     int counter = 0;
 
     //for writing text
     int j = 0;
 
     //for switching back to old color after using selected color
     float recallColor[4];
     glGetFloatv(GL_CURRENT_COLOR,recallColor);
 
     //get the properties for coloring the points
     float unselectedColor[4] = {1.0, 1.0, 0.0, 1.0};//yellow
     //check if there is an unselected property
     if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(renderer)->GetProperty("unselectedcolor")) != NULL)
     {
       mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("unselectedcolor"))->GetValue();
       unselectedColor[0] = tmpColor[0];
       unselectedColor[1] = tmpColor[1];
       unselectedColor[2] = tmpColor[2];
       unselectedColor[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
     }
     else if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(NULL)->GetProperty("unselectedcolor")) != NULL)
     {
       mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("unselectedcolor"))->GetValue();
       unselectedColor[0] = tmpColor[0];
       unselectedColor[1] = tmpColor[1];
       unselectedColor[2] = tmpColor[2];
       unselectedColor[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
     }
     else
     {
       //get the color from the dataNode
       node->GetColor(unselectedColor, NULL);
     }
 
     //get selected property
     float selectedColor[4] = {1.0, 0.0, 0.6, 1.0};
     if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(renderer)->GetProperty("selectedcolor")) != NULL)
     {
       mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor"))->GetValue();
       selectedColor[0] = tmpColor[0];
       selectedColor[1] = tmpColor[1];
       selectedColor[2] = tmpColor[2];
       selectedColor[3] = 1.0f;
     }
     else if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(NULL)->GetProperty("selectedcolor")) != NULL)
     {
       mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor"))->GetValue();
       selectedColor[0] = tmpColor[0];
       selectedColor[1] = tmpColor[1];
       selectedColor[2] = tmpColor[2];
       selectedColor[3] = 1.0f;
     }
 
     //check if there is an pointLineWidth property
     if (dynamic_cast<mitk::IntProperty*>(node->GetPropertyList(renderer)->GetProperty("point line width")) != NULL)
     {
       m_PointLineWidth = dynamic_cast<mitk::IntProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("point line width"))->GetValue();
     }
     else if (dynamic_cast<mitk::IntProperty*>(node->GetPropertyList(NULL)->GetProperty("point line width")) != NULL)
     {
       m_PointLineWidth = dynamic_cast<mitk::IntProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("point line width"))->GetValue();
     }
 
     //check if there is an point 2D size property
     if (dynamic_cast<mitk::IntProperty*>(node->GetPropertyList(renderer)->GetProperty("point 2D size")) != NULL)
     {
       m_Point2DSize = dynamic_cast<mitk::IntProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("point 2D size"))->GetValue();
     }
     else if (dynamic_cast<mitk::IntProperty*>(node->GetPropertyList(NULL)->GetProperty("point 2D size")) != NULL)
     {
       m_Point2DSize = dynamic_cast<mitk::IntProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("point 2D size"))->GetValue();
     }
 
     Point3D p;                      // currently visited point
     Point3D lastP;                  // last visited point
     Vector3D vec;                   // p - lastP
     Vector3D lastVec;               // lastP - point before lastP
     vec.Fill(0);
 
     mitk::Point3D projected_p;      // p projected on viewplane
 
     Point2D pt2d;       // projected_p in display coordinates
     Point2D lastPt2d;   // last projected_p in display coordinates
     Point2D preLastPt2d;// projected_p in display coordinates before lastPt2d
 
     Point2D lastPt2DInPointSet; // The last point in the pointset in display coordinates
     mitk::PointSet::DataType::PointType plob;
     plob.Fill(0);
     itkPointSet->GetPoint( itkPointSet->GetNumberOfPoints()-1, &plob);
 
     //map lastPt2DInPointSet to display coordinates
     float vtkp[3];
 
     itk2vtk(plob, vtkp);
     transform->TransformPoint(vtkp, vtkp);
     vtk2itk(vtkp,p);
 
     displayGeometry->Project(p, projected_p);
 
     displayGeometry->Map(projected_p, lastPt2DInPointSet);
     displayGeometry->WorldToDisplay(lastPt2DInPointSet, lastPt2DInPointSet);
 
     while(it!=end) // iterate over all points
     {
       lastP = p;        // valid only for counter > 0
       lastVec = vec;    // valid only for counter > 1
 
       preLastPt2d = lastPt2d; // valid only for counter > 1
       lastPt2d = pt2d;  // valid only for counter > 0
 
 
       itk2vtk(it->Value(), vtkp);
       transform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp,p);
 
       vec = p-lastP;    // valid only for counter > 0
 
       displayGeometry->Project(p, projected_p);
       Vector3D diff=p-projected_p;
       ScalarType scalardiff = diff.GetSquaredNorm();
 
       //MouseOrientation
       bool isInputDevice=false;
 
       bool isRendererSlice = scalardiff < 0.00001; //cause roundoff error
       if(this->GetDataNode()->GetBoolProperty("inputdevice",isInputDevice) && isInputDevice && !isRendererSlice )
       {
         displayGeometry->Map(projected_p, pt2d);
         displayGeometry->WorldToDisplay(pt2d, pt2d);
 
         //Point size depending of distance to slice
         /*float p_size = (1/scalardiff)*10*m_Point2DSize;
         if(p_size < m_Point2DSize * 0.6 )
           p_size = m_Point2DSize * 0.6 ;
         else if ( p_size > m_Point2DSize )
           p_size = m_Point2DSize;*/
         float p_size = (1/scalardiff)*100.0;
         if(p_size < 6.0 )
           p_size = 6.0 ;
         else if ( p_size > 10.0 )
           p_size = 10.0;
 
         //draw Point
         float opacity = (p_size<8)?0.3:1.0;//don't get the opacity from the node? Feature not a bug! Otehrwise the 2D cross is hardly seen.
         glColor4f(unselectedColor[0],unselectedColor[1],unselectedColor[2],opacity);
         glPointSize(p_size);
         //glShadeModel(GL_FLAT);
         glBegin (GL_POINTS);
-          glVertex2fv(&pt2d[0]);
+          glVertex2dv(&pt2d[0]);
         glEnd ();
       }
 
       //for point set
       if(!isInputDevice && ( (scalardiff<4.0) || (m_Polygon)))
       {
         Point2D tmp;
         displayGeometry->Map(projected_p, pt2d);
         displayGeometry->WorldToDisplay(pt2d, pt2d);
 
         Vector2D horz,vert;
         horz[0]=(float)m_Point2DSize-scalardiff*2; horz[1]=0;
         vert[0]=0;                vert[1]=(float)m_Point2DSize-scalardiff*2;
 
         // now paint text if available
         if (dynamic_cast<mitk::StringProperty *>(this->GetDataNode()
               ->GetProperty("label")) != NULL)
         {
           const char * pointLabel = dynamic_cast<mitk::StringProperty *>(
             this->GetDataNode()->GetProperty("label"))->GetValue();
           std::string l = pointLabel;
           if (input->GetSize()>1)
           {
             // char buffer[20];
             // sprintf(buffer,"%d",it->Index());
             std::stringstream ss;
             ss << it->Index();
             l.append(ss.str());
           }
           if (unselectedColor != NULL)
           {
             mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
             float rgb[3];//yellow
             rgb[0] = unselectedColor[0]; rgb[1] = unselectedColor[1]; rgb[2] = unselectedColor[2];
             OpenGLrenderer->WriteSimpleText(l, pt2d[0] + text2dDistance, pt2d[1] + text2dDistance,rgb[0], rgb[1],rgb[2]);
           }
           else
           {
             mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
             OpenGLrenderer->WriteSimpleText(l, pt2d[0] + text2dDistance, pt2d[1] + text2dDistance,0.0,1.0,0.0);
           }
         }
 
         if((m_ShowPoints) && (scalardiff<4.0))
         {
           //check if the point is to be marked as selected
           if(selIt != selEnd || pointDataBroken)
           {
             bool addAsSelected = false;
             if (pointDataBroken)
               addAsSelected = false;
             else if (selIt->Value().selected)
               addAsSelected = true;
             else
               addAsSelected = false;
 
             if (addAsSelected)
             {
               horz[0]=(float)m_Point2DSize;
               vert[1]=(float)m_Point2DSize;
               glColor3f(selectedColor[0],selectedColor[1],selectedColor[2]);
               glLineWidth(m_PointLineWidth);
               //a diamond around the point with the selected color
               glBegin (GL_LINE_LOOP);
-               tmp=pt2d-horz;      glVertex2fv(&tmp[0]);
-               tmp=pt2d+vert;      glVertex2fv(&tmp[0]);
-               tmp=pt2d+horz;      glVertex2fv(&tmp[0]);
-               tmp=pt2d-vert;      glVertex2fv(&tmp[0]);
+               tmp=pt2d-horz;      glVertex2dv(&tmp[0]);
+               tmp=pt2d+vert;      glVertex2dv(&tmp[0]);
+               tmp=pt2d+horz;      glVertex2dv(&tmp[0]);
+               tmp=pt2d-vert;      glVertex2dv(&tmp[0]);
               glEnd ();
               glLineWidth(1);
               //the actual point in the specified color to see the usual color of the point
               glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
               glPointSize(1);
               glBegin (GL_POINTS);
-              tmp=pt2d;             glVertex2fv(&tmp[0]);
+              tmp=pt2d;             glVertex2dv(&tmp[0]);
               glEnd ();
             }
             else //if not selected
             {
               glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
               glLineWidth(m_PointLineWidth);
               //drawing crosses
               glBegin (GL_LINES);
-              tmp=pt2d-horz;      glVertex2fv(&tmp[0]);
-              tmp=pt2d+horz;      glVertex2fv(&tmp[0]);
-              tmp=pt2d-vert;      glVertex2fv(&tmp[0]);
-              tmp=pt2d+vert;      glVertex2fv(&tmp[0]);
+              tmp=pt2d-horz;      glVertex2dv(&tmp[0]);
+              tmp=pt2d+horz;      glVertex2dv(&tmp[0]);
+              tmp=pt2d-vert;      glVertex2dv(&tmp[0]);
+              tmp=pt2d+vert;      glVertex2dv(&tmp[0]);
               glEnd ();
               glLineWidth(1);
             }
           }
         }
 
         bool drawLinesEtc = true;
         if (!m_ShowDistantLines && counter > 0) // check, whether this line should be drawn
         {
           ScalarType currentDistance = displayGeometry->GetWorldGeometry()->SignedDistance(p);
           ScalarType lastDistance =    displayGeometry->GetWorldGeometry()->SignedDistance(lastP);
           if ( currentDistance * lastDistance > 0.5 ) // points on same side of plane
             drawLinesEtc = false;
         }
 
         // draw a line
         if ((m_Polygon && counter>0 && drawLinesEtc) ||
             (m_Polygon && m_PolygonClosed && drawLinesEtc))
         {
            if ((counter == 0) && ( m_PolygonClosed))
            {
                lastPt2d = lastPt2DInPointSet;
            }
 
            //get contour color property
            float contourColor[4] = {unselectedColor[0], unselectedColor[1], unselectedColor[2], unselectedColor[3]};//so if no property set, then use unselected color
            if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(renderer)->GetProperty("contourcolor")) != NULL)
            {
               mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor"))->GetValue();
               contourColor[0] = tmpColor[0];
               contourColor[1] = tmpColor[1];
               contourColor[2] = tmpColor[2];
               contourColor[3] = 1.0f;
            }
            else if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(NULL)->GetProperty("contourcolor")) != NULL)
            {
               mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor"))->GetValue();
               contourColor[0] = tmpColor[0];
               contourColor[1] = tmpColor[1];
               contourColor[2] = tmpColor[2];
               contourColor[3] = 1.0f;
            }
            //set this color
            glColor3f(contourColor[0],contourColor[1],contourColor[2]);
 
            glLineWidth( m_LineWidth );
            glBegin (GL_LINES);
-           glVertex2fv(&pt2d[0]);
-           glVertex2fv(&lastPt2d[0]);
+           glVertex2dv(&pt2d[0]);
+           glVertex2dv(&lastPt2d[0]);
            glEnd ();
            glLineWidth(1.0);
            if(m_ShowDistances) // calculate and print a distance
            {
               std::stringstream buffer;
               float distance = vec.GetNorm();
               buffer<<std::fixed <<std::setprecision(m_DistancesDecimalDigits)<<distance<<" mm";
 
               Vector2D vec2d = pt2d-lastPt2d;
               makePerpendicularVector2D(vec2d, vec2d);
 
               Vector2D pos2d = (lastPt2d.GetVectorFromOrigin()+pt2d)*0.5+vec2d*text2dDistance;
 
               mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
               OpenGLrenderer->WriteSimpleText(buffer.str(), pos2d[0], pos2d[1]);
               //this->WriteTextXY(pos2d[0], pos2d[1], buffer.str(),renderer);
            }
 
            if(m_ShowAngles && counter > 1 ) // calculate and print the angle btw. two lines
            {
               std::stringstream buffer;
               //buffer << angle(vec.Get_vnl_vector(), -lastVec.Get_vnl_vector())*180/vnl_math::pi << "�";
               buffer << angle(vec.GetVnlVector(), -lastVec.GetVnlVector())*180/vnl_math::pi << (char)176;
 
               Vector2D vec2d = pt2d-lastPt2d;
               vec2d.Normalize();
               Vector2D lastVec2d = lastPt2d-preLastPt2d;
               lastVec2d.Normalize();
               vec2d=vec2d-lastVec2d;
               vec2d.Normalize();
 
               Vector2D pos2d = lastPt2d.GetVectorFromOrigin()+vec2d*text2dDistance*text2dDistance;
 
               mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
               OpenGLrenderer->WriteSimpleText(buffer.str(), pos2d[0], pos2d[1]);
               //this->WriteTextXY(pos2d[0], pos2d[1], buffer.str(),renderer);
            }
         }
         counter++;
       }
       ++it;
       if(selIt != selEnd && !pointDataBroken)
          ++selIt;
       j++;
     }
 
     //recall the color to the same color before this drawing
     glColor3f(recallColor[0],recallColor[1],recallColor[2]);
   }
 }
 
 void mitk::PointSetGLMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "line width", mitk::IntProperty::New(2), renderer, overwrite ); // width of the line from one point to another
   node->AddProperty( "point line width", mitk::IntProperty::New(1), renderer, overwrite ); //width of the cross marking a point
   node->AddProperty( "point 2D size", mitk::IntProperty::New(8), renderer, overwrite ); // length of the cross marking a point // length of an edge of the box marking a point
   node->AddProperty( "show contour", mitk::BoolProperty::New(false), renderer, overwrite ); // contour of the line between points
   node->AddProperty( "close contour", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "show points", mitk::BoolProperty::New(true), renderer, overwrite ); //show or hide points
   node->AddProperty( "show distances", mitk::BoolProperty::New(false), renderer, overwrite ); //show or hide distance measure (not always available)
   node->AddProperty( "distance decimal digits", mitk::IntProperty::New(2), renderer, overwrite ); //set the number of decimal digits to be shown
   node->AddProperty( "show angles", mitk::BoolProperty::New(false), renderer, overwrite ); //show or hide angle measurement (not always available)
   node->AddProperty( "show distant lines", mitk::BoolProperty::New(false), renderer, overwrite ); //show the line between to points from a distant view (equals "always on top" option)
   node->AddProperty( "layer", mitk::IntProperty::New(1), renderer, overwrite ); // default to draw pointset above images (they have a default layer of 0)
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
diff --git a/Core/Code/Rendering/vtkMitkRectangleProp.cpp b/Core/Code/Rendering/vtkMitkRectangleProp.cpp
index a8354dcb3f..524e73602f 100644
--- a/Core/Code/Rendering/vtkMitkRectangleProp.cpp
+++ b/Core/Code/Rendering/vtkMitkRectangleProp.cpp
@@ -1,128 +1,128 @@
 /*===================================================================
 
 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 "vtkMitkRectangleProp.h"
 #include "vtkObjectFactory.h"
 
 #include "mitkGL.h"
 
 vtkStandardNewMacro(vtkMitkRectangleProp);
 
 vtkMitkRectangleProp::vtkMitkRectangleProp()
 {
 }
 
 vtkMitkRectangleProp::~vtkMitkRectangleProp()
 {
 }
 
 double *vtkMitkRectangleProp::GetBounds()
 {
   return NULL;
 }
 
 int vtkMitkRectangleProp::RenderOverlay(vtkViewport* /*viewport*/)
 {
   m_RenderWindow->MakeCurrent();
 
   Enable2DOpenGL();
 
   //make it nicer
   glEnable(GL_LINE_SMOOTH);
   glHint(GL_LINE_SMOOTH_HINT,GL_NICEST);
 
   //size and position
   int * i = m_RenderWindow->GetSize();
-  GLfloat bbox[8] = {0.f , 0.f, (float)i[0], 0.f, (float)i[0], (float)i[1], 0.f, (float)i[1]};
+  GLdouble bbox[8] = {0.f , 0.f, (double)i[0], 0.f, (double)i[0], (double)i[1], 0.f, (double)i[1]};
 
   //render rectangle
   glLineWidth(5.0f);
   glBegin(GL_LINE_LOOP);
   for (int j = 0; j < 4; j++)
   {
     glColor3f(m_Color[0],m_Color[1],m_Color[2]);
-    glVertex2fv(&bbox[2*j]);
+    glVertex2dv(&bbox[2*j]);
   }
   glEnd();
   glLineWidth(1.0f);
 
   glDisable(GL_LINE_SMOOTH);
 
   Disable2DOpenGL();
 
   return 1;
 }
 
 void vtkMitkRectangleProp::SetRenderWindow(vtkRenderWindow* renWin)
 {
   m_RenderWindow = renWin;
 }
 
 void vtkMitkRectangleProp::SetColor(float col1, float col2, float col3)
 {
   m_Color[0] = col1;
   m_Color[1] = col2;
   m_Color[2] = col3;
 }
 
 
 int vtkMitkRectangleProp::RenderTranslucentGeometry(vtkViewport* /*viewport*/)
 {
   return 0;
 }
 
 int vtkMitkRectangleProp::RenderOpaqueGeometry(vtkViewport* /*viewport*/)
 {
   return 0;
 }
 
 void vtkMitkRectangleProp::Enable2DOpenGL()
 {
   GLint iViewport[4];
 
   // Get a copy of the viewport
   glGetIntegerv( GL_VIEWPORT, iViewport );
 
   // Save a copy of the projection matrix so that we can restore it
   // when it's time to do 3D rendering again.
   glMatrixMode( GL_PROJECTION );
   glPushMatrix();
   glLoadIdentity();
 
   // Set up the orthographic projection
   glOrtho( iViewport[0], iViewport[0]+iViewport[2],
   iViewport[1]+iViewport[3], iViewport[1], -1, 1 );
   glMatrixMode( GL_MODELVIEW );
   glPushMatrix();
   glLoadIdentity();
 
   // Make sure depth testing and lighting are disabled for 2D rendering until
   // we are finished rendering in 2D
   glPushAttrib( GL_DEPTH_BUFFER_BIT | GL_LIGHTING_BIT | GL_TEXTURE_2D);
   glDisable( GL_DEPTH_TEST );
   glDisable( GL_LIGHTING   );
   glDisable( GL_TEXTURE_2D );
 }
 
 void vtkMitkRectangleProp::Disable2DOpenGL()
 {
   glPopAttrib();
   glMatrixMode( GL_PROJECTION );
   glPopMatrix();
   glMatrixMode( GL_MODELVIEW );
   glPopMatrix();
 }
 
diff --git a/Core/Code/Testing/files.cmake b/Core/Code/Testing/files.cmake
index 9b4d7653a4..c749448b9d 100644
--- a/Core/Code/Testing/files.cmake
+++ b/Core/Code/Testing/files.cmake
@@ -1,154 +1,156 @@
 
 # tests with no extra command line parameter
 set(MODULE_TESTS
   mitkAccessByItkTest.cpp
   mitkCoreObjectFactoryTest.cpp
   mitkMaterialTest.cpp
   mitkActionTest.cpp
   mitkDispatcherTest.cpp
   mitkEnumerationPropertyTest.cpp
   mitkEventTest.cpp
   mitkFocusManagerTest.cpp
   mitkGenericPropertyTest.cpp
   mitkGeometry3DTest.cpp
   mitkGeometryDataToSurfaceFilterTest.cpp
   mitkGlobalInteractionTest.cpp
   mitkImageDataItemTest.cpp
   #mitkImageMapper2DTest.cpp
   mitkImageGeneratorTest.cpp
   mitkBaseDataTest.cpp
   #mitkImageToItkTest.cpp
   mitkImportItkImageTest.cpp
   mitkGrabItkImageMemoryTest.cpp
   mitkInstantiateAccessFunctionTest.cpp
   mitkInteractorTest.cpp
   #mitkITKThreadingTest.cpp
   mitkLevelWindowTest.cpp
   mitkMessageTest.cpp
   #mitkPipelineSmartPointerCorrectnessTest.cpp
   mitkPixelTypeTest.cpp
   mitkPlaneGeometryTest.cpp
   mitkPointSetFileIOTest.cpp
   mitkPointSetTest.cpp
   mitkPointSetWriterTest.cpp
   mitkPointSetReaderTest.cpp
   mitkPointSetInteractorTest.cpp
   mitkPropertyTest.cpp
   mitkPropertyListTest.cpp
   #mitkRegistrationBaseTest.cpp
   #mitkSegmentationInterpolationTest.cpp
   mitkSlicedGeometry3DTest.cpp
   mitkSliceNavigationControllerTest.cpp
   mitkStateMachineTest.cpp
   ##mitkStateMachineContainerTest.cpp ## rewrite test, indirect since no longer exported Bug 14529
   mitkStateTest.cpp
   mitkSurfaceTest.cpp
   mitkSurfaceToSurfaceFilterTest.cpp
   mitkTimeSlicedGeometryTest.cpp
   mitkTransitionTest.cpp
   mitkUndoControllerTest.cpp
   mitkVtkWidgetRenderingTest.cpp
   mitkVerboseLimitedLinearUndoTest.cpp
   mitkWeakPointerTest.cpp
   mitkTransferFunctionTest.cpp
   #mitkAbstractTransformGeometryTest.cpp
   mitkStepperTest.cpp
   itkTotalVariationDenoisingImageFilterTest.cpp
   mitkRenderingManagerTest.cpp
   vtkMitkThickSlicesFilterTest.cpp
   mitkNodePredicateSourceTest.cpp
   mitkVectorTest.cpp
   mitkClippedSurfaceBoundsCalculatorTest.cpp
   mitkExceptionTest.cpp
   mitkExtractSliceFilterTest.cpp
   mitkLogTest.cpp
   mitkImageDimensionConverterTest.cpp
   mitkLoggingAdapterTest.cpp
   mitkUIDGeneratorTest.cpp
   mitkShaderRepositoryTest.cpp
   mitkPlanePositionManagerTest.cpp
+  mitkTypeConversionTest.cpp
+  mitkTypeOperationTest.cpp
 )
 
 # test with image filename as an extra command line parameter
 set(MODULE_IMAGE_TESTS
   mitkImageTimeSelectorTest.cpp #only runs on images
   mitkImageAccessorTest.cpp #only runs on images
   mitkDataNodeFactoryTest.cpp #runs on all types of data
 )
 
 set(MODULE_SURFACE_TESTS
   mitkSurfaceVtkWriterTest.cpp #only runs on surfaces
   mitkDataNodeFactoryTest.cpp #runs on all types of data
 )
 
 # list of images for which the tests are run
 set(MODULE_TESTIMAGES
   US4DCyl.nrrd
   Pic3D.nrrd
   Pic2DplusT.nrrd
   BallBinary30x30x30.nrrd
   Png2D-bw.png
 )
 set(MODULE_TESTSURFACES
   binary.stl
   ball.stl
 )
 
 set(MODULE_CUSTOM_TESTS
     #mitkLabeledImageToSurfaceFilterTest.cpp
     #mitkExternalToolsTest.cpp
     mitkDataStorageTest.cpp
     mitkDataNodeTest.cpp
     mitkDicomSeriesReaderTest.cpp
     mitkDICOMLocaleTest.cpp
     mitkEventMapperTest.cpp
     mitkEventConfigTest.cpp
     mitkNodeDependentPointSetInteractorTest.cpp
     mitkStateMachineFactoryTest.cpp
     mitkPointSetLocaleTest.cpp
     mitkImageTest.cpp
     mitkImageWriterTest.cpp
     mitkImageVtkMapper2DTest.cpp
     mitkImageVtkMapper2DLevelWindowTest.cpp
     mitkImageVtkMapper2DOpacityTest.cpp
     mitkImageVtkMapper2DResliceInterpolationPropertyTest.cpp
     mitkImageVtkMapper2DColorTest.cpp
     mitkImageVtkMapper2DSwivelTest.cpp
     mitkImageVtkMapper2DTransferFunctionTest.cpp
     mitkIOUtilTest.cpp
     mitkSurfaceVtkMapper3DTest
     mitkSurfaceVtkMapper3DTexturedSphereTest.cpp
     mitkSurfaceGLMapper2DColorTest.cpp
     mitkSurfaceGLMapper2DOpacityTest.cpp
     mitkVolumeCalculatorTest.cpp
     mitkLevelWindowManagerTest.cpp
     mitkPointSetVtkMapper2DTest.cpp
     mitkPointSetVtkMapper2DImageTest.cpp
     mitkPointSetVtkMapper2DGlyphTypeTest.cpp
 )
 
 set(MODULE_RESOURCE_FILES
   Interactions/AddAndRemovePoints.xml
   Interactions/globalConfig.xml
   Interactions/StatemachineTest.xml
   Interactions/StatemachineConfigTest.xml
 )
 
 # Create an artificial module initializing class for
 # the usServiceListenerTest.cpp
 usFunctionGenerateModuleInit(testdriver_init_file
                              NAME ${MODULE_NAME}TestDriver
                              DEPENDS "Mitk"
                              VERSION "0.1.0"
                              EXECUTABLE
                             )
 
 # Embed the resources
 set(testdriver_resources )
 usFunctionEmbedResources(testdriver_resources
                          EXECUTABLE_NAME ${MODULE_NAME}TestDriver
                          ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Resources
                          FILES ${MODULE_RESOURCE_FILES}
                         )
 
 set(TEST_CPP_FILES ${testdriver_init_file} ${testdriver_resources})
diff --git a/Core/Code/Testing/mitkBaseDataTest.cpp b/Core/Code/Testing/mitkBaseDataTest.cpp
index 7f4fb8b044..f4efc3468b 100644
--- a/Core/Code/Testing/mitkBaseDataTest.cpp
+++ b/Core/Code/Testing/mitkBaseDataTest.cpp
@@ -1,118 +1,118 @@
 /*===================================================================
 
 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 "mitkBaseDataTestImplementation.h"
 #include "mitkStringProperty.h"
 #include "mitkTestingMacros.h"
 #include "itkImage.h"
 
 
 int mitkBaseDataTest(int /*argc*/, char* /*argv*/[])
 {
 
   MITK_TEST_BEGIN("BaseData")
 
   //Create a BaseData implementation
   MITK_INFO << "Creating a base data instance...";
   mitk::BaseDataTestImplementation::Pointer baseDataImpl = mitk::BaseDataTestImplementation::New();
 
   MITK_TEST_CONDITION_REQUIRED(baseDataImpl.IsNotNull(),"Testing instantiation");
   MITK_TEST_CONDITION(baseDataImpl->IsInitialized(), "BaseDataTestImplementation is initialized");
   MITK_TEST_CONDITION(baseDataImpl->IsEmpty(), "BaseDataTestImplementation is initialized and empty");
 
   mitk::BaseDataTestImplementation::Pointer cloneBaseData = baseDataImpl->Clone();
   MITK_TEST_CONDITION_REQUIRED(cloneBaseData.IsNotNull(),"Testing instantiation of base data clone");
   MITK_TEST_CONDITION(cloneBaseData->IsInitialized(), "Clone of BaseDataTestImplementation is initialized");
   MITK_TEST_CONDITION(cloneBaseData->IsEmpty(), "Clone of BaseDataTestImplementation is initialized and empty");
 
   MITK_INFO << "Testing setter and getter for geometries...";
 
   //test method GetTimeSlicedGeometry()
   MITK_TEST_CONDITION(baseDataImpl->GetTimeSlicedGeometry(), "Testing creation of TimeSlicedGeometry");
 
   mitk::TimeSlicedGeometry* geo = NULL;
   baseDataImpl->SetGeometry(geo);
 
   MITK_TEST_CONDITION(baseDataImpl->GetTimeSlicedGeometry() == NULL, "Reset Geometry");
 
   mitk::TimeSlicedGeometry::Pointer geo2 = mitk::TimeSlicedGeometry::New();
   baseDataImpl->SetGeometry(geo2);
   baseDataImpl->InitializeTimeSlicedGeometry(2);
   MITK_TEST_CONDITION(baseDataImpl->GetTimeSlicedGeometry() == geo2, "Correct Reinit of TimeslicedGeometry");
 
   //test method GetGeometry(int timeStep)
   MITK_TEST_CONDITION(baseDataImpl->GetGeometry(1) != NULL, "... and single Geometries");
 
   //test method Expand(unsigned int timeSteps)
   baseDataImpl->Expand(5);
   MITK_TEST_CONDITION(baseDataImpl->GetTimeSteps() == 5, "Expand the geometry to further time slices!");
 
   //test method GetUpdatedGeometry(int timeStep);
   mitk::Geometry3D::Pointer geo3 = mitk::Geometry3D::New();
   mitk::TimeSlicedGeometry::Pointer timeSlicedGeometry = baseDataImpl->GetTimeSlicedGeometry();
   if (timeSlicedGeometry.IsNotNull() )
   {
     timeSlicedGeometry->SetGeometry3D(geo3, 1);
   }
 
   MITK_TEST_CONDITION(baseDataImpl->GetUpdatedGeometry(1) == geo3, "Set Geometry for time step 1");
   MITK_TEST_CONDITION(baseDataImpl->GetMTime()!= 0, "Check if modified time is set");
   baseDataImpl->SetClonedGeometry(geo3, 1);
 
-  float x[3];
+  mitk::ScalarType x[3];
   x[0] = 2;
   x[1] = 4;
   x[2] = 6;
   mitk::Point3D p3d(x);
   baseDataImpl->SetOrigin(p3d);
   geo3->SetOrigin(p3d);
 
   MITK_TEST_CONDITION(baseDataImpl->GetGeometry(1)->GetOrigin() == geo3->GetOrigin(), "Testing Origin set");
 
   cloneBaseData = baseDataImpl->Clone();
   MITK_TEST_CONDITION(cloneBaseData->GetGeometry(1)->GetOrigin() == geo3->GetOrigin(), "Testing origin set in clone!");
 
   MITK_TEST_CONDITION(!baseDataImpl->IsEmptyTimeStep(1), "Is not empty before clear()!");
   baseDataImpl->Clear();
   MITK_TEST_CONDITION(baseDataImpl->IsEmptyTimeStep(1), "...but afterwards!");
   //test method Set-/GetProperty()
   baseDataImpl->SetProperty("property38", mitk::StringProperty::New("testproperty"));
   //baseDataImpl->SetProperty("visibility", mitk::BoolProperty::New());
   MITK_TEST_CONDITION(baseDataImpl->GetProperty("property38")->GetValueAsString() == "testproperty","Check if base property is set correctly!");
 
   cloneBaseData = baseDataImpl->Clone();
   MITK_TEST_CONDITION(cloneBaseData->GetProperty("property38")->GetValueAsString() == "testproperty", "Testing origin set in clone!");
 
   //test method Set-/GetPropertyList
   mitk::PropertyList::Pointer propertyList = mitk::PropertyList::New();
   propertyList->SetFloatProperty("floatProperty1", 123.45);
   propertyList->SetBoolProperty("visibility",true);
   propertyList->SetStringProperty("nameXY","propertyName");
   baseDataImpl->SetPropertyList(propertyList);
   bool value = false;
   MITK_TEST_CONDITION(baseDataImpl->GetPropertyList() == propertyList, "Check if base property list is set correctly!");
   MITK_TEST_CONDITION(baseDataImpl->GetPropertyList()->GetBoolProperty("visibility", value) == true, "Check if base property is set correctly in the property list!");
 
   //test method UpdateOutputInformation()
    baseDataImpl->UpdateOutputInformation();
   MITK_TEST_CONDITION(baseDataImpl->GetUpdatedTimeSlicedGeometry() == geo2, "TimeSlicedGeometry update!");
   //Test method CopyInformation()
   mitk::BaseDataTestImplementation::Pointer newBaseData =  mitk::BaseDataTestImplementation::New();
   newBaseData->CopyInformation(baseDataImpl);
   MITK_TEST_CONDITION_REQUIRED(  newBaseData->GetTimeSlicedGeometry()->GetTimeSteps() == 5, "Check copying of of Basedata Data Object!");
 
   MITK_TEST_END()
 }
diff --git a/Core/Code/Testing/mitkExtractSliceFilterTest.cpp b/Core/Code/Testing/mitkExtractSliceFilterTest.cpp
index a2f5084a2e..3fed1eb757 100644
--- a/Core/Code/Testing/mitkExtractSliceFilterTest.cpp
+++ b/Core/Code/Testing/mitkExtractSliceFilterTest.cpp
@@ -1,1162 +1,1162 @@
 /*===================================================================
 
 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 <mitkExtractSliceFilter.h>
 #include <mitkTestingMacros.h>
 #include <mitkItkImageFileReader.h>
 #include <itkImageRegionIterator.h>
 #include <mitkImageCast.h>
 #include <itkImage.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkStandardFileLocations.h>
 #include <mitkImageWriter.h>
 #include <mitkITKImageImport.h>
 #include <mitkRotationOperation.h>
 #include <mitkInteractionConst.h>
 #include <mitkVector.h>
 
 #include <ctime>
 #include <cstdlib>
 #include <math.h>
 
 
 #include <mitkGeometry3D.h>
 
 #include <vtkImageData.h>
 #include <vtkSmartPointer.h>
 #include <vtkActor.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderWindow.h>
 #include <vtkInteractorStyleImage.h>
 #include <vtkRenderer.h>
 #include <vtkImageMapper.h>
 #include <vtkImageReslice.h>
 #include <vtkImageActor.h>
 #include <vtkImageMapToColors.h>
 #include <vtkLookupTable.h>
 #include <vtkTexture.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkPlaneSource.h>
 
 
 //use this to create the test volume on the fly
 #define CREATE_VOLUME
 
 //use this to save the created volume
 //#define SAVE_VOLUME
 
 //use this to calculate the error from the sphere mathematical model to our pixel based one
 //#define CALC_TESTFAILURE_DEVIATION
 
 //use this to render an oblique slice through a specified image
 //#define SHOW_SLICE_IN_RENDER_WINDOW
 
 //use this to have infos printed in mbilog
 //#define EXTRACTOR_DEBUG
 
 
 /*these are the deviations calculated by the function CalcTestFailureDeviation (see for details)*/
 #define Testfailure_Deviation_Mean_128 0.853842
 
 #define Testfailure_Deviation_Volume_128 0.145184
 #define Testfailure_Deviation_Diameter_128 1.5625
 
 
 
 #define Testfailure_Deviation_Mean_256 0.397693
 
 #define Testfailure_Deviation_Volume_256 0.0141357
 #define Testfailure_Deviation_Diameter_256 0.78125
 
 
 
 #define Testfailure_Deviation_Mean_512 0.205277
 
 #define Testfailure_Deviation_Volume_512 0.01993
 #define Testfailure_Deviation_Diameter_512 0.390625
 
 
 
 class mitkExtractSliceFilterTestClass{
 
 public:
 
 
   static void TestSlice(mitk::PlaneGeometry* planeGeometry, std::string testname)
   {
     TestPlane = planeGeometry;
     TestName = testname;
 
-    float centerCoordValue = TestvolumeSize / 2.0;
-    float center[3] = {centerCoordValue, centerCoordValue, centerCoordValue};
+    mitk::ScalarType centerCoordValue = TestvolumeSize / 2.0;
+    mitk::ScalarType center[3] = {centerCoordValue, centerCoordValue, centerCoordValue};
     mitk::Point3D centerIndex(center);
 
     double radius = TestvolumeSize / 4.0;
     if(TestPlane->Distance(centerIndex) >= radius ) return;//outside sphere
 
 
 
     //feed ExtractSliceFilter
     mitk::ExtractSliceFilter::Pointer slicer = mitk::ExtractSliceFilter::New();
 
     slicer->SetInput(TestVolume);
     slicer->SetWorldGeometry(TestPlane);
     slicer->Update();
 
     MITK_TEST_CONDITION_REQUIRED(slicer->GetOutput() != NULL, "Extractor returned a slice");
 
     mitk::Image::Pointer reslicedImage = slicer->GetOutput();
 
     AccessFixedDimensionByItk(reslicedImage, TestSphereRadiusByItk, 2);
     AccessFixedDimensionByItk(reslicedImage, TestSphereAreaByItk, 2);
 
     /*
     double devArea, devDiameter;
     if(TestvolumeSize == 128.0){ devArea = Testfailure_Deviation_Volume_128; devDiameter = Testfailure_Deviation_Diameter_128; }
     else if(TestvolumeSize == 256.0){devArea = Testfailure_Deviation_Volume_256; devDiameter = Testfailure_Deviation_Diameter_256;}
     else if (TestvolumeSize == 512.0){devArea = Testfailure_Deviation_Volume_512; devDiameter = Testfailure_Deviation_Diameter_512;}
     else{devArea = Testfailure_Deviation_Volume_128; devDiameter = Testfailure_Deviation_Diameter_128;}
     */
 
     std::string areatestName = TestName.append(" area");
     std::string diametertestName = TestName.append(" testing diameter");
 
     //TODO think about the deviation, 1% makes no sense at all
     MITK_TEST_CONDITION(std::abs(100 - testResults.percentageAreaCalcToPixel) < 1, areatestName );
     MITK_TEST_CONDITION(std::abs(100 - testResults.percentageRadiusToPixel) < 1, diametertestName );
 
   #ifdef EXTRACTOR_DEBUG
     MITK_INFO << TestName << " >>> " << "planeDistanceToSphereCenter: " << testResults.planeDistanceToSphereCenter;
     MITK_INFO << "area in pixels: " << testResults.areaInPixel << " <-> area in mm: " << testResults.areaCalculated << " = " << testResults.percentageAreaCalcToPixel << "%";
 
     MITK_INFO << "calculated diameter: " << testResults.diameterCalculated << " <-> diameter in mm: " << testResults.diameterInMM << " <-> diameter in pixel: " << testResults.diameterInPixel << " = " << testResults.percentageRadiusToPixel << "%";
   #endif
   }
 
 
   /*
    * get the radius of the slice of a sphere based on pixel distance from edge to edge of the circle.
    */
   template<typename TPixel, unsigned int VImageDimension>
   static void TestSphereRadiusByItk (itk::Image<TPixel, VImageDimension>* inputImage)
   {
     typedef itk::Image<TPixel, VImageDimension> InputImageType;
 
 
     //set the index to the middle of the image's edge at x and y axis
     typename InputImageType::IndexType currentIndexX;
     currentIndexX[0] = (int)(TestvolumeSize / 2.0);
     currentIndexX[1] = 0;
 
     typename InputImageType::IndexType currentIndexY;
     currentIndexY[0] = 0;
     currentIndexY[1] = (int)(TestvolumeSize / 2.0);
 
 
     //remember the last pixel value
     double lastValueX = inputImage->GetPixel(currentIndexX);
     double lastValueY = inputImage->GetPixel(currentIndexY);
 
 
     //storage for the index marks
                 std::vector<typename InputImageType::IndexType> indicesX;
                 std::vector<typename InputImageType::IndexType> indicesY;
 
 
     /*Get four indices on the edge of the circle*/
     while(currentIndexX[1] < TestvolumeSize && currentIndexX[0] < TestvolumeSize)
     {
       //move x direction
       currentIndexX[1] += 1;
 
       //move y direction
       currentIndexY[0] += 1;
 
       if(inputImage->GetPixel(currentIndexX) > lastValueX)
       {
         //mark the current index
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndexX[0];
         markIndex[1] = currentIndexX[1];
 
 
         indicesX.push_back(markIndex);
       }
       else if( inputImage->GetPixel(currentIndexX) < lastValueX)
       {
         //mark the current index
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndexX[0];
         markIndex[1] = currentIndexX[1] - 1;//value inside the sphere
 
 
         indicesX.push_back(markIndex);
       }
 
       if(inputImage->GetPixel(currentIndexY) > lastValueY)
       {
         //mark the current index
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndexY[0];
         markIndex[1] = currentIndexY[1];
 
 
         indicesY.push_back(markIndex);
       }
       else if( inputImage->GetPixel(currentIndexY) < lastValueY)
       {
         //mark the current index
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndexY[0];
         markIndex[1] = currentIndexY[1] - 1;//value inside the sphere
 
 
         indicesY.push_back(markIndex);
       }
 
 
       //found both marks?
       if(indicesX.size() == 2 && indicesY.size() == 2) break;
 
       //the new 'last' values
       lastValueX = inputImage->GetPixel(currentIndexX);
       lastValueY = inputImage->GetPixel(currentIndexY);
     }
 
     /*
      *If we are here we found the four marks on the edge of the circle.
      *For the case our plane is rotated and shifted, we have to calculate the center of the circle,
      *else the center is the intersection of both straight lines between the marks.
      *When we have the center, the diameter of the circle will be checked to the reference value(math!).
      */
 
     //each distance from the first mark of each direction to the center of the straight line between the marks
     double distanceToCenterX = std::abs(indicesX[0][1] - indicesX[1][1]) / 2.0;
     //double distanceToCenterY = std::abs(indicesY[0][0] - indicesY[1][0]) / 2.0;
 
 
     //the center of the straight lines
     typename InputImageType::IndexType centerX;
     //typename InputImageType::IndexType centerY;
 
     centerX[0] = indicesX[0][0];
     centerX[1] = indicesX[0][1] + distanceToCenterX;
     //TODO think about implicit cast to int. this is not the real center of the image, which could be between two pixels
 
     //centerY[0] = indicesY[0][0] + distanceToCenterY;
     //centerY[1] = inidcesY[0][1];
 
     typename InputImageType::IndexType currentIndex(centerX);
     lastValueX = inputImage->GetPixel(currentIndex);
 
     long sumpixels = 0;
 
                 std::vector<typename InputImageType::IndexType> diameterIndices;
 
     //move up
     while(currentIndex[1] < TestvolumeSize)
     {
       currentIndex[1] += 1;
 
       if( inputImage->GetPixel(currentIndex) != lastValueX)
       {
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndex[0];
         markIndex[1] = currentIndex[1] - 1;
 
         diameterIndices.push_back(markIndex);
         break;
       }
 
       sumpixels++;
       lastValueX = inputImage->GetPixel(currentIndex);
     }
 
     currentIndex[1] -= sumpixels; //move back to center to go in the other direction
     lastValueX = inputImage->GetPixel(currentIndex);
 
     //move down
     while(currentIndex[1] >= 0)
     {
       currentIndex[1] -= 1;
 
       if( inputImage->GetPixel(currentIndex) != lastValueX)
         {
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndex[0];
         markIndex[1] = currentIndex[1];//outside sphere because we want to calculate the distance from edge to edge
 
         diameterIndices.push_back(markIndex);
         break;
       }
 
       sumpixels++;
       lastValueX = inputImage->GetPixel(currentIndex);
     }
 
 
 
     /*
     *Now sumpixels should be the apromximate diameter of the circle. This is checked with the calculated diameter from the plane transformation(math).
     */
     mitk::Point3D volumeCenter;
     volumeCenter[0] = volumeCenter[1] = volumeCenter[2] = TestvolumeSize / 2.0;
 
 
     double planeDistanceToSphereCenter = TestPlane->Distance(volumeCenter);
 
 
     double sphereRadius = TestvolumeSize/4.0;
 
     //calculate the radius of the circle cut from the sphere by the plane
     double diameter = 2.0 * std::sqrt(std::pow(sphereRadius, 2) - std::pow( planeDistanceToSphereCenter  , 2));
 
     double percentageRadiusToPixel = 100 /  diameter  * sumpixels;
 
 
 
     /*
      *calculate the radius in mm by the both marks of the center line by using the world coordinates
      */
     //get the points as 3D coordinates
     mitk::Vector3D diameterPointRight, diameterPointLeft;
 
     diameterPointRight[2] = diameterPointLeft[2] = 0.0;
 
     diameterPointLeft[0] = diameterIndices[0][0];
     diameterPointLeft[1] = diameterIndices[0][1];
 
     diameterPointRight[0] = diameterIndices[1][0];
     diameterPointRight[1] = diameterIndices[1][1];
 
     //transform to worldcoordinates
     TestVolume->GetGeometry()->IndexToWorld(diameterPointLeft, diameterPointLeft);
     TestVolume->GetGeometry()->IndexToWorld(diameterPointRight, diameterPointRight);
 
     //euklidian distance
     double diameterInMM = ( (diameterPointLeft * -1.0) + diameterPointRight).GetNorm();
 
 
     testResults.diameterInMM = diameterInMM;
     testResults.diameterCalculated = diameter;
     testResults.diameterInPixel = sumpixels;
     testResults.percentageRadiusToPixel = percentageRadiusToPixel;
     testResults.planeDistanceToSphereCenter = planeDistanceToSphereCenter;
   }
 
 
 
 
 
   /*brute force the area pixel by pixel*/
   template<typename TPixel, unsigned int VImageDimension>
   static void TestSphereAreaByItk (itk::Image<TPixel, VImageDimension>* inputImage)
   {
     typedef itk::Image<TPixel, VImageDimension> InputImageType;
     typedef itk::ImageRegionConstIterator< InputImageType > ImageIterator;
 
 
     ImageIterator imageIterator( inputImage, inputImage->GetLargestPossibleRegion() );
     imageIterator.GoToBegin();
 
     int sumPixelsInArea = 0;
 
     while( !imageIterator.IsAtEnd() )
     {
       if(inputImage->GetPixel(imageIterator.GetIndex()) == pixelValueSet) sumPixelsInArea++;
       ++imageIterator;
     }
 
     mitk::Point3D volumeCenter;
     volumeCenter[0] = volumeCenter[1] = volumeCenter[2] = TestvolumeSize / 2.0;
 
 
     double planeDistanceToSphereCenter = TestPlane->Distance(volumeCenter);
 
     double sphereRadius = TestvolumeSize/4.0;
 
     //calculate the radius of the circle cut from the sphere by the plane
     double radius = std::sqrt(std::pow(sphereRadius, 2) - std::pow( planeDistanceToSphereCenter  , 2));
 
     double areaInMM = 3.14159265358979 * std::pow(radius, 2);
 
 
     testResults.areaCalculated = areaInMM;
     testResults.areaInPixel = sumPixelsInArea;
     testResults.percentageAreaCalcToPixel = 100 / areaInMM * sumPixelsInArea;
   }
 
 
 
   /*
    * random a voxel. define plane through this voxel. reslice at the plane. compare the pixel vaues of the voxel
    * in the volume with the pixel value in the resliced image.
    * there are some indice shifting problems which causes the test to fail for oblique planes. seems like the chosen
    * worldcoordinate is not corrresponding to the index in the 2D image. and so the pixel values are not the same as
    * expected.
    */
   static void PixelvalueBasedTest()
   {
     /* setup itk image */
     typedef itk::Image<unsigned short, 3> ImageType;
 
     typedef itk::ImageRegionConstIterator< ImageType > ImageIterator;
 
     ImageType::Pointer image = ImageType::New();
 
     ImageType::IndexType start;
     start[0] = start[1] = start[2] = 0;
 
     ImageType::SizeType size;
     size[0] = size[1] = size[2] = 32;
 
     ImageType::RegionType imgRegion;
     imgRegion.SetSize(size);
     imgRegion.SetIndex(start);
 
     image->SetRegions(imgRegion);
     image->SetSpacing(1.0);
     image->Allocate();
 
 
     ImageIterator imageIterator( image, image->GetLargestPossibleRegion() );
     imageIterator.GoToBegin();
 
 
     unsigned short pixelValue = 0;
 
     //fill the image with distinct values
     while ( !imageIterator.IsAtEnd() )
     {
       image->SetPixel(imageIterator.GetIndex(), pixelValue);
       ++imageIterator;
       ++pixelValue;
     }
     /* end setup itk image */
 
 
 
     mitk::Image::Pointer imageInMitk;
     CastToMitkImage(image, imageInMitk);
 
 
 
     /*mitk::ImageWriter::Pointer writer = mitk::ImageWriter::New();
     writer->SetInput(imageInMitk);
     std::string file = "C:\\Users\\schroedt\\Desktop\\cube.nrrd";
     writer->SetFileName(file);
     writer->Update();*/
 
                 PixelvalueBasedTestByPlane(imageInMitk, mitk::PlaneGeometry::Frontal);
                 PixelvalueBasedTestByPlane(imageInMitk, mitk::PlaneGeometry::Sagittal);
                 PixelvalueBasedTestByPlane(imageInMitk, mitk::PlaneGeometry::Axial);
 
   }
 
   static void PixelvalueBasedTestByPlane(mitk::Image* imageInMitk, mitk::PlaneGeometry::PlaneOrientation orientation){
 
     typedef itk::Image<unsigned short, 3> ImageType;
 
     //set the seed of the rand function
     srand((unsigned)time(0));
 
     /* setup a random orthogonal plane */
     int sliceindex = 17;//rand() % 32;
     bool isFrontside = true;
     bool isRotated = false;
 
 
                 if( orientation == mitk::PlaneGeometry::Axial)
     {
       /*isFrontside = false;
       isRotated = true;*/
     }
 
 
 
     mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
 
 
     plane->InitializeStandardPlane(imageInMitk->GetGeometry(), orientation, sliceindex, isFrontside, isRotated);
 
     mitk::Point3D origin = plane->GetOrigin();
     mitk::Vector3D normal;
     normal = plane->GetNormal();
 
 
     normal.Normalize();
 
     origin += normal * 0.5;//pixelspacing is 1, so half the spacing is 0.5
 
     plane->SetOrigin(origin);
 
     //we dont need this any more, because we are only testing orthogonal planes
     /*mitk::Vector3D rotationVector;
     rotationVector[0] = randFloat();
     rotationVector[1] = randFloat();
     rotationVector[2] = randFloat();
 
 
     float degree = randFloat() * 180.0;
 
     mitk::RotationOperation* op = new mitk::RotationOperation(mitk::OpROTATE, plane->GetCenter(), rotationVector, degree);
     plane->ExecuteOperation(op);
     delete op;*/
 
     /* end setup plane */
 
 
     /* define a point in the 3D volume.
      * add the two axis vectors of the plane (each multiplied with a
      * random number) to the origin. now the two random numbers
      * become our index coordinates in the 2D image, because the
      * length of the axis vectors is 1.
      */
     mitk::Point3D planeOrigin =  plane->GetOrigin();
     mitk::Vector3D axis0, axis1;
     axis0 = plane->GetAxisVector(0);
     axis1 = plane->GetAxisVector(1);
     axis0.Normalize();
     axis1.Normalize();
 
 
     unsigned char n1 = 7;// rand() % 32;
     unsigned char n2 = 13;// rand() % 32;
 
 
     mitk::Point3D testPoint3DInWorld;
     testPoint3DInWorld = planeOrigin + (axis0 * n1) + (axis1 * n2);
 
     //get the index of the point in the 3D volume
     ImageType::IndexType testPoint3DInIndex;
     imageInMitk->GetGeometry()->WorldToIndex(testPoint3DInWorld, testPoint3DInIndex);
 
     mitk::Index3D testPoint2DInIndex;
 
     /* end define a point in the 3D volume.*/
 
 
     //do reslicing at the plane
     mitk::ExtractSliceFilter::Pointer slicer = mitk::ExtractSliceFilter::New();
     slicer->SetInput(imageInMitk);
     slicer->SetWorldGeometry(plane);
 
     slicer->Update();
 
     mitk::Image::Pointer slice = slicer->GetOutput();
 
     // Get TestPoiont3D as Index in Slice
     slice->GetGeometry()->WorldToIndex(testPoint3DInWorld,testPoint2DInIndex);
 
 
     mitk::Point3D p, sliceIndexToWorld, imageIndexToWorld;
     p[0] = testPoint2DInIndex[0];
     p[1] = testPoint2DInIndex[1];
     p[2] = testPoint2DInIndex[2];
     slice->GetGeometry()->IndexToWorld(p, sliceIndexToWorld);
 
     p[0] = testPoint3DInIndex[0];
     p[1] = testPoint3DInIndex[1];
     p[2] = testPoint3DInIndex[2];
     imageInMitk->GetGeometry()->IndexToWorld(p, imageIndexToWorld);
 
 
 
     //compare the pixelvalues of the defined point in the 3D volume with the value of the resliced image
     unsigned short valueAt3DVolume = imageInMitk->GetPixelValueByIndex(testPoint3DInIndex);//image->GetPixel(testPoint3DInIndex);
     //unsigned short valueAt3DVolumeByWorld = imageInMitk->GetPixelValueByWorldCoordinate(testPoint3DInWorld);
     unsigned short valueAtSlice = slice->GetPixelValueByIndex(testPoint2DInIndex);
 
     //valueAt3DVolume == valueAtSlice is not always working. because of rounding errors
     //indices are shifted
     MITK_TEST_CONDITION(valueAt3DVolume == valueAtSlice, "comparing pixelvalues for orthogonal plane");
 
 
     vtkSmartPointer<vtkImageData> imageInVtk = vtkSmartPointer<vtkImageData>::New();
     imageInVtk = imageInMitk->GetVtkImageData();
     vtkSmartPointer<vtkImageData> sliceInVtk = vtkSmartPointer<vtkImageData>::New();
     sliceInVtk = slice->GetVtkImageData();
 
     double PixelvalueByMitkOutput = sliceInVtk->GetScalarComponentAsDouble(n1, n2, 0, 0);
     //double valueVTKinImage = imageInVtk->GetScalarComponentAsDouble(testPoint3DInIndex[0], testPoint3DInIndex[1], testPoint3DInIndex[2], 0);
 
 
     /* Test that everything is working equally if vtkoutput is used instead of the default output
      * from mitk ImageToImageFilter
      */
     mitk::ExtractSliceFilter::Pointer slicerWithVtkOutput = mitk::ExtractSliceFilter::New();
     slicerWithVtkOutput->SetInput(imageInMitk);
     slicerWithVtkOutput->SetWorldGeometry(plane);
     slicerWithVtkOutput->SetVtkOutputRequest(true);
 
     slicerWithVtkOutput->Update();
     vtkSmartPointer<vtkImageData> vtkImageByVtkOutput = vtkSmartPointer<vtkImageData>::New();
     vtkImageByVtkOutput = slicerWithVtkOutput->GetVtkOutput();
     double PixelvalueByVtkOutput = vtkImageByVtkOutput->GetScalarComponentAsDouble(n1, n2, 0, 0);
 
     MITK_TEST_CONDITION(PixelvalueByMitkOutput == PixelvalueByVtkOutput, "testing convertion of image output vtk->mitk by reslicer");
 
 
 
 /*================ mbilog outputs ===========================*/
 #ifdef EXTRACTOR_DEBUG
     MITK_INFO << "\n" << "TESTINFO index: " << sliceindex << " orientation: " << orientation << " frontside: " << isFrontside << " rotated: " << isRotated;
     MITK_INFO << "\n" << "slice index to world: " << sliceIndexToWorld;
     MITK_INFO << "\n" << "image index to world: "  << imageIndexToWorld;
 
     MITK_INFO  << "\n" << "vtk: slice: " << PixelvalueByMitkOutput << ", image: "<< valueVTKinImage;
 
     MITK_INFO << "\n" << "testPoint3D InWorld" << testPoint3DInWorld << " is " << testPoint2DInIndex << " in 2D";
     MITK_INFO << "\n" << "randoms: " << ((int)n1) << ", " << ((int)n2);
     MITK_INFO << "\n" << "point is inside plane: " << plane->IsInside(testPoint3DInWorld) << " and volume: " << imageInMitk->GetGeometry()->IsInside(testPoint3DInWorld);
 
     MITK_INFO << "\n" << "volume idx: " << testPoint3DInIndex << " = " << valueAt3DVolume ;
     MITK_INFO << "\n" << "volume world: " << testPoint3DInWorld << " = " << valueAt3DVolumeByWorld ;
     MITK_INFO << "\n" << "slice idx: " << testPoint2DInIndex << " = " << valueAtSlice ;
 
     mitk::Index3D curr;
     curr[0] = curr[1] = curr[2] = 0;
 
     for( int i = 0; i < 32 ; ++i){
       for( int j = 0; j < 32; ++j){
         ++curr[1];
         if(slice->GetPixelValueByIndex(curr) == valueAt3DVolume){
           MITK_INFO << "\n" << valueAt3DVolume << " MATCHED mitk " << curr;
         }
       }
       curr[1] = 0;
       ++curr[0];
     }
 
     typedef itk::Image<unsigned short, 2> Image2DType;
 
     Image2DType::Pointer img  = Image2DType::New();
     CastToItkImage(slice, img);
     typedef itk::ImageRegionConstIterator< Image2DType > Iterator2D;
 
     Iterator2D iter(img, img->GetLargestPossibleRegion());
     iter.GoToBegin();
     while( !iter.IsAtEnd() ){
 
       if(img->GetPixel(iter.GetIndex()) == valueAt3DVolume) MITK_INFO << "\n" << valueAt3DVolume << " MATCHED itk " << iter.GetIndex();
 
       ++iter;
     }
 #endif //EXTRACTOR_DEBUG
   }
 
 
   /* random a float value */
   static float randFloat(){ return (((float)rand()+1.0) / ((float)RAND_MAX + 1.0)) + (((float)rand()+1.0) / ((float)RAND_MAX + 1.0)) / ((float)RAND_MAX + 1.0);}
 
 
 
 
   /* create a sphere with the size of the given testVolumeSize*/
   static void InitializeTestVolume()
   {
 
   #ifdef CREATE_VOLUME
 
 
     //do sphere creation
     ItkVolumeGeneration();
 
     #ifdef SAVE_VOLUME
       //save in file
       mitk::ImageWriter::Pointer writer = mitk::ImageWriter::New();
       writer->SetInput(TestVolume);
 
 
       std::string file;
 
       std::ostringstream filename;
       filename << "C:\\home\\schroedt\\MITK\\Modules\\ImageExtraction\\Testing\\Data\\sphere_";
       filename << TestvolumeSize;
       filename << ".nrrd";
 
       file = filename.str();
 
       writer->SetFileName(file);
       writer->Update();
     #endif//SAVE_VOLUME
 
   #endif
 
 
   #ifndef CREATE_VOLUME //read from file
 
     mitk::StandardFileLocations::Pointer locator = mitk::StandardFileLocations::GetInstance();
 
     std::string filename = locator->FindFile("sphere_512.nrrd.mhd", "Modules/ImageExtraction/Testing/Data");
 
     mitk::ItkImageFileReader::Pointer reader = mitk::ItkImageFileReader::New();
     reader->SetFileName(filename);
 
     reader->Update();
     TestVolume = reader->GetOutput();
 
   #endif
 
   #ifdef CALC_TESTFAILURE_DEVIATION
     //get the TestFailureDeviation in %
     AccessFixedDimensionByItk(TestVolume, CalcTestFailureDeviation, 3);
   #endif
   }
 
 
   //the test result of the sphere reslice
   struct SliceProperties{
     double planeDistanceToSphereCenter;
     double diameterInMM;
     double diameterInPixel;
     double diameterCalculated;
     double percentageRadiusToPixel;
     double areaCalculated;
     double areaInPixel;
     double percentageAreaCalcToPixel;
   };
 
 
   static mitk::Image::Pointer TestVolume;
   static double TestvolumeSize;
   static mitk::PlaneGeometry::Pointer TestPlane;
   static std::string TestName;
   static unsigned char pixelValueSet;
   static SliceProperties testResults;
   static double TestFailureDeviation;
 
 
 
 private:
 
   /*
    * Generate a sphere with a radius of TestvolumeSize / 4.0
    */
   static void ItkVolumeGeneration ()
   {
     typedef itk::Image<unsigned char, 3> TestVolumeType;
 
     typedef itk::ImageRegionConstIterator< TestVolumeType > ImageIterator;
 
     TestVolumeType::Pointer sphereImage = TestVolumeType::New();
 
     TestVolumeType::IndexType start;
     start[0] = start[1] = start[2] = 0;
 
     TestVolumeType::SizeType size;
     size[0] = size[1] = size[2] = TestvolumeSize;
 
     TestVolumeType::RegionType imgRegion;
     imgRegion.SetSize(size);
     imgRegion.SetIndex(start);
 
     sphereImage->SetRegions(imgRegion);
     sphereImage->SetSpacing(1.0);
     sphereImage->Allocate();
 
     sphereImage->FillBuffer(0);
 
 
     mitk::Vector3D center;
     center[0] = center[1] = center[2] = TestvolumeSize / 2.0;
 
 
     double radius = TestvolumeSize / 4.0;
 
     double pixelValue = pixelValueSet;
 
     double distanceToCenter = 0.0;
 
 
     ImageIterator imageIterator( sphereImage, sphereImage->GetLargestPossibleRegion() );
     imageIterator.GoToBegin();
 
 
     mitk::Vector3D currentVoxelInIndex;
 
     while ( !imageIterator.IsAtEnd() )
     {
       currentVoxelInIndex[0] = imageIterator.GetIndex()[0];
       currentVoxelInIndex[1] = imageIterator.GetIndex()[1];
       currentVoxelInIndex[2] = imageIterator.GetIndex()[2];
 
       distanceToCenter = (center + ( currentVoxelInIndex * -1.0 )).GetNorm();
 
       //if distance to center is smaller then the radius of the sphere
       if( distanceToCenter < radius)
       {
         sphereImage->SetPixel(imageIterator.GetIndex(), pixelValue);
       }
 
       ++imageIterator;
     }
 
     CastToMitkImage(sphereImage, TestVolume);
   }
 
 
 
 
 
   /* calculate the devation of the voxel object to the mathematical sphere object.
    * this is use to make a statement about the accuracy of the resliced image, eg. the circle's diameter or area.
    */
   template<typename TPixel, unsigned int VImageDimension>
   static void CalcTestFailureDeviation (itk::Image<TPixel, VImageDimension>* inputImage)
   {
     typedef itk::Image<TPixel, VImageDimension> InputImageType;
     typedef itk::ImageRegionConstIterator< InputImageType > ImageIterator;
 
     ImageIterator iterator(inputImage, inputImage->GetLargestPossibleRegion());
     iterator.GoToBegin();
 
     int volumeInPixel = 0;
 
     while( !iterator.IsAtEnd() )
     {
       if(inputImage->GetPixel(iterator.GetIndex()) == pixelValueSet) volumeInPixel++;
       ++iterator;
     }
 
     double diameter  = TestvolumeSize / 2.0;
     double volumeCalculated = (1.0 / 6.0) * 3.14159265358979 * std::pow(diameter, 3);
 
 
     double volumeDeviation = std::abs( 100 - (100 / volumeCalculated * volumeInPixel) );
 
 
     typename InputImageType::IndexType index;
     index[0] = index[1] =  TestvolumeSize / 2.0;
     index[2] = 0;
 
     int sumpixels = 0;
     while (index[2] < TestvolumeSize )
     {
       if(inputImage->GetPixel(index) == pixelValueSet) sumpixels++;
       index[2] += 1;
     }
 
 
     double diameterDeviation = std::abs( 100 - (100 / diameter * sumpixels) );
   #ifdef DEBUG
     MITK_INFO << "volume deviation: " << volumeDeviation << " diameter deviation:" << diameterDeviation;
   #endif
     mitkExtractSliceFilterTestClass::TestFailureDeviation = (volumeDeviation + diameterDeviation) / 2.0;
   }
 
 
 };
 /*================ #END class ================*/
 
 
 
 
 
 /*================#BEGIN Instanciation of members ================*/
 mitk::Image::Pointer mitkExtractSliceFilterTestClass::TestVolume = mitk::Image::New();
 double mitkExtractSliceFilterTestClass::TestvolumeSize = 256.0;
 mitk::PlaneGeometry::Pointer mitkExtractSliceFilterTestClass::TestPlane = mitk::PlaneGeometry::New();
 std::string mitkExtractSliceFilterTestClass::TestName = "";
 unsigned char mitkExtractSliceFilterTestClass::pixelValueSet = 255;
 mitkExtractSliceFilterTestClass::SliceProperties mitkExtractSliceFilterTestClass::testResults = {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0};
 double mitkExtractSliceFilterTestClass::TestFailureDeviation = 0.0;
 /*================ #END Instanciation of members ================*/
 
 
 
 
 
 /*================ #BEGIN test main ================*/
 int mitkExtractSliceFilterTest(int argc, char* argv[])
 {
 
   MITK_TEST_BEGIN("mitkExtractSliceFilterTest")
 
 
   //pixelvalue based testing
   mitkExtractSliceFilterTestClass::PixelvalueBasedTest();
 
   //initialize sphere test volume
   mitkExtractSliceFilterTestClass::InitializeTestVolume();
 
 
   mitk::Vector3D spacing = mitkExtractSliceFilterTestClass::TestVolume->GetGeometry()->GetSpacing();
 
 
   //the center of the sphere = center of image
   double sphereCenter = mitkExtractSliceFilterTestClass::TestvolumeSize / 2.0;
 
   double planeSize = mitkExtractSliceFilterTestClass::TestvolumeSize;
 
 
 
   /* axial plane */
   mitk::PlaneGeometry::Pointer geometryAxial = mitk::PlaneGeometry::New();
         geometryAxial->InitializeStandardPlane(planeSize, planeSize, spacing, mitk::PlaneGeometry::Axial, sphereCenter, false, true);
   geometryAxial->ChangeImageGeometryConsideringOriginOffset(true);
 
   mitk::Point3D origin = geometryAxial->GetOrigin();
   mitk::Vector3D normal;
   normal = geometryAxial->GetNormal();
 
 
   normal.Normalize();
 
   origin += normal * 0.5;//pixelspacing is 1, so half the spacing is 0.5
 
   //geometryAxial->SetOrigin(origin);
 
   mitkExtractSliceFilterTestClass::TestSlice(geometryAxial, "Testing axial plane");
   /* end axial plane */
 
 
 
   /* sagittal plane */
   mitk::PlaneGeometry::Pointer geometrySagital = mitk::PlaneGeometry::New();
   geometrySagital->InitializeStandardPlane(planeSize, planeSize, spacing, mitk::PlaneGeometry::Sagittal, sphereCenter, true, false);
   geometrySagital->ChangeImageGeometryConsideringOriginOffset(true);
 
   origin = geometrySagital->GetOrigin();
   normal = geometrySagital->GetNormal();
 
 
   normal.Normalize();
 
   origin += normal * 0.5;//pixelspacing is 1, so half the spacing is 0.5
 
   //geometrySagital->SetOrigin(origin);
 
   mitkExtractSliceFilterTestClass::TestSlice(geometrySagital, "Testing sagittal plane");
   /* sagittal plane */
 
 
 
   /* sagittal shifted plane */
   mitk::PlaneGeometry::Pointer geometrySagitalShifted = mitk::PlaneGeometry::New();
   geometrySagitalShifted->InitializeStandardPlane(planeSize, planeSize, spacing, mitk::PlaneGeometry::Sagittal, (sphereCenter - 14), true, false);
   geometrySagitalShifted->ChangeImageGeometryConsideringOriginOffset(true);
 
   origin = geometrySagitalShifted->GetOrigin();
   normal = geometrySagitalShifted->GetNormal();
 
 
   normal.Normalize();
 
   origin += normal * 0.5;//pixelspacing is 1, so half the spacing is 0.5
 
   //geometrySagitalShifted->SetOrigin(origin);
 
   mitkExtractSliceFilterTestClass::TestSlice(geometrySagitalShifted, "Testing sagittal plane shifted");
   /* end sagittal shifted plane */
 
 
 
   /* coronal plane */
   mitk::PlaneGeometry::Pointer geometryCoronal = mitk::PlaneGeometry::New();
   geometryCoronal->InitializeStandardPlane(planeSize, planeSize, spacing, mitk::PlaneGeometry::Frontal, sphereCenter, true, false);
   geometryCoronal->ChangeImageGeometryConsideringOriginOffset(true);
 
   origin = geometryCoronal->GetOrigin();
   normal = geometryCoronal->GetNormal();
 
 
   normal.Normalize();
 
   origin += normal * 0.5;//pixelspacing is 1, so half the spacing is 0.5
 
   //geometryCoronal->SetOrigin(origin);
 
   mitkExtractSliceFilterTestClass::TestSlice(geometryCoronal, "Testing coronal plane");
   /* end coronal plane */
 
 
 
   /* oblique plane */
   mitk::PlaneGeometry::Pointer obliquePlane = mitk::PlaneGeometry::New();
   obliquePlane->InitializeStandardPlane(planeSize, planeSize, spacing, mitk::PlaneGeometry::Sagittal, sphereCenter, true, false);
   obliquePlane->ChangeImageGeometryConsideringOriginOffset(true);
 
   origin = obliquePlane->GetOrigin();
   normal = obliquePlane->GetNormal();
 
 
   normal.Normalize();
 
   origin += normal * 0.5;//pixelspacing is 1, so half the spacing is 0.5
 
   //obliquePlane->SetOrigin(origin);
 
   mitk::Vector3D rotationVector;
   rotationVector[0] = 0.2;
   rotationVector[1] = 0.4;
   rotationVector[2] = 0.62;
 
   float degree = 37.0;
 
   mitk::RotationOperation* op = new mitk::RotationOperation(mitk::OpROTATE, obliquePlane->GetCenter(), rotationVector, degree);
   obliquePlane->ExecuteOperation(op);
   delete op;
 
   mitkExtractSliceFilterTestClass::TestSlice(obliquePlane, "Testing oblique plane");
   /* end oblique plane */
 
 
 
   #ifdef SHOW_SLICE_IN_RENDER_WINDOW
     /*================ #BEGIN vtk render code ================*/
 
     //set reslicer for renderwindow
     mitk::ItkImageFileReader::Pointer reader = mitk::ItkImageFileReader::New();
 
     std::string filename =  "C:\\home\\Pics\\Pic3D.nrrd";
     reader->SetFileName(filename);
 
     reader->Update();
 
     mitk::Image::Pointer pic = reader->GetOutput();
     vtkSmartPointer<vtkImageReslice> slicer = vtkSmartPointer<vtkImageReslice>::New();
 
     slicer->SetInput(pic->GetVtkImageData());
 
 
     mitk::PlaneGeometry::Pointer obliquePl = mitk::PlaneGeometry::New();
                 obliquePl->InitializeStandardPlane(pic->GetGeometry(), mitk::PlaneGeometry::Sagittal, pic->GetGeometry()->GetCenter()[0], true, false);
     obliquePl->ChangeImageGeometryConsideringOriginOffset(true);
 
                mitk::Point3D origin2 = obliquePl->GetOrigin();
     mitk::Vector3D n;
     n = obliquePl->GetNormal();
 
 
     n.Normalize();
 
                 origin2 += n * 0.5;//pixelspacing is 1, so half the spacing is 0.5
 
                 obliquePl->SetOrigin(origin2);
 
     mitk::Vector3D rotation;
     rotation[0] = 0.534307;
     rotation[1] = 0.000439605;
     rotation[2] = 0.423017;
     MITK_INFO << rotation;
 
     float rotateDegree = 70;
 
     mitk::RotationOperation* operation = new mitk::RotationOperation(mitk::OpROTATE, obliquePl->GetCenter(), rotationVector, degree);
     obliquePl->ExecuteOperation(operation);
     delete operation;
 
 
     double origin[3];
     origin[0] = obliquePl->GetOrigin()[0];
     origin[1] = obliquePl->GetOrigin()[1];
     origin[2] = obliquePl->GetOrigin()[2];
     slicer->SetResliceAxesOrigin(origin);
 
 
     mitk::Vector3D right, bottom, normal;
     right  = obliquePl->GetAxisVector( 0 );
     bottom = obliquePl->GetAxisVector( 1 );
     normal = obliquePl->GetNormal();
 
     right.Normalize();
     bottom.Normalize();
     normal.Normalize();
 
     double cosines[9];
 
     mitk::vnl2vtk(right.GetVnlVector(), cosines);//x
 
     mitk::vnl2vtk(bottom.GetVnlVector(), cosines + 3);//y
 
     mitk::vnl2vtk(normal.GetVnlVector(), cosines + 6);//n
 
     slicer->SetResliceAxesDirectionCosines(cosines);
 
     slicer->SetOutputDimensionality(2);
     slicer->Update();
 
 
     //set vtk renderwindow
     vtkSmartPointer<vtkPlaneSource> vtkPlane = vtkSmartPointer<vtkPlaneSource>::New();
     vtkPlane->SetOrigin(0.0, 0.0, 0.0);
 
     //These two points define the axes of the plane in combination with the origin.
     //Point 1 is the x-axis and point 2 the y-axis.
     //Each plane is transformed according to the view (axial, coronal and saggital) afterwards.
     vtkPlane->SetPoint1(1.0, 0.0, 0.0); //P1: (xMax, yMin, depth)
     vtkPlane->SetPoint2(0.0, 1.0, 0.0); //P2: (xMin, yMax, depth)
     //these are not the correct values for all slices, only a square plane by now
 
     vtkSmartPointer<vtkPolyDataMapper> imageMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     imageMapper->SetInputConnection(vtkPlane->GetOutputPort());
 
 
     vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
 
     //built a default lookuptable
     lookupTable->SetRampToLinear();
     lookupTable->SetSaturationRange( 0.0, 0.0 );
     lookupTable->SetHueRange( 0.0, 0.0 );
     lookupTable->SetValueRange( 0.0, 1.0 );
     lookupTable->Build();
     //map all black values to transparent
     lookupTable->SetTableValue(0, 0.0, 0.0, 0.0, 0.0);
     lookupTable->SetRange(-255.0, 255.0);
     //lookupTable->SetRange(-1022.0, 1184.0);//pic3D range
 
     vtkSmartPointer<vtkTexture> texture = vtkSmartPointer<vtkTexture>::New();
 
 
     texture->SetInput(slicer->GetOutput());
 
     texture->SetLookupTable(lookupTable);
 
     texture->SetMapColorScalarsThroughLookupTable(true);
 
     vtkSmartPointer<vtkActor> imageActor = vtkSmartPointer<vtkActor>::New();
     imageActor->SetMapper(imageMapper);
     imageActor->SetTexture(texture);
 
 
     // Setup renderers
     vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();
     renderer->AddActor(imageActor);
 
     // Setup render window
     vtkSmartPointer<vtkRenderWindow> renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
     renderWindow->AddRenderer(renderer);
 
     // Setup render window interactor
     vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor = vtkSmartPointer<vtkRenderWindowInteractor>::New();
     vtkSmartPointer<vtkInteractorStyleImage> style = vtkSmartPointer<vtkInteractorStyleImage>::New();
     renderWindowInteractor->SetInteractorStyle(style);
 
     // Render and start interaction
     renderWindowInteractor->SetRenderWindow(renderWindow);
     //renderer->AddViewProp(imageActor);
 
 
     renderWindow->Render();
     renderWindowInteractor->Start();
     // always end with this!
     /*================ #END vtk render code ================*/
   #endif //SHOW_SLICE_IN_RENDER_WINDOW
 
 
   MITK_TEST_END()
 }
diff --git a/Core/Code/Testing/mitkTypeConversionTest.cpp b/Core/Code/Testing/mitkTypeConversionTest.cpp
new file mode 100644
index 0000000000..43167954ab
--- /dev/null
+++ b/Core/Code/Testing/mitkTypeConversionTest.cpp
@@ -0,0 +1,134 @@
+/*===================================================================
+
+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 "mitkTestingMacros.h"
+#include "mitkVector.h"
+#include "itkPoint.h"
+#include "vtkPoints.h"
+#include "vtkSmartPointer.h"
+#include "vnl/vnl_vector_ref.h"
+
+#include <iostream>
+
+using namespace mitk;
+
+static mitk::Point3D         point3D;
+static itk::Point<ScalarType, 3> itkPoint3D;
+
+static vtkSmartPointer<vtkPoints>   a_vtkPoints = vtkSmartPointer<vtkPoints>::New();
+
+//static vnl_vector_fixed<ScalarType, 3> vnl_vector;
+
+static void Setup(void)
+{
+  const ScalarType  mitkValues[]= {1.0, 2.0, 3.0}; /* the values for the mitk point */
+  const double  othersValues[]  = {4.0, 5.0, 6.0}; /* the values for all other data representations */
+
+  point3D    = mitkValues;
+  itkPoint3D = othersValues;
+
+  a_vtkPoints->Initialize();
+  a_vtkPoints->InsertNextPoint(othersValues);
+
+
+  //vnl_vector.copy_in(othersValues2);
+}
+
+static void Test_Mitk2Itk_PointCompatibility()
+{
+  Setup();
+  const itk::Point<ScalarType, 3> copiedPoint = point3D;
+
+  MITK_TEST_CONDITION(
+       Equal(copiedPoint[0], point3D[0])
+    && Equal(copiedPoint[1], point3D[1])
+    && Equal(copiedPoint[2], point3D[2]), "mitk point assigned to itk point")
+}
+
+static void Test_Itk2Mitk_PointCompatibility()
+{
+  Setup();
+
+  const mitk::Point3D copiedPoint = itkPoint3D;
+
+  MITK_TEST_CONDITION(
+       Equal(copiedPoint[0], itkPoint3D[0])
+    && Equal(copiedPoint[1], itkPoint3D[1])
+    && Equal(copiedPoint[2], itkPoint3D[2]), "itk point assigned to mitk point")
+}
+
+
+
+static void Test_Vtk2Mitk_PointCompatibility()
+{
+  Setup();
+
+  double vtkPoint[3];
+  a_vtkPoints->GetPoint(0, vtkPoint);
+
+  //mitk::Point3D copiedPoint = vtkPoint;
+
+  MITK_TEST_CONDITION(false, "this test is passed if there is no compile error in this method when not commented out :)")
+}
+
+static void Test_Vnl2Mitk_PointCompatibility()
+{
+  Setup();
+
+  Point3D copiedPoint;
+
+  //  copiedPoint = vnl2mitk(vnl_vector);
+
+  //MITK_TEST_CONDITION(
+  //     Equal(copiedPoint[0], static_cast<ScalarType>(vnl_vector[0]))
+  //  && Equal(copiedPoint[1], static_cast<ScalarType>(vnl_vector[1]))
+  //  && Equal(copiedPoint[2], static_cast<ScalarType>(vnl_vector[2])), "vnl point assigned to mitk point")
+}
+
+static void Test_Mitk2Vnl_PointCompatibility()
+{
+  Setup();
+
+  //vnl_vector_fixed<ScalarType, 3> copiedPoint;
+
+  //  copiedPoint = mitk2vnl(point3D);
+
+  //MITK_TEST_CONDITION(
+  //     Equal(static_cast<ScalarType>(copiedPoint[0]), point3D[0])
+  //  && Equal(static_cast<ScalarType>(copiedPoint[1]), point3D[1])
+  //  && Equal(static_cast<ScalarType>(copiedPoint[2]), point3D[2]), "mitk point assigned to vnl point")
+}
+
+/**
+ * Test the conversions from and to mitk types
+ */
+int mitkTypeConversionTest(int /*argc*/ , char* /*argv*/[])
+{
+  // always start with this!
+  MITK_TEST_BEGIN("TypeConversionTest")
+
+  Test_Mitk2Itk_PointCompatibility();
+  Test_Itk2Mitk_PointCompatibility();
+
+  Test_Vtk2Mitk_PointCompatibility();
+
+  Test_Vnl2Mitk_PointCompatibility();
+  Test_Mitk2Vnl_PointCompatibility();
+
+  MITK_TEST_END()
+
+}
diff --git a/Core/Code/DataManagement/mitkVector.cpp b/Core/Code/Testing/mitkTypeOperationTest.cpp
similarity index 51%
copy from Core/Code/DataManagement/mitkVector.cpp
copy to Core/Code/Testing/mitkTypeOperationTest.cpp
index 8a75c8cc09..f28030d2f8 100644
--- a/Core/Code/DataManagement/mitkVector.cpp
+++ b/Core/Code/Testing/mitkTypeOperationTest.cpp
@@ -1,23 +1,50 @@
 /*===================================================================
 
 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 "mitkTestingMacros.h"
 #include "mitkVector.h"
-#include <vtkSystemIncludes.h>
-#include <vtkMatrix4x4.h>
 
-const mitk::ScalarType mitk::eps     = vnl_math::float_eps*100;
-const mitk::ScalarType mitk::sqrteps = vnl_math::float_sqrteps;
-extern const double mitk::large      = VTK_LARGE_FLOAT;
+#include <iostream>
+
+using namespace mitk;
+
+Point3D a, b, c;
+
+static void Setup(void)
+{
+
+}
+
+static void TestAddition(void)
+{
+  Setup();
+
+  // c = a + b;
+
+  MITK_TEST_CONDITION_REQUIRED(false, "this test is passed if there is no compile error in this method when not commented out :)")
+}
+
+int mitkTypeOperationTest(int /*argc*/ , char* /*argv*/[])
+{
+  // always start with this!
+  MITK_TEST_BEGIN("TypeOperationTest")
+
+  TestAddition();
+
+  MITK_TEST_END()
+
+}
diff --git a/Core/Code/Testing/mitkVectorTest.cpp b/Core/Code/Testing/mitkVectorTest.cpp
index f5ed207d5c..cfe371615a 100644
--- a/Core/Code/Testing/mitkVectorTest.cpp
+++ b/Core/Code/Testing/mitkVectorTest.cpp
@@ -1,137 +1,137 @@
 /*===================================================================
 
 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 <mitkTestingMacros.h>
 #include <mitkVector.h>
 
 int mitkVectorTest(int /*argc*/, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("mitkVector");
   // test itk vector equality methods
-  itk::Vector<float,3> itkVector_1;
+  itk::Vector<mitk::ScalarType,3> itkVector_1;
   itkVector_1[0] = 4.6;
   itkVector_1[1] = 9.76543;
   itkVector_1[2] = 746.09;
 
-  itk::Vector<float,3> itkVector_2;
-  itk::Vector<float,3> itkVector_3;
+  itk::Vector<mitk::ScalarType,3> itkVector_2;
+  itk::Vector<mitk::ScalarType,3> itkVector_3;
   for (int i=0; i<3; i++)
   {
     itkVector_2[i] = itkVector_1[i] - mitk::eps*1.1;
     itkVector_3[i] = itkVector_1[i] - mitk::eps*0.9;
   }
 
   MITK_TEST_CONDITION(mitk::Equal(itkVector_1,itkVector_1), "Test vector equality using the same vector with mitk::eps");
   MITK_TEST_CONDITION(!mitk::Equal(itkVector_1,itkVector_2), "Test vector equality using different vectors with an element-wise difference greater than mitk::eps");
-  MITK_TEST_CONDITION( mitk::Equal(itkVector_1, itkVector_2, mitk::eps*1.2f), "Vectors are equal for higher epsilon tolerance ( 1.2 * mitk::eps )");
+  MITK_TEST_CONDITION( mitk::Equal(itkVector_1, itkVector_2, mitk::eps*1.2), "Vectors are equal for higher epsilon tolerance ( 1.2 * mitk::eps )");
   MITK_TEST_CONDITION(mitk::Equal(itkVector_1,itkVector_3), "Test vector equality using different vectors with an element-wise difference less than mitk::eps");
   // test itk point equality methods
-  itk::Point<float,3> itkPoint_1;
-  itk::Point<float,3> itkPoint_2;
-  itk::Point<float,3> itkPoint_3;
+  itk::Point<mitk::ScalarType,3> itkPoint_1;
+  itk::Point<mitk::ScalarType,3> itkPoint_2;
+  itk::Point<mitk::ScalarType,3> itkPoint_3;
   for (int i=0; i<3; i++)
   {
     itkPoint_1[i] = itkVector_1[i];
     itkPoint_2[i] = itkVector_2[i];
     itkPoint_3[i] = itkVector_3[i];
   }
   MITK_TEST_CONDITION(mitk::Equal(itkPoint_1,itkPoint_1), "Test point equality using the same point with mitk::eps");
   MITK_TEST_CONDITION(!mitk::Equal(itkPoint_1,itkPoint_2), "Test point equality using different points with an element-wise difference greater than mitk::eps");
-  MITK_TEST_CONDITION( mitk::Equal(itkPoint_1, itkPoint_2, mitk::eps * 1.2f), "Points are equal for higher epsilon tolerance ( 1.2 * mitk::eps )");
+  MITK_TEST_CONDITION( mitk::Equal(itkPoint_1, itkPoint_2, mitk::eps * 1.2), "Points are equal for higher epsilon tolerance ( 1.2 * mitk::eps )");
   MITK_TEST_CONDITION(mitk::Equal(itkPoint_1,itkPoint_3), "Test point equality using different points with an element-wise difference less than mitk::eps");
   // test mitk vnl vector equality methods
   mitk::VnlVector mitk_vnl_vector_1(3);
   mitk::VnlVector mitk_vnl_vector_2(3);
   mitk::VnlVector mitk_vnl_vector_3(3);
   for (int i=0; i<3; i++)
   {
     mitk_vnl_vector_1.put(i,itkVector_1[i]);
     mitk_vnl_vector_2.put(i,itkVector_2[i]);
     mitk_vnl_vector_3.put(i,itkVector_1[i]);
   }
 
   MITK_TEST_CONDITION(mitk::Equal(mitk_vnl_vector_1,mitk_vnl_vector_1), "Test mitk vnl vector equality using the same mitk vnl vector with mitk::eps");
   MITK_TEST_CONDITION(!mitk::Equal(mitk_vnl_vector_1,mitk_vnl_vector_2), "Test mitk vnl vector equality using different mitk vnl vectors with an element-wise difference greater than mitk::eps");
   MITK_TEST_CONDITION( mitk::Equal(mitk_vnl_vector_1, mitk_vnl_vector_2, mitk::eps*1.2), "Vnl vectors are equal for higher epsilon tolerance ( 1.2 * mitk::eps )");
   MITK_TEST_CONDITION(mitk::Equal(mitk_vnl_vector_1,mitk_vnl_vector_3), "Test mitk vnl vector equality using different mitk vnl vectors with an element-wise difference less than mitk::eps");
 
   // test vnl_vector equality method
   typedef mitk::ScalarType VnlValueType;
   vnl_vector_fixed<VnlValueType,7> vnlVector_1;
   vnlVector_1[3] = 56.98;
   vnlVector_1[4] = 22.32;
   vnlVector_1[5] = 1.00;
   vnlVector_1[6] = 746.09;
   vnl_vector_fixed<VnlValueType,7> vnlVector_2;
   vnl_vector_fixed<VnlValueType,7> vnlVector_3;
   for (int i=0; i<7; i++)
   {
     if (i<3)
     {
       vnlVector_1.put(i,itkVector_1[i]);
     }
 
     vnlVector_2[i] = vnlVector_1[i] - mitk::eps * 1.1f;
     vnlVector_3[i] = vnlVector_1[i] - mitk::eps * 0.9f;
   }
 
   MITK_TEST_CONDITION( (mitk::Equal<VnlValueType, 7>(vnlVector_1,vnlVector_1)), "vnl_fixed : v_1 == v_1 ");
   // the v_2 is constructed so that the equality test fails for mitk::eps, the norm of the difference between the vectors is 7 * eps/6.9
   MITK_TEST_CONDITION(!(mitk::Equal<VnlValueType, 7>(vnlVector_1,vnlVector_2)), "vnl_fixed : v_1 != v_2 with mitk::eps ");
   // increase the epsilon value used for testing equality - should now pass  ( 1.2 * mitk::eps > 7 * mitk::eps/6.9 )
   MITK_TEST_CONDITION( (mitk::Equal<VnlValueType, 7>(vnlVector_1,vnlVector_2, mitk::eps*1.2f)) , "vnl_fixed : v_1 == v_2 with eps = 1.2 * mitk::eps ");
   MITK_TEST_CONDITION( (mitk::Equal<VnlValueType, 7>(vnlVector_1,vnlVector_3, mitk::eps)), "vnl_fixed : v_1 == v_3 with eps = 0.8 * mitk::eps ");
   MITK_TEST_CONDITION(!(mitk::Equal<VnlValueType, 7>(vnlVector_1,vnlVector_3, mitk::eps*0.8f)), "vnl_fixed : v_1 != v_3 with eps = 0.8 * mitk::eps ");
 
   // test scalar equality method
-  double scalar1 = 0.5689;
-  double scalar2 = scalar1 + mitk::eps;
-  double scalar3 = scalar1 + mitk::eps*0.95;
+  mitk::ScalarType scalar1 = 0.5689;
+  mitk::ScalarType scalar2 = scalar1 + mitk::eps;
+  mitk::ScalarType scalar3 = scalar1 + mitk::eps*0.95;
   MITK_TEST_CONDITION(mitk::Equal(scalar1,scalar1), "Test scalar equality using the same scalar with mitk::eps");
   MITK_TEST_CONDITION(!mitk::Equal(scalar1,scalar2), "Test scalar equality using the different scalars with a difference greater than mitk::eps");
   MITK_TEST_CONDITION(mitk::Equal(scalar1,scalar3), "Test scalar equality using the different scalars with a difference less than mitk::eps");
 
   // test matrix equality methods
   vnl_matrix_fixed<mitk::ScalarType,3,3> vnlMatrix3x3_1;
   vnlMatrix3x3_1(0,0) = 1.1;
   vnlMatrix3x3_1(0,1) = 0.4;
   vnlMatrix3x3_1(0,2) = 5.3;
   vnlMatrix3x3_1(1,0) = 2.7;
   vnlMatrix3x3_1(1,1) = 3578.56418;
   vnlMatrix3x3_1(1,2) = 123.56;
   vnlMatrix3x3_1(2,0) = 546.89;
   vnlMatrix3x3_1(2,1) = 0.0001;
   vnlMatrix3x3_1(2,2) = 1.0;
   vnl_matrix_fixed<mitk::ScalarType,3,3> vnlMatrix3x3_2;
   vnlMatrix3x3_2(0,0) = 1.1000009;
   vnlMatrix3x3_2(0,1) = 0.4000009;
   vnlMatrix3x3_2(0,2) = 5.3000009;
   vnlMatrix3x3_2(1,0) = 2.7000009;
   vnlMatrix3x3_2(1,1) = 3578.5641809;
   vnlMatrix3x3_2(1,2) = 123.5600009;
   vnlMatrix3x3_2(2,0) = 546.8900009;
   vnlMatrix3x3_2(2,1) = 0.0001009;
   vnlMatrix3x3_2(2,2) = 1.0000009;
 
   mitk::ScalarType epsilon = 0.000001;
   MITK_TEST_CONDITION(mitk::MatrixEqualElementWise(vnlMatrix3x3_1,vnlMatrix3x3_1,0.0),"Test for matrix equality with given epsilon=0.0 and exactly the same matrix elements");
   MITK_TEST_CONDITION(!mitk::MatrixEqualElementWise(vnlMatrix3x3_1,vnlMatrix3x3_2,0.0),"Test for matrix equality with given epsilon=0.0 and slightly different matrix elements");
   MITK_TEST_CONDITION(mitk::MatrixEqualElementWise(vnlMatrix3x3_1,vnlMatrix3x3_2,epsilon),"Test for matrix equality with given epsilon and slightly different matrix elements");
   MITK_TEST_CONDITION(!mitk::MatrixEqualRMS(vnlMatrix3x3_1,vnlMatrix3x3_2,0.0),"Test for matrix equality with given epsilon=0.0 and slightly different matrix elements");
   MITK_TEST_CONDITION(mitk::MatrixEqualRMS(vnlMatrix3x3_1,vnlMatrix3x3_2,epsilon),"Test for matrix equality with given epsilon and slightly different matrix elements");
 
   MITK_TEST_END();
 }
diff --git a/Modules/CameraCalibration/mitkCameraIntrinsics.cpp b/Modules/CameraCalibration/mitkCameraIntrinsics.cpp
index 6b3f8a1165..30e764f7b9 100644
--- a/Modules/CameraCalibration/mitkCameraIntrinsics.cpp
+++ b/Modules/CameraCalibration/mitkCameraIntrinsics.cpp
@@ -1,510 +1,510 @@
 /*===================================================================
 
 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 "mitkCameraIntrinsics.h"
 #include <itkMutexLockHolder.h>
 #include <mitkEndoMacros.h>
 #include <mitkEndoDebug.h>
 
 mitk::CameraIntrinsics::CameraIntrinsics()
   : m_Valid(false), m_Mutex(itk::FastMutexLock::New())
 {
   m_CameraMatrix = cv::Mat::zeros(3, 3, cv::DataType<double>::type);
   m_CameraMatrix.at<double>(2,2) = 1.0;
   m_DistorsionCoeffs = cv::Mat::zeros(1, 5, cv::DataType<double>::type);
 }
 
 mitk::CameraIntrinsics::CameraIntrinsics(const CameraIntrinsics& other)
   : itk::Object()
   , mitk::XMLSerializable()
   , m_Valid(false)
   , m_Mutex(itk::FastMutexLock::New())
 {
   this->Copy(&other);
 }
 
 mitk::CameraIntrinsics::~CameraIntrinsics()
 {
 
 }
 
 bool mitk::CameraIntrinsics::Equals( const CameraIntrinsics* other ) const
 {
   return other->GetDistorsionCoeffsAsPoint4D()==
       this->GetDistorsionCoeffsAsPoint4D() &&
     other->GetFocalPoint()==
       this->GetFocalPoint() &&
     other->GetPrincipalPoint()
       == this->GetPrincipalPoint();
 }
 
 void mitk::CameraIntrinsics::Copy(const CameraIntrinsics* other)
 {
   this->SetIntrinsics( other->GetCameraMatrix().clone()
     , other->GetDistorsionCoeffs().clone() );
   this->SetValid(other->m_Valid);
 }
 
 bool mitk::CameraIntrinsics::IsValid() const
 {
   itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
   return m_Valid;
 }
 
 vnl_matrix_fixed<mitk::ScalarType, 3, 3>
     mitk::CameraIntrinsics::GetVnlCameraMatrix() const
 {
   vnl_matrix_fixed<mitk::ScalarType, 3, 3> mat;
   mat.set_identity();
 
   {
     itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
     mat(0,0) = m_CameraMatrix.at<double>(0,0);
     mat(1,1) = m_CameraMatrix.at<double>(1,1);
 
     mat(0,2) = m_CameraMatrix.at<double>(0,2);
     mat(1,2) = m_CameraMatrix.at<double>(1,2);
   }
 
   return mat;
 }
 
 void mitk::CameraIntrinsics::SetCameraMatrix(
     const vnl_matrix_fixed<mitk::ScalarType, 3, 3>& _CameraMatrix )
 {
   itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
   m_CameraMatrix.at<double>(0,0) = _CameraMatrix(0,0);
   m_CameraMatrix.at<double>(1,1) = _CameraMatrix(1,1);
 
   m_CameraMatrix.at<double>(0,2) = _CameraMatrix(0,2);
   m_CameraMatrix.at<double>(1,2) = _CameraMatrix(1,2);
 }
 
 vnl_matrix_fixed<mitk::ScalarType, 3, 4>
     mitk::CameraIntrinsics::GetVnlCameraMatrix3x4() const
 {
   vnl_matrix_fixed<mitk::ScalarType, 3, 4> mat;
   mat.fill(0);
   mat.update( this->GetVnlCameraMatrix().as_matrix() );
 
   return mat;
 }
 
 void mitk::CameraIntrinsics::SetIntrinsics( const cv::Mat& _CameraMatrix
                         , const cv::Mat& _DistorsionCoeffs)
 {
   {
     itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
     if( _CameraMatrix.cols != 3 || _CameraMatrix.rows != 3)
       throw std::invalid_argument("Wrong format of camera matrix. Should be 3x3"
                                   " double.");
 
     endoAssertMsg( (_DistorsionCoeffs.cols == 5) &&
       _DistorsionCoeffs.rows == 1, "Wrong format of distorsion coefficients"
                                   " vector. Should be 5x1 double.");
 
     m_CameraMatrix = _CameraMatrix.clone();
     m_DistorsionCoeffs = _DistorsionCoeffs.clone();
 
     m_Valid = true;
   }
   this->Modified();
 }
 
 void mitk::CameraIntrinsics::SetIntrinsics( const mitk::Point3D& focalPoint,
                     const mitk::Point3D& principalPoint,
                     const mitk::Point4D& distortionCoefficients)
 
 {
   {
     itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
     m_CameraMatrix.at<double>(0,0) = focalPoint[0];
     m_CameraMatrix.at<double>(1,1) = focalPoint[1];
 
     m_CameraMatrix.at<double>(0,2) = principalPoint[0];
     m_CameraMatrix.at<double>(1,2) = principalPoint[1];
 
     m_DistorsionCoeffs.at<double>(0,0) = distortionCoefficients[0];
     m_DistorsionCoeffs.at<double>(0,1) = distortionCoefficients[1];
     m_DistorsionCoeffs.at<double>(0,2) = distortionCoefficients[2];
     m_DistorsionCoeffs.at<double>(0,3) = distortionCoefficients[3];
   }
   this->Modified();
 }
 
 void mitk::CameraIntrinsics::SetFocalLength( double x, double y )
 {
   {
     itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
     m_CameraMatrix.at<double>(0,0) = x;
     m_CameraMatrix.at<double>(1,1) = y;
   }
   this->Modified();
 }
 
 void mitk::CameraIntrinsics::SetPrincipalPoint( double x, double y )
 {
   {
     itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
     m_CameraMatrix.at<double>(0,2) = x;
     m_CameraMatrix.at<double>(1,2) = y;
   }
   this->Modified();
 }
 
 void mitk::CameraIntrinsics::SetDistorsionCoeffs( double k1, double k2,
                                                  double p1, double p2 )
 {
 
   {
     itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
 
     m_DistorsionCoeffs.at<double>(0,0) = k1;
     m_DistorsionCoeffs.at<double>(0,1) = k2;
     m_DistorsionCoeffs.at<double>(0,2) = p1;
     m_DistorsionCoeffs.at<double>(0,3) = p2;
   }
   this->Modified();
 }
 
 cv::Mat mitk::CameraIntrinsics::GetCameraMatrix() const
 {
   itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
   return m_CameraMatrix.clone(); // return a copy of this small matrix
 }
 
 cv::Mat mitk::CameraIntrinsics::GetDistorsionCoeffs() const
 {
   itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
   return m_DistorsionCoeffs.clone(); // return a copy of this small matrix
 }
 
 cv::Mat mitk::CameraIntrinsics::GetDistorsionCoeffs()
 {
   const CameraIntrinsics* intrinsics = this;
   return intrinsics->GetDistorsionCoeffs();
 }
 
 std::string mitk::CameraIntrinsics::ToString() const
 {
   itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
   std::ostringstream s; s.precision(12);
   const cv::Mat& CameraMatrix = m_CameraMatrix;
   const cv::Mat& DistorsionCoeffs = m_DistorsionCoeffs;
 
   s.str(""); s << this->GetNameOfClass() << ": ";
   s << "fx = " << CameraMatrix.at<double>(0,0);
   s << ", fy = " << CameraMatrix.at<double>(1,1);
   s << ", cx = " << CameraMatrix.at<double>(0,2);
   s << ", cy = " << CameraMatrix.at<double>(1,2);
 
   s << ", k1 = " << DistorsionCoeffs.at<double>(0,0);
   s << ", k2 = " << DistorsionCoeffs.at<double>(0,1);
   s << ", p1 = " << DistorsionCoeffs.at<double>(0,2);
   s << ", p2 = " << DistorsionCoeffs.at<double>(0,3);
   //s << ", k3 = " << DistorsionCoeffs.at<double>(0,4);
 
   return s.str();
 }
 
 void mitk::CameraIntrinsics::ToXML(TiXmlElement* elem) const
 {
   itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
   elem->SetValue(this->GetNameOfClass());
   std::ostringstream s; s.precision(12);
   const cv::Mat& CameraMatrix = m_CameraMatrix;
   s.str(""); s << CameraMatrix.at<double>(0,0);
   elem->SetAttribute( "fx", s.str() );
   s.str(""); s << CameraMatrix.at<double>(1,1);
   elem->SetAttribute( "fy", s.str() );
   s.str(""); s << CameraMatrix.at<double>(0,2);
   elem->SetAttribute( "cx", s.str() );
   s.str(""); s << CameraMatrix.at<double>(1,2);
   elem->SetAttribute( "cy", s.str() );
 
   const cv::Mat& DistorsionCoeffs = m_DistorsionCoeffs;
   s.str(""); s << DistorsionCoeffs.at<double>(0,0);
   elem->SetAttribute( "k1", s.str() );
   s.str(""); s << DistorsionCoeffs.at<double>(0,1);
   elem->SetAttribute( "k2", s.str() );
   s.str(""); s << DistorsionCoeffs.at<double>(0,2);
   elem->SetAttribute( "p1", s.str() );
   s.str(""); s << DistorsionCoeffs.at<double>(0,3);
   elem->SetAttribute( "p2", s.str() );
   elem->SetAttribute("Valid", m_Valid);
   //s.str(""); s << DistorsionCoeffs.at<double>(4,0);
   //elem->SetAttribute( "k3", s.str() );
 }
 
 void mitk::CameraIntrinsics::FromGMLCalibrationXML(TiXmlElement* elem)
 {
   assert( elem );
   assert( elem->ValueStr() == "results" );
   cv::Mat CameraMatrix = cv::Mat::zeros(3, 3, cv::DataType<double>::type);
   CameraMatrix.at<double>(2,2) = 1.0;
   cv::Mat DistorsionCoeffs = cv::Mat::zeros(1, 5, cv::DataType<double>::type);
 
   TiXmlElement* focus_lenXElem = elem->FirstChildElement("focus_lenX");
   endoAssert( focus_lenXElem != 0 );
   CameraMatrix.at<double>(0,0) = atof( focus_lenXElem->GetText() );
 
   TiXmlElement* focus_lenYElem = elem->FirstChildElement("focus_lenY");
   endoAssert( focus_lenYElem != 0 );
   CameraMatrix.at<double>(1,1) = atof( focus_lenYElem->GetText() );
 
   TiXmlElement* PrincipalXElem = elem->FirstChildElement("PrincipalX");
   endoAssert( PrincipalXElem != 0 );
   CameraMatrix.at<double>(0,2) = atof( PrincipalXElem->GetText() );
 
   TiXmlElement* PrincipalYElem = elem->FirstChildElement("PrincipalY");
   endoAssert( PrincipalYElem != 0 );
   CameraMatrix.at<double>(1,2) = atof( PrincipalYElem->GetText() );
 
   // DISTORSION COEFFS
 
   TiXmlElement* Dist1Elem = elem->FirstChildElement("Dist1");
   endoAssert( Dist1Elem != 0 );
   DistorsionCoeffs.at<double>(0,0) = atof( Dist1Elem->GetText() );
 
   TiXmlElement* Dist2Elem = elem->FirstChildElement("Dist2");
   endoAssert( Dist2Elem != 0 );
   DistorsionCoeffs.at<double>(0,1) = atof( Dist2Elem->GetText() );
 
   TiXmlElement* Dist3Elem = elem->FirstChildElement("Dist3");
   endoAssert( Dist3Elem != 0 );
   DistorsionCoeffs.at<double>(0,2) = atof( Dist3Elem->GetText() );
 
   TiXmlElement* Dist4Elem = elem->FirstChildElement("Dist4");
   endoAssert( Dist4Elem != 0 );
   DistorsionCoeffs.at<double>(0,3) = atof( Dist4Elem->GetText() );
 
   int valid = 0;
   elem->QueryIntAttribute("Valid", &valid);
 
   {
     itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
     m_Valid = static_cast<bool>(valid);
     m_CameraMatrix = CameraMatrix;
     m_DistorsionCoeffs = DistorsionCoeffs;
   }
 
   this->Modified();
 }
 
 void mitk::CameraIntrinsics::FromXML(TiXmlElement* elem)
 {
   endoAssert ( elem );
   MITK_DEBUG << elem->Value();
   std::string filename;
   if(elem->QueryStringAttribute("file", &filename) == TIXML_SUCCESS)
   {
     this->FromXMLFile(filename);
     return;
   }
   else if(strcmp(elem->Value(), "CalibrationProject") == 0)
   {
     this->FromGMLCalibrationXML(elem->FirstChildElement("results"));
     return;
   }
 
   assert ( elem );
   if(strcmp(elem->Value(), this->GetNameOfClass()) != 0)
     elem = elem->FirstChildElement(this->GetNameOfClass());
 
   std::ostringstream err;
   // CAMERA MATRIX
   cv::Mat CameraMatrix = cv::Mat::zeros(3, 3, cv::DataType<double>::type);
   CameraMatrix.at<double>(2,2) = 1.0;
-  float val = 0.0f;
-  if(elem->QueryFloatAttribute("fx", &val) == TIXML_SUCCESS)
+  double val = 0.0;
+  if(elem->QueryDoubleAttribute("fx", &val) == TIXML_SUCCESS)
     CameraMatrix.at<double>(0,0) = val;
   else
     err << "fx, ";
 
-  if(elem->QueryFloatAttribute("fy", &val) == TIXML_SUCCESS)
+  if(elem->QueryDoubleAttribute("fy", &val) == TIXML_SUCCESS)
     CameraMatrix.at<double>(1,1) = val;
   else
     err << "fy, ";
 
-  if(elem->QueryFloatAttribute("cx", &val) == TIXML_SUCCESS)
+  if(elem->QueryDoubleAttribute("cx", &val) == TIXML_SUCCESS)
     CameraMatrix.at<double>(0,2) = val;
   else
     err << "cx, ";
 
-  if(elem->QueryFloatAttribute("cy", &val) == TIXML_SUCCESS)
+  if(elem->QueryDoubleAttribute("cy", &val) == TIXML_SUCCESS)
     CameraMatrix.at<double>(1,2) = val;
   else
     err << "cy, ";
 
   // DISTORSION COEFFS
   endodebug( "creating DistorsionCoeffs from XML file")
   cv::Mat DistorsionCoeffs = cv::Mat::zeros(1, 5, cv::DataType<double>::type);
-  if(elem->QueryFloatAttribute("k1", &val) == TIXML_SUCCESS)
+  if(elem->QueryDoubleAttribute("k1", &val) == TIXML_SUCCESS)
     DistorsionCoeffs.at<double>(0,0) = val;
   else
     err << "k1, ";
 
-  if(elem->QueryFloatAttribute("k2", &val) == TIXML_SUCCESS)
+  if(elem->QueryDoubleAttribute("k2", &val) == TIXML_SUCCESS)
     DistorsionCoeffs.at<double>(0,1) = val;
   else
     err << "k2, ";
 
-  if(elem->QueryFloatAttribute("p1", &val) == TIXML_SUCCESS)
+  if(elem->QueryDoubleAttribute("p1", &val) == TIXML_SUCCESS)
     DistorsionCoeffs.at<double>(0,2) = val;
   else
     err << "p1, ";
 
-  if(elem->QueryFloatAttribute("p2", &val) == TIXML_SUCCESS)
+  if(elem->QueryDoubleAttribute("p2", &val) == TIXML_SUCCESS)
     DistorsionCoeffs.at<double>(0,3) = val;
   else
     err << "p2, ";
 
   DistorsionCoeffs.at<double>(0,4) = 0.0;
 
-  /*if(elem->QueryFloatAttribute("k3", &val) == TIXML_SUCCESS)
+  /*if(elem->QueryDoubleAttribute("k3", &val) == TIXML_SUCCESS)
     DistorsionCoeffs.at<double>(4,0) = val;
   else
     err << "k3, ";*/
 
   std::string errorStr = err.str();
   int errLength = errorStr.length();
   if(errLength > 0)
   {
     errorStr = errorStr.substr(0, errLength-2);
     errorStr.append(" not found");
     throw std::invalid_argument(err.str());
   }
 
   int valid = 0;
   elem->QueryIntAttribute("Valid", &valid);
 
   {
     itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
     m_Valid = static_cast<bool>(valid);
     m_CameraMatrix = CameraMatrix;
     m_DistorsionCoeffs = DistorsionCoeffs;
   }
 
   this->Modified();
 }
 
 double mitk::CameraIntrinsics::GetFocalLengthX() const
 {
   itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
   double FocalLengthX = m_CameraMatrix.at<double>(0,0);
 
   return FocalLengthX;
 }
 double mitk::CameraIntrinsics::GetFocalLengthY() const
 {
   itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
   double FocalLengthY = m_CameraMatrix.at<double>(1,1);;
   return FocalLengthY;
 }
 double mitk::CameraIntrinsics::GetPrincipalPointX() const
 {
   itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
   double PrincipalPointX = m_CameraMatrix.at<double>(0,2);
   return PrincipalPointX;
 }
 double mitk::CameraIntrinsics::GetPrincipalPointY() const
 {
   itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
   double PrincipalPointY = m_CameraMatrix.at<double>(1,2);
   return PrincipalPointY;
 }
 mitk::Point4D mitk::CameraIntrinsics::GetDistorsionCoeffsAsPoint4D() const
 {
   itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
   mitk::Point4D coeffs;
 
   coeffs[0] = m_DistorsionCoeffs.at<double>(0,0);
   coeffs[1] = m_DistorsionCoeffs.at<double>(0,1);
   coeffs[2] = m_DistorsionCoeffs.at<double>(0,2);
   coeffs[3] = m_DistorsionCoeffs.at<double>(0,3);
 
   return coeffs;
 }
 
 mitk::Point3D mitk::CameraIntrinsics::GetFocalPoint() const
 {
   mitk::Point3D p;
   p[0] = this->GetFocalLengthX();
   p[1] = this->GetFocalLengthY();
   p[2] = 0;
   return p;
 }
 
 mitk::Point3D mitk::CameraIntrinsics::GetPrincipalPoint() const
 {
   mitk::Point3D p;
   p[0] = this->GetPrincipalPointX();
   p[1] = this->GetPrincipalPointY();
   p[2] = 0;
   return p;
 }
 
 vnl_vector_fixed<mitk::ScalarType, 2>
      mitk::CameraIntrinsics::GetFocalPointAsVnlVector() const
 {
   vnl_vector_fixed<mitk::ScalarType, 2> vec;
   vec[0] = this->GetFocalLengthX();
   vec[1] = this->GetFocalLengthY();
   return vec;
 }
 
 vnl_vector_fixed<mitk::ScalarType, 2>
      mitk::CameraIntrinsics::GetPrincipalPointAsVnlVector() const
 {
   vnl_vector_fixed<mitk::ScalarType, 2> vec;
   vec[0] = this->GetPrincipalPointX();
   vec[1] = this->GetPrincipalPointY();
   return vec;
 }
 
 std::ostream& operator<< (std::ostream& os, mitk::CameraIntrinsics::Pointer p)
 {
   os << p->ToString();
   return os;
 }
 
 std::string mitk::CameraIntrinsics::GetString()
 {
   return this->ToString();
 }
 
 std::string mitk::CameraIntrinsics::ToOctaveString(
     const std::string& varName)
 {
   std::ostringstream s;
   s << varName << " = [" << this->GetFocalLengthX() << " 0 "
       << this->GetPrincipalPointX() << "; 0 " <<
       this->GetFocalLengthY() << " " << this->GetPrincipalPointY() << ";"
       << " 0 0 1 ];";
   return s.str();
 }
 
 void mitk::CameraIntrinsics::SetValid( bool valid )
 {
   itk::MutexLockHolder<itk::FastMutexLock> lock(*m_Mutex);
   m_Valid = valid;
 }
 
 itk::LightObject::Pointer mitk::CameraIntrinsics::InternalClone() const
 {
   itk::LightObject::Pointer result(new Self(*this));
   return result;
 }
diff --git a/Modules/CameraCalibration/mitkTransform.cpp b/Modules/CameraCalibration/mitkTransform.cpp
index c0151ef3b7..db9d0ae9ee 100644
--- a/Modules/CameraCalibration/mitkTransform.cpp
+++ b/Modules/CameraCalibration/mitkTransform.cpp
@@ -1,749 +1,749 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #include "mitkTransform.h"
 #include <fstream>
 #include <vnl/vnl_inverse.h>
 #include <mitkVnlVectorFixedCaster.h>
 #include <mitkVnlVectorFromCvMat.h>
 #include <mitkVnlMatrixFromCvMat.h>
 #include <mitkCvMatFromVnlVector.h>
 namespace mitk
 {
   // DO NOT CHANGE THE VALUES OF THESE CONSTANTS!!
   const std::string Transform::UNKNOWN_TYPE = "Unknown type";
   const std::string Transform::ENDOSCOPE_SCOPE_TOOL = "Endoscope scope tool";
   const std::string Transform::ENDOSCOPE_CAM_TOOL = "Endoscope camera tool";
   const std::string Transform::CHESSBOARD_TOOL = "Chessboard tool";
   const std::string Transform::POINTER_TOOL = "Pointer tool";
   const std::string Transform::POINTER_TO_CHESSBOARD_ORIGIN = "Pointer to chessboard origin";
   const std::string Transform::POINTER_TO_CHESSBOARD_X_SUPPORT_POINT = "Pointer to chessboard X support origin";
   const std::string Transform::POINTER_TO_CHESSBOARD_Y_SUPPORT_POINT = "Pointer to chessboard Y support origin";
   const std::string Transform::BOARD_TO_BOARD_TOOL = "Board to board tool";
   const std::string Transform::REFERENCE_CAMERA_TRANSFORM = "Reference camera transform";
   const std::string Transform::REFERENCE_SCOPE_TRANSFORM = "Reference scope transform";
   const std::string Transform::EYE_TO_HAND_TRANSFORM = "Eye to hand transform";
   const std::string Transform::CAMERA_EXTRINSICS = "Camera extrinsics";
 
   Transform::Transform()
     : m_NavData(mitk::NavigationData::New()), m_Type( UNKNOWN_TYPE )
   {
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> rot;
     rot.set_identity();
     this->SetRotation( rot );
   }
 
   Transform::Transform(const mitk::NavigationData* nd)
     : m_NavData(mitk::NavigationData::New()), m_Type( UNKNOWN_TYPE )
   {
         m_NavData->Graft(nd);
   }
 
   Transform::Transform(const std::string& s)
     : m_NavData(mitk::NavigationData::New()), m_Type( s )
   {
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> rot;
     rot.set_identity();
     this->SetRotation( rot );
   }
 
   void Transform::Copy(const mitk::NavigationData* nd)
   {
     (const_cast<mitk::NavigationData*>(m_NavData.GetPointer()))->Graft(nd);
   }
 
   void Transform::Concatenate( mitk::Transform* transform )
   {
     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::Reset()
   {
     mitk::NavigationData::Pointer nd
       = NavigationData::New();
     this->Copy( nd );
   }
   void  Transform::SetOrientation(
       const vnl_quaternion<mitk::ScalarType>& orientation)
   {
     m_NavData->SetOrientation(orientation);
     this->Modified();
   }
 
   void Transform::SetTranslation( const vnl_vector_fixed<mitk::ScalarType, 3>&
                                   transl)
   {
     mitk::Point3D p;
     for(unsigned int i=0; i<3; ++i)
       p[i] = transl[i];
 
     m_NavData->SetPosition(p);
     this->Modified();
   }
 
   void Transform::SetTranslation( float* array )
   {
     vnl_vector_fixed<mitk::ScalarType, 3> vec;
     for(unsigned int i=0; i<vec.size(); i++)
       vec(i) = array[i];
     this->SetTranslation( vec );
   }
 
   void Transform::SetRotation( float* array )
   {
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> mat;
 
     unsigned int row = 0;
     unsigned int col = 0;
     for(unsigned int i=0; i<mat.rows()*mat.cols(); i++)
     {
       if( i > 0 && i % 3 == 0 )
       {
         ++row;
         col = 0;
       }
 
       mat(row,col) = array[i];
       ++col;
     }
 
     this->SetRotation( mat );
   }
 
-  void Transform::SetOrientation( const vnl_quaternion<double>& orientation)
+  void Transform::SetOrientation( const vnl_quaternion<float>& orientation)
   {
     vnl_vector_fixed<mitk::ScalarType, 4> qvec;
-    VnlVectorFixedCaster<double, mitk::ScalarType, 4> caster( &orientation, &qvec );
+    VnlVectorFixedCaster<float, mitk::ScalarType, 4> caster( &orientation, &qvec );
     caster.Update();
 
     mitk::Quaternion p( qvec );
 
     this->SetOrientation( p );
   }
 
   vnl_vector_fixed<double, 3> Transform::GetVnlDoubleTranslation() const
   {
     vnl_vector_fixed<mitk::ScalarType, 3> vecFloat = this->GetVnlTranslation();
     vnl_vector_fixed<double, 3> vecDouble;
     VnlVectorFixedCaster<mitk::ScalarType, double, 3> caster( &vecFloat, &vecDouble );
     caster.Update();
 
     return vecDouble;
   }
 
   void Transform::SetTranslation( const vnl_vector<double>& transl)
   {
     vnl_vector_fixed<double, 3> dTransl(transl);
     vnl_vector_fixed<mitk::ScalarType, 3> fTransl;
     VnlVectorFixedCaster<double, mitk::ScalarType, 3> caster( &dTransl, &fTransl );
     caster.Update();
 
     this->SetTranslation( fTransl );
   }
 
   vnl_quaternion<double> Transform::GetVnlDoubleQuaternion() const
   {
     mitk::Quaternion fOrientation = this->GetOrientation();
     vnl_quaternion<double> dOrientation;
     VnlVectorFixedCaster<mitk::ScalarType, double, 4> caster( &fOrientation, &dOrientation );
     caster.Update();
 
     return dOrientation;
   }
 
   void Transform::FromCSVFile(const std::string& file)
   {
     std::ifstream csvFile (file.c_str());
     endoAssert ( csvFile.fail() == false );
 
     mitk::Transform::Pointer transform = mitk::Transform::New();
     vnl_matrix_fixed<mitk::ScalarType, 4, 4> mat;
     std::string line;
     mitk::ScalarType d = 0.0f;
     int row=0,column = 0;
 
     while (std::getline (csvFile, line))
     {
       std::istringstream linestream(line);
       std::string item;
       column = 0;
       while (std::getline (linestream, item, ','))
       {
         std::istringstream number;
         number.str(item);
         number >> d;
         mat(row, column) = d;
         ++column;
       }
       ++row;
     }
     endoAssert( row == 4 && column == 4 );
     transform->SetMatrix( mat );
 
     this->SetNavigationData( transform->GetNavigationData() );
     // modified is called in SetNavigationData
   }
 
   std::string Transform::ToCSVString() const
   {
     std::ostringstream s; s.precision(12);
 
     vnl_matrix_fixed<mitk::ScalarType, 4, 4> mat
       = this->GetMatrix();
 
     for( unsigned int j=0; j<mat.rows(); ++j )
     {
       for( unsigned int k=0; k<mat.cols(); ++k )
       {
         s << mat(j,k);
         if(k+1<mat.cols())
           s  << ",";
       }
       if(j+1<mat.rows())
         s << std::endl;
     }
 
     return s.str();
 
   }
 
   std::string Transform::ToMatlabString(const std::string& varname
                                         , bool printLastRow) const
   {
     std::ostringstream s; s.precision(12);
 
     vnl_matrix_fixed<mitk::ScalarType, 4, 4> mat
       = this->GetMatrix();
 
     s << varname << " = [";
     for( unsigned int j=0; j<mat.rows(); ++j )
     {
       if( !printLastRow && j+1 == mat.rows() )
         break;
       for( unsigned int k=0; k<mat.cols(); ++k )
       {
         s << mat(j,k) << " ";
       }
       s << ";";
     }
     s << "];" << std::endl;
 
     return s.str();
   }
 
   void Transform::Copy( const mitk::Transform* transform )
   {
     m_NavData->Graft(transform->GetNavigationData());
     m_Type = transform->GetType();
   }
 
   mitk::Transform::Pointer Transform::Clone() const
   {
     Transform::Pointer copy = Transform::New();
     copy->Copy( this );
     return copy;
   }
 
   void Transform::SetMatrix( const vtkMatrix4x4* mat)
   {
     vnl_matrix_fixed<mitk::ScalarType, 4, 4> vnlMat;
     for(unsigned int i=0; i<4; ++i)
       for(unsigned int j=0; j<4; ++j)
         vnlMat(i,j) = mat->GetElement(i, j);
 
     this->SetMatrix( vnlMat );
   }
 
   void Transform::ToCSVFile(const std::string& file) const
   {
     std::ofstream csvFile;
     csvFile.open(file.c_str());
     endoAssert ( csvFile.fail() == false );
     csvFile << this->ToCSVString();
     csvFile.close();
   }
 
   void Transform::ToMatlabFile(const std::string& file
                                , const std::string& varname) const
   {
     std::ofstream csvFile;
     csvFile.open(file.c_str());
     endoAssert ( csvFile.fail() == false );
     csvFile << this->ToMatlabString(varname);
     csvFile.close();
   }
 
   void Transform::SetNavigationData( const mitk::NavigationData* naviData )
   {
     endoAssert( naviData != 0 );
     m_NavData->Graft( naviData );
     this->Modified();
   }
 
   void Transform::SetRotation( vnl_matrix_fixed<mitk::ScalarType, 3, 3>& mat)
   {
     this->m_NavData->SetOrientation( mitk::Quaternion(mat) );
     this->Modified();
   }
 
   void Transform::SetRotation( vnl_matrix<mitk::ScalarType>& mat)
   {
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> tmp(mat);
     this->SetRotation( tmp );
   }
 
   void Transform::SetPosition( const mitk::Point3D& transl)
   {
     this->SetTranslation( transl.GetVnlVector() );
   }
 
   void Transform::SetTranslation( double array[3] )
   {
     mitk::Point3D p;
     for(unsigned int i = 0; i < 3; ++i)
       p.SetElement(i, array[i]);
     this->SetTranslation( p.GetVnlVector() );
   }
 
 
   void Transform::SetRotation( double array[3][3] )
   {
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> mat;
 
     for(unsigned int i = 0; i < 3; ++i)
       for(unsigned int j = 0; j < 3; ++j)
         mat(i, j) = array[i][j];
     this->SetRotation( mat );
   }
 
   void Transform::Invert()
   {
     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);
   }
 
   mitk::Point3D Transform::TransformPoint(mitk::Point3D point) const
   {
       itk::Matrix<mitk::ScalarType,3,3> R(GetVnlRotationMatrix());
       itk::Point<mitk::ScalarType,3> pointR = (R * point);
       mitk::Point3D retPoint = pointR;
       retPoint[0] = pointR[0] + GetPosition()[0];
       retPoint[1] = pointR[1] + GetPosition()[1];
       retPoint[2] = pointR[2] + GetPosition()[2];
       return retPoint;
   }
 
   //# cv getter
   cv::Mat Transform::GetCvTranslation() const
   {
     cv::Mat mat;
     vnl_vector<mitk::ScalarType> vec = this->GetVnlTranslation().as_vector();
     endodebugvar( vec )
     CvMatFromVnlVector<mitk::ScalarType> _CvMatFromVnlVector(&vec, &mat);
     _CvMatFromVnlVector.Update();
     return mat;
   }
 
   cv::Mat Transform::GetCvRotationMatrix() const
   {
     cv::Mat mat;
     vnl_matrix<mitk::ScalarType> vec = this->GetVnlRotationMatrix().as_matrix();
     endodebugvar( vec )
     CvMatFromVnlMatrix<mitk::ScalarType> _CvMatFromVnlMatrix(&vec, &mat);
     _CvMatFromVnlMatrix.Update();
     return mat;
   }
 
   cv::Mat Transform::GetCvMatrix() const
   {
     cv::Mat mat;
     vnl_matrix<mitk::ScalarType> vec = this->GetMatrix().as_matrix();
     CvMatFromVnlMatrix<mitk::ScalarType> _CvMatFromVnlMatrix(&vec, &mat);
     _CvMatFromVnlMatrix.Update();
     return mat;
   }
 
   cv::Mat Transform::GetCvRotationVector() const
   {
     cv::Mat rotVec(3,1,cv::DataType<mitk::ScalarType>::type);
     cv::Rodrigues( this->GetCvRotationMatrix(), rotVec );
     return rotVec;
   }
 
   //# vnl getter
   vnl_vector_fixed<mitk::ScalarType, 3> Transform::GetVnlTranslation() const
   {
     vnl_vector_fixed<mitk::ScalarType, 3> vec(m_NavData->GetPosition()
                                               .GetVnlVector());
     return vec;
   }
 
   vnl_matrix_fixed<mitk::ScalarType, 3, 3> Transform::GetVnlRotationMatrix() const
   {
     return 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->SetAttribute("Type", m_Type);
     elem->SetDoubleAttribute("Time", timestamp);
     elem->SetDoubleAttribute("X", position[0]);
     elem->SetDoubleAttribute("Y", position[1]);
     elem->SetDoubleAttribute("Z", position[2]);
 
     elem->SetDoubleAttribute("QX", orientation[0]);
     elem->SetDoubleAttribute("QY", orientation[1]);
     elem->SetDoubleAttribute("QZ", orientation[2]);
     elem->SetDoubleAttribute("QR", orientation[3]);
 
     elem->SetDoubleAttribute("C00", matrix[0][0]);
     elem->SetDoubleAttribute("C01", matrix[0][1]);
     elem->SetDoubleAttribute("C02", matrix[0][2]);
     elem->SetDoubleAttribute("C03", matrix[0][3]);
     elem->SetDoubleAttribute("C04", matrix[0][4]);
     elem->SetDoubleAttribute("C05", matrix[0][5]);
     elem->SetDoubleAttribute("C10", matrix[1][0]);
     elem->SetDoubleAttribute("C11", matrix[1][1]);
     elem->SetDoubleAttribute("C12", matrix[1][2]);
     elem->SetDoubleAttribute("C13", matrix[1][3]);
     elem->SetDoubleAttribute("C14", matrix[1][4]);
     elem->SetDoubleAttribute("C15", matrix[1][5]);
 
     if (dataValid)
       elem->SetAttribute("Valid",1);
     else
       elem->SetAttribute("Valid",0);
 
     if (hasOrientation)
       elem->SetAttribute("hO",1);
     else
       elem->SetAttribute("hO",0);
 
     if (hasPosition)
       elem->SetAttribute("hP",1);
     else
       elem->SetAttribute("hP",0);
   }
 
   void mitk::Transform::FromXML(TiXmlElement* elem)
   {
     assert(elem);
 
     mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
     mitk::NavigationData::PositionType position;
     mitk::NavigationData::OrientationType orientation(0.0,0.0,0.0,0.0);
     mitk::NavigationData::TimeStampType timestamp = -1;
     mitk::NavigationData::CovarianceMatrixType matrix;
 
     bool hasPosition = true;
     bool hasOrientation = true;
     bool dataValid = false;
 
     position.Fill(0.0);
     matrix.SetIdentity();
 
     std::string type = Transform::UNKNOWN_TYPE;
     elem->QueryStringAttribute("Type", &type);
     elem->QueryDoubleAttribute("Time",&timestamp);
 
     // position and orientation is mandatory!
-    if(elem->QueryFloatAttribute("X", &position[0]) != TIXML_SUCCESS)
+    if(elem->QueryDoubleAttribute("X", &position[0]) != TIXML_SUCCESS)
       throw std::invalid_argument("No X position found in xml");
-    if(elem->QueryFloatAttribute("Y", &position[1]) != TIXML_SUCCESS)
+    if(elem->QueryDoubleAttribute("Y", &position[1]) != TIXML_SUCCESS)
       throw std::invalid_argument("No Y position found in xml");
-    if(elem->QueryFloatAttribute("Z", &position[2]) != TIXML_SUCCESS)
+    if(elem->QueryDoubleAttribute("Z", &position[2]) != TIXML_SUCCESS)
       throw std::invalid_argument("No Z position found in xml");
 
-    if(elem->QueryFloatAttribute("QX", &orientation[0]) != TIXML_SUCCESS)
+    if(elem->QueryDoubleAttribute("QX", &orientation[0]) != TIXML_SUCCESS)
       throw std::invalid_argument("No QX orientation found in xml");
-    if(elem->QueryFloatAttribute("QY", &orientation[1]) != TIXML_SUCCESS)
+    if(elem->QueryDoubleAttribute("QY", &orientation[1]) != TIXML_SUCCESS)
       throw std::invalid_argument("No QY orientation found in xml");
-    if(elem->QueryFloatAttribute("QZ", &orientation[2]) != TIXML_SUCCESS)
+    if(elem->QueryDoubleAttribute("QZ", &orientation[2]) != TIXML_SUCCESS)
       throw std::invalid_argument("No QZ orientation found in xml");
-    if(elem->QueryFloatAttribute("QR", &orientation[3]) != TIXML_SUCCESS)
+    if(elem->QueryDoubleAttribute("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]);
+    elem->QueryDoubleAttribute("C00", &matrix[0][0]);
+    elem->QueryDoubleAttribute("C01", &matrix[0][1]);
+    elem->QueryDoubleAttribute("C02", &matrix[0][2]);
+    elem->QueryDoubleAttribute("C03", &matrix[0][3]);
+    elem->QueryDoubleAttribute("C04", &matrix[0][4]);
+    elem->QueryDoubleAttribute("C05", &matrix[0][5]);
+    elem->QueryDoubleAttribute("C10", &matrix[1][0]);
+    elem->QueryDoubleAttribute("C11", &matrix[1][1]);
+    elem->QueryDoubleAttribute("C12", &matrix[1][2]);
+    elem->QueryDoubleAttribute("C13", &matrix[1][3]);
+    elem->QueryDoubleAttribute("C14", &matrix[1][4]);
+    elem->QueryDoubleAttribute("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->SetIGTTimeStamp(timestamp);
     nd->SetPosition(position);
     nd->SetOrientation(orientation);
     nd->SetCovErrorMatrix(matrix);
     nd->SetDataValid(dataValid);
     nd->SetHasOrientation(hasOrientation);
     nd->SetHasPosition(hasPosition);
 
     m_NavData = nd;
     m_Type = type;
 
     this->Modified();
   }
 
 } // namespace mitk
 
 std::ostream& operator<< (std::ostream& os, mitk::Transform::Pointer p)
 {
   os << p->ToString();
   return os;
 }
diff --git a/Modules/CameraCalibration/mitkTransform.h b/Modules/CameraCalibration/mitkTransform.h
index 60829e106d..ca03343940 100644
--- a/Modules/CameraCalibration/mitkTransform.h
+++ b/Modules/CameraCalibration/mitkTransform.h
@@ -1,305 +1,305 @@
 /*===================================================================
 
 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 MITKTRANSFORM_H
 #define MITKTRANSFORM_H
 
 #include <itkObject.h>
 #include <cv.h>
 #include <mitkCommon.h>
 #include <mitkVector.h>
 #include <mitkNavigationData.h>
 #include <tinyxml.h>
 #include <sstream>
 #include <vtkMatrix4x4.h>
 #include <mitkXMLSerializable.h>
 #include <mitkCameraCalibrationExports.h>
 
 namespace mitk {
 
   ///
   /// \brief class representing a transfrom in 3D
   ///
   /// internally it stores a mitk navigation data. this is more
   /// or less a wrapper for navigation data for easy casting
   /// between opencv/vnl/mitk/xml representations of transform
   /// data
   ///
   class mitkCameraCalibration_EXPORT Transform: public itk::Object,
     public XMLSerializable
   {
   public:
     mitkClassMacro(Transform, itk::Object);
     itkFactorylessNewMacro(Transform);
     mitkNewMacro1Param(Transform, const mitk::NavigationData*);
     mitkNewMacro1Param(Transform, const std::string&);
 
     ///
     /// constants describing the type of transform
     /// represented here
     ///
     static const std::string UNKNOWN_TYPE;
     static const std::string ENDOSCOPE_SCOPE_TOOL;
     static const std::string ENDOSCOPE_CAM_TOOL;
     static const std::string CHESSBOARD_TOOL;
     static const std::string POINTER_TOOL;
     static const std::string POINTER_TO_CHESSBOARD_ORIGIN;
     static const std::string POINTER_TO_CHESSBOARD_X_SUPPORT_POINT;
     static const std::string POINTER_TO_CHESSBOARD_Y_SUPPORT_POINT;
     static const std::string BOARD_TO_BOARD_TOOL;
     static const std::string REFERENCE_CAMERA_TRANSFORM;
     static const std::string REFERENCE_SCOPE_TRANSFORM;
     static const std::string EYE_TO_HAND_TRANSFORM;
     static const std::string CAMERA_EXTRINSICS;
 
     itkGetConstMacro(Type, std::string);
     itkSetMacro(Type, std::string&);
     ///
     /// Copies the content of transform to this
     /// instance
     ///
     void Copy( const mitk::Transform* transform );
 
     ///
     /// Copies the content of transform to this
     /// instance
     ///
     void Copy( const mitk::NavigationData* transform );
 
     ///
     /// Inverts the rotation of this transform
     /// (Polaris navigation Data have inverted rotation
     /// so you may want to call this function when using
     /// polaris data)
     ///
     void TransposeRotation();
 
     ///
     /// get a copy of this transform
     ///
     mitk::Transform::Pointer Clone() const;
 
     ///
     /// concatenate this transform with the given one,
     /// i.e. this transform is done first, then transform
     /// ( if x is this transform, y is transform, then this will be y*x)
     /// post multiply semantics!
     /// \see vtkTransform
     ///
     void Concatenate( mitk::Transform* transform );
     ///
     /// same as above with vnl mat argument
     ///
     void Concatenate( const vnl_matrix_fixed<mitk::ScalarType, 4, 4>& transform );
 
     ///
     /// same as above with vtk mat argument
     ///
     void Concatenate( const vtkMatrix4x4* transform );
 
     ///
     /// invert this transform
     ///
     void Invert();
     ///
     /// resets the internal variables except type
     ///
     void Reset();
 
     ///
     /// read from xml
     ///
     void FromXML(TiXmlElement* elem);
     ///
     /// read csv file
     ///
     void FromCSVFile(const std::string& file);
     ///
     /// grafts the data from naviData to this transform
     ///
     void SetNavigationData( const mitk::NavigationData* naviData );
     ///
     /// method to set orientation quat
     ///
     void SetOrientation( const vnl_quaternion<mitk::ScalarType>& orientation);
     ///
-    /// method to set double valued orientation quat
+    /// method to set float valued orientation quat
     ///
-    void SetOrientation( const vnl_quaternion<double>& orientation);
+    void SetOrientation( const vnl_quaternion<float>& orientation);
     ///
     /// method to set translation
     ///
     void SetTranslation( const vnl_vector_fixed<mitk::ScalarType, 3>& transl);
     ///
     /// method to set a vector of doubles as translation
     ///
     void SetTranslation( const vnl_vector<double>& transl);
     ///
     /// method to set a mitk::Point3D as position
     ///
     void SetPosition( const mitk::Point3D& transl);
     ///
     /// sets rotation with a rotation matrix
     ///
     void SetRotation( vnl_matrix_fixed<mitk::ScalarType, 3, 3>& mat);
     ///
     /// sets rotation with a non fixed rotation matrix
     ///
     void SetRotation( vnl_matrix<mitk::ScalarType>& mat);
     ///
     /// sets rotation and translation with a transformation matrix
     ///
     void SetMatrix( const vnl_matrix_fixed<mitk::ScalarType, 4, 4>& mat);
     ///
     /// sets rotation and translation with a vtk transformation matrix
     ///
     void SetMatrix( const vtkMatrix4x4* mat);
     ///
     /// sets translation from a POD vector
     ///
     void SetTranslation( float* array );
     ///
     /// sets translation from a POD vector. this must be a
     /// 3x3=9 sized vector in row major format (first row = first
     /// three elements)
     ///
     void SetRotation( float* array );
     ///
     /// sets translation from a POD vector
     ///
     void SetTranslation( double array[3] );
     ///
     /// sets translation from a POD vector
     ///
     void SetRotation( double array[3][3] );
 
     ///
     /// method to set translation by cv vector
     ///
     void SetTranslation( const cv::Mat& transl);
     ///
     /// sets rotation with a rotation matrix
     ///
     void SetRotation( const cv::Mat& mat );
     ///
     /// sets rotation with a rodrigues rotation vector
     ///
     void SetRotationVector( const cv::Mat& rotVec);
 
     ///
     /// \return the navigation data that stores all information
     ///
     mitk::NavigationData::Pointer GetNavigationData() const;
     ///
     /// calls navigationdata::GetPosition()
     ///
     mitk::Point3D GetPosition() const;
     ///
     /// same as GetPosition
     ///
     mitk::Point3D GetTranslation() const;
     ///
     /// calls navigationdata::IsValid()
     ///
     bool IsValid() const;
     ///
     /// calls navigationdata::SetValid()
     ///
     void SetValid(bool valid);
 
     ///
     /// calls navigationdata::GetOrientation()
     ///
     mitk::Quaternion GetOrientation() const;
 
     ///
     /// \return the homogeneous matrix representing this transform
     ///
     vnl_matrix_fixed<mitk::ScalarType, 4, 4> GetMatrix() const;
     ///
     /// \return the homogeneous vtk matrix representing this transform
     ///
     void GetMatrix(vtkMatrix4x4* matrix) const;
     ///
     /// \return the homogeneous vtk matrix representing this transform
     /// in !OpenGL! left handed coordinate system
     ///
     void GetVtkOpenGlMatrix(vtkMatrix4x4* matrix) const;
 
     mitk::Point3D TransformPoint(mitk::Point3D point) const;
 
     ///
     /// create xml representation
     ///
     void ToXML(TiXmlElement* elem) const;
     ///
     /// create string representation
     ///
     std::string ToString() const;
     ///
     /// create string csv representation (only the transformation values!!!!)
     ///
     std::string ToCSVString() const;
     ///
     /// create matlab representation
     ///
     std::string ToMatlabString(const std::string& varname="transform",
                                bool printLastRow=true) const;
     ///
     /// write csv representation to file (only the transformation values!!!!)
     ///
     void ToCSVFile(const std::string& file) const;
     ///
     /// write matlab representation to file
     ///
     void ToMatlabFile(const std::string& file
                       , const std::string& varname="transform") const;
     ///
     /// conversion to cv types
     ///
     cv::Mat GetCvTranslation() const;
     cv::Mat GetCvRotationVector() const;
     cv::Mat GetCvRotationMatrix() const;
     cv::Mat GetCvMatrix() const;
 
     ///
     /// conversion to vnl types
     ///
     vnl_vector_fixed<mitk::ScalarType, 3> GetVnlTranslation() const;
     vnl_vector_fixed<double, 3> GetVnlDoubleTranslation() const;
     vnl_quaternion<double> GetVnlDoubleQuaternion() const;
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> GetVnlRotationMatrix() const;
     vnl_matrix_fixed<double, 4, 4> GetVnlDoubleMatrix() const;
 
   protected:
     Transform();
     Transform(const mitk::NavigationData* nd);
     Transform(const std::string& s);
 
     // everything is stored here
     mitk::NavigationData::Pointer m_NavData;
 
     ///
     /// saves the type of the transform (Default is UNKNOWN_TYPE)
     ///
     std::string m_Type;
 };
 
 } // namespace mitk
 
 mitkCameraCalibration_EXPORT std::ostream& operator<<
     (std::ostream& os, mitk::Transform::Pointer p);
 
 #endif // MITKTRANSFORM_H
diff --git a/Modules/IGT/IGTFilters/mitkCameraVisualization.h b/Modules/IGT/IGTFilters/mitkCameraVisualization.h
index daccb868bd..b834218867 100644
--- a/Modules/IGT/IGTFilters/mitkCameraVisualization.h
+++ b/Modules/IGT/IGTFilters/mitkCameraVisualization.h
@@ -1,123 +1,123 @@
 /*===================================================================
 
 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 CAMERAVISUALIZATION_H_INCLUDED
 #define CAMERAVISUALIZATION_H_INCLUDED
 
 #include "mitkCommon.h"
 #include "mitkNavigationDataToNavigationDataFilter.h"
 #include "mitkBaseRenderer.h"
 
 namespace mitk {
   /**Documentation
   * \brief CameraVisualization controls the camera according to the spatial information of the navigation data
   *
   * The camera of the renderer will be placed at the position of the navigation data and oriented according to
   * its orientation and the camera specific information "direction of projection", "view up", "focal length", "view angle"
   *
   * \ingroup IGT
   */  class MitkIGT_EXPORT CameraVisualization : public NavigationDataToNavigationDataFilter
   {
   public:
     mitkClassMacro(CameraVisualization, NavigationDataToNavigationDataFilter);
     itkNewMacro(Self);
 
     /**
     * \brief sets the direction of projection of the camera of the renderer in tool coordinates
     */
     itkSetMacro(DirectionOfProjectionInToolCoordinates, mitk::Vector3D);
 
     /**
     * \brief sets the view up vector of the camera of the renderer in tool coordinates
     */
     itkSetMacro(ViewUpInToolCoordinates, mitk::Vector3D);
 
     /**
     * \brief sets the focal length of the camera
     */
     itkSetMacro(FocalLength, float);
 
     /**
     * \brief returns the direction of projection of the camera of the renderer in tool coordinates
     */
     itkGetConstMacro(DirectionOfProjectionInToolCoordinates, mitk::Vector3D);
 
     /**
     * \brief returns the view up vector of the camera of the renderer in tool coordinates
     */
     itkGetConstMacro(ViewUpInToolCoordinates, mitk::Vector3D);
 
     /**
     * \brief returns the focal length of the camera
     */
     itkGetConstMacro(FocalLength, float);
 
     /**
     * \brief sets renderer that visualizes the navigation data
     */
     virtual void SetRenderer( mitk::BaseRenderer* renderer );
 
     /**
     * \brief returns the renderer that visualizes the navigation data
     */
     virtual const mitk::BaseRenderer* GetRenderer();
 
     /**Documentation
     *\brief Set all filter parameters as the PropertyList p
     *
     * This method reads the following properties from the PropertyList (name : data type):
     *  - "CameraVisualization_DirectionOfProjectionInToolCoordinates" : mitk::Vector3DProperty
     *  - "CameraVisualization_ViewUpInToolCoordinates" : mitk::Vector3DProperty
     *  - "CameraVisualization_FocalLength" : mitk::FloatProperty
     *  - "CameraVisualization_ViewAngle" : mitk::FloatProperty
     */
     virtual void SetParameters(const mitk::PropertyList* p);
 
     /**Documentation
     *\brief Get all filter parameters as a PropertyList
     *
     * This method returns a PropertyList containing the following
     * properties (name : data type):
     *  - "CameraVisualization_DirectionOfProjectionInToolCoordinates" : mitk::Vector3DProperty
     *  - "CameraVisualization_ViewUpInToolCoordinates" : mitk::Vector3DProperty
     *  - "CameraVisualization_FocalLength" : mitk::FloatProperty
     *  - "CameraVisualization_ViewAngle" : mitk::FloatProperty
     * The returned PropertyList must be assigned to a
     * SmartPointer immediately, or else it will get destroyed.
     */
     mitk::PropertyList::ConstPointer GetParameters() const;
 
   protected:
     CameraVisualization();
     virtual ~CameraVisualization();
 
     /**Documentation
     * \brief filter execute method
     *
     * positions and orients camera according to the position and orientation hold in the NavigationData
     */
     virtual void GenerateData();
 
     mitk::BaseRenderer::Pointer m_Renderer; ///< renderer that visualizes the navigation data-
 
     Vector3D m_DirectionOfProjectionInToolCoordinates; ///< vector of the direction of projection in tool coordinates
     Vector3D m_ViewUpInToolCoordinates; ///< view up vector in tool coordinates
     Vector3D m_DirectionOfProjection; ///< vector of the current direction of view of the camera in world coordinates
     Point3D m_CameraPosition; ///< current position of the camera
-    float m_FocalLength; ///< focal length of the camera: distance between camera position and focal point.
+    ScalarType m_FocalLength; ///< focal length of the camera: distance between camera position and focal point.
   };
 } // namespace mitk
 #endif
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataObjectVisualizationFilter.cpp b/Modules/IGT/IGTFilters/mitkNavigationDataObjectVisualizationFilter.cpp
index 2d4aefb603..3c88d8500a 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataObjectVisualizationFilter.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataObjectVisualizationFilter.cpp
@@ -1,219 +1,219 @@
 /*===================================================================
 
 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 "mitkNavigationDataObjectVisualizationFilter.h"
 
 #include "mitkDataStorage.h"
 
 
 mitk::NavigationDataObjectVisualizationFilter::NavigationDataObjectVisualizationFilter()
 : NavigationDataToNavigationDataFilter(),
 m_RepresentationList(), m_TransformPosition(), m_TransformOrientation()
 {
 }
 
 
 mitk::NavigationDataObjectVisualizationFilter::~NavigationDataObjectVisualizationFilter()
 {
   m_RepresentationList.clear();
 }
 
 
 const mitk::BaseData* mitk::NavigationDataObjectVisualizationFilter::GetRepresentationObject(unsigned int idx)
 {
   //if (idx >= this->GetNumberOfInputs())
   //  return NULL;
 
   //const NavigationData* nd = this->GetInput(idx);
   //if (nd == NULL)
   //  return NULL;
 
   RepresentationPointerMap::const_iterator iter = m_RepresentationList.find(idx);
   if (iter != m_RepresentationList.end())
     return iter->second;
 
   return NULL;
 }
 
 
 void mitk::NavigationDataObjectVisualizationFilter::SetRepresentationObject(unsigned int idx, BaseData* data)
 {
   //if (idx >= this->GetNumberOfInputs())
   //  return false;
 
   //const NavigationData* nd = this->GetInput(idx);
 
   //if (nd == NULL || data == NULL)
   //  return false;
 
   m_RepresentationList[idx] = RepresentationPointer(data);
   //std::pair<RepresentationPointerMap::iterator, bool> returnEl; //pair for returning the result
   //returnEl = m_RepresentationList.insert( RepresentationPointerMap::value_type(nd, data) ); //insert the given elements
   //return returnEl.second; // return if insert was successful
 }
 
 
 void mitk::NavigationDataObjectVisualizationFilter::GenerateData()
 {
   /*get each input, lookup the associated BaseData and transfer the data*/
   DataObjectPointerArray inputs = this->GetInputs(); //get all inputs
   for (unsigned int index=0; index < inputs.size(); index++)
   {
     //get the needed variables
     const mitk::NavigationData* nd = this->GetInput(index);
     assert(nd);
 
     mitk::NavigationData* output = this->GetOutput(index);
     assert(output);
 
     //check if the data is valid
     if (!nd->IsDataValid())
     {
       output->SetDataValid(false);
       continue;
     }
     output->Graft(nd); // copy all information from input to output
     const mitk::BaseData* data = this->GetRepresentationObject(index);
     if (data == NULL)
     {
       itkWarningMacro("NavigationDataObjectVisualizationFilter: Wrong/No BaseData associated with input.");
       return;
     }
 
     //get the transform from data
     mitk::AffineTransform3D::Pointer affineTransform = data->GetGeometry()->GetIndexToWorldTransform();
     if (affineTransform.IsNull())
     {
       //replace with mitk standard output
       itkWarningMacro("NavigationDataObjectVisualizationFilter: AffineTransform IndexToWorldTransform not initialized!");
       return;
     }
 
     //store the current scaling to set it after transformation
     mitk::Vector3D spacing = data->GetGeometry()->GetSpacing();
     //clear spacing of data to be able to set it again afterwards
-    float scale[] = {1.0, 1.0, 1.0};
+    ScalarType scale[] = {1.0, 1.0, 1.0};
     data->GetGeometry()->SetSpacing(scale);
 
     /*now bring quaternion to affineTransform by using vnl_Quaternion*/
     affineTransform->SetIdentity();
 
 
     if (this->GetTransformOrientation(index) == true)
     {
       //calculate the transform from the quaternions
       static itk::QuaternionRigidTransform<double>::Pointer quatTransform = itk::QuaternionRigidTransform<double>::New();
 
       mitk::NavigationData::OrientationType orientation = nd->GetOrientation();
       // convert mitk::ScalarType quaternion to double quaternion because of itk bug
       vnl_quaternion<double> doubleQuaternion(orientation.x(), orientation.y(), orientation.z(), orientation.r());
       quatTransform->SetIdentity();
       quatTransform->SetRotation(doubleQuaternion);
       quatTransform->Modified();
 
       /* because of an itk bug, the transform can not be calculated with float data type.
       To use it in the mitk geometry classes, it has to be transfered to mitk::ScalarType which is float */
       static AffineTransform3D::MatrixType m;
       mitk::TransferMatrix(quatTransform->GetMatrix(), m);
       affineTransform->SetMatrix(m);
     }
     if (this->GetTransformPosition(index) == true)
     {
       ///*set the offset by convert from itkPoint to itkVector and setting offset of transform*/
       mitk::Vector3D pos;
       pos.Set_vnl_vector(nd->GetPosition().Get_vnl_vector());
       affineTransform->SetOffset(pos);
     }
     affineTransform->Modified();
     //set the transform to data
     data->GetGeometry()->SetIndexToWorldTransform(affineTransform);
     //set the original spacing to keep scaling of the geometrical object
     data->GetGeometry()->SetSpacing(spacing);
     data->GetGeometry()->TransferItkToVtkTransform(); // update VTK Transform for rendering too
     data->GetGeometry()->Modified();
     data->Modified();
     output->SetDataValid(true); // operation was successful, therefore data of output is valid.
   }
 }
 
 
 void mitk::NavigationDataObjectVisualizationFilter::SetTransformPosition( unsigned int index, bool applyTransform )
 {
   itkDebugMacro("setting TransformPosition for index " << index << " to " << applyTransform);
   BooleanInputMap::const_iterator it = this->m_TransformPosition.find(index);
   if ((it != this->m_TransformPosition.end()) && (it->second == applyTransform))
     return;
 
   this->m_TransformPosition[index] = applyTransform;
   this->Modified(); \
 }
 
 
 bool mitk::NavigationDataObjectVisualizationFilter::GetTransformPosition( unsigned int index ) const
 {
   itkDebugMacro("returning TransformPosition for index " << index);
   BooleanInputMap::const_iterator it = this->m_TransformPosition.find(index);
   if (it != this->m_TransformPosition.end())
     return it->second;
   else
     return true; // default to true
 }
 
 
 void mitk::NavigationDataObjectVisualizationFilter::TransformPositionOn( unsigned int index )
 {
   this->SetTransformPosition(index, true);
 }
 
 
 void mitk::NavigationDataObjectVisualizationFilter::TransformPositionOff( unsigned int index )
 {
   this->SetTransformPosition(index, false);
 }
 
 
 void mitk::NavigationDataObjectVisualizationFilter::SetTransformOrientation( unsigned int index, bool applyTransform )
 {
   itkDebugMacro("setting TransformOrientation for index " << index << " to " << applyTransform);
   BooleanInputMap::const_iterator it = this->m_TransformOrientation.find(index);
   if ((it != this->m_TransformOrientation.end()) && (it->second == applyTransform))
     return;
 
   this->m_TransformOrientation[index] = applyTransform;
   this->Modified(); \
 }
 
 
 bool mitk::NavigationDataObjectVisualizationFilter::GetTransformOrientation( unsigned int index ) const
 {
   itkDebugMacro("returning TransformOrientation for index " << index);
   BooleanInputMap::const_iterator it = this->m_TransformOrientation.find(index);
   if (it != this->m_TransformOrientation.end())
     return it->second;
   else
     return true; // default to true
 }
 
 
 void mitk::NavigationDataObjectVisualizationFilter::TransformOrientationOn( unsigned int index )
 {
   this->SetTransformOrientation(index, true);
 }
 
 
 void mitk::NavigationDataObjectVisualizationFilter::TransformOrientationOff( unsigned int index )
 {
   this->SetTransformOrientation(index, false);
 }
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataPlayerBase.cpp b/Modules/IGT/IGTFilters/mitkNavigationDataPlayerBase.cpp
index e9adf664e5..8edca1fb68 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataPlayerBase.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataPlayerBase.cpp
@@ -1,118 +1,118 @@
 /*===================================================================
 
 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 "mitkNavigationDataPlayerBase.h"
 
 
 mitk::NavigationDataPlayerBase::NavigationDataPlayerBase() : m_StreamValid(true), m_ErrorMessage("")
 {
   m_Name ="Navigation Data Player Source";
 }
 
 mitk::NavigationDataPlayerBase::~NavigationDataPlayerBase()
 {
 }
 
 
 
 
 
 void mitk::NavigationDataPlayerBase::UpdateOutputInformation()
 {
   this->Modified();  // make sure that we need to be updated
   Superclass::UpdateOutputInformation();
 }
 
 
 
 mitk::NavigationData::Pointer mitk::NavigationDataPlayerBase::ReadNavigationData(TiXmlElement* elem)
 {
   if (elem == NULL) {mitkThrow() << "Error: Element is NULL!";}
 
   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);
   if (timestamp == -1)
   {
     return NULL;  //the calling method should check the return value if it is valid/not NULL
   }
 
-  elem->QueryFloatAttribute("X", &position[0]);
-  elem->QueryFloatAttribute("Y", &position[1]);
-  elem->QueryFloatAttribute("Z", &position[2]);
-
-  elem->QueryFloatAttribute("QX", &orientation[0]);
-  elem->QueryFloatAttribute("QY", &orientation[1]);
-  elem->QueryFloatAttribute("QZ", &orientation[2]);
-  elem->QueryFloatAttribute("QR", &orientation[3]);
-
-  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]);
+  elem->QueryDoubleAttribute("X", &position[0]);
+  elem->QueryDoubleAttribute("Y", &position[1]);
+  elem->QueryDoubleAttribute("Z", &position[2]);
+
+  elem->QueryDoubleAttribute("QX", &orientation[0]);
+  elem->QueryDoubleAttribute("QY", &orientation[1]);
+  elem->QueryDoubleAttribute("QZ", &orientation[2]);
+  elem->QueryDoubleAttribute("QR", &orientation[3]);
+
+  elem->QueryDoubleAttribute("C00", &matrix[0][0]);
+  elem->QueryDoubleAttribute("C01", &matrix[0][1]);
+  elem->QueryDoubleAttribute("C02", &matrix[0][2]);
+  elem->QueryDoubleAttribute("C03", &matrix[0][3]);
+  elem->QueryDoubleAttribute("C04", &matrix[0][4]);
+  elem->QueryDoubleAttribute("C05", &matrix[0][5]);
+  elem->QueryDoubleAttribute("C10", &matrix[1][0]);
+  elem->QueryDoubleAttribute("C11", &matrix[1][1]);
+  elem->QueryDoubleAttribute("C12", &matrix[1][2]);
+  elem->QueryDoubleAttribute("C13", &matrix[1][3]);
+  elem->QueryDoubleAttribute("C14", &matrix[1][4]);
+  elem->QueryDoubleAttribute("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->SetIGTTimeStamp(timestamp);
   nd->SetPosition(position);
   nd->SetOrientation(orientation);
   nd->SetCovErrorMatrix(matrix);
   nd->SetDataValid(dataValid);
   nd->SetHasOrientation(hasOrientation);
   nd->SetHasPosition(hasPosition);
 
 
   return nd;
 }
diff --git a/Modules/IGT/IGTTrackingDevices/mitkInternalTrackingTool.cpp b/Modules/IGT/IGTTrackingDevices/mitkInternalTrackingTool.cpp
index 7b6c6bb9a0..bdc9b12b1b 100644
--- a/Modules/IGT/IGTTrackingDevices/mitkInternalTrackingTool.cpp
+++ b/Modules/IGT/IGTTrackingDevices/mitkInternalTrackingTool.cpp
@@ -1,234 +1,234 @@
 /*===================================================================
 
 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 "mitkInternalTrackingTool.h"
 
 #include <itkMutexLockHolder.h>
 
 typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
 
 mitk::InternalTrackingTool::InternalTrackingTool()
 : TrackingTool(),
 m_TrackingError(0.0f),
 m_Enabled(true),
 m_DataValid(false),
 m_ToolTipSet(false)
 {
   m_Position[0] = 0.0f;
   m_Position[1] = 0.0f;
   m_Position[2] = 0.0f;
   m_Orientation[0] = 0.0f;
   m_Orientation[1] = 0.0f;
   m_Orientation[2] = 0.0f;
   m_Orientation[3] = 0.0f;
   // this should not be necessary as the tools bring their own tooltip transformation
   m_ToolTip[0] = 0.0f;
   m_ToolTip[1] = 0.0f;
   m_ToolTip[2] = 0.0f;
   m_ToolTipRotation[0] = 0.0f;
   m_ToolTipRotation[1] = 0.0f;
   m_ToolTipRotation[2] = 0.0f;
   m_ToolTipRotation[3] = 1.0f;
 }
 
 mitk::InternalTrackingTool::~InternalTrackingTool()
 {
 }
 
 
 void mitk::InternalTrackingTool::SetToolName(const char* _arg)
 {
   itkDebugMacro("setting  m_ToolName to " << _arg);
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if ( _arg && (_arg == this->m_ToolName) )
   {
     return;
   }
   if (_arg)
   {
     this->m_ToolName= _arg;
   }
   else
   {
     this->m_ToolName= "";
   }
   this->Modified();
 }
 
 
 void mitk::InternalTrackingTool::SetToolName( const std::string _arg )
 {
   this->SetToolName(_arg.c_str());
 }
 
 
 void mitk::InternalTrackingTool::GetPosition(mitk::Point3D& position) const
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if (m_ToolTipSet)
     {
     //compute position of tooltip
-    vnl_vector<float> pos_vnl = (m_ToolTipRotation.rotate(m_Position.Get_vnl_vector()))+ m_ToolTip.Get_vnl_vector();
+    vnl_vector<ScalarType> pos_vnl = (m_ToolTipRotation.rotate(m_Position.Get_vnl_vector()))+ m_ToolTip.Get_vnl_vector();
     position[0] = pos_vnl[0];
     position[1] = pos_vnl[1];
     position[2] = pos_vnl[2];
     }
   else
     {
     position[0] = m_Position[0];
     position[1] = m_Position[1];
     position[2] = m_Position[2];
     }
   this->Modified();
 }
 
 
 void mitk::InternalTrackingTool::SetPosition(mitk::Point3D position)
 {
   itkDebugMacro("setting  m_Position to " << position);
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   m_Position = position;
   this->Modified();
 }
 
 
 void mitk::InternalTrackingTool::GetOrientation(mitk::Quaternion& orientation) const
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if (m_ToolTipSet)
     {
     //compute rotation of tooltip
     orientation = m_ToolTipRotation * m_Orientation;
     }
   else
     {
     orientation = m_Orientation;
     }
 }
 
 void mitk::InternalTrackingTool::SetToolTip(mitk::Point3D toolTipPosition, mitk::Quaternion orientation)
 {
 if( (toolTipPosition[0] == 0) &&
     (toolTipPosition[1] == 0) &&
     (toolTipPosition[2] == 0) &&
     (orientation.x() == 0) &&
     (orientation.y() == 0) &&
     (orientation.z() == 0) &&
     (orientation.r() == 1))
     {
     m_ToolTipSet = false;
     }
 else
     {
     m_ToolTipSet = true;
     }
 m_ToolTip = toolTipPosition;
 m_ToolTipRotation = orientation;
 }
 
 void mitk::InternalTrackingTool::SetOrientation(mitk::Quaternion orientation)
 {
   itkDebugMacro("setting  m_Orientation to " << orientation);
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   m_Orientation = orientation;
   this->Modified();
 }
 
 
 void mitk::InternalTrackingTool::SetTrackingError(float error)
 {
   itkDebugMacro("setting  m_TrackingError  to " << error);
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if (error == m_TrackingError)
   {
     return;
   }
   m_TrackingError = error;
   this->Modified();
 }
 
 
 float mitk::InternalTrackingTool::GetTrackingError() const
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   float r = m_TrackingError;
   return r;
 }
 
 
 bool mitk::InternalTrackingTool::Enable()
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if (m_Enabled == false)
   {
     this->m_Enabled = true;
     this->Modified();
   }
   return true;
 }
 
 
 bool mitk::InternalTrackingTool::Disable()
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if (m_Enabled == true)
   {
     this->m_Enabled = false;
     this->Modified();
   }
   return true;
 }
 
 
 bool mitk::InternalTrackingTool::IsEnabled() const
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   return m_Enabled;
 }
 
 
 bool mitk::InternalTrackingTool::IsDataValid() const
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   return m_DataValid;
 }
 
 
 void mitk::InternalTrackingTool::SetDataValid(bool _arg)
 {
   itkDebugMacro("setting m_DataValid to " << _arg);
   if (this->m_DataValid != _arg)
   {
     MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
     this->m_DataValid = _arg;
     this->Modified();
   }
 }
 
 
 void mitk::InternalTrackingTool::SetErrorMessage(const char* _arg)
 {
   itkDebugMacro("setting  m_ErrorMessage  to " << _arg);
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if ((_arg == NULL) || (_arg == this->m_ErrorMessage))
     return;
 
   if (_arg != NULL)
     this->m_ErrorMessage = _arg;
   else
     this->m_ErrorMessage = "";
   this->Modified();
 }
diff --git a/Modules/MitkExt/Rendering/mitkMeshMapper2D.cpp b/Modules/MitkExt/Rendering/mitkMeshMapper2D.cpp
index 4b29bdf907..e1d28678d2 100644
--- a/Modules/MitkExt/Rendering/mitkMeshMapper2D.cpp
+++ b/Modules/MitkExt/Rendering/mitkMeshMapper2D.cpp
@@ -1,481 +1,481 @@
 /*===================================================================
 
 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 "mitkMeshMapper2D.h"
 #include "mitkMesh.h"
 #include "mitkBaseRenderer.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkLine.h"
 #include "mitkGL.h"
 
 #include <vtkLinearTransform.h>
 
 #include <algorithm>
 
 const float selectedColor[]={1.0,0.0,0.6}; //for selected!
 
 mitk::MeshMapper2D::MeshMapper2D()
 {
 }
 
 
 mitk::MeshMapper2D::~MeshMapper2D()
 {
 }
 
 const mitk::Mesh *mitk::MeshMapper2D::GetInput(void)
 {
     return static_cast<const mitk::Mesh * > ( GetDataNode()->GetData() );
 }
 
 // Return whether a point is "smaller" than the second
 static bool point3DSmaller( const mitk::Point3D& elem1, const mitk::Point3D& elem2 )
 {
   if(elem1[0]!=elem2[0])
     return elem1[0] < elem2[0];
   if(elem1[1]!=elem2[1])
     return elem1[1] < elem2[1];
   return elem1[2] < elem2[2];
 }
 
 void mitk::MeshMapper2D::Paint( mitk::BaseRenderer *renderer )
 {
 
     bool visible = true;
 
     GetDataNode()->GetVisibility(visible, renderer, "visible");
 
     if(!visible) return;
 
   //  @FIXME: Logik fuer update
   bool updateNeccesary = true;
 
   if (updateNeccesary)
   {
   //aus GenerateData
     mitk::Mesh::Pointer input = const_cast<mitk::Mesh*>(this->GetInput());
 
     // Get the TimeSlicedGeometry of the input object
     const TimeSlicedGeometry* inputTimeGeometry = input->GetTimeSlicedGeometry();
     if (( inputTimeGeometry == NULL ) || ( inputTimeGeometry->GetTimeSteps() == 0 ) )
     {
       return;
     }
 
     //
     // get the world time
     //
     const Geometry2D* worldGeometry = renderer->GetCurrentWorldGeometry2D();
     assert( worldGeometry != NULL );
     ScalarType time = worldGeometry->GetTimeBounds()[ 0 ];
 
     //
     // convert the world time in time steps of the input object
     //
     int timeStep=0;
     if ( time > ScalarTypeNumericTraits::NonpositiveMin() )
       timeStep = inputTimeGeometry->MSToTimeStep( time );
     if ( inputTimeGeometry->IsValidTime( timeStep ) == false )
     {
       return;
     }
 
 
     mitk::Mesh::MeshType::Pointer itkMesh = input->GetMesh( timeStep );
 
     if ( itkMesh.GetPointer() == NULL)
     {
       return;
     }
 
 
     mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
     assert(displayGeometry.IsNotNull());
 
     const PlaneGeometry* worldplanegeometry = dynamic_cast<const PlaneGeometry*>(renderer->GetCurrentWorldGeometry2D());
 
     //apply color and opacity read from the PropertyList
     ApplyColorAndOpacityProperties(renderer);
 
     vtkLinearTransform* transform = GetDataNode()->GetVtkTransform();
 
     //List of the Points
     Mesh::DataType::PointsContainerConstIterator it, end;
     it=itkMesh->GetPoints()->Begin();
     end=itkMesh ->GetPoints()->End();
 
     //iterator on the additional data of each point
     Mesh::PointDataIterator dataIt;//, dataEnd;
     dataIt=itkMesh->GetPointData()->Begin();
 
     //for switching back to old color after using selected color
     float unselectedColor[4];
     glGetFloatv(GL_CURRENT_COLOR,unselectedColor);
 
     while(it!=end)
     {
       mitk::Point3D p, projected_p;
       float vtkp[3];
 
       itk2vtk(it->Value(), vtkp);
       transform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp,p);
 
       displayGeometry->Project(p, projected_p);
       Vector3D diff=p-projected_p;
       if(diff.GetSquaredNorm()<4.0)
       {
         Point2D pt2d, tmp;
         displayGeometry->Map(projected_p, pt2d);
         displayGeometry->WorldToDisplay(pt2d, pt2d);
 
         Vector2D horz,vert;
         horz[0]=5; horz[1]=0;
         vert[0]=0; vert[1]=5;
 
         //check if the point is to be marked as selected
         if (dataIt->Value().selected)
         {
           horz[0]=8;
           vert[1]=8;
           glColor3f(selectedColor[0],selectedColor[1],selectedColor[2]);//red
 
           switch (dataIt->Value().pointSpec)
           {
           case PTSTART:
             {
               //a quad
               glBegin (GL_LINE_LOOP);
-                tmp=pt2d-horz+vert;      glVertex2fv(&tmp[0]);
-                tmp=pt2d+horz+vert;      glVertex2fv(&tmp[0]);
-                tmp=pt2d+horz-vert;      glVertex2fv(&tmp[0]);
-                tmp=pt2d-horz-vert;      glVertex2fv(&tmp[0]);
+                tmp=pt2d-horz+vert;      glVertex2dv(&tmp[0]);
+                tmp=pt2d+horz+vert;      glVertex2dv(&tmp[0]);
+                tmp=pt2d+horz-vert;      glVertex2dv(&tmp[0]);
+                tmp=pt2d-horz-vert;      glVertex2dv(&tmp[0]);
               glEnd ();
             }
             break;
           case PTUNDEFINED:
             {
               //a diamond around the point
               glBegin (GL_LINE_LOOP);
-                tmp=pt2d-horz;      glVertex2fv(&tmp[0]);
-                tmp=pt2d+vert;      glVertex2fv(&tmp[0]);
-                tmp=pt2d+horz;      glVertex2fv(&tmp[0]);
-                tmp=pt2d-vert;      glVertex2fv(&tmp[0]);
+                tmp=pt2d-horz;      glVertex2dv(&tmp[0]);
+                tmp=pt2d+vert;      glVertex2dv(&tmp[0]);
+                tmp=pt2d+horz;      glVertex2dv(&tmp[0]);
+                tmp=pt2d-vert;      glVertex2dv(&tmp[0]);
               glEnd ();
             }
             break;
           default:
             break;
           }//switch
 
           //the actual point
           glBegin (GL_POINTS);
-            tmp=pt2d;             glVertex2fv(&tmp[0]);
+            tmp=pt2d;             glVertex2dv(&tmp[0]);
           glEnd ();
         }
         else //if not selected
         {
           glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
           switch (dataIt->Value().pointSpec)
           {
           case PTSTART:
             {
               //a quad
               glBegin (GL_LINE_LOOP);
-                tmp=pt2d-horz+vert;      glVertex2fv(&tmp[0]);
-                tmp=pt2d+horz+vert;      glVertex2fv(&tmp[0]);
-                tmp=pt2d+horz-vert;      glVertex2fv(&tmp[0]);
-                tmp=pt2d-horz-vert;      glVertex2fv(&tmp[0]);
+                tmp=pt2d-horz+vert;      glVertex2dv(&tmp[0]);
+                tmp=pt2d+horz+vert;      glVertex2dv(&tmp[0]);
+                tmp=pt2d+horz-vert;      glVertex2dv(&tmp[0]);
+                tmp=pt2d-horz-vert;      glVertex2dv(&tmp[0]);
               glEnd ();
             }
           case PTUNDEFINED:
             {
               //drawing crosses
               glBegin (GL_LINES);
-                  tmp=pt2d-horz;      glVertex2fv(&tmp[0]);
-                  tmp=pt2d+horz;      glVertex2fv(&tmp[0]);
-                  tmp=pt2d-vert;      glVertex2fv(&tmp[0]);
-                  tmp=pt2d+vert;      glVertex2fv(&tmp[0]);
+                  tmp=pt2d-horz;      glVertex2dv(&tmp[0]);
+                  tmp=pt2d+horz;      glVertex2dv(&tmp[0]);
+                  tmp=pt2d-vert;      glVertex2dv(&tmp[0]);
+                  tmp=pt2d+vert;      glVertex2dv(&tmp[0]);
               glEnd ();
             }
     default:
             {
         break;
             }
           }//switch
         }//else
       }
       ++it;
       ++dataIt;
     }
 
     //now connect the lines inbetween
     mitk::Mesh::PointType thisPoint; thisPoint.Fill(0);
     Point2D *firstOfCell = NULL;
     Point2D *lastPoint = NULL;
     unsigned int lastPointId = 0;
     bool lineSelected = false;
 
     Point3D firstOfCell3D;
     Point3D lastPoint3D;
     bool first;
     mitk::Line<mitk::ScalarType> line;
     std::vector<mitk::Point3D> intersectionPoints;
     double t;
 
     //iterate through all cells and then iterate through all indexes of points in that cell
     Mesh::CellIterator cellIt, cellEnd;
     Mesh::CellDataIterator cellDataIt;//, cellDataEnd;
     Mesh::PointIdIterator cellIdIt, cellIdEnd;
 
     cellIt = itkMesh->GetCells()->Begin();
     cellEnd = itkMesh->GetCells()->End();
     cellDataIt = itkMesh->GetCellData()->Begin();
 
     while (cellIt != cellEnd)
     {
       unsigned int numOfPointsInCell = cellIt->Value()->GetNumberOfPoints();
       if (numOfPointsInCell>1)
       {
         //iterate through all id's in the cell
         cellIdIt = cellIt->Value()->PointIdsBegin();
         cellIdEnd = cellIt->Value()->PointIdsEnd();
 
         firstOfCell3D = input->GetPoint(*cellIdIt);
 
         intersectionPoints.clear();
         intersectionPoints.reserve(numOfPointsInCell);
 
         first = true;
 
         while(cellIdIt != cellIdEnd)
         {
           lastPoint3D = thisPoint;
 
           thisPoint = input->GetPoint(*cellIdIt);
 
           //search in data (vector<> selectedLines) if the index of the point is set. if so, then the line is selected.
           lineSelected = false;
           Mesh::SelectedLinesType selectedLines = cellDataIt->Value().selectedLines;
 
           //a line between 1(lastPoint) and 2(pt2d) has the Id 1, so look for the Id of lastPoint
           //since we only start, if we have more than one point in the cell, lastPointId is initiated with 0
           Mesh::SelectedLinesIter position = std::find(selectedLines.begin(), selectedLines.end(), lastPointId);
           if (position != selectedLines.end())
           {
             lineSelected = true;
           }
 
           mitk::Point3D p, projected_p;
           float vtkp[3];
           itk2vtk(thisPoint, vtkp);
           transform->TransformPoint(vtkp, vtkp);
           vtk2itk(vtkp,p);
           displayGeometry->Project(p, projected_p);
           Vector3D diff=p-projected_p;
           if(diff.GetSquaredNorm()<4.0)
           {
             Point2D pt2d, tmp;
             displayGeometry->Map(projected_p, pt2d);
             displayGeometry->WorldToDisplay(pt2d, pt2d);
 
             if (lastPoint == NULL)
             {
               //set the first point in the cell. This point in needed to close the polygon
               firstOfCell = new Point2D;
               *firstOfCell = pt2d;
               lastPoint = new Point2D;
               *lastPoint = pt2d;
               lastPointId = *cellIdIt;
             }
             else
             {
               if (lineSelected)
               {
                 glColor3f(selectedColor[0],selectedColor[1],selectedColor[2]);//red
                 //a line from lastPoint to thisPoint
                 glBegin (GL_LINES);
-                  glVertex2fv(&(*lastPoint)[0]);
-                  glVertex2fv(&pt2d[0]);
+                  glVertex2dv(&(*lastPoint)[0]);
+                  glVertex2dv(&pt2d[0]);
                 glEnd ();
               }
               else //if not selected
               {
                 glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
                 //drawing crosses
                 glBegin (GL_LINES);
-                  glVertex2fv(&(*lastPoint)[0]);
-                  glVertex2fv(&pt2d[0]);
+                  glVertex2dv(&(*lastPoint)[0]);
+                  glVertex2dv(&pt2d[0]);
                 glEnd ();
               }
               //to draw the line to the next in iteration step
               *lastPoint = pt2d;
               //and to search for the selection state of the line
               lastPointId = *cellIdIt;
             }//if..else
           }//if <4.0
 
           //fill off-plane polygon part 1
           if((!first) && (worldplanegeometry!=NULL))
           {
             line.SetPoints(lastPoint3D, thisPoint);
             if(worldplanegeometry->IntersectionPointParam(line, t) &&
               ((t>=0) && (t<=1))
               )
             {
               intersectionPoints.push_back(line.GetPoint(t));
             }
           }
           ++cellIdIt;
           first=false;
         }//while cellIdIter
 
         //closed polygon?
         if ( cellDataIt->Value().closed )
         {
           //close the polygon if needed
           if( firstOfCell != NULL )
           {
             lineSelected = false;
             Mesh::SelectedLinesType selectedLines = cellDataIt->Value().selectedLines;
             Mesh::SelectedLinesIter position = std::find(selectedLines.begin(), selectedLines.end(), lastPointId);
             if (position != selectedLines.end())//found the index
             {
               glColor3f(selectedColor[0],selectedColor[1],selectedColor[2]);//red
               //a line from lastPoint to firstPoint
               glBegin (GL_LINES);
-                glVertex2fv(&(*lastPoint)[0]);
-                glVertex2fv(&(*firstOfCell)[0]);
+                glVertex2dv(&(*lastPoint)[0]);
+                glVertex2dv(&(*firstOfCell)[0]);
               glEnd ();
             }
             else
             {
               glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
               glBegin (GL_LINES);
-                glVertex2fv(&(*lastPoint)[0]);
-                glVertex2fv(&(*firstOfCell)[0]);
+                glVertex2dv(&(*lastPoint)[0]);
+                glVertex2dv(&(*firstOfCell)[0]);
               glEnd ();
             }
           }
         }//if closed
 
         //Axis-aligned bounding box(AABB) around the cell if selected and set in Property
         bool showBoundingBox;
         if (dynamic_cast<mitk::BoolProperty *>(this->GetDataNode()->GetProperty("showBoundingBox")) == NULL)
           showBoundingBox = false;
         else
           showBoundingBox = dynamic_cast<mitk::BoolProperty *>(this->GetDataNode()->GetProperty("showBoundingBox"))->GetValue();
 
         if(showBoundingBox)
         {
           if (cellDataIt->Value().selected)
           {
             mitk::Mesh::DataType::BoundingBoxPointer aABB = input->GetBoundingBoxFromCell(cellIt->Index());
             if (aABB.IsNotNull())
             {
               mitk::Mesh::PointType min, max;
               min = aABB->GetMinimum();
               max = aABB->GetMaximum();
 
               //project to the displayed geometry
               Point2D min2D, max2D;
               Point3D p, projected_p;
               float vtkp[3];
               itk2vtk(min, vtkp);
               transform->TransformPoint(vtkp, vtkp);
               vtk2itk(vtkp,p);
               displayGeometry->Project(p, projected_p);
               displayGeometry->Map(projected_p, min2D);
               displayGeometry->WorldToDisplay(min2D, min2D);
 
               itk2vtk(max, vtkp);
               transform->TransformPoint(vtkp, vtkp);
               vtk2itk(vtkp,p);
               displayGeometry->Project(p, projected_p);
               Vector3D diff=p-projected_p;
               if(diff.GetSquaredNorm()<4.0)
               {
                 displayGeometry->Map(projected_p, max2D);
                 displayGeometry->WorldToDisplay(max2D, max2D);
 
                 //draw the BoundingBox
                 glColor3f(selectedColor[0],selectedColor[1],selectedColor[2]);//red
                 //a line from lastPoint to firstPoint
                 glBegin(GL_LINE_LOOP);
                   glVertex2f(min2D[0], min2D[1]);
                   glVertex2f(min2D[0], max2D[1]);
                   glVertex2f(max2D[0], max2D[1]);
                   glVertex2f(max2D[0], min2D[1]);
                 glEnd();
               }//draw bounding-box
             }//bounding-box exists
           }//cell selected
         }//show bounding-box
 
         //fill off-plane polygon part 2
         if(worldplanegeometry!=NULL)
         {
           //consider line from last to first
           line.SetPoints(thisPoint, firstOfCell3D);
           if(worldplanegeometry->IntersectionPointParam(line, t) &&
             ((t>=0) && (t<=1))
             )
           {
             intersectionPoints.push_back(line.GetPoint(t));
           }
           std::sort(intersectionPoints.begin(), intersectionPoints.end(), point3DSmaller);
           std::vector<mitk::Point3D>::iterator it, end;
           end=intersectionPoints.end();
           if((intersectionPoints.size()%2)!=0)
           {
             --end; //ensure even number of intersection-points
           }
-          float p[2];
+          double p[2];
           Point3D pt3d;
           Point2D pt2d;
           for ( it = intersectionPoints.begin( ); it != end; ++it )
           {
             glBegin (GL_LINES);
               displayGeometry->Map(*it, pt2d); displayGeometry->WorldToDisplay(pt2d, pt2d);
-              p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2fv(p);
+              p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2dv(p);
               ++it;
               displayGeometry->Map(*it, pt2d); displayGeometry->WorldToDisplay(pt2d, pt2d);
-              p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2fv(p);
+              p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2dv(p);
             glEnd ();
           }
           if(it!=intersectionPoints.end())
           {
             glBegin (GL_LINES);
               displayGeometry->Map(*it, pt2d); displayGeometry->WorldToDisplay(pt2d, pt2d);
-              p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2fv(p);
-              p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2fv(p);
+              p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2dv(p);
+              p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2dv(p);
             glEnd ();
           }
         }//fill off-plane polygon part 2
       }//if numOfPointsInCell>1
       delete firstOfCell;
       delete lastPoint;
       lastPoint = NULL;
       firstOfCell = NULL;
       lastPointId = 0;
       ++cellIt;
       ++cellDataIt;
     }
   }
 }
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarCircle.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarCircle.cpp
index 573223e4ab..92f9aee8a9 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarCircle.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarCircle.cpp
@@ -1,164 +1,164 @@
 /*===================================================================
 
 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 "mitkPlanarCircle.h"
 #include "mitkGeometry2D.h"
 
 #include "mitkProperties.h"
 
 
 mitk::PlanarCircle::PlanarCircle()
 : FEATURE_ID_RADIUS( this->AddFeature( "Radius", "mm" ) ),
   FEATURE_ID_DIAMETER( this->AddFeature( "Diameter", "mm" ) ),
   FEATURE_ID_AREA( this->AddFeature( "Area", "mm2" ) ),
   m_MinRadius(0),
   m_MaxRadius(100),
   m_MinMaxRadiusContraintsActive(false)
 {
   // Circle has two control points
   this->ResetNumberOfControlPoints( 2 );
   this->SetNumberOfPolyLines( 1 );
   this->SetProperty( "closed", mitk::BoolProperty::New(true) );
 }
 
 
 mitk::PlanarCircle::~PlanarCircle()
 {
 }
 
 bool mitk::PlanarCircle::SetControlPoint( unsigned int index, const Point2D &point, bool /*createIfDoesNotExist*/ )
 {
   // moving center point
   if(index == 0)
   {
     const Point2D &centerPoint = GetControlPoint( 0 );
     Point2D boundaryPoint = GetControlPoint( 1 );
-    vnl_vector<float> vec = (point.GetVnlVector() - centerPoint.GetVnlVector());
+    vnl_vector<ScalarType> vec = (point.GetVnlVector() - centerPoint.GetVnlVector());
 
     boundaryPoint[0] += vec[0];
     boundaryPoint[1] += vec[1];
     PlanarFigure::SetControlPoint( 0, point );
     PlanarFigure::SetControlPoint( 1, boundaryPoint );
   }
   else if ( index == 1 )
   {
     PlanarFigure::SetControlPoint( index, point );
     return true;
   }
   return false;
 }
 
 mitk::Point2D mitk::PlanarCircle::ApplyControlPointConstraints(unsigned int index, const Point2D &point)
 {
   if ( this->GetGeometry2D() ==  NULL )
   {
     return point;
   }
 
   Point2D indexPoint;
   this->GetGeometry2D()->WorldToIndex( point, indexPoint );
 
   BoundingBox::BoundsArrayType bounds = this->GetGeometry2D()->GetBounds();
   if ( indexPoint[0] < bounds[0] ) { indexPoint[0] = bounds[0]; }
   if ( indexPoint[0] > bounds[1] ) { indexPoint[0] = bounds[1]; }
   if ( indexPoint[1] < bounds[2] ) { indexPoint[1] = bounds[2]; }
   if ( indexPoint[1] > bounds[3] ) { indexPoint[1] = bounds[3]; }
 
   Point2D constrainedPoint;
   this->GetGeometry2D()->IndexToWorld( indexPoint, constrainedPoint );
 
   if(m_MinMaxRadiusContraintsActive)
   {
     if( index != 0)
     {
       const Point2D &centerPoint = this->GetControlPoint(0);
       double euclideanDinstanceFromCenterToPoint1 = centerPoint.EuclideanDistanceTo(point);
 
       Vector2D vectorProjectedPoint;
       vectorProjectedPoint = point - centerPoint;
       vectorProjectedPoint.Normalize();
 
       if( euclideanDinstanceFromCenterToPoint1 > m_MaxRadius )
       {
         vectorProjectedPoint *= m_MaxRadius;
         constrainedPoint = centerPoint;
         constrainedPoint += vectorProjectedPoint;
       }
       else if( euclideanDinstanceFromCenterToPoint1 < m_MinRadius )
       {
         vectorProjectedPoint *= m_MinRadius;
         constrainedPoint = centerPoint;
         constrainedPoint += vectorProjectedPoint;
       }
     }
   }
 
   return constrainedPoint;
 }
 
 void mitk::PlanarCircle::GeneratePolyLine()
 {
   // TODO: start circle at specified boundary point...
 
   // clear the PolyLine-Contrainer, it will be reconstructed soon enough...
   this->ClearPolyLines();
 
   const Point2D &centerPoint = GetControlPoint( 0 );
   const Point2D &boundaryPoint = GetControlPoint( 1 );
 
   double radius = centerPoint.EuclideanDistanceTo( boundaryPoint );
 
   // Generate poly-line with 64 segments
   for ( int t = 0; t < 64; ++t )
   {
     double alpha = (double) t * vnl_math::pi / 32.0;
 
     // construct the new polyline point ...
     Point2D polyLinePoint;
     polyLinePoint[0] = centerPoint[0] + radius * cos( alpha );
     polyLinePoint[1] = centerPoint[1] + radius * sin( alpha );
 
     // ... and append it to the PolyLine.
     // No extending supported here, so we can set the index of the PolyLineElement to '0'
     AppendPointToPolyLine( 0, PolyLineElement( polyLinePoint, 0 ) );
   }
 }
 
 void mitk::PlanarCircle::GenerateHelperPolyLine(double /*mmPerDisplayUnit*/, unsigned int /*displayHeight*/)
 {
   // A circle does not require a helper object
 }
 
 void mitk::PlanarCircle::EvaluateFeaturesInternal()
 {
   // Calculate circle radius and area
   const Point3D &p0 = this->GetWorldControlPoint( 0 );
   const Point3D &p1 = this->GetWorldControlPoint( 1 );
 
   double radius = p0.EuclideanDistanceTo( p1 );
   double area = vnl_math::pi * radius * radius;
 
   this->SetQuantity( FEATURE_ID_RADIUS, radius );
   this->SetQuantity( FEATURE_ID_DIAMETER, 2*radius );
   this->SetQuantity( FEATURE_ID_AREA, area );
 }
 
 
 void mitk::PlanarCircle::PrintSelf( std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf( os, indent );
 }
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarEllipse.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarEllipse.cpp
index bbb5823c0f..0a766813e3 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarEllipse.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarEllipse.cpp
@@ -1,273 +1,273 @@
 /*===================================================================
 
 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 "mitkPlanarEllipse.h"
 #include "mitkGeometry2D.h"
 #include "mitkProperties.h"
 
 
 mitk::PlanarEllipse::PlanarEllipse()
     : m_MinRadius(0),
       m_MaxRadius(100),
       m_MinMaxRadiusContraintsActive(false),
       m_TreatAsCircle(true)
 {
     // Ellipse has three control points
     this->ResetNumberOfControlPoints( 4 );
     this->SetNumberOfPolyLines( 2 );
     this->SetProperty( "closed", mitk::BoolProperty::New(true) );
 }
 
 
 mitk::PlanarEllipse::~PlanarEllipse()
 {
 }
 
 bool mitk::PlanarEllipse::SetControlPoint( unsigned int index, const Point2D &point, bool createIfDoesNotExist )
 {
     if(index == 0) // moving center point and control points accordingly
     {
         const Point2D &centerPoint = GetControlPoint( 0 );
         Point2D boundaryPoint1 = GetControlPoint( 1 );
         Point2D boundaryPoint2 = GetControlPoint( 2 );
         Point2D boundaryPoint3 = GetControlPoint( 3 );
-        vnl_vector<float> vec = (point.GetVnlVector() - centerPoint.GetVnlVector());
+        vnl_vector<ScalarType> vec = (point.GetVnlVector() - centerPoint.GetVnlVector());
 
         boundaryPoint1[0] += vec[0];
         boundaryPoint1[1] += vec[1];
         boundaryPoint2[0] += vec[0];
         boundaryPoint2[1] += vec[1];
         boundaryPoint3[0] += vec[0];
         boundaryPoint3[1] += vec[1];
         PlanarFigure::SetControlPoint( 0, point, createIfDoesNotExist );
         PlanarFigure::SetControlPoint( 1, boundaryPoint1, createIfDoesNotExist );
         PlanarFigure::SetControlPoint( 2, boundaryPoint2, createIfDoesNotExist );
         PlanarFigure::SetControlPoint( 3, boundaryPoint3, createIfDoesNotExist );
         return true;
     }
     else if (index < 3)
     {
         PlanarFigure::SetControlPoint( index, point, createIfDoesNotExist );
         int otherIndex = index+1;
         if (otherIndex > 2)
             otherIndex = 1;
 
         const Point2D &centerPoint = GetControlPoint( 0 );
         Point2D otherPoint = GetControlPoint( otherIndex );
         Point2D point3 = GetControlPoint( 3 );
 
         Vector2D vec1 = point - centerPoint;
         Vector2D vec2;
 
         if (index == 1 && m_TreatAsCircle )
         {
             float x = vec1[0];
             vec2[0] = vec1[1];
             vec2[1] = x;
 
             if (index==1)
                 vec2[0] *= -1;
             else
                 vec2[1] *= -1;
 
             otherPoint = centerPoint+vec2;
             PlanarFigure::SetControlPoint( otherIndex, otherPoint, createIfDoesNotExist );
             float r = centerPoint.EuclideanDistanceTo(otherPoint);
 
             // adjust additional third control point
             Point2D p3 = this->GetControlPoint(3);
             Vector2D vec3;
             vec3[0] = p3[0]-centerPoint[0];
             vec3[1] = p3[1]-centerPoint[1];
             if (vec3[0]!=0 || vec3[1]!=0)
             {
                 vec3.Normalize();
                 vec3 *= r;
             }
             else
             {
                 vec3[0] = r;
                 vec3[1] = 0;
             }
             point3 = centerPoint + vec3;
             PlanarFigure::SetControlPoint( 3, point3, createIfDoesNotExist );
         }
         else if ( vec1.GetNorm() > 0 )
         {
             float r = centerPoint.EuclideanDistanceTo(otherPoint);
             float x = vec1[0];
             vec2[0] = vec1[1];
             vec2[1] = x;
 
             if (index==1)
                 vec2[0] *= -1;
             else
                 vec2[1] *= -1;
 
             vec2.Normalize(); vec2 *= r;
 
             if ( vec2.GetNorm() > 0 )
             {
                 otherPoint = centerPoint+vec2;
                 PlanarFigure::SetControlPoint( otherIndex, otherPoint, createIfDoesNotExist );
             }
 
             // adjust third control point
             Vector2D vec3 = point3 - centerPoint; vec3.Normalize();
             double r1 = centerPoint.EuclideanDistanceTo( GetControlPoint( 1 ) );
             double r2 = centerPoint.EuclideanDistanceTo( GetControlPoint( 2 ) );
             Point2D newPoint = centerPoint + vec3*std::max(r1, r2);
             PlanarFigure::SetControlPoint( 3, newPoint, createIfDoesNotExist );
 
             m_TreatAsCircle = false;
         }
         return true;
     }
     else if (index == 3)
     {
         Point2D centerPoint = GetControlPoint( 0 );
         Vector2D vec3 = point - centerPoint; vec3.Normalize();
         double r1 = centerPoint.EuclideanDistanceTo( GetControlPoint( 1 ) );
         double r2 = centerPoint.EuclideanDistanceTo( GetControlPoint( 2 ) );
         Point2D newPoint = centerPoint + vec3*std::max(r1, r2);
         PlanarFigure::SetControlPoint( index, newPoint, createIfDoesNotExist );
         m_TreatAsCircle = false;
         return true;
     }
     return false;
 }
 
 void mitk::PlanarEllipse::PlaceFigure( const mitk::Point2D &point )
 {
     PlanarFigure::PlaceFigure( point );
     m_SelectedControlPoint = 1;
 }
 
 mitk::Point2D mitk::PlanarEllipse::ApplyControlPointConstraints(unsigned int index, const Point2D &point)
 {
     return point;
 
     Point2D indexPoint;
     this->GetGeometry2D()->WorldToIndex( point, indexPoint );
 
     BoundingBox::BoundsArrayType bounds = this->GetGeometry2D()->GetBounds();
     if ( indexPoint[0] < bounds[0] ) { indexPoint[0] = bounds[0]; }
     if ( indexPoint[0] > bounds[1] ) { indexPoint[0] = bounds[1]; }
     if ( indexPoint[1] < bounds[2] ) { indexPoint[1] = bounds[2]; }
     if ( indexPoint[1] > bounds[3] ) { indexPoint[1] = bounds[3]; }
 
     Point2D constrainedPoint;
     this->GetGeometry2D()->IndexToWorld( indexPoint, constrainedPoint );
 
     if(m_MinMaxRadiusContraintsActive)
     {
         if( index != 0)
         {
             const Point2D &centerPoint = this->GetControlPoint(0);
             double euclideanDinstanceFromCenterToPoint1 = centerPoint.EuclideanDistanceTo(point);
 
             Vector2D vectorProjectedPoint;
             vectorProjectedPoint = point - centerPoint;
             vectorProjectedPoint.Normalize();
 
             if( euclideanDinstanceFromCenterToPoint1 > m_MaxRadius )
             {
                 vectorProjectedPoint *= m_MaxRadius;
                 constrainedPoint = centerPoint;
                 constrainedPoint += vectorProjectedPoint;
             }
             else if( euclideanDinstanceFromCenterToPoint1 < m_MinRadius )
             {
                 vectorProjectedPoint *= m_MinRadius;
                 constrainedPoint = centerPoint;
                 constrainedPoint += vectorProjectedPoint;
             }
         }
     }
 
     return constrainedPoint;
 }
 
 void mitk::PlanarEllipse::GeneratePolyLine()
 {
     // clear the PolyLine-Contrainer, it will be reconstructed soon enough...
     this->ClearPolyLines();
 
     const Point2D &centerPoint = GetControlPoint( 0 );
     const Point2D &boundaryPoint1 = GetControlPoint( 1 );
     const Point2D &boundaryPoint2 = GetControlPoint( 2 );
 
     Vector2D dir = boundaryPoint1 - centerPoint; dir.Normalize();
     vnl_matrix_fixed<float, 2, 2> rot;
 
     // differentiate between clockwise and counterclockwise rotation
     int start = 0;
     int end = 64;
     if (dir[1]<0)
     {
         dir[0] = -dir[0];
         start = -32;
         end = 32;
     }
     // construct rotation matrix to align ellipse with control point vector
     rot[0][0] = dir[0];
     rot[1][1] = rot[0][0];
     rot[1][0] = sin(acos(rot[0][0]));
     rot[0][1] = -rot[1][0];
 
     double radius1 = centerPoint.EuclideanDistanceTo( boundaryPoint1 );
     double radius2 = centerPoint.EuclideanDistanceTo( boundaryPoint2 );
 
     // Generate poly-line with 64 segments
     for ( int t = start; t < end; ++t )
     {
         double alpha = (double) t * vnl_math::pi / 32.0;
 
         // construct the new polyline point ...
         vnl_vector_fixed< float, 2 > vec;
         vec[0] = radius1 * cos( alpha );
         vec[1] = radius2 * sin( alpha );
         vec = rot*vec;
 
         Point2D polyLinePoint;
         polyLinePoint[0] = centerPoint[0] + vec[0];
         polyLinePoint[1] = centerPoint[1] + vec[1];
 
         // ... and append it to the PolyLine.
         // No extending supported here, so we can set the index of the PolyLineElement to '0'
         AppendPointToPolyLine( 0, PolyLineElement( polyLinePoint, 0 ) );
     }
 
     AppendPointToPolyLine( 1, PolyLineElement( centerPoint, 0 ) );
     AppendPointToPolyLine( 1, PolyLineElement( GetControlPoint( 3 ), 0 ) );
 }
 
 void mitk::PlanarEllipse::GenerateHelperPolyLine(double /*mmPerDisplayUnit*/, unsigned int /*displayHeight*/)
 {
     // A circle does not require a helper object
 }
 
 void mitk::PlanarEllipse::EvaluateFeaturesInternal()
 {
 
 }
 
 
 void mitk::PlanarEllipse::PrintSelf( std::ostream& os, itk::Indent indent) const
 {
     Superclass::PrintSelf( os, indent );
 }
diff --git a/Modules/PlanarFigure/IO/mitkPlanarFigureReader.cpp b/Modules/PlanarFigure/IO/mitkPlanarFigureReader.cpp
index da351f5580..ceba97b601 100644
--- a/Modules/PlanarFigure/IO/mitkPlanarFigureReader.cpp
+++ b/Modules/PlanarFigure/IO/mitkPlanarFigureReader.cpp
@@ -1,429 +1,429 @@
 /*===================================================================
 
 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 "mitkPlanarFigureReader.h"
 
 #include "mitkPlanarAngle.h"
 #include "mitkPlanarCircle.h"
 #include "mitkPlanarLine.h"
 #include "mitkPlanarArrow.h"
 #include "mitkPlanarCross.h"
 #include "mitkPlanarFourPointAngle.h"
 #include "mitkPlanarPolygon.h"
 #include "mitkPlanarSubdivisionPolygon.h"
 #include "mitkPlanarRectangle.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkPlanarEllipse.h"
 
 #include "mitkBasePropertySerializer.h"
 
 #include <tinyxml.h>
 #include <itksys/SystemTools.hxx>
 
 
 mitk::PlanarFigureReader::PlanarFigureReader() : PlanarFigureSource(), FileReader(),
 m_FileName(""), m_FilePrefix(""), m_FilePattern(""), m_Success(false)
 {
   this->SetNumberOfRequiredOutputs(1);
   this->SetNumberOfIndexedOutputs(1);
   this->SetNthOutput(0, this->MakeOutput(0));
 
   m_CanReadFromMemory = true;
 
 
   //this->Modified();
   //this->GetOutput()->Modified();
   //this->GetOutput()->ReleaseData();
 }
 
 
 mitk::PlanarFigureReader::~PlanarFigureReader()
 {}
 
 
 void mitk::PlanarFigureReader::GenerateData()
 {
   m_Success = false;
   this->SetNumberOfIndexedOutputs(0); // reset all outputs, we add new ones depending on the file content
 
   TiXmlDocument document;
 
   if(m_ReadFromMemory)
   {
     if(m_MemoryBuffer == NULL || m_MemorySize == 0)
     {
       //check
       itkWarningMacro( << "Sorry, memory buffer has not been set!" );
       return;
     }
     if(m_MemoryBuffer[ m_MemorySize - 1 ]  == '\0')
     {
       document.Parse(m_MemoryBuffer);
     }
     else
     {
       char * tmpArray = new char[(int)m_MemorySize+1];
       tmpArray[m_MemorySize] = '\0';
       memcpy(tmpArray,m_MemoryBuffer,m_MemorySize);
 
       document.Parse(m_MemoryBuffer);
 
       delete [] tmpArray;
     }
   }
   else
   {
     if (m_FileName.empty())
     {
       itkWarningMacro( << "Sorry, filename has not been set!" );
       return;
     }
     if (this->CanReadFile( m_FileName.c_str()) == false)
     {
       itkWarningMacro( << "Sorry, can't read file " << m_FileName << "!" );
       return;
     }
     if (!document.LoadFile(m_FileName))
     {
       MITK_ERROR << "Could not open/read/parse " << m_FileName << ". TinyXML reports: '" << document.ErrorDesc() << "'. "
               << "The error occurred in row " << document.ErrorRow() << ", column " << document.ErrorCol() << ".";
       return;
     }
   }
 
   int fileVersion = 1;
   TiXmlElement* versionObject = document.FirstChildElement("Version");
   if (versionObject != NULL)
   {
     if ( versionObject->QueryIntAttribute( "FileVersion", &fileVersion ) != TIXML_SUCCESS )
     {
       MITK_WARN << m_FileName << " does not contain version information! Trying version 1 format." << std::endl;
     }
   }
   else
   {
     MITK_WARN << m_FileName << " does not contain version information! Trying version 1 format." << std::endl;
   }
   if (fileVersion != 1)  // add file version selection and version specific file parsing here, if newer file versions are created
   {
     MITK_WARN << "File version > 1 is not supported by this reader.";
       return;
   }
 
   /* file version 1 reader code */
   for( TiXmlElement* pfElement = document.FirstChildElement("PlanarFigure");
        pfElement != NULL;
        pfElement = pfElement->NextSiblingElement("PlanarFigure") )
   {
     if (pfElement == NULL)
       continue;
 
     std::string type = pfElement->Attribute("type");
 
     mitk::PlanarFigure::Pointer planarFigure = NULL;
     if (type == "PlanarAngle")
     {
       planarFigure = mitk::PlanarAngle::New();
     }
     else if (type == "PlanarCircle")
     {
       planarFigure = mitk::PlanarCircle::New();
     }
     else if (type == "PlanarEllipse")
     {
       planarFigure = mitk::PlanarEllipse::New();
     }
     else if (type == "PlanarCross")
     {
       planarFigure = mitk::PlanarCross::New();
     }
     else if (type == "PlanarFourPointAngle")
     {
       planarFigure = mitk::PlanarFourPointAngle::New();
     }
     else if (type == "PlanarLine")
     {
       planarFigure = mitk::PlanarLine::New();
     }
     else if (type == "PlanarPolygon")
     {
       planarFigure = mitk::PlanarPolygon::New();
     }
     else if (type == "PlanarSubdivisionPolygon")
     {
       planarFigure = mitk::PlanarSubdivisionPolygon::New();
     }
     else if (type == "PlanarRectangle")
     {
       planarFigure = mitk::PlanarRectangle::New();
     }
     else if (type == "PlanarArrow")
     {
       planarFigure = mitk::PlanarArrow::New();
     }
     else
     {
       // unknown type
       MITK_WARN << "encountered unknown planar figure type '" << type << "'. Skipping this element.";
       continue;
     }
 
 
     // Read properties of the planar figure
     for( TiXmlElement* propertyElement = pfElement->FirstChildElement("property");
          propertyElement != NULL;
          propertyElement = propertyElement->NextSiblingElement("property") )
     {
       const char* keya = propertyElement->Attribute("key");
       std::string key( keya ? keya : "");
 
       const char* typea = propertyElement->Attribute("type");
       std::string type( typea ? typea : "");
 
       // hand propertyElement to specific reader
       std::stringstream propertyDeserializerClassName;
       propertyDeserializerClassName << type << "Serializer";
 
       std::list<itk::LightObject::Pointer> readers =
         itk::ObjectFactoryBase::CreateAllInstance(propertyDeserializerClassName.str().c_str());
       if (readers.size() < 1)
       {
         MITK_ERROR << "No property reader found for " << type;
       }
       if (readers.size() > 1)
       {
         MITK_WARN << "Multiple property readers found for " << type << ". Using arbitrary first one.";
       }
 
       for ( std::list<itk::LightObject::Pointer>::iterator iter = readers.begin();
         iter != readers.end();
         ++iter )
       {
         if (BasePropertySerializer* reader = dynamic_cast<BasePropertySerializer*>( iter->GetPointer() ) )
         {
           BaseProperty::Pointer property = reader->Deserialize( propertyElement->FirstChildElement() );
           if (property.IsNotNull())
           {
             planarFigure->GetPropertyList()->ReplaceProperty(key, property);
           }
           else
           {
             MITK_ERROR << "There were errors while loading property '" << key << "' of type " << type << ". Your data may be corrupted";
           }
           break;
         }
       }
     }
 
 
     // Read geometry of containing plane
     TiXmlElement* geoElement = pfElement->FirstChildElement("Geometry");
     if (geoElement != NULL)
     {
       try
       {
         // Create plane geometry
         mitk::PlaneGeometry::Pointer planeGeo = mitk::PlaneGeometry::New();
 
         // Extract and set plane transform parameters
         DoubleList transformList = this->GetDoubleAttributeListFromXMLNode( geoElement->FirstChildElement( "transformParam" ), "param", 12 );
 
         typedef mitk::AffineGeometryFrame3D::TransformType TransformType;
         TransformType::ParametersType parameters;
         parameters.SetSize( 12 );
 
         unsigned int i;
         DoubleList::iterator it;
         for ( it = transformList.begin(), i = 0;
               it != transformList.end();
               ++it, ++i )
         {
           parameters.SetElement( i, *it );
         }
 
         typedef mitk::AffineGeometryFrame3D::TransformType TransformType;
         TransformType::Pointer affineGeometry = TransformType::New();
         affineGeometry->SetParameters( parameters );
         planeGeo->SetIndexToWorldTransform( affineGeometry );
 
 
         // Extract and set plane bounds
         DoubleList boundsList = this->GetDoubleAttributeListFromXMLNode( geoElement->FirstChildElement( "boundsParam" ), "bound", 6 );
 
         typedef mitk::Geometry3D::BoundsArrayType BoundsArrayType;
 
         BoundsArrayType bounds;
         for ( it = boundsList.begin(), i = 0;
               it != boundsList.end();
               ++it, ++i )
         {
           bounds[i] = *it;
         }
 
         planeGeo->SetBounds( bounds );
 
 
         // Extract and set spacing and origin
         Vector3D spacing = this->GetVectorFromXMLNode(geoElement->FirstChildElement("Spacing"));
         planeGeo->SetSpacing( spacing );
 
         Point3D origin = this->GetPointFromXMLNode(geoElement->FirstChildElement("Origin"));
         planeGeo->SetOrigin( origin );
         planarFigure->SetGeometry2D(planeGeo);
       }
       catch (...)
       {
       }
     }
     TiXmlElement* cpElement = pfElement->FirstChildElement("ControlPoints");
     bool first = true;
     if (cpElement != NULL)
       for( TiXmlElement* vertElement = cpElement->FirstChildElement("Vertex"); vertElement != NULL; vertElement = vertElement->NextSiblingElement("Vertex"))
       {
         if (vertElement == NULL)
           continue;
         int id = 0;
         mitk::Point2D::ValueType x = 0.0;
         mitk::Point2D::ValueType y = 0.0;
         if (vertElement->QueryIntAttribute("id", &id) == TIXML_WRONG_TYPE)
           return; // TODO: can we do a better error handling?
-        if (vertElement->QueryFloatAttribute("x", &x) == TIXML_WRONG_TYPE)
+        if (vertElement->QueryDoubleAttribute("x", &x) == TIXML_WRONG_TYPE)
           return; // TODO: can we do a better error handling?
-        if (vertElement->QueryFloatAttribute("y", &y) == TIXML_WRONG_TYPE)
+        if (vertElement->QueryDoubleAttribute("y", &y) == TIXML_WRONG_TYPE)
           return; // TODO: can we do a better error handling?
         Point2D p;
         p.SetElement(0, x);
         p.SetElement(1, y);
         if (first == true)  // needed to set m_FigurePlaced to true
         {
           planarFigure->PlaceFigure(p);
           first = false;
         }
         planarFigure->SetControlPoint(id, p, true);
       }
 
     // Calculate feature quantities of this PlanarFigure
     planarFigure->EvaluateFeatures();
 
     // Make sure that no control point is currently selected
     planarFigure->DeselectControlPoint();
 
     // \TODO: what about m_FigurePlaced and m_SelectedControlPoint ??
     this->SetNthOutput( this->GetNumberOfOutputs(), planarFigure );  // add planarFigure as new output of this filter
   }
   m_Success = true;
 }
 
 mitk::Point3D mitk::PlanarFigureReader::GetPointFromXMLNode(TiXmlElement* e)
 {
   if (e == NULL)
     throw std::invalid_argument("node invalid"); // TODO: can we do a better error handling?
   mitk::Point3D point;
   mitk::ScalarType p(-1.0);
-  if (e->QueryFloatAttribute("x", &p) == TIXML_WRONG_TYPE)
+  if (e->QueryDoubleAttribute("x", &p) == TIXML_WRONG_TYPE)
     throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
   point.SetElement(0, p);
-  if (e->QueryFloatAttribute("y", &p) == TIXML_WRONG_TYPE)
+  if (e->QueryDoubleAttribute("y", &p) == TIXML_WRONG_TYPE)
     throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
   point.SetElement(1, p);
-  if (e->QueryFloatAttribute("z", &p) == TIXML_WRONG_TYPE)
+  if (e->QueryDoubleAttribute("z", &p) == TIXML_WRONG_TYPE)
     throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
   point.SetElement(2, p);
   return point;
 }
 
 
 mitk::Vector3D mitk::PlanarFigureReader::GetVectorFromXMLNode(TiXmlElement* e)
 {
   if (e == NULL)
     throw std::invalid_argument("node invalid"); // TODO: can we do a better error handling?
   mitk::Vector3D vector;
   mitk::ScalarType p(-1.0);
-  if (e->QueryFloatAttribute("x", &p) == TIXML_WRONG_TYPE)
+  if (e->QueryDoubleAttribute("x", &p) == TIXML_WRONG_TYPE)
     throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
   vector.SetElement(0, p);
-  if (e->QueryFloatAttribute("y", &p) == TIXML_WRONG_TYPE)
+  if (e->QueryDoubleAttribute("y", &p) == TIXML_WRONG_TYPE)
     throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
   vector.SetElement(1, p);
-  if (e->QueryFloatAttribute("z", &p) == TIXML_WRONG_TYPE)
+  if (e->QueryDoubleAttribute("z", &p) == TIXML_WRONG_TYPE)
     throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
   vector.SetElement(2, p);
   return vector;
 }
 
 mitk::PlanarFigureReader::DoubleList
 mitk::PlanarFigureReader::GetDoubleAttributeListFromXMLNode(TiXmlElement* e, const char *attributeNameBase, unsigned int count)
 {
   DoubleList list;
 
   if (e == NULL)
     throw std::invalid_argument("node invalid"); // TODO: can we do a better error handling?
 
   for ( unsigned int i = 0; i < count; ++i )
   {
     mitk::ScalarType p(-1.0);
     std::stringstream attributeName;
     attributeName << attributeNameBase << i;
 
-    if (e->QueryFloatAttribute( attributeName.str().c_str(), &p ) == TIXML_WRONG_TYPE)
+    if (e->QueryDoubleAttribute( attributeName.str().c_str(), &p ) == TIXML_WRONG_TYPE)
       throw std::invalid_argument("node malformatted"); // TODO: can we do a better error handling?
     list.push_back( p );
   }
 
 
   return list;
 }
 
 void mitk::PlanarFigureReader::GenerateOutputInformation()
 {
 }
 
 int mitk::PlanarFigureReader::CanReadFile ( const char *name )
 {
   if (std::string(name).empty())
     return false;
 
   return (itksys::SystemTools::LowerCase(itksys::SystemTools::GetFilenameLastExtension(name)) == ".pf");  //assume, we can read all .pf files
 
   //TiXmlDocument document(name);
   //if (document.LoadFile() == false)
   //  return false;
   //return (document.FirstChildElement("PlanarFigure") != NULL);
 }
 
 bool mitk::PlanarFigureReader::CanReadFile(const std::string filename, const std::string, const std::string)
 {
   if (filename.empty())
     return false;
 
   return (itksys::SystemTools::LowerCase(itksys::SystemTools::GetFilenameLastExtension(filename)) == ".pf");  //assume, we can read all .pf files
 
   //TiXmlDocument document(filename);
   //if (document.LoadFile() == false)
   //  return false;
   //return (document.FirstChildElement("PlanarFigure") != NULL);
 }
 
 void mitk::PlanarFigureReader::ResizeOutputs( const unsigned int& num )
 {
   unsigned int prevNum = this->GetNumberOfOutputs();
   this->SetNumberOfIndexedOutputs( num );
   for ( unsigned int i = prevNum; i < num; ++i )
   {
     this->SetNthOutput( i, this->MakeOutput( i ).GetPointer() );
   }
 }
diff --git a/Modules/SceneSerializationBase/BasePropertySerializer/mitkAnnotationPropertySerializer.cpp b/Modules/SceneSerializationBase/BasePropertySerializer/mitkAnnotationPropertySerializer.cpp
index 1e4305db8b..5fe7952376 100644
--- a/Modules/SceneSerializationBase/BasePropertySerializer/mitkAnnotationPropertySerializer.cpp
+++ b/Modules/SceneSerializationBase/BasePropertySerializer/mitkAnnotationPropertySerializer.cpp
@@ -1,77 +1,77 @@
 /*===================================================================
 
 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 mitkAnnotationPropertySerializer_h_included
 #define mitkAnnotationPropertySerializer_h_included
 
 #include "mitkBasePropertySerializer.h"
 
 #include "mitkAnnotationProperty.h"
 
 #include "SceneSerializationBaseExports.h"
 
 namespace mitk
 {
 
 class SceneSerializationBase_EXPORT AnnotationPropertySerializer : public BasePropertySerializer
 {
   public:
 
     mitkClassMacro( AnnotationPropertySerializer, BasePropertySerializer );
     itkNewMacro(Self);
 
     virtual TiXmlElement* Serialize()
     {
       if (const AnnotationProperty* prop = dynamic_cast<const AnnotationProperty*>(m_Property.GetPointer()))
       {
         TiXmlElement* element = new TiXmlElement("annotation");
         element->SetAttribute("label", prop->GetLabel());
         Point3D point = prop->GetPosition();
         element->SetDoubleAttribute("x", point[0]);
         element->SetDoubleAttribute("y", point[1]);
         element->SetDoubleAttribute("z", point[2]);
         return element;
       }
       else return NULL;
     }
 
     virtual BaseProperty::Pointer Deserialize(TiXmlElement* element)
     {
       if (!element) return NULL;
       const char* label( element->Attribute("label") );
       Point3D p;
-      if ( element->QueryFloatAttribute( "x", &p[0] ) != TIXML_SUCCESS )
+      if ( element->QueryDoubleAttribute( "x", &p[0] ) != TIXML_SUCCESS )
         return NULL;
-      if ( element->QueryFloatAttribute( "y", &p[1] ) != TIXML_SUCCESS )
+      if ( element->QueryDoubleAttribute( "y", &p[1] ) != TIXML_SUCCESS )
         return NULL;
-      if ( element->QueryFloatAttribute( "z", &p[2] ) != TIXML_SUCCESS )
+      if ( element->QueryDoubleAttribute( "z", &p[2] ) != TIXML_SUCCESS )
         return NULL;
       return AnnotationProperty::New(label, p).GetPointer();
     }
 
   protected:
 
     AnnotationPropertySerializer() {}
     virtual ~AnnotationPropertySerializer() {}
 };
 
 } // namespace
 
 // important to put this into the GLOBAL namespace (because it starts with 'namespace mitk')
 MITK_REGISTER_SERIALIZER(AnnotationPropertySerializer);
 
 #endif
 
diff --git a/Modules/SceneSerializationBase/BasePropertySerializer/mitkClippingPropertySerializer.cpp b/Modules/SceneSerializationBase/BasePropertySerializer/mitkClippingPropertySerializer.cpp
index bdd2e98343..17a49e17e4 100644
--- a/Modules/SceneSerializationBase/BasePropertySerializer/mitkClippingPropertySerializer.cpp
+++ b/Modules/SceneSerializationBase/BasePropertySerializer/mitkClippingPropertySerializer.cpp
@@ -1,99 +1,99 @@
 /*===================================================================
 
 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 mitkClippingPropertySerializer_h_included
 #define mitkClippingPropertySerializer_h_included
 
 #include "mitkBasePropertySerializer.h"
 
 #include "mitkClippingProperty.h"
 #include "mitkVector.h"
 
 #include "SceneSerializationBaseExports.h"
 
 namespace mitk
 {
 class SceneSerializationBase_EXPORT ClippingPropertySerializer : public BasePropertySerializer
 {
   public:
     mitkClassMacro( ClippingPropertySerializer, BasePropertySerializer );
     itkNewMacro(Self);
 
     virtual TiXmlElement* Serialize()
     {
       if (const ClippingProperty* prop = dynamic_cast<const ClippingProperty*>(m_Property.GetPointer()))
       {
         TiXmlElement* element = new TiXmlElement("clipping");
         if (prop->GetClippingEnabled())
           element->SetAttribute("enabled", "true");
         else
           element->SetAttribute("enabled", "false");
         TiXmlElement* originElement = new TiXmlElement("origin");
         const Point3D origin = prop->GetOrigin();
         originElement->SetDoubleAttribute("x", origin[0]);
         originElement->SetDoubleAttribute("y", origin[1]);
         originElement->SetDoubleAttribute("z", origin[2]);
         element->LinkEndChild(originElement);
         TiXmlElement* normalElement = new TiXmlElement("normal");
         const Vector3D normal = prop->GetNormal();
         normalElement->SetDoubleAttribute("x", normal[0]);
         normalElement->SetDoubleAttribute("y", normal[1]);
         normalElement->SetDoubleAttribute("z", normal[2]);
         element->LinkEndChild(normalElement);
         return element;
       }
       else
         return NULL;
     }
 
     virtual BaseProperty::Pointer Deserialize(TiXmlElement* element)
     {
       if (!element)
         return NULL;
       bool enabled = std::string(element->Attribute("enabled")) == "true";
 
       TiXmlElement* originElement = element->FirstChildElement("origin");
       if (originElement == NULL)
         return NULL;
       Point3D origin;
-      if ( originElement->QueryFloatAttribute( "x", &origin[0] ) != TIXML_SUCCESS )
+      if ( originElement->QueryDoubleAttribute( "x", &origin[0] ) != TIXML_SUCCESS )
         return NULL;
-      if ( originElement->QueryFloatAttribute( "y", &origin[1] ) != TIXML_SUCCESS )
+      if ( originElement->QueryDoubleAttribute( "y", &origin[1] ) != TIXML_SUCCESS )
         return NULL;
-      if ( originElement->QueryFloatAttribute( "z", &origin[2] ) != TIXML_SUCCESS )
+      if ( originElement->QueryDoubleAttribute( "z", &origin[2] ) != TIXML_SUCCESS )
         return NULL;
       TiXmlElement* normalElement = element->FirstChildElement("normal");
       if (normalElement == NULL)
         return NULL;
       Vector3D normal;
-      if ( normalElement->QueryFloatAttribute( "x", &normal[0] ) != TIXML_SUCCESS )
+      if ( normalElement->QueryDoubleAttribute( "x", &normal[0] ) != TIXML_SUCCESS )
         return NULL;
-      if ( normalElement->QueryFloatAttribute( "y", &normal[1] ) != TIXML_SUCCESS )
+      if ( normalElement->QueryDoubleAttribute( "y", &normal[1] ) != TIXML_SUCCESS )
         return NULL;
-      if ( normalElement->QueryFloatAttribute( "z", &normal[2] ) != TIXML_SUCCESS )
+      if ( normalElement->QueryDoubleAttribute( "z", &normal[2] ) != TIXML_SUCCESS )
         return NULL;
       ClippingProperty::Pointer cp = ClippingProperty::New(origin, normal);
       cp->SetClippingEnabled(enabled);
      return cp.GetPointer();
     }
   protected:
     ClippingPropertySerializer() {}
     virtual ~ClippingPropertySerializer() {}
 };
 } // namespace
 // important to put this into the GLOBAL namespace (because it starts with 'namespace mitk')
 MITK_REGISTER_SERIALIZER(ClippingPropertySerializer);
 #endif
diff --git a/Modules/SceneSerializationBase/BasePropertySerializer/mitkPoint3dPropertySerializer.cpp b/Modules/SceneSerializationBase/BasePropertySerializer/mitkPoint3dPropertySerializer.cpp
index 9ab0ac8a0d..1fe7cc82f3 100644
--- a/Modules/SceneSerializationBase/BasePropertySerializer/mitkPoint3dPropertySerializer.cpp
+++ b/Modules/SceneSerializationBase/BasePropertySerializer/mitkPoint3dPropertySerializer.cpp
@@ -1,74 +1,74 @@
 /*===================================================================
 
 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 mitkPoint3dPropertySerializer_h_included
 #define mitkPoint3dPropertySerializer_h_included
 
 #include "mitkBasePropertySerializer.h"
 
 #include "mitkProperties.h"
 
 #include "SceneSerializationBaseExports.h"
 
 namespace mitk
 {
 
 class SceneSerializationBase_EXPORT Point3dPropertySerializer : public BasePropertySerializer
 {
   public:
 
     mitkClassMacro( Point3dPropertySerializer, BasePropertySerializer );
     itkNewMacro(Self);
 
     virtual TiXmlElement* Serialize()
     {
       if (const Point3dProperty* prop = dynamic_cast<const Point3dProperty*>(m_Property.GetPointer()))
       {
         TiXmlElement* element = new TiXmlElement("point");
         Point3D point = prop->GetValue();
         element->SetDoubleAttribute("x", point[0]);
         element->SetDoubleAttribute("y", point[1]);
         element->SetDoubleAttribute("z", point[2]);
         return element;
       }
       else return NULL;
     }
 
     virtual BaseProperty::Pointer Deserialize(TiXmlElement* element)
     {
       if (!element) return NULL;
 
       Point3D v;
-      if ( element->QueryFloatAttribute( "x", &v[0] ) != TIXML_SUCCESS ) return NULL;
-      if ( element->QueryFloatAttribute( "y", &v[1] ) != TIXML_SUCCESS ) return NULL;
-      if ( element->QueryFloatAttribute( "z", &v[2] ) != TIXML_SUCCESS ) return NULL;
+      if ( element->QueryDoubleAttribute( "x", &v[0] ) != TIXML_SUCCESS ) return NULL;
+      if ( element->QueryDoubleAttribute( "y", &v[1] ) != TIXML_SUCCESS ) return NULL;
+      if ( element->QueryDoubleAttribute( "z", &v[2] ) != TIXML_SUCCESS ) return NULL;
 
      return Point3dProperty::New( v ).GetPointer();
     }
 
   protected:
 
     Point3dPropertySerializer() {}
     virtual ~Point3dPropertySerializer() {}
 };
 
 } // namespace
 
 // important to put this into the GLOBAL namespace (because it starts with 'namespace mitk')
 MITK_REGISTER_SERIALIZER(Point3dPropertySerializer);
 
 #endif
 
diff --git a/Modules/SceneSerializationBase/BasePropertySerializer/mitkPoint4dPropertySerializer.cpp b/Modules/SceneSerializationBase/BasePropertySerializer/mitkPoint4dPropertySerializer.cpp
index 1e638a6c51..fa74f433c1 100644
--- a/Modules/SceneSerializationBase/BasePropertySerializer/mitkPoint4dPropertySerializer.cpp
+++ b/Modules/SceneSerializationBase/BasePropertySerializer/mitkPoint4dPropertySerializer.cpp
@@ -1,76 +1,76 @@
 /*===================================================================
 
 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 mitkPoint4dPropertySerializer_h_included
 #define mitkPoint4dPropertySerializer_h_included
 
 #include "mitkBasePropertySerializer.h"
 
 #include "mitkProperties.h"
 
 #include "SceneSerializationBaseExports.h"
 
 namespace mitk
 {
 
 class SceneSerializationBase_EXPORT Point4dPropertySerializer : public BasePropertySerializer
 {
   public:
 
     mitkClassMacro( Point4dPropertySerializer, BasePropertySerializer );
     itkNewMacro(Self);
 
     virtual TiXmlElement* Serialize()
     {
       if (const Point4dProperty* prop = dynamic_cast<const Point4dProperty*>(m_Property.GetPointer()))
       {
         TiXmlElement* element = new TiXmlElement("point");
         Point4D point = prop->GetValue();
         element->SetDoubleAttribute("x", point[0]);
         element->SetDoubleAttribute("y", point[1]);
         element->SetDoubleAttribute("z", point[2]);
         element->SetDoubleAttribute("t", point[3]);
         return element;
       }
       else return NULL;
     }
 
     virtual BaseProperty::Pointer Deserialize(TiXmlElement* element)
     {
       if (!element) return NULL;
 
       Point4D v;
-      if ( element->QueryFloatAttribute( "x", &v[0] ) != TIXML_SUCCESS ) return NULL;
-      if ( element->QueryFloatAttribute( "y", &v[1] ) != TIXML_SUCCESS ) return NULL;
-      if ( element->QueryFloatAttribute( "z", &v[2] ) != TIXML_SUCCESS ) return NULL;
-      if ( element->QueryFloatAttribute( "t", &v[3] ) != TIXML_SUCCESS ) return NULL;
+      if ( element->QueryDoubleAttribute( "x", &v[0] ) != TIXML_SUCCESS ) return NULL;
+      if ( element->QueryDoubleAttribute( "y", &v[1] ) != TIXML_SUCCESS ) return NULL;
+      if ( element->QueryDoubleAttribute( "z", &v[2] ) != TIXML_SUCCESS ) return NULL;
+      if ( element->QueryDoubleAttribute( "t", &v[3] ) != TIXML_SUCCESS ) return NULL;
 
      return Point4dProperty::New( v ).GetPointer();
     }
 
   protected:
 
     Point4dPropertySerializer() {}
     virtual ~Point4dPropertySerializer() {}
 };
 
 } // namespace
 
 // important to put this into the GLOBAL namespace (because it starts with 'namespace mitk')
 MITK_REGISTER_SERIALIZER(Point4dPropertySerializer);
 
 #endif
 
diff --git a/Modules/SceneSerializationBase/BasePropertySerializer/mitkVector3DPropertySerializer.cpp b/Modules/SceneSerializationBase/BasePropertySerializer/mitkVector3DPropertySerializer.cpp
index ceb0e6e767..32580c0435 100644
--- a/Modules/SceneSerializationBase/BasePropertySerializer/mitkVector3DPropertySerializer.cpp
+++ b/Modules/SceneSerializationBase/BasePropertySerializer/mitkVector3DPropertySerializer.cpp
@@ -1,74 +1,74 @@
 /*===================================================================
 
 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 mitkVector3DPropertySerializer_h_included
 #define mitkVector3DPropertySerializer_h_included
 
 #include "mitkBasePropertySerializer.h"
 
 #include "mitkProperties.h"
 
 #include "SceneSerializationBaseExports.h"
 
 namespace mitk
 {
 
 class SceneSerializationBase_EXPORT Vector3DPropertySerializer : public BasePropertySerializer
 {
   public:
 
     mitkClassMacro( Vector3DPropertySerializer, BasePropertySerializer );
     itkNewMacro(Self);
 
     virtual TiXmlElement* Serialize()
     {
       if (const Vector3DProperty* prop = dynamic_cast<const Vector3DProperty*>(m_Property.GetPointer()))
       {
         TiXmlElement* element = new TiXmlElement("vector");
         Vector3D point = prop->GetValue();
         element->SetDoubleAttribute("x", point[0]);
         element->SetDoubleAttribute("y", point[1]);
         element->SetDoubleAttribute("z", point[2]);
         return element;
       }
       else return NULL;
     }
 
     virtual BaseProperty::Pointer Deserialize(TiXmlElement* element)
     {
       if (!element) return NULL;
 
       Vector3D v;
-      if ( element->QueryFloatAttribute( "x", &v[0] ) != TIXML_SUCCESS ) return NULL;
-      if ( element->QueryFloatAttribute( "y", &v[1] ) != TIXML_SUCCESS ) return NULL;
-      if ( element->QueryFloatAttribute( "z", &v[2] ) != TIXML_SUCCESS ) return NULL;
+      if ( element->QueryDoubleAttribute( "x", &v[0] ) != TIXML_SUCCESS ) return NULL;
+      if ( element->QueryDoubleAttribute( "y", &v[1] ) != TIXML_SUCCESS ) return NULL;
+      if ( element->QueryDoubleAttribute( "z", &v[2] ) != TIXML_SUCCESS ) return NULL;
 
      return Vector3DProperty::New( v ).GetPointer();
     }
 
   protected:
 
     Vector3DPropertySerializer() {}
     virtual ~Vector3DPropertySerializer() {}
 };
 
 } // namespace
 
 // important to put this into the GLOBAL namespace (because it starts with 'namespace mitk')
 MITK_REGISTER_SERIALIZER(Vector3DPropertySerializer);
 
 #endif
 
diff --git a/Modules/Segmentation/Algorithms/mitkCalculateSegmentationVolume.cpp b/Modules/Segmentation/Algorithms/mitkCalculateSegmentationVolume.cpp
index c688dbb05e..9cf3fc3b15 100644
--- a/Modules/Segmentation/Algorithms/mitkCalculateSegmentationVolume.cpp
+++ b/Modules/Segmentation/Algorithms/mitkCalculateSegmentationVolume.cpp
@@ -1,124 +1,124 @@
 /*===================================================================
 
 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 <mitkImageAccessByItk.h>
 
 #include "mitkCalculateSegmentationVolume.h"
 #include "itkImageRegionConstIteratorWithIndex.h"
 
 #include <limits>
 
 namespace mitk
 {
 
 CalculateSegmentationVolume::CalculateSegmentationVolume()
 {
 }
 
 
 CalculateSegmentationVolume::~CalculateSegmentationVolume()
 {
 }
 
 
 template < typename TPixel, unsigned int VImageDimension >
 void CalculateSegmentationVolume::ItkImageProcessing( itk::Image< TPixel, VImageDimension >* itkImage, TPixel* itkNotUsed(dummy) )
 {
   itk::ImageRegionConstIteratorWithIndex<itk::Image<TPixel, VImageDimension> > iterBinaryImage( itkImage, itkImage->GetLargestPossibleRegion() );
   typename itk::ImageRegionConstIteratorWithIndex<itk::Image<TPixel, VImageDimension> >::IndexType currentIndex;
   typename itk::ImageRegionConstIteratorWithIndex<itk::Image<TPixel, VImageDimension> >::IndexType minIndex;
   for (unsigned int i = 0; i < VImageDimension; ++i) minIndex[i] = std::numeric_limits<long int>::max();
 
   typename itk::ImageRegionConstIteratorWithIndex<itk::Image<TPixel, VImageDimension> >::IndexType maxIndex;
   for (unsigned int i = 0; i < VImageDimension; ++i) maxIndex[i] = std::numeric_limits<long int>::min();
 
   m_CenterOfMass.Fill(0.0);
 
   m_Volume = 0;
   while (!iterBinaryImage.IsAtEnd())
   {
     if ( iterBinaryImage.Get() > static_cast<TPixel>(0.0) )
     {
       // update center of mass
       currentIndex = iterBinaryImage.GetIndex();
-      itk::Vector<float, VImageDimension> currentPoint;
+      itk::Vector<ScalarType, VImageDimension> currentPoint;
       for (unsigned int i = 0; i < VImageDimension; ++i) currentPoint[i] = currentIndex[i];
 
-      m_CenterOfMass =    (m_CenterOfMass * ( static_cast<float>(m_Volume) / static_cast<float>(m_Volume+1) ) )  // e.g. 3 points:   old center * 2/3 + currentPoint * 1/3;
-             + currentPoint / static_cast<float>(m_Volume+1);
+      m_CenterOfMass =    (m_CenterOfMass * ( static_cast<ScalarType>(m_Volume) / static_cast<ScalarType>(m_Volume+1) ) )  // e.g. 3 points:   old center * 2/3 + currentPoint * 1/3;
+             + currentPoint / static_cast<ScalarType>(m_Volume+1);
 
       // update number of voxels
       ++m_Volume;
 
       // update bounding box
       for (unsigned int i = 0; i < VImageDimension; ++i)
       {
         if (currentIndex[i] < minIndex[i]) minIndex[i] = currentIndex[i];
         if (currentIndex[i] > maxIndex[i]) maxIndex[i] = currentIndex[i];
       }
     }
 
     ++iterBinaryImage;
   }
 
   m_MinIndexOfBoundingBox[2] = 0.0;
   m_MaxIndexOfBoundingBox[2] = 0.0;
   for (unsigned int i = 0; i < VImageDimension; ++i)
   {
     m_MinIndexOfBoundingBox[i] = minIndex[i];
     m_MaxIndexOfBoundingBox[i] = maxIndex[i];
   }
 }
 
 
 bool CalculateSegmentationVolume::ReadyToRun()
 {
   Image::Pointer image;
   GetPointerParameter("Input", image);
 
   return image.IsNotNull() && GetGroupNode();
 }
 
 
 bool CalculateSegmentationVolume::ThreadedUpdateFunction()
 {
   // get image
   Image::Pointer image;
   GetPointerParameter("Input", image);
 
   AccessFixedDimensionByItk( image.GetPointer(), ItkImageProcessing, 3 ); // some magic to call the correctly templated function (we only do 3D images here!)
 
   // consider single voxel volume
   Vector3D spacing = image->GetSlicedGeometry()->GetSpacing(); // spacing in mm
   float volumeML = (ScalarType) m_Volume * spacing[0] * spacing[1] * spacing[2] / 1000.0; // convert to ml
 
   DataNode* groupNode = GetGroupNode();
   if (groupNode)
   {
     groupNode->SetProperty( "volume", FloatProperty::New(volumeML) );
     groupNode->SetProperty( "centerOfMass", Vector3DProperty::New(m_CenterOfMass) );
     groupNode->SetProperty( "boundingBoxMinimum", Vector3DProperty::New(m_MinIndexOfBoundingBox) );
     groupNode->SetProperty( "boundingBoxMaximum", Vector3DProperty::New(m_MaxIndexOfBoundingBox) );
     groupNode->SetProperty( "showVolume", BoolProperty::New(true) );
   }
 
   return true;
 }
 
 
 } // namespace
 
 
diff --git a/Modules/Segmentation/DataManagement/mitkContour.cpp b/Modules/Segmentation/DataManagement/mitkContour.cpp
index 25de442b69..62d4d1d7aa 100644
--- a/Modules/Segmentation/DataManagement/mitkContour.cpp
+++ b/Modules/Segmentation/DataManagement/mitkContour.cpp
@@ -1,162 +1,162 @@
 /*===================================================================
 
 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 "mitkContour.h"
 
 mitk::Contour::Contour() :
 m_ContourPath (PathType::New()),
 m_CurrentWindow ( NULL ),
 m_BoundingBox (BoundingBoxType::New()),
 m_Vertices ( BoundingBoxType::PointsContainer::New() ),
 m_Closed ( true ),
 m_Selected ( false ),
 m_Width (3.0)
 {
   Superclass::InitializeTimeSlicedGeometry();
 }
 
 mitk::Contour::Contour( const Contour & other ): BaseData(other),
 m_ContourPath(other.m_ContourPath),
 m_CurrentWindow(other.m_CurrentWindow),
 m_BoundingBox(other.m_BoundingBox),
 m_Vertices(other.m_Vertices),
 m_Closed(other.m_Closed),
 m_Selected(other.m_Selected),
 m_Width(other.m_Width)
 {
 }
 
 mitk::Contour::~Contour()
 {
 }
 
 void mitk::Contour::AddVertex(mitk::Point3D newPoint)
 {
   BoundingBoxType::PointType p;
   p.CastFrom(newPoint);
   m_Vertices->InsertElement(m_Vertices->Size(), p);
   ContinuousIndexType idx;
   idx.CastFrom(newPoint);
   m_ContourPath->AddVertex(idx);
   m_BoundingBox->SetPoints(m_Vertices);
   Modified();
 }
 
 void mitk::Contour::UpdateOutputInformation()
 {
   // \todo probably we should do this additionally for each time-step
-  float mitkBounds[6];
+  ScalarType mitkBounds[6];
   if (m_Vertices->Size() == 0)  {
     mitkBounds[0] = 0.0;
     mitkBounds[1] = 0.0;
     mitkBounds[2] = 0.0;
     mitkBounds[3] = 0.0;
     mitkBounds[4] = 0.0;
     mitkBounds[5] = 0.0;
   }
   else
   {
     m_BoundingBox->ComputeBoundingBox();
     BoundingBoxType::BoundsArrayType tmp = m_BoundingBox->GetBounds();
     mitkBounds[0] = tmp[0];
     mitkBounds[1] = tmp[1];
     mitkBounds[2] = tmp[2];
     mitkBounds[3] = tmp[3];
     mitkBounds[4] = tmp[4];
     mitkBounds[5] = tmp[5];
   }
   Geometry3D* geometry3d = GetGeometry(0);
   geometry3d->SetBounds(mitkBounds);
   GetTimeSlicedGeometry()->UpdateInformation();
 }
 
 void mitk::Contour::SetRequestedRegionToLargestPossibleRegion()
 {
 }
 
 bool mitk::Contour::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   return false;
 }
 
 bool mitk::Contour::VerifyRequestedRegion()
 {
   return true;
 }
 
 void mitk::Contour::SetRequestedRegion( const itk::DataObject*)
 {
 }
 
 mitk::Contour::PathType::Pointer mitk::Contour::GetContourPath() const
 {
   return m_ContourPath;
 }
 
 void mitk::Contour::SetCurrentWindow(vtkRenderWindow* rw)
 {
   m_CurrentWindow = rw;
 }
 
 vtkRenderWindow* mitk::Contour::GetCurrentWindow() const
 {
   return m_CurrentWindow;
 }
 
 void mitk::Contour::Initialize()
 {
   m_ContourPath = PathType::New();
   m_ContourPath->Initialize();
   m_BoundingBox = BoundingBoxType::New();
   m_Vertices = BoundingBoxType::PointsContainer::New();
   GetTimeSlicedGeometry()->InitializeEvenlyTimed(1);
 }
 
 unsigned int mitk::Contour::GetNumberOfPoints() const
 {
   return m_Vertices->Size();
 }
 
 mitk::Contour::PointsContainerPointer
 mitk::Contour::GetPoints() const
 {
   return m_Vertices;
 }
 
 void mitk::Contour::SetPoints(mitk::Contour::PointsContainerPointer points)
 {
   m_Vertices = points;
   Modified();
 }
 
 void mitk::Contour::PrintSelf( std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf( os, indent );
 
   os << indent << "Number of verticies:  " << GetNumberOfPoints() << std::endl;
 
   mitk::Contour::PointsContainerIterator pointsIt = m_Vertices->Begin(), end = m_Vertices->End();
 
   os << indent << "Verticies:  " << std::endl;
 
   int i = 0;
   while ( pointsIt != end )
   {
     os << indent << indent << i << ": " << pointsIt.Value() << std::endl;
     ++pointsIt; ++i;
   }
 }
diff --git a/Modules/Segmentation/DataManagement/mitkContourModel.cpp b/Modules/Segmentation/DataManagement/mitkContourModel.cpp
index a7da7afaad..80ca6ba22c 100644
--- a/Modules/Segmentation/DataManagement/mitkContourModel.cpp
+++ b/Modules/Segmentation/DataManagement/mitkContourModel.cpp
@@ -1,552 +1,552 @@
 /*===================================================================
 
 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 <mitkContourModel.h>
 #include <mitkPlaneGeometry.h>
 
 mitk::ContourModel::ContourModel()
 {
   //set to initial state
   this->InitializeEmpty();
 }
 
 
 
 mitk::ContourModel::ContourModel(const mitk::ContourModel &other) :
 m_ContourSeries(other.m_ContourSeries), m_lineInterpolation(other.m_lineInterpolation)
 {
   m_SelectedVertex = NULL;
 }
 
 
 
 mitk::ContourModel::~ContourModel()
 {
   m_SelectedVertex = NULL;
   this->m_ContourSeries.clear();//TODO check destruction
 }
 
 
 
 void mitk::ContourModel::AddVertex(mitk::Point3D &vertex, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep) )
   {
     this->AddVertex(vertex, false, timestep);
   }
 }
 
 
 
 void mitk::ContourModel::AddVertex(mitk::Point3D &vertex, bool isControlPoint, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->AddVertex(vertex, isControlPoint);
     this->InvokeEvent( ContourModelSizeChangeEvent() );
     this->Modified();
   }
 }
 
 
 
 void mitk::ContourModel::AddVertex(VertexType &vertex, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->AddVertex(vertex);
     this->InvokeEvent( ContourModelSizeChangeEvent() );
     this->Modified();
   }
 }
 
 
 
 void mitk::ContourModel::AddVertexAtFront(mitk::Point3D &vertex, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep) )
   {
     this->AddVertexAtFront(vertex, false, timestep);
   }
 }
 
 
 
 void mitk::ContourModel::AddVertexAtFront(mitk::Point3D &vertex, bool isControlPoint, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->AddVertexAtFront(vertex, isControlPoint);
     this->InvokeEvent( ContourModelSizeChangeEvent() );
     this->Modified();
   }
 }
 
 
 
 void mitk::ContourModel::AddVertexAtFront(VertexType &vertex, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->AddVertexAtFront(vertex);
     this->InvokeEvent( ContourModelSizeChangeEvent() );
     this->Modified();
   }
 }
 
 
 
 void mitk::ContourModel::InsertVertexAtIndex(mitk::Point3D &vertex, int index, bool isControlPoint, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     if(index > 0 && this->m_ContourSeries[timestep]->GetSize() > index)
     {
       this->m_ContourSeries[timestep]->InsertVertexAtIndex(vertex, isControlPoint, index);
       this->InvokeEvent( ContourModelSizeChangeEvent() );
       this->Modified();
     }
   }
 }
 
 
 
 int mitk::ContourModel::GetNumberOfVertices( int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->GetSize();
   }
   return -1;
 }
 
 
 
 const mitk::ContourModel::VertexType* mitk::ContourModel::GetVertexAt(int index, int timestep) const
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->GetVertexAt(index);
   }
   return NULL;
 }
 
 
 
 void mitk::ContourModel::Close( int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->Close();
     this->InvokeEvent( ContourModelClosedEvent() );
     this->Modified();
   }
 }
 
 
 void mitk::ContourModel::Open( int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->Open();
     this->InvokeEvent( ContourModelClosedEvent() );
     this->Modified();
   }
 }
 
 
 void mitk::ContourModel::SetIsClosed(bool isClosed, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->SetIsClosed(isClosed);
     this->InvokeEvent( ContourModelClosedEvent() );
     this->Modified();
   }
 }
 
 
 
 bool mitk::ContourModel::IsEmptyTimeStep( int t) const
 {
   return (t < 0) || (this->m_ContourSeries.size() <= t);
 }
 
 
 
 void mitk::ContourModel::Concatenate(mitk::ContourModel* other, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     if( !this->m_ContourSeries[timestep]->IsClosed() )
     {
       this->m_ContourSeries[timestep]->Concatenate(other->m_ContourSeries[timestep]);
       this->InvokeEvent( ContourModelSizeChangeEvent() );
       this->Modified();
     }
   }
 }
 
 
 
 mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorBegin( int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->IteratorBegin();
   }
   else
   {
     mitkThrow() << "No iterator at invalid timestep " << timestep << ". There are only " << this->GetTimeSteps() << " timesteps available.";
   }
 }
 
 
 
 mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorEnd( int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->IteratorEnd();
   }
   else
   {
     mitkThrow() << "No iterator at invalid timestep " << timestep << ". There are only " << this->GetTimeSteps() << " timesteps available.";
   }
 }
 
 
 
 bool mitk::ContourModel::IsClosed( int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->IsClosed();
   }
   return false;
 }
 
 
 
 bool mitk::ContourModel::SelectVertexAt(int index, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     return (this->m_SelectedVertex = this->m_ContourSeries[timestep]->GetVertexAt(index));
   }
   return false;
 }
 
 
 
 bool mitk::ContourModel::SelectVertexAt(mitk::Point3D &point, float eps, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     this->m_SelectedVertex = this->m_ContourSeries[timestep]->GetVertexAt(point, eps);
   }
   return this->m_SelectedVertex != NULL;
 }
 
 
 
 bool mitk::ContourModel::RemoveVertex(VertexType* vertex, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     if(this->m_ContourSeries[timestep]->RemoveVertex(vertex))
     {
       this->Modified();
       this->InvokeEvent( ContourModelSizeChangeEvent() );
       return true;
     }
   }
   return false;
 }
 
 
 
 bool mitk::ContourModel::RemoveVertexAt(int index, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     if(this->m_ContourSeries[timestep]->RemoveVertexAt(index))
     {
       this->Modified();
       this->InvokeEvent( ContourModelSizeChangeEvent() );
       return true;
     }
   }
   return false;
 }
 
 
 
 bool mitk::ContourModel::RemoveVertexAt(mitk::Point3D &point, float eps, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     if(this->m_ContourSeries[timestep]->RemoveVertexAt(point, eps))
     {
       this->Modified();
       this->InvokeEvent( ContourModelSizeChangeEvent() );
       return true;
     }
   }
   return false;
 }
 
 
 
 void mitk::ContourModel::ShiftSelectedVertex(mitk::Vector3D &translate)
 {
   if(this->m_SelectedVertex)
   {
     this->ShiftVertex(this->m_SelectedVertex,translate);
     this->Modified();
   }
 }
 
 
 
 void mitk::ContourModel::ShiftContour(mitk::Vector3D &translate, int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     VertexListType* vList = this->m_ContourSeries[timestep]->GetVertexList();
     VertexIterator it = vList->begin();
     VertexIterator end = vList->end();
 
     //shift all vertices
     while(it != end)
     {
       this->ShiftVertex((*it),translate);
       it++;
     }
 
     this->Modified();
     this->InvokeEvent( ContourModelShiftEvent() );
   }
 }
 
 
 
 void mitk::ContourModel::ShiftVertex(VertexType* vertex, mitk::Vector3D &vector)
 {
   vertex->Coordinates[0] += vector[0];
   vertex->Coordinates[1] += vector[1];
   vertex->Coordinates[2] += vector[2];
 }
 
 
 
 void mitk::ContourModel::Clear(int timestep)
 {
   if(!this->IsEmptyTimeStep(timestep))
   {
     //clear data at timestep
     this->m_ContourSeries[timestep]->Clear();
     this->InitializeEmpty();
     this->Modified();
   }
 }
 
 
 
 void mitk::ContourModel::Expand( int timeSteps )
 {
   int oldSize = this->m_ContourSeries.size();
 
   if( timeSteps > 0 && timeSteps > oldSize )
   {
     Superclass::Expand(timeSteps);
 
     //insert contours for each new timestep
     for( int i = oldSize; i < timeSteps; i++)
     {
       m_ContourSeries.push_back(mitk::ContourElement::New());
     }
 
     this->InvokeEvent( ContourModelExpandTimeBoundsEvent() );
   }
 }
 
 
 
 void mitk::ContourModel::SetRequestedRegionToLargestPossibleRegion ()
 {
   //no support for regions
 }
 
 
 
 bool mitk::ContourModel::RequestedRegionIsOutsideOfTheBufferedRegion ()
 {
   //no support for regions
   return false;
 }
 
 
 
 bool mitk::ContourModel::VerifyRequestedRegion ()
 {
   //no support for regions
   return true;
 }
 
 
 
 const mitk::Geometry3D * mitk::ContourModel::GetUpdatedGeometry (int t)
 {
   return Superclass::GetUpdatedGeometry(t);
 }
 
 
 
 mitk::Geometry3D* mitk::ContourModel::GetGeometry (int t)const
 {
   return Superclass::GetGeometry(t);
 }
 
 
 
 void mitk::ContourModel::SetRequestedRegion( const itk::DataObject *data)
 {
   //no support for regions
 }
 
 
 void mitk::ContourModel::Clear()
 {
   //clear data and set to initial state again
   this->ClearData();
   this->InitializeEmpty();
   this->Modified();
 }
 
 
 
 void mitk::ContourModel::ClearData()
 {
   //call the superclass, this releases the data of BaseData
   Superclass::ClearData();
 
   //clear out the time resolved contours
   this->m_ContourSeries.clear();
 }
 
 
 
 void mitk::ContourModel::InitializeEmpty()
 {
   //clear data at timesteps
   this->m_ContourSeries.resize(0);
   this->m_ContourSeries.push_back(mitk::ContourElement::New());
 
   //set number of timesteps to one
   this->InitializeTimeSlicedGeometry(1);
 
   m_SelectedVertex = NULL;
   this->m_lineInterpolation = ContourModel::LINEAR;
 }
 
 
 
 void mitk::ContourModel::UpdateOutputInformation()
 {
 
   if ( this->GetSource() )
   {
     this->GetSource()->UpdateOutputInformation();
   }
 
 
 
   //update the bounds of the geometry according to the stored vertices
-  float mitkBounds[6];
+  ScalarType mitkBounds[6];
 
 
   //calculate the boundingbox at each timestep
 
   typedef itk::BoundingBox<unsigned long, 3, ScalarType>        BoundingBoxType;
   typedef BoundingBoxType::PointsContainer                      PointsContainer;
 
   int timesteps = this->GetTimeSteps();
 
   //iterate over the timesteps
   for(int currenTimeStep = 0; currenTimeStep < timesteps; currenTimeStep++)
   {
     if( dynamic_cast< mitk::PlaneGeometry* >(this->GetGeometry(currenTimeStep)) )
     {
       //do not update bounds for 2D geometries, as they are unfortunately defined with min bounds 0!
       return;
     }
     else
     {//we have a 3D geometry -> let's update bounds
       //only update bounds if the contour was modified
       if (this->GetMTime() > this->GetGeometry(currenTimeStep)->GetBoundingBox()->GetMTime())
       {
         mitkBounds[0] = 0.0;
         mitkBounds[1] = 0.0;
         mitkBounds[2] = 0.0;
         mitkBounds[3] = 0.0;
         mitkBounds[4] = 0.0;
         mitkBounds[5] = 0.0;
 
         BoundingBoxType::Pointer boundingBox = BoundingBoxType::New();
 
         PointsContainer::Pointer points = PointsContainer::New();
 
         VertexIterator it = this->IteratorBegin(currenTimeStep);
         VertexIterator end = this->IteratorEnd(currenTimeStep);
 
         //fill the boundingbox with the points
         while(it != end)
         {
           Point3D currentP = (*it)->Coordinates;
           BoundingBoxType::PointType p;
           p.CastFrom(currentP);
           points->InsertElement(points->Size(), p);
 
           it++;
         }
 
         //construct the new boundingBox
         boundingBox->SetPoints(points);
         boundingBox->ComputeBoundingBox();
         BoundingBoxType::BoundsArrayType tmp = boundingBox->GetBounds();
         mitkBounds[0] = tmp[0];
         mitkBounds[1] = tmp[1];
         mitkBounds[2] = tmp[2];
         mitkBounds[3] = tmp[3];
         mitkBounds[4] = tmp[4];
         mitkBounds[5] = tmp[5];
 
         //set boundingBox at current timestep
         Geometry3D* geometry3d = this->GetGeometry(currenTimeStep);
         geometry3d->SetBounds(mitkBounds);
       }
     }
   }
   GetTimeSlicedGeometry()->UpdateInformation();
 }
 
 
 
 
 void mitk::ContourModel::ExecuteOperation(mitk::Operation* operation)
 {
   //not supported yet
 }
diff --git a/Modules/Segmentation/Rendering/mitkContourModelGLMapper2D.cpp b/Modules/Segmentation/Rendering/mitkContourModelGLMapper2D.cpp
index 80f4ead147..490d34a509 100644
--- a/Modules/Segmentation/Rendering/mitkContourModelGLMapper2D.cpp
+++ b/Modules/Segmentation/Rendering/mitkContourModelGLMapper2D.cpp
@@ -1,282 +1,282 @@
 /*===================================================================
 
 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 "mitkContourModelGLMapper2D.h"
 #include "mitkBaseRenderer.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkContourModel.h"
 #include "mitkContourModelSubDivisionFilter.h"
 #include <vtkLinearTransform.h>
 
 #include "mitkGL.h"
 
 mitk::ContourModelGLMapper2D::ContourModelGLMapper2D()
 {
 }
 
 mitk::ContourModelGLMapper2D::~ContourModelGLMapper2D()
 {
 }
 
 
 void mitk::ContourModelGLMapper2D::Paint(mitk::BaseRenderer * renderer)
 {
   BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if ( !visible ) return;
 
   bool updateNeccesary=true;
 
   int timestep = renderer->GetTimeStep();
 
   mitk::ContourModel::Pointer input =  const_cast<mitk::ContourModel*>(this->GetInput());
   mitk::ContourModel::Pointer renderingContour = input;
 
   bool subdivision = false;
   this->GetDataNode()->GetBoolProperty( "subdivision curve", subdivision, renderer );
   if (subdivision)
   {
 
     mitk::ContourModel::Pointer subdivContour = mitk::ContourModel::New();
 
     mitk::ContourModelSubDivisionFilter::Pointer subdivFilter = mitk::ContourModelSubDivisionFilter::New();
 
     subdivFilter->SetInput(input);
     subdivFilter->Update();
 
     subdivContour = subdivFilter->GetOutput();
 
     if(subdivContour->GetNumberOfVertices() == 0 )
     {
       subdivContour = input;
     }
 
     renderingContour = subdivContour;
   }
 
   renderingContour->UpdateOutputInformation();
 
 
   if( renderingContour->GetMTime() < ls->GetLastGenerateDataTime() )
     updateNeccesary = false;
 
   if(renderingContour->GetNumberOfVertices(timestep) < 1)
     updateNeccesary = false;
 
   if (updateNeccesary)
   {
     // ok, das ist aus GenerateData kopiert
     mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
     assert(displayGeometry.IsNotNull());
 
     //apply color and opacity read from the PropertyList
     ApplyProperties(renderer);
 
     mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty("contour.color", renderer));
     if(colorprop)
     {
       //set the color of the contour
       double red = colorprop->GetColor().GetRed();
       double green = colorprop->GetColor().GetGreen();
       double blue = colorprop->GetColor().GetBlue();
       glColor4f(red,green,blue,0.5);
     }
 
     mitk::ColorProperty::Pointer selectedcolor = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty("points.color", renderer));
     if(!selectedcolor)
     {
       selectedcolor = mitk::ColorProperty::New(1.0,0.0,0.1);
     }
 
 
     vtkLinearTransform* transform = GetDataNode()->GetVtkTransform();
 
     //    ContourModel::OutputType point;
     mitk::Point3D point;
 
     mitk::Point3D p, projected_p;
     float vtkp[3];
     float lineWidth = 3.0;
 
     if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("contour.width")) != NULL)
       lineWidth = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("contour.width"))->GetValue();
     glLineWidth(lineWidth);
 
 
     bool drawit=false;
 
     mitk::ContourModel::VertexIterator pointsIt = renderingContour->IteratorBegin(timestep);
 
     Point2D pt2d;       // projected_p in display coordinates
     Point2D lastPt2d;
 
     while ( pointsIt != renderingContour->IteratorEnd(timestep) )
     {
       lastPt2d = pt2d;
 
       point = (*pointsIt)->Coordinates;
 
       itk2vtk(point, vtkp);
       transform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp,p);
 
       displayGeometry->Project(p, projected_p);
 
       displayGeometry->Map(projected_p, pt2d);
       displayGeometry->WorldToDisplay(pt2d, pt2d);
 
       Vector3D diff=p-projected_p;
       ScalarType scalardiff = diff.GetNorm();
 
       //draw lines
       bool projectmode=false;
       GetDataNode()->GetVisibility(projectmode, renderer, "contour.project-onto-plane");
 
       if(projectmode)
       {
         drawit=true;
       }
       else if(scalardiff<0.25)
       {
         drawit=true;
       }
 
       if(drawit)
       {
         //lastPt2d is not valid in first step
         if( !(pointsIt == renderingContour->IteratorBegin(timestep)) )
         {
           glBegin (GL_LINES);
           glVertex2f(pt2d[0], pt2d[1]);
           glVertex2f(lastPt2d[0], lastPt2d[1]);
           glEnd();
         }
 
 
         //draw active points
         if ((*pointsIt)->IsControlPoint)
         {
           float pointsize = 4;
           Point2D  tmp;
 
           Vector2D horz,vert;
           horz[1]=0;
           vert[0]=0;
           horz[0]=pointsize;
           vert[1]=pointsize;
           glColor3f(selectedcolor->GetColor().GetRed(), selectedcolor->GetColor().GetBlue(), selectedcolor->GetColor().GetGreen());
           glLineWidth(1);
           //a rectangle around the point with the selected color
           glBegin (GL_LINE_LOOP);
-          tmp=pt2d-horz;      glVertex2fv(&tmp[0]);
-          tmp=pt2d+vert;      glVertex2fv(&tmp[0]);
-          tmp=pt2d+horz;      glVertex2fv(&tmp[0]);
-          tmp=pt2d-vert;      glVertex2fv(&tmp[0]);
+          tmp=pt2d-horz;      glVertex2dv(&tmp[0]);
+          tmp=pt2d+vert;      glVertex2dv(&tmp[0]);
+          tmp=pt2d+horz;      glVertex2dv(&tmp[0]);
+          tmp=pt2d-vert;      glVertex2dv(&tmp[0]);
           glEnd();
           glLineWidth(1);
           //the actual point in the specified color to see the usual color of the point
           glColor3f(colorprop->GetColor().GetRed(),colorprop->GetColor().GetGreen(),colorprop->GetColor().GetBlue());
           glPointSize(1);
           glBegin (GL_POINTS);
-          tmp=pt2d;             glVertex2fv(&tmp[0]);
+          tmp=pt2d;             glVertex2dv(&tmp[0]);
           glEnd ();
         }
       }
 
       pointsIt++;
     }//end while iterate over controlpoints
 
     //close contour if necessary
     if(renderingContour->IsClosed(timestep) && drawit)
     {
       lastPt2d = pt2d;
       point = renderingContour->GetVertexAt(0,timestep)->Coordinates;
       itk2vtk(point, vtkp);
       transform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp,p);
       displayGeometry->Project(p, projected_p);
       displayGeometry->Map(projected_p, pt2d);
       displayGeometry->WorldToDisplay(pt2d, pt2d);
 
       glBegin (GL_LINES);
       glVertex2f(lastPt2d[0], lastPt2d[1]);
       glVertex2f( pt2d[0], pt2d[1] );
       glEnd();
     }
 
     //draw selected vertex if exists
     if(renderingContour->GetSelectedVertex())
     {
       //transform selected vertex
       point = renderingContour->GetSelectedVertex()->Coordinates;
 
       itk2vtk(point, vtkp);
       transform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp,p);
 
       displayGeometry->Project(p, projected_p);
 
       displayGeometry->Map(projected_p, pt2d);
       displayGeometry->WorldToDisplay(pt2d, pt2d);
 
       Vector3D diff=p-projected_p;
       ScalarType scalardiff = diff.GetNorm();
       //----------------------------------
 
       //draw point if close to plane
       if(scalardiff<0.25)
       {
 
         float pointsize = 3.2;
         Point2D  tmp;
         glColor3f(0.0, 1.0, 0.0);
         glLineWidth(1);
         //a diamond around the point
         glBegin (GL_LINE_LOOP);
         //begin from upper left corner and paint clockwise
-        tmp[0]=pt2d[0]-pointsize;    tmp[1]=pt2d[1]+pointsize;    glVertex2fv(&tmp[0]);
-        tmp[0]=pt2d[0]+pointsize;    tmp[1]=pt2d[1]+pointsize;    glVertex2fv(&tmp[0]);
-        tmp[0]=pt2d[0]+pointsize;    tmp[1]=pt2d[1]-pointsize;    glVertex2fv(&tmp[0]);
-        tmp[0]=pt2d[0]-pointsize;    tmp[1]=pt2d[1]-pointsize;    glVertex2fv(&tmp[0]);
+        tmp[0]=pt2d[0]-pointsize;    tmp[1]=pt2d[1]+pointsize;    glVertex2dv(&tmp[0]);
+        tmp[0]=pt2d[0]+pointsize;    tmp[1]=pt2d[1]+pointsize;    glVertex2dv(&tmp[0]);
+        tmp[0]=pt2d[0]+pointsize;    tmp[1]=pt2d[1]-pointsize;    glVertex2dv(&tmp[0]);
+        tmp[0]=pt2d[0]-pointsize;    tmp[1]=pt2d[1]-pointsize;    glVertex2dv(&tmp[0]);
         glEnd ();
       }
       //------------------------------------
     }
   }
 }
 
 const mitk::ContourModel* mitk::ContourModelGLMapper2D::GetInput(void)
 {
   return static_cast<const mitk::ContourModel * > ( GetDataNode()->GetData() );
 }
 
 void mitk::ContourModelGLMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "contour.color", ColorProperty::New(0.9, 1.0, 0.1), renderer, overwrite );
   node->AddProperty( "points.color", ColorProperty::New(1.0, 0.0, 0.1), renderer, overwrite );
   node->AddProperty( "contour.width", mitk::FloatProperty::New( 1.0 ), renderer, overwrite );
 
   node->AddProperty( "subdivision curve", mitk::BoolProperty::New( false ), renderer, overwrite );
   node->AddProperty( "contour.project-onto-plane", mitk::BoolProperty::New( false ), renderer, overwrite );
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
diff --git a/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.cpp b/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.cpp
index 8c9375727a..c72e04f1ce 100644
--- a/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.cpp
+++ b/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.cpp
@@ -1,317 +1,317 @@
 /*===================================================================
 
 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 "mitkSurfaceInterpolationController.h"
 #include "mitkMemoryUtilities.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 
 #include "mitkImageToSurfaceFilter.h"
 
 mitk::SurfaceInterpolationController::SurfaceInterpolationController()
   :m_SelectedSegmentation(0)
 {
   m_ReduceFilter = ReduceContourSetFilter::New();
   m_NormalsFilter = ComputeContourSetNormalsFilter::New();
   m_InterpolateSurfaceFilter = CreateDistanceImageFromSurfaceFilter::New();
 
   m_ReduceFilter->SetUseProgressBar(false);
   m_NormalsFilter->SetUseProgressBar(false);
   m_InterpolateSurfaceFilter->SetUseProgressBar(false);
 
   m_Contours = Surface::New();
 
   m_PolyData = vtkSmartPointer<vtkPolyData>::New();
   m_PolyData->SetPoints(vtkPoints::New());
 
   m_InterpolationResult = 0;
   m_CurrentNumberOfReducedContours = 0;
 }
 
 mitk::SurfaceInterpolationController::~SurfaceInterpolationController()
 {
   ContourListMap::iterator it = m_MapOfContourLists.begin();
   for (; it != m_MapOfContourLists.end(); it++)
   {
       for (unsigned int j = 0; j < m_MapOfContourLists[(*it).first].size(); ++j)
       {
           delete(m_MapOfContourLists[(*it).first].at(j).position);
       }
       m_MapOfContourLists.erase(it);
   }
 
   //Removing all observers
   std::map<mitk::Image*, unsigned long>::iterator dataIter = m_SegmentationObserverTags.begin();
   for (; dataIter != m_SegmentationObserverTags.end(); ++dataIter )
   {
     (*dataIter).first->GetProperty("visible")->RemoveObserver( (*dataIter).second );
   }
   m_SegmentationObserverTags.clear();
 }
 
 mitk::SurfaceInterpolationController* mitk::SurfaceInterpolationController::GetInstance()
 {
   static mitk::SurfaceInterpolationController* m_Instance;
 
   if ( m_Instance == 0)
   {
     m_Instance = new SurfaceInterpolationController();
   }
 
   return m_Instance;
 }
 
 void mitk::SurfaceInterpolationController::AddNewContour (mitk::Surface::Pointer newContour ,RestorePlanePositionOperation* op)
 {
   AffineTransform3D::Pointer transform = AffineTransform3D::New();
   transform = op->GetTransform();
 
   mitk::Vector3D direction = op->GetDirectionVector();
   int pos (-1);
 
   for (unsigned int i = 0; i < m_MapOfContourLists[m_SelectedSegmentation].size(); i++)
   {
-      itk::Matrix<float> diffM = transform->GetMatrix()-m_MapOfContourLists[m_SelectedSegmentation].at(i).position->GetTransform()->GetMatrix();
+      itk::Matrix<ScalarType> diffM = transform->GetMatrix()-m_MapOfContourLists[m_SelectedSegmentation].at(i).position->GetTransform()->GetMatrix();
       bool isSameMatrix(true);
       for (unsigned int j = 0; j < 3; j++)
       {
         if (fabs(diffM[j][0]) > 0.0001 && fabs(diffM[j][1]) > 0.0001 && fabs(diffM[j][2]) > 0.0001)
         {
           isSameMatrix = false;
           break;
         }
       }
-      itk::Vector<float> diffV = m_MapOfContourLists[m_SelectedSegmentation].at(i).position->GetTransform()->GetOffset()-transform->GetOffset();
+      itk::Vector<ScalarType> diffV = m_MapOfContourLists[m_SelectedSegmentation].at(i).position->GetTransform()->GetOffset()-transform->GetOffset();
       if ( isSameMatrix && m_MapOfContourLists[m_SelectedSegmentation].at(i).position->GetPos() == op->GetPos() && (fabs(diffV[0]) < 0.0001 && fabs(diffV[1]) < 0.0001 && fabs(diffV[2]) < 0.0001) )
       {
         pos = i;
         break;
       }
 
   }
 
   //Don't save a new empty contour
   if (pos == -1 && newContour->GetVtkPolyData()->GetNumberOfPoints() > 0)
   {
     mitk::RestorePlanePositionOperation* newOp = new mitk::RestorePlanePositionOperation (OpRESTOREPLANEPOSITION, op->GetWidth(),
       op->GetHeight(), op->GetSpacing(), op->GetPos(), direction, transform);
     ContourPositionPair newData;
     newData.contour = newContour;
     newData.position = newOp;
 
     m_ReduceFilter->SetInput(m_MapOfContourLists[m_SelectedSegmentation].size(), newContour);
     m_MapOfContourLists[m_SelectedSegmentation].push_back(newData);
   }
   //Edit a existing contour. If the contour is empty, edit it anyway so that the interpolation will always be consistent
   else if (pos != -1)
   {
     m_MapOfContourLists[m_SelectedSegmentation].at(pos).contour = newContour;
     m_ReduceFilter->SetInput(pos, newContour);
   }
 
   m_ReduceFilter->Update();
   m_CurrentNumberOfReducedContours = m_ReduceFilter->GetNumberOfOutputs();
 
   for (unsigned int i = 0; i < m_CurrentNumberOfReducedContours; i++)
   {
     m_NormalsFilter->SetInput(i, m_ReduceFilter->GetOutput(i));
     m_InterpolateSurfaceFilter->SetInput(i, m_NormalsFilter->GetOutput(i));
   }
 
   this->Modified();
 }
 
 void mitk::SurfaceInterpolationController::Interpolate()
 {
   if (m_CurrentNumberOfReducedContours< 2)
   {
     //If no interpolation is possible reset the interpolation result
     m_InterpolationResult = 0;
     return;
   }
 
   //Setting up progress bar
    /*
     * Removed due to bug 12441. ProgressBar messes around with Qt event queue which is fatal for segmentation
     */
   //mitk::ProgressBar::GetInstance()->AddStepsToDo(8);
 
   // update the filter and get teh resulting distance-image
   m_InterpolateSurfaceFilter->Update();
   Image::Pointer distanceImage = m_InterpolateSurfaceFilter->GetOutput();
 
   // create a surface from the distance-image
   mitk::ImageToSurfaceFilter::Pointer imageToSurfaceFilter = mitk::ImageToSurfaceFilter::New();
   imageToSurfaceFilter->SetInput( distanceImage );
   imageToSurfaceFilter->SetThreshold( 0 );
   imageToSurfaceFilter->Update();
   m_InterpolationResult = imageToSurfaceFilter->GetOutput();
 
 
   vtkSmartPointer<vtkAppendPolyData> polyDataAppender = vtkSmartPointer<vtkAppendPolyData>::New();
   for (unsigned int i = 0; i < m_ReduceFilter->GetNumberOfOutputs(); i++)
   {
     polyDataAppender->AddInput(m_ReduceFilter->GetOutput(i)->GetVtkPolyData());
   }
   polyDataAppender->Update();
   m_Contours->SetVtkPolyData(polyDataAppender->GetOutput());
 
   //Last progress step
   /*
    * Removed due to bug 12441. ProgressBar messes around with Qt event queue which is fatal for segmentation
    */
   //mitk::ProgressBar::GetInstance()->Progress(8);
 
   m_InterpolationResult->DisconnectPipeline();
 }
 
 mitk::Surface::Pointer mitk::SurfaceInterpolationController::GetInterpolationResult()
 {
     return m_InterpolationResult;
 }
 
 mitk::Surface* mitk::SurfaceInterpolationController::GetContoursAsSurface()
 {
   return m_Contours;
 }
 
 void mitk::SurfaceInterpolationController::SetDataStorage(DataStorage::Pointer ds)
 {
   m_DataStorage = ds;
 }
 
 void mitk::SurfaceInterpolationController::SetMinSpacing(double minSpacing)
 {
   m_ReduceFilter->SetMinSpacing(minSpacing);
 }
 
 void mitk::SurfaceInterpolationController::SetMaxSpacing(double maxSpacing)
 {
   m_ReduceFilter->SetMaxSpacing(maxSpacing);
   m_NormalsFilter->SetMaxSpacing(maxSpacing);
 }
 
 void mitk::SurfaceInterpolationController::SetDistanceImageVolume(unsigned int distImgVolume)
 {
   m_InterpolateSurfaceFilter->SetDistanceImageVolume(distImgVolume);
 }
 
 void mitk::SurfaceInterpolationController::SetSegmentationImage(Image* workingImage)
 {
   m_NormalsFilter->SetSegmentationBinaryImage(workingImage);
 }
 
 mitk::Image* mitk::SurfaceInterpolationController::GetImage()
 {
   return m_InterpolateSurfaceFilter->GetOutput();
 }
 
 double mitk::SurfaceInterpolationController::EstimatePortionOfNeededMemory()
 {
   double numberOfPointsAfterReduction = m_ReduceFilter->GetNumberOfPointsAfterReduction()*3;
   double sizeOfPoints = pow(numberOfPointsAfterReduction,2)*sizeof(double);
   double totalMem = mitk::MemoryUtilities::GetTotalSizeOfPhysicalRam();
   double percentage = sizeOfPoints/totalMem;
   return percentage;
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void mitk::SurfaceInterpolationController::GetImageBase(itk::Image<TPixel, VImageDimension>* input, itk::ImageBase<3>::Pointer& result)
 {
   result->Graft(input);
 }
 
 void mitk::SurfaceInterpolationController::SetCurrentSegmentationInterpolationList(mitk::Image* segmentation)
 {
   if (segmentation == m_SelectedSegmentation)
     return;
 
   m_ReduceFilter->Reset();
   m_NormalsFilter->Reset();
   m_InterpolateSurfaceFilter->Reset();
 
   if (segmentation == 0)
   {
     m_SelectedSegmentation = 0;
     return;
   }
   ContourListMap::iterator it = m_MapOfContourLists.find(segmentation);
 
   m_SelectedSegmentation = segmentation;
 
 
   itk::ImageBase<3>::Pointer itkImage = itk::ImageBase<3>::New();
   AccessFixedDimensionByItk_1( m_SelectedSegmentation, GetImageBase, 3, itkImage );
   m_InterpolateSurfaceFilter->SetReferenceImage( itkImage.GetPointer() );
 
   if (it == m_MapOfContourLists.end())
   {
     ContourPositionPairList newList;
     m_MapOfContourLists.insert(std::pair<mitk::Image*, ContourPositionPairList>(segmentation, newList));
     m_InterpolationResult = 0;
     m_CurrentNumberOfReducedContours = 0;
 
     itk::MemberCommand<SurfaceInterpolationController>::Pointer command = itk::MemberCommand<SurfaceInterpolationController>::New();
     command->SetCallbackFunction(this, &SurfaceInterpolationController::OnSegmentationDeleted);
     m_SegmentationObserverTags.insert( std::pair<mitk::Image*, unsigned long>( segmentation, segmentation->AddObserver( itk::DeleteEvent(), command ) ) );
 
   }
   else
   {
     for (unsigned int i = 0; i < m_MapOfContourLists[m_SelectedSegmentation].size(); i++)
     {
       m_ReduceFilter->SetInput(i, m_MapOfContourLists[m_SelectedSegmentation].at(i).contour);
     }
 
     m_ReduceFilter->Update();
 
     m_CurrentNumberOfReducedContours = m_ReduceFilter->GetNumberOfOutputs();
 
     for (unsigned int i = 0; i < m_CurrentNumberOfReducedContours; i++)
     {
       m_NormalsFilter->SetInput(i, m_ReduceFilter->GetOutput(i));
       m_InterpolateSurfaceFilter->SetInput(i, m_NormalsFilter->GetOutput(i));
     }
   }
   Modified();
 }
 
 void mitk::SurfaceInterpolationController::RemoveSegmentationFromContourList(mitk::Image *segmentation)
 {
   if (segmentation != 0)
   {
     m_MapOfContourLists.erase(segmentation);
     if (m_SelectedSegmentation == segmentation)
     {
       SetSegmentationImage(NULL);
       m_SelectedSegmentation = 0;
     }
   }
 }
 
 void mitk::SurfaceInterpolationController::OnSegmentationDeleted(const itk::Object *caller, const itk::EventObject &/*event*/)
 {
   mitk::Image* tempImage = dynamic_cast<mitk::Image*>(const_cast<itk::Object*>(caller));
   if (tempImage)
   {
     RemoveSegmentationFromContourList(tempImage);
     if (tempImage == m_SelectedSegmentation)
     {
       SetSegmentationImage(NULL);
       m_SelectedSegmentation = 0;
     }
   }
 }