diff --git a/Modules/DICOMReader/mitkClassicDICOMSeriesReader.cpp b/Modules/DICOMReader/mitkClassicDICOMSeriesReader.cpp
index 408c5ba673..38255881a3 100644
--- a/Modules/DICOMReader/mitkClassicDICOMSeriesReader.cpp
+++ b/Modules/DICOMReader/mitkClassicDICOMSeriesReader.cpp
@@ -1,80 +1,82 @@
 /*===================================================================
 
 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 "mitkClassicDICOMSeriesReader.h"
 
 #include "mitkDICOMTagBasedSorter.h"
 #include "mitkDICOMSortByTag.h"
 #include "mitkSortByImagePositionPatient.h"
 
 
 mitk::ClassicDICOMSeriesReader
 ::ClassicDICOMSeriesReader()
 :DICOMITKSeriesGDCMReader()
 {
   mitk::DICOMTagBasedSorter::Pointer tagSorter = mitk::DICOMTagBasedSorter::New();
 
   // all the things that split by tag in mitk::DicomSeriesReader
   tagSorter->AddDistinguishingTag( DICOMTag(0x0028, 0x0010) ); // Number of Rows
   tagSorter->AddDistinguishingTag( DICOMTag(0x0028, 0x0011) ); // Number of Columns
   tagSorter->AddDistinguishingTag( DICOMTag(0x0028, 0x0030) ); // Pixel Spacing
   tagSorter->AddDistinguishingTag( DICOMTag(0x0018, 0x1164) ); // Imager Pixel Spacing
   tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x0037), new mitk::DICOMTagBasedSorter::CutDecimalPlaces(5) ); // Image Orientation (Patient)
   tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x000e) ); // Series Instance UID
   tagSorter->AddDistinguishingTag( DICOMTag(0x0018, 0x0050) ); // Slice Thickness
   tagSorter->AddDistinguishingTag( DICOMTag(0x0028, 0x0008) ); // Number of Frames
   //tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x0052) ); // Frame of Reference UID
 
   // a sorter...
   // TODO ugly syntax, improve..
   mitk::DICOMSortCriterion::ConstPointer sorting =
     mitk::SortByImagePositionPatient::New( // image position patient and image orientation
       mitk::DICOMSortByTag::New( DICOMTag(0x0020, 0x0012), // aqcuisition number
         mitk::DICOMSortByTag::New( DICOMTag(0x0008, 0x0032), // aqcuisition time
           mitk::DICOMSortByTag::New( DICOMTag(0x0018, 0x1060), // trigger time
             mitk::DICOMSortByTag::New( DICOMTag(0x0008, 0x0018) // SOP instance UID (last resort, not really meaningful but decides clearly)
             ).GetPointer()
           ).GetPointer()
         ).GetPointer()
       ).GetPointer()
     ).GetPointer();
   tagSorter->SetSortCriterion( sorting );
 
   // define above sorting for this class
   this->AddSortingElement( tagSorter );
+
+  this->SetFixTiltByShearing(true);
 }
 
 mitk::ClassicDICOMSeriesReader
 ::ClassicDICOMSeriesReader(const ClassicDICOMSeriesReader& other )
 :DICOMITKSeriesGDCMReader(other)
 {
 }
 
 mitk::ClassicDICOMSeriesReader
 ::~ClassicDICOMSeriesReader()
 {
 }
 
 mitk::ClassicDICOMSeriesReader&
 mitk::ClassicDICOMSeriesReader
 ::operator=(const ClassicDICOMSeriesReader& other)
 {
   if (this != &other)
   {
     DICOMITKSeriesGDCMReader::operator=(other);
   }
   return *this;
 }
diff --git a/Modules/DICOMReader/mitkDICOMITKSeriesGDCMReader.cpp b/Modules/DICOMReader/mitkDICOMITKSeriesGDCMReader.cpp
index 33c023558a..7139e3bfd2 100644
--- a/Modules/DICOMReader/mitkDICOMITKSeriesGDCMReader.cpp
+++ b/Modules/DICOMReader/mitkDICOMITKSeriesGDCMReader.cpp
@@ -1,361 +1,361 @@
 /*===================================================================
 
 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 "mitkDICOMITKSeriesGDCMReader.h"
 #include "mitkITKDICOMSeriesReaderHelper.h"
 #include "mitkGantryTiltInformation.h"
 
 #include <itkTimeProbesCollectorBase.h>
 
 #include <gdcmScanner.h>
 
 mitk::DICOMITKSeriesGDCMReader
 ::DICOMITKSeriesGDCMReader()
 :DICOMFileReader()
-,m_FixTiltByShearing(false)
+,m_FixTiltByShearing(true)
 ,m_Group3DplusT(false)
 {
 }
 
 mitk::DICOMITKSeriesGDCMReader
 ::DICOMITKSeriesGDCMReader(const DICOMITKSeriesGDCMReader& other )
 :DICOMFileReader(other)
 ,m_FixTiltByShearing(false)
 ,m_Group3DplusT(false)
 {
 }
 
 mitk::DICOMITKSeriesGDCMReader
 ::~DICOMITKSeriesGDCMReader()
 {
 }
 
 mitk::DICOMITKSeriesGDCMReader&
 mitk::DICOMITKSeriesGDCMReader
 ::operator=(const DICOMITKSeriesGDCMReader& other)
 {
   if (this != &other)
   {
     DICOMFileReader::operator=(other);
   }
   return *this;
 }
 
 void
 mitk::DICOMITKSeriesGDCMReader
 ::SetFixTiltByShearing(bool on)
 {
   m_FixTiltByShearing = on;
 }
 
 mitk::DICOMGDCMImageFrameList
 mitk::DICOMITKSeriesGDCMReader
 ::FromDICOMDatasetList(DICOMDatasetList& input)
 {
   DICOMGDCMImageFrameList output;
   output.reserve(input.size());
 
   for(DICOMDatasetList::iterator inputIter = input.begin();
       inputIter != input.end();
       ++inputIter)
   {
     DICOMGDCMImageFrameInfo* gfi = dynamic_cast<DICOMGDCMImageFrameInfo*>(*inputIter);
     assert(gfi);
     output.push_back(gfi);
   }
 
   return output;
 }
 
 mitk::DICOMDatasetList
 mitk::DICOMITKSeriesGDCMReader
 ::ToDICOMDatasetList(DICOMGDCMImageFrameList& input)
 {
   DICOMDatasetList output;
   output.reserve(input.size());
 
   for(DICOMGDCMImageFrameList::iterator inputIter = input.begin();
       inputIter != input.end();
       ++inputIter)
   {
     DICOMDatasetAccess* da = inputIter->GetPointer();
     assert(da);
     output.push_back(da);
   }
 
   return output;
 }
 
 mitk::DICOMImageFrameList
 mitk::DICOMITKSeriesGDCMReader
 ::ToDICOMImageFrameList(DICOMGDCMImageFrameList& input)
 {
   DICOMImageFrameList output;
   output.reserve(input.size());
 
   for(DICOMGDCMImageFrameList::iterator inputIter = input.begin();
       inputIter != input.end();
       ++inputIter)
   {
     DICOMImageFrameInfo::Pointer fi = (*inputIter)->GetFrameInfo();
     assert(fi.IsNotNull());
     output.push_back(fi);
   }
 
   return output;
 }
 
 void
 mitk::DICOMITKSeriesGDCMReader
 ::AnalyzeInputFiles()
 {
   // TODO at this point, make sure we have a sorting element at the end that splits geometrically separate blocks
   this->EnsureMandatorySortersArePresent();
 
   itk::TimeProbesCollectorBase timer;
 
   timer.Start("Reset");
   this->ClearOutputs();
   timer.Stop("Reset");
 
   // prepare initial sorting (== list of input files)
   StringList inputFilenames = this->GetInputFiles();
 
   // scan files for sorting-relevant tags
 
   // TODO provide tagToValueMappings to items in initialFramelist  / m_SortingResultInProgress
   timer.Start("Setup scanning");
   gdcm::Scanner gdcmScanner;
   for(SorterList::iterator sorterIter = m_Sorter.begin();
       sorterIter != m_Sorter.end();
       ++sorterIter)
   {
     assert(sorterIter->IsNotNull());
 
     DICOMTagList tags = (*sorterIter)->GetTagsOfInterest();
     for(DICOMTagList::const_iterator tagIter = tags.begin();
         tagIter != tags.end();
         ++tagIter)
     {
       MITK_DEBUG << "Sorting uses tag " << tagIter->GetGroup() << "," << tagIter->GetElement();
       gdcmScanner.AddTag( gdcm::Tag(tagIter->GetGroup(), tagIter->GetElement()) );
     }
   }
 
   // Add some of our own interest
   gdcmScanner.AddTag( gdcm::Tag(0x0018,0x1164) );
   gdcmScanner.AddTag( gdcm::Tag(0x0028,0x0030) );
 
   timer.Stop("Setup scanning");
 
   timer.Start("Tag scanning");
   gdcmScanner.Scan( inputFilenames );
   timer.Stop("Tag scanning");
 
   timer.Start("Setup sorting");
   DICOMGDCMImageFrameList initialFramelist;
   for (StringList::const_iterator inputIter = inputFilenames.begin();
        inputIter != inputFilenames.end();
        ++inputIter)
   {
     // TODO check DICOMness and non-multi-framedness
     initialFramelist.push_back( DICOMGDCMImageFrameInfo::New( DICOMImageFrameInfo::New(*inputIter, 0), gdcmScanner.GetMapping(inputIter->c_str()) ) );
   }
   m_SortingResultInProgress.clear();
   m_SortingResultInProgress.push_back( initialFramelist );
   timer.Stop("Setup sorting");
 
   // sort and split blocks as configured
 
   timer.Start("Sorting frames");
   SortingBlockList nextStepSorting; // we should not modify our input list while processing it
   unsigned int sorterIndex = 0;
   for(SorterList::iterator sorterIter = m_Sorter.begin();
       sorterIter != m_Sorter.end();
       ++sorterIndex, ++sorterIter)
   {
     std::stringstream ss; ss << "Sorting step " << sorterIndex;
     timer.Start( ss.str().c_str() );
     nextStepSorting.clear();
     DICOMDatasetSorter::Pointer& sorter = *sorterIter;
 
     MITK_DEBUG << "================================================================================";
     MITK_DEBUG << "DICOMIKTSeriesGDCMReader: " << ss.str() << ": " << m_SortingResultInProgress.size() << " groups input";
     unsigned int groupIndex = 0;
 
     for(SortingBlockList::iterator blockIter = m_SortingResultInProgress.begin();
         blockIter != m_SortingResultInProgress.end();
         ++groupIndex, ++blockIter)
     {
       DICOMGDCMImageFrameList& gdcmInfoFrameList = *blockIter;
       DICOMDatasetList datasetList = ToDICOMDatasetList( gdcmInfoFrameList );
 
       MITK_DEBUG << "--------------------------------------------------------------------------------";
       MITK_DEBUG << "DICOMIKTSeriesGDCMReader: " << ss.str() << ", dataset group " << groupIndex << " (" << datasetList.size() << " datasets): ";
       for (DICOMDatasetList::iterator oi = datasetList.begin();
            oi != datasetList.end();
            ++oi)
       {
         MITK_DEBUG << "  INPUT     : " << (*oi)->GetFilenameIfAvailable();
       }
 
       sorter->SetInput(datasetList);
       sorter->Sort();
       unsigned int numberOfResultingBlocks = sorter->GetNumberOfOutputs();
 
       for (unsigned int b = 0; b < numberOfResultingBlocks; ++b)
       {
         DICOMDatasetList blockResult = sorter->GetOutput(b);
 
         for (DICOMDatasetList::iterator oi = blockResult.begin();
              oi != blockResult.end();
              ++oi)
         {
           MITK_DEBUG << "  OUTPUT(" << b << ") :" << (*oi)->GetFilenameIfAvailable();
         }
 
         DICOMGDCMImageFrameList sortedGdcmInfoFrameList = FromDICOMDatasetList(blockResult);
         nextStepSorting.push_back( sortedGdcmInfoFrameList );
       }
     }
 
     m_SortingResultInProgress = nextStepSorting;
     timer.Stop( ss.str().c_str() );
   }
   timer.Stop("Sorting frames");
 
   // provide final result as output
 
   timer.Start("Output");
   this->SetNumberOfOutputs( m_SortingResultInProgress.size() );
   unsigned int o = 0;
   for (SortingBlockList::iterator blockIter = m_SortingResultInProgress.begin();
        blockIter != m_SortingResultInProgress.end();
        ++o, ++blockIter)
   {
     DICOMGDCMImageFrameList& gdcmFrameInfoList = *blockIter;
     DICOMImageFrameList frameList = ToDICOMImageFrameList( gdcmFrameInfoList );
     assert(!gdcmFrameInfoList.empty());
     assert(!frameList.empty());
 
     DICOMImageBlockDescriptor block;
     block.SetImageFrameList( frameList );
 
     bool hasTilt = false;
     const GantryTiltInformation& tiltInfo = m_EquiDistantBlocksSorter->GetTiltInformation( (gdcmFrameInfoList.front())->GetFilenameIfAvailable(), hasTilt );
     block.SetHasGantryTilt( hasTilt );
     block.SetTiltInformation( tiltInfo );
 
     // assume
     static const DICOMTag tagPixelSpacing(0x0028,0x0030);
     static const DICOMTag tagImagerPixelSpacing(0x0018,0x1164);
     std::string pixelSpacingString = (gdcmFrameInfoList.front())->GetTagValueAsString( tagPixelSpacing );
     std::string imagerPixelSpacingString = gdcmFrameInfoList.front()->GetTagValueAsString( tagImagerPixelSpacing );
     block.SetPixelSpacingInformation(pixelSpacingString, imagerPixelSpacingString);
 
     this->SetOutput( o, block );
   }
   timer.Stop("Output");
 
   std::cout << "---------------------------------------------------------------" << std::endl;
   timer.Report( std::cout );
   std::cout << "---------------------------------------------------------------" << std::endl;
 }
 
 // void AllocateOutputImages();
 
 bool
 mitk::DICOMITKSeriesGDCMReader
 ::LoadImages()
 {
   mitk::ITKDICOMSeriesReaderHelper helper;
 
   unsigned int numberOfOutputs = this->GetNumberOfOutputs();
   for (unsigned int o = 0; o < numberOfOutputs; ++o)
   {
     DICOMImageBlockDescriptor& block = this->InternalGetOutput(o);
     const DICOMImageFrameList& frames = block.GetImageFrameList();
     const GantryTiltInformation tiltInfo = block.GetTiltInformation();
     bool hasTilt = block.HasGantryTilt();
     if (hasTilt)
     {
       MITK_DEBUG << "When loading image " << o << ": got tilt info:";
       tiltInfo.Print(std::cout);
     }
     else
     {
       MITK_DEBUG << "When loading image " << o << ": has NO info.";
     }
 
     ITKDICOMSeriesReaderHelper::StringContainer filenames;
     for (DICOMImageFrameList::const_iterator frameIter = frames.begin();
         frameIter != frames.end();
         ++frameIter)
     {
       filenames.push_back( (*frameIter)->Filename );
     }
 
     mitk::Image::Pointer mitkImage = helper.Load( filenames, m_FixTiltByShearing && hasTilt, tiltInfo ); // TODO preloaded images, caching..?
 
     Vector3D imageSpacing = mitkImage->GetGeometry()->GetSpacing();
 
     ScalarType desiredSpacingX = imageSpacing[0];
     ScalarType desiredSpacingY = imageSpacing[1];
     block.GetDesiredMITKImagePixelSpacing( desiredSpacingX, desiredSpacingY ); // prefer pixel spacing over imager pixel spacing
 
     MITK_DEBUG << "Loaded image with spacing " << imageSpacing[0] << ", " << imageSpacing[1];
     MITK_DEBUG << "Found correct spacing info " << desiredSpacingX << ", " << desiredSpacingY;
 
     imageSpacing[0] = desiredSpacingX;
     imageSpacing[1] = desiredSpacingY;
     mitkImage->GetGeometry()->SetSpacing( imageSpacing );
 
     block.SetMitkImage( mitkImage );
   }
 
   return true;
 }
 
 
 bool
 mitk::DICOMITKSeriesGDCMReader
 ::CanHandleFile(const std::string& itkNotUsed(filename))
 {
   return true; // can handle all
 }
 
 void
 mitk::DICOMITKSeriesGDCMReader
 ::AddSortingElement(DICOMDatasetSorter* sorter)
 {
   assert(sorter);
   m_Sorter.push_back( sorter );
 }
 
 void
 mitk::DICOMITKSeriesGDCMReader
 ::EnsureMandatorySortersArePresent()
 {
   // TODO: cols, rows, etc. are also not optional
   if (m_EquiDistantBlocksSorter.IsNull())
   {
     m_EquiDistantBlocksSorter = mitk::EquiDistantBlocksSorter::New();
   }
   m_EquiDistantBlocksSorter->SetAcceptTilt( m_FixTiltByShearing );
 
   // TODO CHECK
   this->AddSortingElement( m_EquiDistantBlocksSorter );
 }
diff --git a/Modules/DICOMReader/mitkEquiDistantBlocksSorter.cpp b/Modules/DICOMReader/mitkEquiDistantBlocksSorter.cpp
index 8783460ebc..7ef92bdfca 100644
--- a/Modules/DICOMReader/mitkEquiDistantBlocksSorter.cpp
+++ b/Modules/DICOMReader/mitkEquiDistantBlocksSorter.cpp
@@ -1,457 +1,497 @@
 /*=================================================================== 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 "mitkEquiDistantBlocksSorter.h"
 
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::SliceGroupingAnalysisResult()
 :m_GantryTilt(false)
 {
 }
 
 mitk::DICOMDatasetList
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::GetBlockFilenames()
 {
   return m_GroupedFiles;
 }
 
 mitk::DICOMDatasetList
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::GetUnsortedFilenames()
 {
   return m_UnsortedFiles;
 }
 
 bool
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::ContainsGantryTilt()
 {
   return m_GantryTilt;
 }
 
 void
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::AddFileToSortedBlock(DICOMDatasetAccess* dataset)
 {
   m_GroupedFiles.push_back( dataset );
 }
 
 void
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::AddFileToUnsortedBlock(DICOMDatasetAccess* dataset)
 {
   m_UnsortedFiles.push_back( dataset );
 }
 
 void
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::AddFilesToUnsortedBlock(const DICOMDatasetList& datasets)
 {
   m_UnsortedFiles.insert( m_UnsortedFiles.end(), datasets.begin(), datasets.end() );
 }
 
 void
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::SetFirstFilenameOfBlock(const std::string& filename)
 {
   m_FirstFilenameOfBlock = filename;
 }
 
 std::string
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::GetFirstFilenameOfBlock() const
 {
   return m_FirstFilenameOfBlock;
 }
 
 void
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::FlagGantryTilt(const GantryTiltInformation& tiltInfo)
 {
   m_GantryTilt = true;
   m_TiltInfo = tiltInfo;
 }
 
 const mitk::GantryTiltInformation&
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::GetTiltInfo() const
 {
   return m_TiltInfo;
 }
 
 void
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::UndoPrematureGrouping()
 {
   assert( !m_GroupedFiles.empty() );
   m_UnsortedFiles.insert( m_UnsortedFiles.begin(), m_GroupedFiles.back() );
   m_GroupedFiles.pop_back();
+  m_GantryTilt = false;
 }
 
 // ------------------------ end helper class
 
 mitk::EquiDistantBlocksSorter
 ::EquiDistantBlocksSorter()
 :DICOMDatasetSorter()
 ,m_AcceptTilt(false)
 {
 }
 
 mitk::EquiDistantBlocksSorter
 ::EquiDistantBlocksSorter(const EquiDistantBlocksSorter& other )
 :DICOMDatasetSorter(other)
 ,m_AcceptTilt(false)
 {
 }
 
 mitk::EquiDistantBlocksSorter
 ::~EquiDistantBlocksSorter()
 {
 }
 
 void
 mitk::EquiDistantBlocksSorter
 ::SetAcceptTilt(bool accept)
 {
   m_AcceptTilt = accept;
 }
 
 
 mitk::EquiDistantBlocksSorter&
 mitk::EquiDistantBlocksSorter
 ::operator=(const EquiDistantBlocksSorter& other)
 {
   if (this != &other)
   {
     DICOMDatasetSorter::operator=(other);
   }
   return *this;
 }
 
 mitk::DICOMTagList
 mitk::EquiDistantBlocksSorter
 ::GetTagsOfInterest()
 {
   DICOMTagList tags;
   tags.push_back( DICOMTag(0x0020, 0x0032) ); // ImagePositionPatient
   tags.push_back( DICOMTag(0x0020, 0x0037) ); // ImageOrientationPatient
   tags.push_back( DICOMTag(0x0018, 0x1120) ); // GantryTilt
 
   return tags;
 }
 
 void
 mitk::EquiDistantBlocksSorter
 ::Sort()
 {
   DICOMDatasetList remainingInput = GetInput(); // copy
 
   typedef std::list<DICOMDatasetList> OutputListType;
   OutputListType outputs;
 
   m_SliceGroupingResults.clear();
 
   while (!remainingInput.empty()) // repeat until all files are grouped somehow
   {
     SliceGroupingAnalysisResult regularBlock = this->AnalyzeFileForITKImageSeriesReaderSpacingAssumption( remainingInput, m_AcceptTilt );
 
     DICOMDatasetList inBlock = regularBlock.GetBlockFilenames();
     DICOMDatasetList laterBlock = regularBlock.GetUnsortedFilenames();
     MITK_DEBUG << "Result: sorted 3D group with " << inBlock.size() << " files";
     for (DICOMDatasetList::const_iterator diter = inBlock.begin(); diter != inBlock.end(); ++diter)
       MITK_DEBUG << "  IN  " << (*diter)->GetFilenameIfAvailable();
     for (DICOMDatasetList::const_iterator diter = laterBlock.begin(); diter != laterBlock.end(); ++diter)
       MITK_DEBUG << " OUT  " << (*diter)->GetFilenameIfAvailable();
 
     outputs.push_back( regularBlock.GetBlockFilenames() );
     m_SliceGroupingResults.push_back( regularBlock );
     remainingInput = regularBlock.GetUnsortedFilenames();
   }
 
   unsigned int numberOfOutputs = outputs.size();
   this->SetNumberOfOutputs(numberOfOutputs);
 
   unsigned int outputIndex(0);
   for (OutputListType::iterator oIter = outputs.begin();
        oIter != outputs.end();
        ++outputIndex, ++oIter)
   {
     this->SetOutput(outputIndex, *oIter);
   }
 }
 
 const mitk::GantryTiltInformation
 mitk::EquiDistantBlocksSorter
 ::GetTiltInformation(const std::string& filename, bool& hasTiltInfo)
 {
   for (ResultsList::iterator ri = m_SliceGroupingResults.begin();
        ri != m_SliceGroupingResults.end();
        ++ri)
   {
     SliceGroupingAnalysisResult& result = *ri;
 
     if (filename == result.GetFirstFilenameOfBlock())
     {
       hasTiltInfo = result.ContainsGantryTilt(); // this is a returning statement, don't remove
       if (hasTiltInfo)
       {
         return result.GetTiltInfo();
       }
     }
   }
 
   return GantryTiltInformation(); // empty
 }
 
 std::string
 mitk::EquiDistantBlocksSorter
 ::ConstCharStarToString(const char* s)
 {
   return s ?  std::string(s) : std::string();
 }
 
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 mitk::EquiDistantBlocksSorter
 ::AnalyzeFileForITKImageSeriesReaderSpacingAssumption(
   const DICOMDatasetList& datasets,
   bool groupImagesWithGantryTilt)
 {
   // 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
   const DICOMTag tagImagePositionPatient = DICOMTag(0x0020,0x0032); // Image Position (Patient)
   const DICOMTag    tagImageOrientation = DICOMTag(0x0020, 0x0037); // Image Orientation
   const DICOMTag          tagGantryTilt = DICOMTag(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 " << datasets.size() << " files for z-spacing assumption of ITK's ImageSeriesReader (group tilted: " << groupImagesWithGantryTilt << ")";
   unsigned int fileIndex(0);
   for (DICOMDatasetList::const_iterator dsIter = datasets.begin();
        dsIter != datasets.end();
        ++dsIter, ++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 = (*dsIter)->GetTagValueAsString( 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 " << *dsIter << " 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( *dsIter );
 
         DICOMDatasetList remainingFiles;
         remainingFiles.insert( remainingFiles.end(), dsIter+1, datasets.end() );
         result.AddFilesToUnsortedBlock( remainingFiles );
 
         fileFitsIntoPattern = false;
         break; // no files anymore
       }
       else
       {
         // ==> this does not match, consider later
         result.AddFileToUnsortedBlock( *dsIter ); // sort away for further analysis
         fileFitsIntoPattern = false;
         continue; // next file
       }
     }
 
     bool ignoredConversionError(-42); // hard to get here, no graceful way to react
     thisOrigin = DICOMStringToPoint3D( thisOriginString, ignoredConversionError );
 
     MITK_DEBUG << "  " << fileIndex << " " << (*dsIter)->GetFilenameIfAvailable()
                        << " at "
                        /* << thisOriginString */ << "(" << thisOrigin[0] << "," << thisOrigin[1] << "," << thisOrigin[2] << ")";
 
     if ( lastOriginInitialized && (thisOrigin == lastOrigin) )
     {
       MITK_DEBUG << "    ==> Sort away " << *dsIter << " for separate time step"; // we already have one occupying this position
       result.AddFileToUnsortedBlock( *dsIter ); // sort away for further analysis
       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
         std::string orientationValue = (*dsIter)->GetTagValueAsString( tagImageOrientation );
         DICOMStringToOrientationVectors( orientationValue, 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 (*dsIter)
 
           // 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
             double angle = 0.0;
             std::string tiltStr = (*dsIter)->GetTagValueAsString( tagGantryTilt );
             const char* convertInput = tiltStr.c_str();
             char* convertEnd(NULL);
             if (!tiltStr.empty())
             {
               // read value, compare to calculated angle
               angle = strtod(convertInput, &convertEnd); // TODO check errors!
             }
 
             if (convertEnd != convertInput)
             {
               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( *dsIter ); // 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
               {
                 assert(!datasets.empty());
 
                 result.FlagGantryTilt(tiltInfo);
                 result.AddFileToSortedBlock( *dsIter ); // this file is good for current block
                 result.SetFirstFilenameOfBlock( datasets.front()->GetFilenameIfAvailable() );
                 fileFitsIntoPattern = true;
               }
             }
             else // we cannot check the calculated tilt angle against the one from the dicom header (so we assume we are right)
             {
               assert(!datasets.empty());
 
               result.FlagGantryTilt(tiltInfo);
               result.AddFileToSortedBlock( *dsIter ); // this file is good for current block
               result.SetFirstFilenameOfBlock( datasets.front()->GetFilenameIfAvailable() );
               fileFitsIntoPattern = true;
             }
           }
           else // caller does not want tilt compensation OR shearing is more complicated than tilt
           {
             result.AddFileToUnsortedBlock( *dsIter ); // sort away for further analysis
             fileFitsIntoPattern = false;
           }
         }
         else // not sheared
         {
           result.AddFileToSortedBlock( *dsIter ); // 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 " << *dsIter << " 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( *dsIter ); // sort away for further analysis
           fileFitsIntoPattern = false;
         }
         else
         {
           result.AddFileToSortedBlock( *dsIter ); // this file is good for current block
           fileFitsIntoPattern = true;
         }
       }
       else // this should be the very first slice
       {
         result.AddFileToSortedBlock( *dsIter ); // 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();
     }
   }
 
