diff --git a/Modules/DICOMReader/mitkDICOMITKSeriesGDCMReader.cpp b/Modules/DICOMReader/mitkDICOMITKSeriesGDCMReader.cpp
index c6cd3a9795..25307a4038 100644
--- a/Modules/DICOMReader/mitkDICOMITKSeriesGDCMReader.cpp
+++ b/Modules/DICOMReader/mitkDICOMITKSeriesGDCMReader.cpp
@@ -1,283 +1,313 @@
 /*===================================================================
 
 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 "mitkEquiDistantBlocksSorter.h"
 
 #include <itkTimeProbesCollectorBase.h>
 
 #include <gdcmScanner.h>
 
 mitk::DICOMITKSeriesGDCMReader
 ::DICOMITKSeriesGDCMReader()
 :DICOMFileReader()
 ,m_FixTiltByShearing(false)
 ,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;
 }
 
 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;
 
     for(SortingBlockList::iterator blockIter = m_SortingResultInProgress.begin();
         blockIter != m_SortingResultInProgress.end();
         ++blockIter)
     {
       DICOMGDCMImageFrameList& gdcmInfoFrameList = *blockIter;
       DICOMDatasetList datasetList = ToDICOMDatasetList( gdcmInfoFrameList );
 
       sorter->SetInput(datasetList);
       sorter->Sort();
       unsigned int numberOfResultingBlocks = sorter->GetNumberOfOutputs();
       for (unsigned int b = 0; b < numberOfResultingBlocks; ++b)
       {
         DICOMDatasetList blockResult = sorter->GetOutput(b);
         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 );
 
     DICOMImageBlockDescriptor block;
     block.SetImageFrameList( frameList );
+
+    if (!gdcmFrameInfoList.empty())
+    {
+      // 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();
 
     bool correctTilt = false; // TODO
     bool tiltInfo = false; // TODO
 
     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, correctTilt, 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
   mitk::EquiDistantBlocksSorter::Pointer distanceKeeper = mitk::EquiDistantBlocksSorter::New();
   this->AddSortingElement( distanceKeeper );
 }
diff --git a/Modules/DICOMReader/mitkDICOMImageBlockDescriptor.cpp b/Modules/DICOMReader/mitkDICOMImageBlockDescriptor.cpp
index 34ec3e1f97..de1c012bd8 100644
--- a/Modules/DICOMReader/mitkDICOMImageBlockDescriptor.cpp
+++ b/Modules/DICOMReader/mitkDICOMImageBlockDescriptor.cpp
@@ -1,179 +1,236 @@
 /*===================================================================
 
 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 "mitkDICOMImageBlockDescriptor.h"
 
 mitk::DICOMImageBlockDescriptor
 ::DICOMImageBlockDescriptor()
 :m_PixelsInterpolated(false)
 ,m_PixelSpacingInterpretation()
+,m_PixelSpacing("")
+,m_ImagerPixelSpacing("")
 {
 }
 
 mitk::DICOMImageBlockDescriptor
 ::~DICOMImageBlockDescriptor()
 {
 }
 
 mitk::DICOMImageBlockDescriptor
 ::DICOMImageBlockDescriptor(const DICOMImageBlockDescriptor& other)
 :m_ImageFrameList( other.m_ImageFrameList )
 ,m_MitkImage( other.m_MitkImage )
 ,m_SliceIsLoaded( other.m_SliceIsLoaded )
 ,m_PixelsInterpolated( other.m_PixelsInterpolated )
 ,m_PixelSpacingInterpretation( other.m_PixelSpacingInterpretation )
+,m_PixelSpacing( other.m_PixelSpacing )
+,m_ImagerPixelSpacing( other.m_ImagerPixelSpacing )
 {
   if (m_MitkImage)
   {
     m_MitkImage = m_MitkImage->Clone();
   }
 }
 
 mitk::DICOMImageBlockDescriptor&
 mitk::DICOMImageBlockDescriptor
 ::operator=(const DICOMImageBlockDescriptor& other)
 {
   if (this != &other)
   {
     m_ImageFrameList = other.m_ImageFrameList;
     m_MitkImage = other.m_MitkImage;
     m_SliceIsLoaded = other.m_SliceIsLoaded;
     m_PixelsInterpolated = other.m_PixelsInterpolated;
     m_PixelSpacingInterpretation = other.m_PixelSpacingInterpretation;
+    m_PixelSpacing = other.m_PixelSpacing;
+    m_ImagerPixelSpacing = other.m_ImagerPixelSpacing;
 
     if (m_MitkImage)
     {
       m_MitkImage = m_MitkImage->Clone();
     }
   }
   return *this;
 }
 
 void
 mitk::DICOMImageBlockDescriptor
 ::SetImageFrameList(const DICOMImageFrameList& framelist)
 {
   m_ImageFrameList = framelist;
   m_SliceIsLoaded.resize(framelist.size());
   m_SliceIsLoaded.assign(framelist.size(), false);
 }
 
 const mitk::DICOMImageFrameList&
 mitk::DICOMImageBlockDescriptor
 ::GetImageFrameList() const
 {
   return m_ImageFrameList;
 }
 
 void
 mitk::DICOMImageBlockDescriptor
 ::SetMitkImage(Image::Pointer image)
 {
   if (m_MitkImage != image)
   {
     m_MitkImage = image;
   }
 }
 
 mitk::Image::Pointer
 mitk::DICOMImageBlockDescriptor
 ::GetMitkImage() const
 {
   return m_MitkImage;
 }
 
 void
 mitk::DICOMImageBlockDescriptor
 ::SetSliceIsLoaded(unsigned int index, bool isLoaded)
 {
   if (index < m_SliceIsLoaded.size())
   {
     m_SliceIsLoaded[index] = isLoaded;
   }
   else
   {
     std::stringstream ss;
     ss << "Index " << index << " out of range (" << m_SliceIsLoaded.size() << " indices reserved)";
     throw std::invalid_argument( ss.str() );
   }
 }
 
 bool
 mitk::DICOMImageBlockDescriptor
 ::IsSliceLoaded(unsigned int index) const
 {
   if (index < m_SliceIsLoaded.size())
   {
     return m_SliceIsLoaded[index];
   }
   else
   {
     std::stringstream ss;
     ss << "Index " << index << " out of range (" << m_SliceIsLoaded.size() << " indices reserved)";
     throw std::invalid_argument( ss.str() );
   }
 }
 
 bool
 mitk::DICOMImageBlockDescriptor
 ::AllSlicesAreLoaded() const
 {
   bool allLoaded = true;
   for (BoolList::const_iterator iter = m_SliceIsLoaded.begin();
        iter != m_SliceIsLoaded.end();
        ++iter)
   {
     allLoaded &= *iter;
   }
 
   return allLoaded;
 }
 
 
 void
 mitk::DICOMImageBlockDescriptor
 ::SetPixelsInterpolated(bool pixelsAreInterpolated)
 {
   if (m_PixelsInterpolated != pixelsAreInterpolated)
   {
     m_PixelsInterpolated = pixelsAreInterpolated;
   }
 }
 
 bool
 mitk::DICOMImageBlockDescriptor
 ::GetPixelsInterpolated() const
 {
   return m_PixelsInterpolated;
 }
 
 
 void
 mitk::DICOMImageBlockDescriptor
 ::SetPixelSpacingInterpretation( PixelSpacingInterpretation interpretation )
 {
   if (m_PixelSpacingInterpretation != interpretation)
   {
     m_PixelSpacingInterpretation = interpretation;
   }
 }
 
 mitk::PixelSpacingInterpretation
 mitk::DICOMImageBlockDescriptor
 ::GetPixelSpacingInterpretation() const
 {
   return m_PixelSpacingInterpretation;
 }
+
+void
+mitk::DICOMImageBlockDescriptor
+::SetPixelSpacingInformation(const std::string& pixelSpacing, const std::string& imagerPixelSpacing)
+{
+  m_PixelSpacing = pixelSpacing;
+  m_ImagerPixelSpacing = imagerPixelSpacing;
+}
+
+void
+mitk::DICOMImageBlockDescriptor
+::GetDesiredMITKImagePixelSpacing( float& spacingX, float& 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
+mitk::DICOMImageBlockDescriptor
+::DICOMStringToSpacing(const std::string& s, float& spacingX, float& spacingY) const
+{
+  bool successful = false;
+
+  MITK_INFO << "Convert '"<<s<<"' to spacings";
+
+  std::istringstream spacingReader(s);
+  std::string spacing;
+  if ( std::getline( spacingReader, spacing, '\\' ) )
+  {
+    spacingY = atof( spacing.c_str() );
+    MITK_INFO  << "A part '"<<spacing<<"'" <<spacingY;
+
+    if ( std::getline( spacingReader, spacing, '\\' ) )
+    {
+    MITK_INFO  << "A part '"<<spacing<<"'" <<spacingX;
+      spacingX = atof( spacing.c_str() );
+
+      successful = true;
+    }
+  }
+
+  return successful;
+}
diff --git a/Modules/DICOMReader/mitkDICOMImageBlockDescriptor.h b/Modules/DICOMReader/mitkDICOMImageBlockDescriptor.h
index e8fca6c1ba..be7f1a6de5 100644
--- a/Modules/DICOMReader/mitkDICOMImageBlockDescriptor.h
+++ b/Modules/DICOMReader/mitkDICOMImageBlockDescriptor.h
@@ -1,65 +1,72 @@
 /*===================================================================
 
 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 mitkDICOMImageBlockDescriptor_h
 #define mitkDICOMImageBlockDescriptor_h
 
 #include "mitkDICOMEnums.h"
 #include "mitkDICOMImageFrameInfo.h"
 
 #include "mitkImage.h"
 
 namespace mitk
 {
 
 class DICOMReader_EXPORT DICOMImageBlockDescriptor
 {
   public:
 
     DICOMImageBlockDescriptor();
     ~DICOMImageBlockDescriptor();
 
     DICOMImageBlockDescriptor(const DICOMImageBlockDescriptor& other);
     DICOMImageBlockDescriptor& operator=(const DICOMImageBlockDescriptor& other);
 
     void SetImageFrameList(const DICOMImageFrameList& framelist);
     const DICOMImageFrameList& GetImageFrameList() const;
 
     void SetMitkImage(Image::Pointer image);
     Image::Pointer GetMitkImage() const;
 
     void SetSliceIsLoaded(unsigned int index, bool isLoaded);
     bool IsSliceLoaded(unsigned int index) const;
     bool AllSlicesAreLoaded() const;
 
     void SetPixelsInterpolated(bool pixelsAreInterpolated);
     bool GetPixelsInterpolated() const;
 
     void SetPixelSpacingInterpretation( PixelSpacingInterpretation interpretation );
     PixelSpacingInterpretation GetPixelSpacingInterpretation() const;
 
+    void SetPixelSpacingInformation(const std::string& pixelSpacing, const std::string& imagerPixelSpacing);
+    void GetDesiredMITKImagePixelSpacing( float& spacingX, float& spacingY) const;
+    bool DICOMStringToSpacing(const std::string& s, float& spacingX, float& spacingY) const;
+
   private:
 
     DICOMImageFrameList m_ImageFrameList;
     Image::Pointer m_MitkImage;
     BoolList m_SliceIsLoaded;
     bool m_PixelsInterpolated;
     PixelSpacingInterpretation m_PixelSpacingInterpretation;
+
+    std::string m_PixelSpacing;
+    std::string m_ImagerPixelSpacing;
 };
 
 }
 
 #endif