diff --git a/Core/Code/IO/mitkFileWriterSelector.cpp b/Core/Code/IO/mitkFileWriterSelector.cpp
index 77e59bf989..7c44d3e414 100644
--- a/Core/Code/IO/mitkFileWriterSelector.cpp
+++ b/Core/Code/IO/mitkFileWriterSelector.cpp
@@ -1,356 +1,368 @@
 /*===================================================================
 
 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 "mitkFileWriterSelector.h"
 
 #include <mitkFileWriterRegistry.h>
 #include <mitkCoreServices.h>
 #include <mitkIMimeTypeProvider.h>
 #include <mitkBaseData.h>
 
 #include <usServiceReference.h>
 #include <usServiceProperties.h>
 #include <usAny.h>
 
 #include <itksys/SystemTools.hxx>
 
 #include <set>
 #include <limits>
 #include <iterator>
 
 namespace mitk {
 
 struct FileWriterSelector::Item::Impl : us::SharedData
 {
   Impl()
     : m_FileWriter(NULL)
     , m_ConfidenceLevel(IFileWriter::Unsupported)
     , m_BaseDataIndex(0)
     , m_Id(-1)
   {}
 
   us::ServiceReference<IFileWriter> m_FileWriterRef;
   IFileWriter* m_FileWriter;
   IFileWriter::ConfidenceLevel m_ConfidenceLevel;
   std::size_t m_BaseDataIndex;
   MimeType m_MimeType;
   long m_Id;
 };
 
 struct FileWriterSelector::Impl : us::SharedData
 {
   Impl()
     : m_BestId(-1)
     , m_SelectedId(m_BestId)
   {}
 
   Impl(const Impl& other)
     : us::SharedData(other)
     , m_BestId(-1)
     , m_SelectedId(m_BestId)
   {}
 
   FileWriterRegistry m_WriterRegistry;
   std::map<long, FileWriterSelector::Item> m_Items;
   std::set<MimeType> m_MimeTypes;
   long m_BestId;
   long m_SelectedId;
 };
 
 FileWriterSelector::FileWriterSelector(const FileWriterSelector& other)
   : m_Data(other.m_Data)
 {
 }
 
 FileWriterSelector::FileWriterSelector(const BaseData* baseData, const std::string& mimeType,
                                        const std::string& path)
   : m_Data(new Impl)
 {
   mitk::CoreServicePointer<mitk::IMimeTypeProvider> mimeTypeProvider(mitk::CoreServices::GetMimeTypeProvider());
 
+  std::vector<FileWriterRegistry::WriterReference> refs;
+
   std::string destMimeType = mimeType;
   if (destMimeType.empty() && !path.empty())
   {
     // try to derive a mime-type from the file
     std::vector<MimeType> mimeTypes = mimeTypeProvider->GetMimeTypesForFile(path);
     if (!mimeTypes.empty())
     {
-      destMimeType = mimeTypes.front().GetName();
+      for( unsigned int index = 0; index < mimeTypes.size(); index++)
+      {
+        std::vector<FileWriterRegistry::WriterReference> tempRefs = m_Data->m_WriterRegistry.GetReferences(baseData, mimeTypes.at(index).GetName());
+        for( unsigned int innerIndex = 0; innerIndex < tempRefs.size(); innerIndex++)
+        {
+          refs.push_back( tempRefs.at(innerIndex) );
+        }
+      }
     }
     else if (!itksys::SystemTools::GetFilenameExtension(path).empty())
     {
       // If there are no suitable mime-type for the file AND an extension
       // was supplied, we stop here.
       return;
     }
   }
+  else
+  {
+    refs = m_Data->m_WriterRegistry.GetReferences(baseData, destMimeType);
+  }
 
   std::vector<std::string> classHierarchy = baseData->GetClassHierarchy();
 
   // Get all writers and their mime types for the given base data type
-  std::vector<FileWriterRegistry::WriterReference> refs = m_Data->m_WriterRegistry.GetReferences(baseData, destMimeType);
   Item bestItem;
   for (std::vector<FileWriterRegistry::WriterReference>::const_iterator iter = refs.begin(),
        iterEnd = refs.end(); iter != iterEnd; ++iter)
   {
     std::string mimeTypeName = iter->GetProperty(IFileWriter::PROP_MIMETYPE()).ToString();
     if (!mimeTypeName.empty())
     {
       MimeType mimeType = mimeTypeProvider->GetMimeTypeForName(mimeTypeName);
       if (mimeType.IsValid())
       {
         // There is a registered mime-type for this writer. Now get the confidence level
         // of this writer for writing the given base data object.
 
         IFileWriter* writer = m_Data->m_WriterRegistry.GetWriter(*iter);
         if (writer == NULL) continue;
         try
         {
           writer->SetInput(baseData);
           IFileWriter::ConfidenceLevel confidenceLevel = writer->GetConfidenceLevel();
           if (confidenceLevel == IFileWriter::Unsupported)
           {
             continue;
           }
 
           std::string baseDataType = iter->GetProperty(IFileWriter::PROP_BASEDATA_TYPE()).ToString();
           std::vector<std::string>::iterator idxIter =
               std::find(classHierarchy.begin(), classHierarchy.end(), baseDataType);
           std::size_t baseDataIndex = std::numeric_limits<std::size_t>::max();
           if (idxIter != classHierarchy.end())
           {
             baseDataIndex = std::distance(classHierarchy.begin(), idxIter);
           }
 
           Item item;
           item.d->m_FileWriterRef = *iter;
           item.d->m_FileWriter = writer;
           item.d->m_ConfidenceLevel = confidenceLevel;
           item.d->m_BaseDataIndex = baseDataIndex;
           item.d->m_MimeType = mimeType;
           item.d->m_Id = us::any_cast<long>(iter->GetProperty(us::ServiceConstants::SERVICE_ID()));
           m_Data->m_Items.insert(std::make_pair(item.d->m_Id, item));
           m_Data->m_MimeTypes.insert(mimeType);
           if (!bestItem.GetReference() || bestItem < item)
           {
             bestItem = item;
           }
         }
         catch (const us::BadAnyCastException& e)
         {
           MITK_WARN << "Unexpected: " << e.what();
         }
         catch (const std::exception& e)
         {
           // Log the error but continue
           MITK_WARN << "IFileWriter::GetConfidenceLevel exception: " << e.what();
         }
       }
     }
   }
 
   if (bestItem.GetReference())
   {
     m_Data->m_BestId = bestItem.GetServiceId();
     m_Data->m_SelectedId = m_Data->m_BestId;
   }
 }
 
 FileWriterSelector::~FileWriterSelector()
 {
 }
 
 FileWriterSelector& FileWriterSelector::operator=(const FileWriterSelector& other)
 {
   m_Data = other.m_Data;
   return *this;
 }
 
 bool FileWriterSelector::IsEmpty() const
 {
   return m_Data->m_Items.empty();
 }
 
 std::vector<FileWriterSelector::Item> FileWriterSelector::Get(const std::string& mimeType) const
 {
   std::vector<Item> result;
   for (std::map<long, Item>::const_iterator iter = m_Data->m_Items.begin(),
        iterEnd = m_Data->m_Items.end(); iter != iterEnd; ++iter)
   {
     if (mimeType.empty() || iter->second.GetMimeType().GetName() == mimeType)
     {
       result.push_back(iter->second);
     }
   }
   std::sort(result.begin(), result.end());
   return result;
 }
 
 std::vector<FileWriterSelector::Item> FileWriterSelector::Get() const
 {
   return Get(this->GetSelected().d->m_MimeType.GetName());
 }
 
 FileWriterSelector::Item FileWriterSelector::Get(long id) const
 {
   std::map<long, Item>::const_iterator iter = m_Data->m_Items.find(id);
   if (iter != m_Data->m_Items.end())
   {
     return iter->second;
   }
   return Item();
 }
 
 FileWriterSelector::Item FileWriterSelector::GetDefault() const
 {
   return Get(m_Data->m_BestId);
 }
 
 long FileWriterSelector::GetDefaultId() const
 {
   return m_Data->m_BestId;
 }
 
 FileWriterSelector::Item FileWriterSelector::GetSelected() const
 {
   return Get(m_Data->m_SelectedId);
 }
 
 long FileWriterSelector::GetSelectedId() const
 {
   return m_Data->m_SelectedId;
 }
 
 bool FileWriterSelector::Select(const std::string& mimeType)
 {
   std::vector<Item> items = Get(mimeType);
   if (items.empty()) return false;
   return Select(items.back());
 }
 
 bool FileWriterSelector::Select(const FileWriterSelector::Item& item)
 {
   return Select(item.d->m_Id);
 }
 
 bool FileWriterSelector::Select(long id)
 {
   if (id > -1)
   {
     if (m_Data->m_Items.find(id) == m_Data->m_Items.end())
     {
       return false;
     }
     m_Data->m_SelectedId = id;
     return true;
   }
   return false;
 }
 
 std::vector<MimeType> FileWriterSelector::GetMimeTypes() const
 {
   std::vector<MimeType> result;
   result.reserve(m_Data->m_MimeTypes.size());
   result.assign(m_Data->m_MimeTypes.begin(), m_Data->m_MimeTypes.end());
   return result;
 }
 
 void FileWriterSelector::Swap(FileWriterSelector& fws)
 {
   m_Data.Swap(fws.m_Data);
 }
 
 FileWriterSelector::Item::Item(const FileWriterSelector::Item& other)
   : d(other.d)
 {
 }
 
 FileWriterSelector::Item::~Item()
 {
 }
 
 FileWriterSelector::Item& FileWriterSelector::Item::operator=(const FileWriterSelector::Item& other)
 {
   d = other.d;
   return *this;
 }
 
 IFileWriter* FileWriterSelector::Item::GetWriter() const
 {
   return d->m_FileWriter;
 }
 
 std::string FileWriterSelector::Item::GetDescription() const
 {
   us::Any descr = d->m_FileWriterRef.GetProperty(IFileWriter::PROP_DESCRIPTION());
   if (descr.Empty()) return std::string();
   return descr.ToString();
 }
 
 IFileWriter::ConfidenceLevel FileWriterSelector::Item::GetConfidenceLevel() const
 {
   return d->m_ConfidenceLevel;
 }
 
 MimeType FileWriterSelector::Item::GetMimeType() const
 {
   return d->m_MimeType;
 }
 
 std::string FileWriterSelector::Item::GetBaseDataType() const
 {
   us::Any any = d->m_FileWriterRef.GetProperty(IFileWriter::PROP_BASEDATA_TYPE());
   if (any.Empty()) return std::string();
   return any.ToString();
 }
 
 us::ServiceReference<IFileWriter> FileWriterSelector::Item::GetReference() const
 {
   return d->m_FileWriterRef;
 }
 
 long FileWriterSelector::Item::GetServiceId() const
 {
   return d->m_Id;
 }
 
 bool FileWriterSelector::Item::operator<(const FileWriterSelector::Item& other) const
 {
   // sort by confidence level first (ascending)
   if (d->m_ConfidenceLevel == other.d->m_ConfidenceLevel)
   {
     // sort by class hierarchy index (writers for more derived
     // based data types are considered a better match)
     if (d->m_BaseDataIndex == other.d->m_BaseDataIndex)
     {
       // sort by file writer service ranking
       return d->m_FileWriterRef < other.d->m_FileWriterRef;
     }
     return other.d->m_BaseDataIndex < d->m_BaseDataIndex;
   }
   return d->m_ConfidenceLevel < other.d->m_ConfidenceLevel;
 }
 
 FileWriterSelector::Item::Item()
   : d(new Impl())
 {}
 
 void swap(FileWriterSelector& fws1, FileWriterSelector& fws2)
 {
   fws1.Swap(fws2);
 }
 
 }
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
index 53c649bd9d..20ac728707 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
@@ -1,235 +1,233 @@
 /*===================================================================
 
 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 "mitkDiffusionIOMimeTypes.h"
 #include "mitkIOMimeTypes.h"
 #include <itksys/SystemTools.hxx>
 #include <itkNrrdImageIO.h>
 #include <itkMetaDataDictionary.h>
 #include <itkMetaDataObject.h>
 #include <mitkLogMacros.h>
 
 namespace mitk
 {
 
 std::vector<CustomMimeType*> DiffusionIOMimeTypes::Get()
 {
   std::vector<CustomMimeType*> mimeTypes;
 
   // order matters here (descending rank for mime types)
 
   mimeTypes.push_back(DWI_MIMETYPE().Clone());
   mimeTypes.push_back(DTI_MIMETYPE().Clone());
   mimeTypes.push_back(QBI_MIMETYPE().Clone());
 
   mimeTypes.push_back(FIBERBUNDLE_MIMETYPE().Clone());
 
   mimeTypes.push_back(CONNECTOMICS_MIMETYPE().Clone());
 
   return mimeTypes;
 }
 
 // Mime Types
 
 CustomMimeType DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE()
 {
   CustomMimeType mimeType(FIBERBUNDLE_MIMETYPE_NAME());
   std::string category = "Fiber Bundle File";
   mimeType.SetComment("Fiber Bundles");
   mimeType.SetCategory(category);
   mimeType.AddExtension("fib");
   mimeType.AddExtension("trk");
   //mimeType.AddExtension("vtk");
   return mimeType;
 }
 
 DiffusionIOMimeTypes::DwiMimeType::DwiMimeType()
   : CustomMimeType(DWI_MIMETYPE_NAME())
 {
   std::string category = "Diffusion Weighted Image";
   this->SetCategory(category);
   this->SetComment("Diffusion Weighted Images");
 
   this->AddExtension("dwi");
   this->AddExtension("hdwi");
   this->AddExtension("fsl");
   this->AddExtension("fslgz");
-  // this is commented out to fix the dashboard, should be enabled again
-  // once mime types have a way to check the base data for properties
-  //this->AddExtension("nrrd");
+  this->AddExtension("nrrd");
 }
 
 bool DiffusionIOMimeTypes::DwiMimeType::AppliesTo(const std::string &path) const
 {
   bool canRead( CustomMimeType::AppliesTo(path) );
 
   // fix for bug 18572
   // Currently this function is called for writing as well as reading, in that case
   // the image information can of course not be read
   // This is a bug, this function should only be called for reading.
   if( ! itksys::SystemTools::FileExists( path.c_str() ) )
   {
     return canRead;
   }
   //end fix for bug 18572
 
   std::string ext = itksys::SystemTools::GetFilenameLastExtension( path );
   ext = itksys::SystemTools::LowerCase( ext );
 
   // Simple NRRD files should only be considered for this mime type if they contain
   // corresponding tags
   if( ext == ".nrrd" )
   {
     itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
     io->SetFileName(path);
     try
     {
       io->ReadImageInformation();
 
       itk::MetaDataDictionary imgMetaDictionary = io->GetMetaDataDictionary();
       std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
       std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
       std::string metaString;
 
       for (; itKey != imgMetaKeys.end(); itKey ++)
       {
         itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
         if (itKey->find("modality") != std::string::npos)
         {
           if (metaString.find("DWMRI") != std::string::npos)
           {
             return canRead;
           }
         }
       }
 
     }
     catch( const itk::ExceptionObject &e )
     {
       MITK_ERROR << "ITK Exception: " << e.what();
     }
     canRead = false;
   }
 
   return canRead;
 }
 
 DiffusionIOMimeTypes::DwiMimeType* DiffusionIOMimeTypes::DwiMimeType::Clone() const
 {
   return new DwiMimeType(*this);
 }
 
 
 DiffusionIOMimeTypes::DwiMimeType DiffusionIOMimeTypes::DWI_MIMETYPE()
 {
   return DwiMimeType();
 }
 
 CustomMimeType DiffusionIOMimeTypes::DTI_MIMETYPE()
 {
   CustomMimeType mimeType(DTI_MIMETYPE_NAME());
   std::string category = "Tensor Images";
   mimeType.SetComment("Diffusion Tensor Images");
   mimeType.SetCategory(category);
   mimeType.AddExtension("dti");
   mimeType.AddExtension("hdti");
   return mimeType;
 }
 
 CustomMimeType DiffusionIOMimeTypes::QBI_MIMETYPE()
 {
   CustomMimeType mimeType(QBI_MIMETYPE_NAME());
   std::string category = "Q-Ball Images";
   mimeType.SetComment("Diffusion Q-Ball Images");
   mimeType.SetCategory(category);
   mimeType.AddExtension("qbi");
   mimeType.AddExtension("hqbi");
   return mimeType;
 }
 
 CustomMimeType DiffusionIOMimeTypes::CONNECTOMICS_MIMETYPE()
 {
   CustomMimeType mimeType(CONNECTOMICS_MIMETYPE_NAME());
   std::string category = "Connectomics Networks";
   mimeType.SetComment("Connectomics Networks");
   mimeType.SetCategory(category);
   mimeType.AddExtension("cnf");
   return mimeType;
 }
 
 // Names
 std::string DiffusionIOMimeTypes::DWI_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".dwi";
   return name;
 }
 
 std::string DiffusionIOMimeTypes::DTI_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".dti";
   return name;
 }
 
 std::string DiffusionIOMimeTypes::QBI_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".qbi";
   return name;
 }
 
 std::string DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".fib";
   return name;
 }
 
 std::string DiffusionIOMimeTypes::CONNECTOMICS_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".cnf";
   return name;
 }
 
 // Descriptions
 std::string DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Fiberbundles";
   return description;
 }
 
 std::string DiffusionIOMimeTypes::DWI_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Diffusion Weighted Images";
   return description;
 }
 
 std::string DiffusionIOMimeTypes::DTI_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Diffusion Tensor Images";
   return description;
 }
 
 std::string DiffusionIOMimeTypes::QBI_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Q-Ball Images";
   return description;
 }
 
 std::string DiffusionIOMimeTypes::CONNECTOMICS_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Connectomics Networks";
   return description;
 }
 
 }
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp
index 94f152f17f..95f42b98e3 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp
@@ -1,332 +1,332 @@
 /*===================================================================
 
 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 __mitkNrrdDiffusionImageWriter__cpp
 #define __mitkNrrdDiffusionImageWriter__cpp
 
 #include "mitkNrrdDiffusionImageWriter.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include "itkNiftiImageIO.h"
 #include "itkImageFileWriter.h"
 #include "itksys/SystemTools.hxx"
 #include "mitkDiffusionIOMimeTypes.h"
 #include "mitkImageCast.h"
 
 #include <iostream>
 #include <fstream>
 
 
 mitk::NrrdDiffusionImageWriter::NrrdDiffusionImageWriter()
   : AbstractFileWriter(mitk::Image::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_NAME() ), mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_DESCRIPTION())
 {
   RegisterService();
 }
 
 mitk::NrrdDiffusionImageWriter::NrrdDiffusionImageWriter(const mitk::NrrdDiffusionImageWriter& other)
   : AbstractFileWriter(other)
 {
 }
 
 mitk::NrrdDiffusionImageWriter::~NrrdDiffusionImageWriter()
 {}
 
 void mitk::NrrdDiffusionImageWriter::Write()
 {
   mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image *>(this->GetInput());
 
   VectorImageType::Pointer itkImg;
   mitk::CastToItkImage(input,itkImg);
 
   if (input.IsNull())
   {
     MITK_ERROR <<"Sorry, input to NrrdDiffusionImageWriter is NULL!";
     return;
   }
   if ( this->GetOutputLocation().empty() )
   {
     MITK_ERROR << "Sorry, filename has not been set!";
     return ;
   }
   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;
     }
   }
 
   char keybuffer[512];
   char valbuffer[512];
 
   //itk::MetaDataDictionary dic = input->GetImage()->GetMetaDataDictionary();
 
   vnl_matrix_fixed<double,3,3> measurementFrame = mitk::DiffusionPropertyHelper::GetMeasurementFrame(input);
   if (measurementFrame(0,0) || measurementFrame(0,1) || measurementFrame(0,2) ||
     measurementFrame(1,0) || measurementFrame(1,1) || measurementFrame(1,2) ||
     measurementFrame(2,0) || measurementFrame(2,1) || measurementFrame(2,2))
   {
     sprintf( valbuffer, " (%lf,%lf,%lf) (%lf,%lf,%lf) (%lf,%lf,%lf)", measurementFrame(0,0), measurementFrame(0,1), measurementFrame(0,2), measurementFrame(1,0), measurementFrame(1,1), measurementFrame(1,2), measurementFrame(2,0), measurementFrame(2,1), measurementFrame(2,2));
     itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("measurement frame"),std::string(valbuffer));
   }
 
   sprintf( valbuffer, "DWMRI");
   itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("modality"),std::string(valbuffer));
 
   if(mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size())
   {
     sprintf( valbuffer, "%1f", mitk::DiffusionPropertyHelper::GetReferenceBValue(input) );
     itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("DWMRI_b-value"),std::string(valbuffer));
   }
 
   for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
   {
     sprintf( keybuffer, "DWMRI_gradient_%04d", i );
 
     /*if(itk::ExposeMetaData<std::string>(input->GetMetaDataDictionary(),
     std::string(keybuffer),tmp))
     continue;*/
 
     sprintf( valbuffer, "%1f %1f %1f", mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(0),
       mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(1), mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(2));
 
     itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
   }
 
   typedef itk::VectorImage<short,3> ImageType;
 
   std::string ext = itksys::SystemTools::GetFilenameLastExtension(this->GetOutputLocation());
   ext = itksys::SystemTools::LowerCase(ext);
 
   // default extension is .dwi
   if( ext == "")
   {
     ext = ".nrrd";
     this->SetOutputLocation(this->GetOutputLocation() + ext);
   }
 
   if (ext == ".hdwi" || ext == ".nrrd" || ext == ".dwi")
   {
 
     MITK_INFO << "Extension " << ext;
     itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
     //io->SetNrrdVectorType( nrrdKindList );
     io->SetFileType( itk::ImageIOBase::Binary );
     io->UseCompressionOn();
 
     typedef itk::ImageFileWriter<ImageType> WriterType;
     WriterType::Pointer nrrdWriter = WriterType::New();
     nrrdWriter->UseInputMetaDataDictionaryOn();
     nrrdWriter->SetInput( itkImg );
     nrrdWriter->SetImageIO(io);
     nrrdWriter->SetFileName(this->GetOutputLocation());
     nrrdWriter->UseCompressionOn();
     nrrdWriter->SetImageIO(io);
     try
     {
       nrrdWriter->Update();
     }
     catch (itk::ExceptionObject e)
     {
       std::cout << e << std::endl;
       throw;
     }
 
   }
   else if (ext == ".fsl" || ext == ".fslgz")
   {
     MITK_INFO << "Writing Nifti-Image for FSL";
 
     typedef itk::Image<short,4> ImageType4D;
     ImageType4D::Pointer img4 = ImageType4D::New();
 
     ImageType::SpacingType spacing = itkImg->GetSpacing();
     ImageType4D::SpacingType spacing4;
     for(int i=0; i<3; i++)
       spacing4[i] = spacing[i];
     spacing4[3] = 1;
     img4->SetSpacing( spacing4 );   // Set the image spacing
 
     ImageType::PointType origin = itkImg->GetOrigin();
     ImageType4D::PointType origin4;
     for(int i=0; i<3; i++)
       origin4[i] = origin[i];
     origin4[3] = 0;
     img4->SetOrigin( origin4 );     // Set the image origin
 
     ImageType::DirectionType direction = itkImg->GetDirection();
     ImageType4D::DirectionType direction4;
     for(int i=0; i<3; i++)
       for(int j=0; j<3; j++)
         direction4[i][j] = direction[i][j];
     for(int i=0; i<4; i++)
       direction4[i][3] = 0;
     for(int i=0; i<4; i++)
       direction4[3][i] = 0;
     direction4[3][3] = 1;
     img4->SetDirection( direction4 );  // Set the image direction
 
     ImageType::RegionType region = itkImg->GetLargestPossibleRegion();
     ImageType4D::RegionType region4;
 
     ImageType::RegionType::SizeType size = region.GetSize();
     ImageType4D::RegionType::SizeType size4;
 
     for(int i=0; i<3; i++)
       size4[i] = size[i];
     size4[3] = itkImg->GetVectorLength();
 
     ImageType::RegionType::IndexType index = region.GetIndex();
     ImageType4D::RegionType::IndexType index4;
     for(int i=0; i<3; i++)
       index4[i] = index[i];
     index4[3] = 0;
 
     region4.SetSize(size4);
     region4.SetIndex(index4);
     img4->SetRegions( region4 );
 
     img4->Allocate();
 
     itk::ImageRegionIterator<ImageType>   it (itkImg, itkImg->GetLargestPossibleRegion() );
     typedef ImageType::PixelType VecPixType;
 
     for (it.GoToBegin(); !it.IsAtEnd(); ++it)
     {
       VecPixType vec = it.Get();
       ImageType::IndexType currentIndex = it.GetIndex();
       for(unsigned int ind=0; ind<vec.Size(); ind++)
       {
 
         for(int i=0; i<3; i++)
           index4[i] = currentIndex[i];
         index4[3] = ind;
         img4->SetPixel(index4, vec[ind]);
       }
     }
 
     // create copy of file with correct ending for mitk
     std::string fname3 = this->GetOutputLocation();
     std::string::iterator itend = fname3.end();
     if (ext == ".fsl")
       fname3.replace( itend-3, itend, "nii");
     else
       fname3.replace( itend-5, itend, "nii.gz");
 
     itk::NiftiImageIO::Pointer io4 = itk::NiftiImageIO::New();
 
     typedef itk::VectorImage<short,3> ImageType;
     typedef itk::ImageFileWriter<ImageType4D> WriterType4;
     WriterType4::Pointer nrrdWriter4 = WriterType4::New();
     nrrdWriter4->UseInputMetaDataDictionaryOn();
     nrrdWriter4->SetInput( img4 );
     nrrdWriter4->SetFileName(fname3);
     nrrdWriter4->UseCompressionOn();
     nrrdWriter4->SetImageIO(io4);
     try
     {
       nrrdWriter4->Update();
     }
     catch (itk::ExceptionObject e)
     {
       std::cout << e << std::endl;
       throw;
     }
 
     itksys::SystemTools::CopyAFile(fname3.c_str(), this->GetOutputLocation().c_str());
 
     if(mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size())
     {
       std::ofstream myfile;
       std::string fname = this->GetOutputLocation();
       fname += ".bvals";
       myfile.open (fname.c_str());
       for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
       {
         double twonorm = mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).two_norm();
         myfile << mitk::DiffusionPropertyHelper::GetReferenceBValue(input)*twonorm*twonorm << " ";
       }
       myfile.close();
 
       std::ofstream myfile2;
       std::string fname2 = this->GetOutputLocation();
       fname2 += ".bvecs";
       myfile2.open (fname2.c_str());
       for(int j=0; j<3; j++)
       {
         for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
         {
           //need to modify the length
           GradientDirectionContainerType::Pointer grads = mitk::DiffusionPropertyHelper::GetGradientContainer(input);
           GradientDirectionType direction = grads->ElementAt(i);
           direction.normalize();
           myfile2 << direction.get(j) << " ";
           //myfile2 << input->GetDirections()->ElementAt(i).get(j) << " ";
         }
         myfile2 << std::endl;
       }
 
       std::ofstream myfile3;
       std::string fname4 = this->GetOutputLocation();
       fname4 += ".ttk";
       myfile3.open (fname4.c_str());
       for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
       {
         for(int j=0; j<3; j++)
         {
           myfile3 << mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(j) << " ";
         }
         myfile3 << std::endl;
       }
     }
   }
   try
   {
     setlocale(LC_ALL, currLocale.c_str());
   }
   catch(...)
   {
     MITK_INFO << "Could not reset locale " << currLocale;
   }
 }
 
 mitk::NrrdDiffusionImageWriter* mitk::NrrdDiffusionImageWriter::Clone() const
 {
   return new NrrdDiffusionImageWriter(*this);
 }
 
 mitk::IFileWriter::ConfidenceLevel mitk::NrrdDiffusionImageWriter::GetConfidenceLevel() const
 {
   mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
-  if (input.IsNull() )
+  if (input.IsNull() || !mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( input ) )
   {
     return Unsupported;
   }
   else
   {
     return Supported;
   }
 }
 
 #endif //__mitkNrrdDiffusionImageWriter__cpp