+  // update tilt info to get maximum precision
+  // earlier, tilt was only calculated from first and second slice.
+  // now that we know the whole range, we can re-calculate using the very first and last slice
+  if ( result.ContainsGantryTilt() && result.GetBlockFilenames().size() > 1 )
+  {
+    DICOMDatasetList datasets = result.GetBlockFilenames();
+    DICOMDatasetAccess* firstDataset = datasets.front();
+    DICOMDatasetAccess* lastDataset = datasets.back();
+    unsigned int numberOfSlicesApart = datasets.size() - 1;
+
+    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
+    std::string orientationValue = firstDataset->GetTagValueAsString( tagImageOrientation );
+    bool orientationConversion(false);
+    DICOMStringToOrientationVectors( orientationValue, right, up, orientationConversion );
+
+    if (orientationConversion)
+    {
+
+      std::string firstOriginString = firstDataset->GetTagValueAsString( tagImagePositionPatient );
+      std::string lastOriginString = lastDataset->GetTagValueAsString( tagImagePositionPatient );
+
+      if (!firstOriginString.empty() && !lastOriginString.empty())
+      {
+        bool firstOriginConversion(false);
+        bool lastOriginConversion(false);
+
+        Point3D firstOrigin = DICOMStringToPoint3D( firstOriginString, firstOriginConversion );
+        Point3D lastOrigin = DICOMStringToPoint3D( lastOriginString, lastOriginConversion );
+
+        if (firstOriginConversion && lastOriginConversion)
+        {
+          GantryTiltInformation updatedTiltInfo( firstOrigin, lastOrigin, right, up, numberOfSlicesApart );
+          result.FlagGantryTilt(updatedTiltInfo);
+        }
+      }
+    }
+  }
+
   return result;
 }
diff --git a/Modules/DICOMReader/mitkEquiDistantBlocksSorter.h b/Modules/DICOMReader/mitkEquiDistantBlocksSorter.h
index 293943a73c..67bcbdc86c 100644
--- a/Modules/DICOMReader/mitkEquiDistantBlocksSorter.h
+++ b/Modules/DICOMReader/mitkEquiDistantBlocksSorter.h
@@ -1,156 +1,156 @@
 /*===================================================================
 
 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 mitkEquiDistantBlocksSorter_h
 #define mitkEquiDistantBlocksSorter_h
 
 #include "mitkDICOMDatasetSorter.h"
 #include "mitkDICOMSortCriterion.h"
 #include "mitkGantryTiltInformation.h"
 
 #include "mitkVector.h"
 
 #include <gdcmScanner.h>
 
 namespace mitk
 {
 
 /**
   \brief Split inputs into blocks of equidant slices.
 
   This kind of splitting is used as a check before loading a DICOM series with ITK ImageSeriesReader.
 */
 class DICOMReader_EXPORT EquiDistantBlocksSorter : public DICOMDatasetSorter
 {
   public:
 
     mitkClassMacro( EquiDistantBlocksSorter, DICOMDatasetSorter )
     itkNewMacro( EquiDistantBlocksSorter )
 
     virtual DICOMTagList GetTagsOfInterest();
 
     virtual void Sort();
 
     void SetAcceptTilt(bool accept);
     const GantryTiltInformation GetTiltInformation(const std::string& filename, bool& hasTiltInfo); // TODO ugly, but bool flag will be removed
 
   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.
          */
-        DICOMDatasetList GetBlockFilenames();
+        DICOMDatasetList GetBlockFilenames(); // TODO rename --> ... Dataset ... instead of filename
 
         void SetFirstFilenameOfBlock(const std::string& filename);
         std::string GetFirstFilenameOfBlock() const;
 
         /**
           \brief Remaining files, which could not be grouped.
          */
         DICOMDatasetList GetUnsortedFilenames();
 
         /**
           \brief Wheter or not the grouped result contain a gantry tilt.
          */
         bool ContainsGantryTilt();
 
         /**
           \brief Detailed description of gantry tilt.
         */
         const GantryTiltInformation& GetTiltInfo() const;
 
         /**
           \brief Meant for internal use by AnalyzeFileForITKImageSeriesReaderSpacingAssumption only.
          */
-        void AddFileToSortedBlock(DICOMDatasetAccess* dataset); // TODO Dataset!
+        void AddFileToSortedBlock(DICOMDatasetAccess* dataset);
 
         /**
           \brief Meant for internal use by AnalyzeFileForITKImageSeriesReaderSpacingAssumption only.
          */
         void AddFileToUnsortedBlock(DICOMDatasetAccess* dataset);
         void AddFilesToUnsortedBlock(const DICOMDatasetList& datasets);
 
         /**
           \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(const GantryTiltInformation& tiltInfo);
 
         /**
           \brief Only meaningful for use by AnalyzeFileForITKImageSeriesReaderSpacingAssumption.
          */
         void UndoPrematureGrouping();
 
       protected:
 
         DICOMDatasetList m_GroupedFiles;
         DICOMDatasetList m_UnsortedFiles;
 
         bool m_GantryTilt; // TODO make the flag part of GantryTiltInformation!
         GantryTiltInformation m_TiltInfo;
         std::string m_FirstFilenameOfBlock;
     };
 
     /**
       \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)
      */
     SliceGroupingAnalysisResult
     AnalyzeFileForITKImageSeriesReaderSpacingAssumption(const DICOMDatasetList& files, bool groupsOfSimilarImages);
 
     /**
       \brief Safely convert const char* to std::string.
      */
     std::string
     ConstCharStarToString(const char* s);
 
     EquiDistantBlocksSorter();
     virtual ~EquiDistantBlocksSorter();
 
     EquiDistantBlocksSorter(const EquiDistantBlocksSorter& other);
     EquiDistantBlocksSorter& operator=(const EquiDistantBlocksSorter& other);
 
     bool m_AcceptTilt;
 
     typedef std::vector<SliceGroupingAnalysisResult> ResultsList;
     ResultsList m_SliceGroupingResults;
 };
 
 }
 
 #endif
diff --git a/Modules/DICOMReader/mitkGantryTiltInformation.cpp b/Modules/DICOMReader/mitkGantryTiltInformation.cpp
index f4874cc972..7e3667c260 100644
--- a/Modules/DICOMReader/mitkGantryTiltInformation.cpp
+++ b/Modules/DICOMReader/mitkGantryTiltInformation.cpp
@@ -1,200 +1,217 @@
+/*===================================================================
+
+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 "mitkGantryTiltInformation.h"
 
 #include "mitkLogMacros.h"
 
 mitk::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];
 
 mitk::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 origin1: " << origin1;
     MITK_DEBUG << "    v origin2: " << origin2;
     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_INFO <<  "    calculated from slices " << m_NumberOfSlicesApart << " slices apart";
     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;
   }
 }
 
 void
 mitk::GantryTiltInformation
 ::Print(std::ostream& os) const
 {
-  os << "  calculated from slices " << m_NumberOfSlicesApart << " slices apart " << std::endl;
+  os << "  calculated from slices " << m_NumberOfSlicesApart << " slices apart" << std::endl;
   os << "  shift normal: " << m_ShiftNormal << std::endl;
   os << "  shift normal assumed by ITK: " << m_ITKAssumedSliceSpacing << std::endl;
   os << "  shift up: " << m_ShiftUp << std::endl;
   os << "  shift right: " << m_ShiftRight << std::endl;
 
   os << "  tilt angle (deg): " << atan( m_ShiftUp / m_ShiftNormal ) * 180.0 / 3.1415926535 << std::endl;
 }
 
 mitk::Point3D
 mitk::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
 mitk::GantryTiltInformation::GetTiltCorrectedAdditionalSize(unsigned int imageSizeZ) const
 {
   return fabs(m_ShiftUp /  static_cast<double>(m_NumberOfSlicesApart) * static_cast<double>(imageSizeZ-1)); // TODO care for SIZE of image
 }
 
 double
 mitk::GantryTiltInformation::GetTiltAngleInDegrees() const
 {
   return atan( fabs(m_ShiftUp) / m_ShiftNormal ) * 180.0 / 3.1415926535;
 }
 
 double
 mitk::GantryTiltInformation::GetMatrixCoefficientForCorrectionInWorldCoordinates() const
 {
   // so many mm need to be shifted per slice!
   return m_ShiftUp / static_cast<double>(m_NumberOfSlicesApart);
 }
 
 double
 mitk::GantryTiltInformation::GetRealZSpacing() const
 {
   return m_ShiftNormal / static_cast<double>(m_NumberOfSlicesApart);
 }
 
 
 bool
 mitk::GantryTiltInformation::IsSheared() const
 {
   return (   fabs(m_ShiftRight) > 0.001
           ||    fabs(m_ShiftUp) > 0.001);
 }
 
 
 bool
 mitk::GantryTiltInformation::IsRegularGantryTilt() const
 {
   return (   fabs(m_ShiftRight) < 0.001
           &&    fabs(m_ShiftUp) > 0.001);
 }