diff --git a/Modules/CEST/autoload/IO/mitkCESTIOActivator.cpp b/Modules/CEST/autoload/IO/mitkCESTIOActivator.cpp
index 7da1044d6c..78e7955706 100644
--- a/Modules/CEST/autoload/IO/mitkCESTIOActivator.cpp
+++ b/Modules/CEST/autoload/IO/mitkCESTIOActivator.cpp
@@ -1,46 +1,56 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkCESTIOActivator.h"
 
 #include "mitkCESTDICOMReaderService.h"
 #include "mitkCESTGenericDICOMReaderService.h"
 
 #include <usModuleContext.h>
 
 #include "mitkCESTIOMimeTypes.h"
-#include "mitkIOMimeTypes.h"
 
 namespace mitk
 {
   void CESTIOActivator::Load(us::ModuleContext *context)
   {
     us::ServiceProperties props;
     props[us::ServiceConstants::SERVICE_RANKING()] = 10;
 
     m_MimeTypes = mitk::MitkCESTIOMimeTypes::Get();
-    for (std::vector<mitk::CustomMimeType *>::const_iterator mimeTypeIter = m_MimeTypes.begin(),
-                                                             iterEnd = m_MimeTypes.end();
-         mimeTypeIter != iterEnd;
-         ++mimeTypeIter)
+    for (auto& mimeType : m_MimeTypes)
     {
-      context->RegisterService(*mimeTypeIter, props);
+      if (mimeType->GetName() == mitk::MitkCESTIOMimeTypes::CEST_DICOM_WITHOUT_META_FILE_NAME())
+      { // "w/o meta" mimetype should only registered with low priority.
+        context->RegisterService(mimeType);
+      }
+      else
+      {
+        context->RegisterService(mimeType, props);
+      }
     }
 
     m_CESTDICOMReader.reset(new CESTDICOMReaderService());
-    m_CESTDICOMManualReader.reset(new CESTDICOMManualReaderService(CustomMimeType(IOMimeTypes::DICOM_MIMETYPE()), "CEST DICOM Manual Reader"));
+    m_CESTDICOMManualWithMetaFileReader.reset(new CESTDICOMManualReaderService(MitkCESTIOMimeTypes::CEST_DICOM_WITH_META_FILE_MIMETYPE(), "CEST DICOM Manual Reader"));
+    m_CESTDICOMManualWithOutMetaFileReader.reset(new CESTDICOMManualReaderService(MitkCESTIOMimeTypes::CEST_DICOM_WITHOUT_META_FILE_MIMETYPE(), "CEST DICOM Manual Reader"));
   }
 
-  void CESTIOActivator::Unload(us::ModuleContext *) {}
+  void CESTIOActivator::Unload(us::ModuleContext *)
+  {
+    for (auto& elem : m_MimeTypes)
+    {
+      delete elem;
+    }
+  }
 }
 
 US_EXPORT_MODULE_ACTIVATOR(mitk::CESTIOActivator)
diff --git a/Modules/CEST/autoload/IO/mitkCESTIOActivator.h b/Modules/CEST/autoload/IO/mitkCESTIOActivator.h
index bbfd824d1d..4c34dc8a6c 100644
--- a/Modules/CEST/autoload/IO/mitkCESTIOActivator.h
+++ b/Modules/CEST/autoload/IO/mitkCESTIOActivator.h
@@ -1,41 +1,42 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKCESTIOActivator_H
 #define MITKCESTIOActivator_H
 
 #include <mitkCustomMimeType.h>
 
 #include <usModuleActivator.h>
 #include <usServiceEvent.h>
 
 #include <memory>
 
 namespace mitk
 {
   struct IFileReader;
   class IDICOMTagsOfInterest;
 
   class CESTIOActivator : public us::ModuleActivator
   {
   public:
     void Load(us::ModuleContext *context) override;
     void Unload(us::ModuleContext *context) override;
 
   private:
     std::unique_ptr<IFileReader> m_CESTDICOMReader;
-    std::unique_ptr<IFileReader> m_CESTDICOMManualReader;
+    std::unique_ptr<IFileReader> m_CESTDICOMManualWithMetaFileReader;
+    std::unique_ptr<IFileReader> m_CESTDICOMManualWithOutMetaFileReader;
     std::vector<mitk::CustomMimeType *> m_MimeTypes;
   };
 }
 
 #endif // MITKCESTIOActivator_H
diff --git a/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.cpp b/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.cpp
index 28b696d7ea..e752e8a8ff 100644
--- a/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.cpp
+++ b/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.cpp
@@ -1,123 +1,223 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkCESTIOMimeTypes.h"
 #include "mitkIOMimeTypes.h"
 #include <mitkCustomTagParser.h>
 #include <mitkDICOMDCMTKTagScanner.h>
 #include <mitkDICOMFileReaderSelector.h>
 
 #include <mitkLogMacros.h>
 
 #include <itkGDCMImageIO.h>
 
 #include <itksys/SystemTools.hxx>
 
 namespace mitk
 {
   std::vector<CustomMimeType *> MitkCESTIOMimeTypes::Get()
   {
     std::vector<CustomMimeType *> mimeTypes;
 
     // order matters here (descending rank for mime types)
 
+    mimeTypes.push_back(CEST_DICOM_WITH_META_FILE_MIMETYPE().Clone());
     mimeTypes.push_back(CEST_DICOM_MIMETYPE().Clone());
+    mimeTypes.push_back(CEST_DICOM_WITHOUT_META_FILE_MIMETYPE().Clone());
 
     return mimeTypes;
   }
 
   // Mime Types
 
-  MitkCESTIOMimeTypes::MitkCESTDicomMimeType::MitkCESTDicomMimeType() : CustomMimeType(CEST_DICOM_MIMETYPE_NAME())
+  MitkCESTIOMimeTypes::MitkCESTDicomMimeType::MitkCESTDicomMimeType() : IOMimeTypes::BaseDicomMimeType(CEST_DICOM_MIMETYPE_NAME())
   {
-    this->AddExtension("gdcm");
-    this->AddExtension("dcm");
-    this->AddExtension("DCM");
-    this->AddExtension("dc3");
-    this->AddExtension("DC3");
-    this->AddExtension("ima");
-    this->AddExtension("img");
-
     this->SetCategory(IOMimeTypes::CATEGORY_IMAGES());
     this->SetComment("CEST DICOM");
   }
 
   bool MitkCESTIOMimeTypes::MitkCESTDicomMimeType::AppliesTo(const std::string &path) const
   {
-    bool canRead(CustomMimeType::AppliesTo(path));
+    bool canRead(IOMimeTypes::BaseDicomMimeType::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
 
-    // Ask the GDCM ImageIO class directly
-    itk::GDCMImageIO::Pointer gdcmIO = itk::GDCMImageIO::New();
-    canRead = gdcmIO->CanReadFile(path.c_str());
-
     if (!canRead)
     {
       return canRead;
     }
 
     mitk::DICOMDCMTKTagScanner::Pointer scanner = mitk::DICOMDCMTKTagScanner::New();
 
     mitk::DICOMTag siemensCESTprivateTag(0x0029, 0x1020);
 
     mitk::StringList relevantFiles;
     relevantFiles.push_back(path);
 
     scanner->AddTag(siemensCESTprivateTag);
     scanner->SetInputFiles(relevantFiles);
     scanner->Scan();
     mitk::DICOMTagCache::Pointer tagCache = scanner->GetScanCache();
 
     mitk::DICOMImageFrameList imageFrameList = mitk::ConvertToDICOMImageFrameList(tagCache->GetFrameInfoList());
     mitk::DICOMImageFrameInfo *firstFrame = imageFrameList.begin()->GetPointer();
 
     std::string byteString = tagCache->GetTagValue(firstFrame, siemensCESTprivateTag).value;
 
     if (byteString.empty()) {
       return false;
     }
     mitk::CustomTagParser tagParser(relevantFiles[0]);
 
     auto parsedPropertyList = tagParser.ParseDicomPropertyString(byteString);
 
     bool mapNotEmpty = parsedPropertyList->GetMap()->size() > 0;
 
     return mapNotEmpty;
   }
 
   MitkCESTIOMimeTypes::MitkCESTDicomMimeType *MitkCESTIOMimeTypes::MitkCESTDicomMimeType::Clone() const
   {
     return new MitkCESTDicomMimeType(*this);
   }
 
   MitkCESTIOMimeTypes::MitkCESTDicomMimeType MitkCESTIOMimeTypes::CEST_DICOM_MIMETYPE()
   {
     return MitkCESTDicomMimeType();
   }
 
-  // Names
   std::string MitkCESTIOMimeTypes::CEST_DICOM_MIMETYPE_NAME()
   {
     // create a unique and sensible name for this mime type
     static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".image.dicom.cest";
     return name;
   }
+
+  MitkCESTIOMimeTypes::MitkCESTDicomWithMetaFileMimeType::MitkCESTDicomWithMetaFileMimeType() : IOMimeTypes::BaseDicomMimeType(CEST_DICOM_WITH_META_FILE_NAME())
+  {
+    this->SetCategory(IOMimeTypes::CATEGORY_IMAGES());
+    this->SetComment("CEST DICOM");
+  }
+
+  bool MitkCESTIOMimeTypes::MitkCESTDicomWithMetaFileMimeType::AppliesTo(const std::string& path) const
+  {
+    bool canRead(IOMimeTypes::BaseDicomMimeType::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
+
+    if (!canRead)
+    {
+      return canRead;
+    }
+
+    std::string dir = path;
+    if (!itksys::SystemTools::FileIsDirectory(path))
+    {
+      dir = itksys::SystemTools::GetProgramPath(path);
+    }
+
+    std::string metafilePath = dir +"/" + "CEST_META.json";
+
+    canRead = itksys::SystemTools::FileExists(metafilePath.c_str());
+
+    return canRead;
+  }
+
+  MitkCESTIOMimeTypes::MitkCESTDicomWithMetaFileMimeType* MitkCESTIOMimeTypes::MitkCESTDicomWithMetaFileMimeType::Clone() const
+  {
+    return new MitkCESTDicomWithMetaFileMimeType(*this);
+  }
+
+  MitkCESTIOMimeTypes::MitkCESTDicomWithMetaFileMimeType MitkCESTIOMimeTypes::CEST_DICOM_WITH_META_FILE_MIMETYPE()
+  {
+    return MitkCESTDicomWithMetaFileMimeType();
+  }
+
+  std::string MitkCESTIOMimeTypes::CEST_DICOM_WITH_META_FILE_NAME()
+  {
+    // create a unique and sensible name for this mime type
+    static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".image.dicom.cest.generic.meta";
+    return name;
+  }
+
+  MitkCESTIOMimeTypes::MitkCESTDicomWOMetaFileMimeType::MitkCESTDicomWOMetaFileMimeType() : IOMimeTypes::BaseDicomMimeType(CEST_DICOM_WITHOUT_META_FILE_NAME())
+  {
+    this->SetCategory(IOMimeTypes::CATEGORY_IMAGES());
+    this->SetComment("CEST DICOM");
+  }
+
+  bool MitkCESTIOMimeTypes::MitkCESTDicomWOMetaFileMimeType::AppliesTo(const std::string& path) const
+  {
+    bool canRead(IOMimeTypes::BaseDicomMimeType::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
+
+    if (!canRead)
+    {
+      return canRead;
+    }
+
+    std::string dir = path;
+    if (!itksys::SystemTools::FileIsDirectory(path))
+    {
+      dir = itksys::SystemTools::GetProgramPath(path);
+    }
+
+    std::string metafilePath = dir + "/" + "CEST_META.json";
+
+    canRead = !itksys::SystemTools::FileExists(metafilePath.c_str());
+
+    return canRead;
+  }
+
+  MitkCESTIOMimeTypes::MitkCESTDicomWOMetaFileMimeType* MitkCESTIOMimeTypes::MitkCESTDicomWOMetaFileMimeType::Clone() const
+  {
+    return new MitkCESTDicomWOMetaFileMimeType(*this);
+  }
+
+  MitkCESTIOMimeTypes::MitkCESTDicomWOMetaFileMimeType MitkCESTIOMimeTypes::CEST_DICOM_WITHOUT_META_FILE_MIMETYPE()
+  {
+    return MitkCESTDicomWOMetaFileMimeType();
+  }
+
+  std::string MitkCESTIOMimeTypes::CEST_DICOM_WITHOUT_META_FILE_NAME()
+  {
+    // create a unique and sensible name for this mime type
+    static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".image.dicom.cest.generic.nometa";
+    return name;
+  }
+
 }
diff --git a/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.h b/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.h
index e94a72adf8..a35ba83274 100644
--- a/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.h
+++ b/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.h
@@ -1,52 +1,85 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKCESTIOMIMETYPES_H
 #define MITKCESTIOMIMETYPES_H
 
-#include "mitkCustomMimeType.h"
+#include "mitkIOMimeTypes.h"
 
 #include <string>
 
 namespace mitk
 {
   /// Provides the custom mime types for MitkCEST
   class MitkCESTIOMimeTypes
   {
   public:
     /** Mime type that parses dicom files to determine whether they are CEST dicom files.
     *
     * Accepts dicom files that contain the substring "CEST_Rev" (via the mitk::CustomTagParser parsing)
     * in the tSequenceFileName parameter in dicom tag (0x0029, 0x1020)
     */
-    class MitkCESTDicomMimeType : public CustomMimeType
+    class MitkCESTDicomMimeType : public IOMimeTypes::BaseDicomMimeType
     {
     public:
       MitkCESTDicomMimeType();
       bool AppliesTo(const std::string &path) const override;
       MitkCESTDicomMimeType *Clone() const override;
     };
 
     static MitkCESTDicomMimeType CEST_DICOM_MIMETYPE();
     static std::string CEST_DICOM_MIMETYPE_NAME();
 
+    /** Mime type that indicated generic CEST dicom files.
+    *
+    * The mime type assumes that dicom files that have a CEST_META.json file in the
+    * same directory are CEST DICOMs and relevant for this mime type.
+    */
+    class MitkCESTDicomWithMetaFileMimeType : public IOMimeTypes::BaseDicomMimeType
+    {
+    public:
+      MitkCESTDicomWithMetaFileMimeType();
+      bool AppliesTo(const std::string& path) const override;
+      MitkCESTDicomWithMetaFileMimeType* Clone() const override;
+    };
+
+    static MitkCESTDicomWithMetaFileMimeType CEST_DICOM_WITH_META_FILE_MIMETYPE();
+    static std::string CEST_DICOM_WITH_META_FILE_NAME();
+
+    /** Mime type that indicated dicom files that can be potantially read as Generic
+    * CEST but have *NO* CEST meta information.
+    *
+    * The mime type is used to offer the manual CEST loading for all DICOM images with
+    * low priority if no CEST meta file is present.
+    */
+    class MitkCESTDicomWOMetaFileMimeType : public IOMimeTypes::BaseDicomMimeType
+    {
+    public:
+      MitkCESTDicomWOMetaFileMimeType();
+      bool AppliesTo(const std::string& path) const override;
+      MitkCESTDicomWOMetaFileMimeType* Clone() const override;
+    };
+
+    static MitkCESTDicomWOMetaFileMimeType CEST_DICOM_WITHOUT_META_FILE_MIMETYPE();
+    static std::string CEST_DICOM_WITHOUT_META_FILE_NAME();
+
     // Get all Mime Types
     static std::vector<CustomMimeType *> Get();
 
   private:
     // purposely not implemented
     MitkCESTIOMimeTypes();
     MitkCESTIOMimeTypes(const MitkCESTIOMimeTypes &);
   };
 }
 
 #endif // MITKCESTIOMIMETYPES_H
diff --git a/Modules/Core/include/mitkIOMimeTypes.h b/Modules/Core/include/mitkIOMimeTypes.h
index 8df3c8f990..472aaf028d 100644
--- a/Modules/Core/include/mitkIOMimeTypes.h
+++ b/Modules/Core/include/mitkIOMimeTypes.h
@@ -1,92 +1,103 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKIOMIMETYPES_H
 #define MITKIOMIMETYPES_H
 
 #include "mitkCustomMimeType.h"
 
 #include <string>
 
 namespace mitk
 {
   /**
    * @ingroup IO
    * @brief The IOMimeTypes class
    */
   class MITKCORE_EXPORT IOMimeTypes
   {
   public:
-    class MITKCORE_EXPORT DicomMimeType : public CustomMimeType
+
+    /** Base mime types for all kind of DICOM images, that can be reused
+    by more specific mime types based on DICOM images.*/
+    class MITKCORE_EXPORT BaseDicomMimeType : public CustomMimeType
+    {
+    public:
+      BaseDicomMimeType(const std::string &name);
+      BaseDicomMimeType(const BaseDicomMimeType& other);
+      bool AppliesTo(const std::string& path) const override;
+      BaseDicomMimeType* Clone() const override;
+    };
+
+    class MITKCORE_EXPORT DicomMimeType : public BaseDicomMimeType
     {
     public:
       DicomMimeType();
-      bool AppliesTo(const std::string &path) const override;
       DicomMimeType *Clone() const override;
     };
 
     static std::vector<CustomMimeType *> Get();
 
     static std::string DEFAULT_BASE_NAME(); // application/vnd.mitk
 
     static std::string CATEGORY_IMAGES();   // Images
     static std::string CATEGORY_SURFACES(); // Surfaces
 
     // ------------------------------ VTK formats ----------------------------------
 
     static CustomMimeType VTK_IMAGE_MIMETYPE();             // (mitk::Image) vti
     static CustomMimeType VTK_IMAGE_LEGACY_MIMETYPE();      // (mitk::Image) vtk
     static CustomMimeType VTK_PARALLEL_IMAGE_MIMETYPE();    // (mitk::Image) pvti
     static CustomMimeType VTK_POLYDATA_MIMETYPE();          // (mitk::Surface) vtp, vtk
     static CustomMimeType VTK_POLYDATA_LEGACY_MIMETYPE();   // (mitk::Surface) vtk
     static CustomMimeType VTK_PARALLEL_POLYDATA_MIMETYPE(); // (mitk::Surface) pvtp
     static CustomMimeType STEREOLITHOGRAPHY_MIMETYPE();     // (mitk::Surface) stl
     static CustomMimeType WAVEFRONT_OBJ_MIMETYPE();         // (mitk::Surface) obj
     static CustomMimeType STANFORD_PLY_MIMETYPE();          // (mitk::Surface) ply
 
     static std::string STEREOLITHOGRAPHY_NAME();     // DEFAULT_BASE_NAME.stl
     static std::string VTK_IMAGE_NAME();             // DEFAULT_BASE_NAME.vtk.image
     static std::string VTK_IMAGE_LEGACY_NAME();      // DEFAULT_BASE_NAME.vtk.image.legacy
     static std::string VTK_PARALLEL_IMAGE_NAME();    // DEFAULT_BASE_NAME.vtk.parallel.image
     static std::string VTK_POLYDATA_NAME();          // DEFAULT_BASE_NAME.vtk.polydata
     static std::string VTK_POLYDATA_LEGACY_NAME();   // DEFAULT_BASE_NAME.vtk.polydata.legacy
     static std::string VTK_PARALLEL_POLYDATA_NAME(); // DEFAULT_BASE_NAME.vtk.parallel.polydata
     static std::string WAVEFRONT_OBJ_NAME();         // DEFAULT_BASE_NAME.obj
     static std::string STANFORD_PLY_NAME();          // DEFAULT_BASE_NAME.ply
 
     // ------------------------- Image formats (ITK based) --------------------------
 
     static CustomMimeType NRRD_MIMETYPE(); // nrrd, nhdr
     static CustomMimeType NIFTI_MIMETYPE();
     static CustomMimeType RAW_MIMETYPE(); // raw
     static DicomMimeType DICOM_MIMETYPE();
 
     static std::string NRRD_MIMETYPE_NAME(); // DEFAULT_BASE_NAME.nrrd
     static std::string NIFTI_MIMETYPE_NAME();
     static std::string RAW_MIMETYPE_NAME(); // DEFAULT_BASE_NAME.raw
     static std::string DICOM_MIMETYPE_NAME();
 
     // ------------------------------ MITK formats ----------------------------------
 
     static CustomMimeType POINTSET_MIMETYPE();      // mps
     static CustomMimeType GEOMETRY_DATA_MIMETYPE(); // .mitkgeometry
 
     static std::string POINTSET_MIMETYPE_NAME(); // DEFAULT_BASE_NAME.pointset
 
   private:
     // purposely not implemented
     IOMimeTypes();
     IOMimeTypes(const IOMimeTypes &);
   };
 }
 
 #endif // MITKIOMIMETYPES_H
diff --git a/Modules/Core/src/IO/mitkIOMimeTypes.cpp b/Modules/Core/src/IO/mitkIOMimeTypes.cpp
index 15983508f6..801bde5c04 100644
--- a/Modules/Core/src/IO/mitkIOMimeTypes.cpp
+++ b/Modules/Core/src/IO/mitkIOMimeTypes.cpp
@@ -1,352 +1,363 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkIOMimeTypes.h"
 
 #include "mitkCustomMimeType.h"
 #include "mitkLogMacros.h"
 
 #include "itkGDCMImageIO.h"
 #include "itkMetaDataObject.h"
 
 #include <itksys/SystemTools.hxx>
 #include <itksys/Directory.hxx>
 
 namespace mitk
 {
-  IOMimeTypes::DicomMimeType::DicomMimeType() : CustomMimeType(DICOM_MIMETYPE_NAME())
+  IOMimeTypes::BaseDicomMimeType::BaseDicomMimeType(const std::string& name) : CustomMimeType(name)
   {
     this->AddExtension("gdcm");
     this->AddExtension("dcm");
     this->AddExtension("DCM");
     this->AddExtension("dc3");
     this->AddExtension("DC3");
     this->AddExtension("ima");
     this->AddExtension("img");
 
     this->SetCategory(CATEGORY_IMAGES());
     this->SetComment("DICOM");
   }
 
-  bool IOMimeTypes::DicomMimeType::AppliesTo(const std::string &path) const
+  IOMimeTypes::BaseDicomMimeType::BaseDicomMimeType(const BaseDicomMimeType& other) : CustomMimeType(other.GetName())
+  {
+  }
+
+  bool IOMimeTypes::BaseDicomMimeType::AppliesTo(const std::string &path) const
   {
     // check whether directory or file
     // if directory try to find first file within it instead
     bool pathIsDirectory = itksys::SystemTools::FileIsDirectory(path);
 
     std::string filepath = path;
 
     if (pathIsDirectory)
     {
       itksys::Directory input;
       input.Load(path.c_str());
 
       std::vector<std::string> files;
       for (unsigned long idx = 0; idx<input.GetNumberOfFiles(); idx++)
       {
         if (!itksys::SystemTools::FileIsDirectory(input.GetFile(idx)))
         {
           std::string fullpath = path + "/" + std::string(input.GetFile(idx));
           files.push_back(fullpath.c_str());
         }
       }
       filepath = files.front();
     }
 
     // Ask the GDCM ImageIO class directly
     itk::GDCMImageIO::Pointer gdcmIO = itk::GDCMImageIO::New();
     gdcmIO->SetFileName(filepath);
     try {
       gdcmIO->ReadImageInformation();
     }
     catch (const itk::ExceptionObject & /*err*/) {
       return false;
     }
 
     //DICOMRT modalities have specific reader, don't read with normal DICOM readers
     std::string modality;
     itk::MetaDataDictionary& dict = gdcmIO->GetMetaDataDictionary();
     itk::ExposeMetaData<std::string>(dict, "0008|0060", modality);
     MITK_INFO << "DICOM Modality is " << modality;
     if (modality == "RTSTRUCT" || modality == "RTDOSE" || modality == "RTPLAN") {
       return false;
     }
     else {
       return gdcmIO->CanReadFile(filepath.c_str());
     }
   }
 
-  IOMimeTypes::DicomMimeType *IOMimeTypes::DicomMimeType::Clone() const { return new DicomMimeType(*this); }
+  IOMimeTypes::BaseDicomMimeType*IOMimeTypes::BaseDicomMimeType::Clone() const { return new BaseDicomMimeType(*this); }
+
+  IOMimeTypes::DicomMimeType::DicomMimeType() : BaseDicomMimeType(DICOM_MIMETYPE_NAME())
+  {
+  }
+
+  IOMimeTypes::DicomMimeType* IOMimeTypes::DicomMimeType::Clone() const { return new DicomMimeType(*this); }
+
   std::vector<CustomMimeType *> IOMimeTypes::Get()
   {
     std::vector<CustomMimeType *> mimeTypes;
 
     // order matters here (descending rank for mime types)
 
     mimeTypes.push_back(NRRD_MIMETYPE().Clone());
     mimeTypes.push_back(NIFTI_MIMETYPE().Clone());
 
     mimeTypes.push_back(VTK_IMAGE_MIMETYPE().Clone());
     mimeTypes.push_back(VTK_PARALLEL_IMAGE_MIMETYPE().Clone());
     mimeTypes.push_back(VTK_IMAGE_LEGACY_MIMETYPE().Clone());
 
     mimeTypes.push_back(DICOM_MIMETYPE().Clone());
 
     mimeTypes.push_back(VTK_POLYDATA_MIMETYPE().Clone());
     mimeTypes.push_back(VTK_PARALLEL_POLYDATA_MIMETYPE().Clone());
     mimeTypes.push_back(VTK_POLYDATA_LEGACY_MIMETYPE().Clone());
 
     mimeTypes.push_back(STEREOLITHOGRAPHY_MIMETYPE().Clone());
     mimeTypes.push_back(WAVEFRONT_OBJ_MIMETYPE().Clone());
     mimeTypes.push_back(STANFORD_PLY_MIMETYPE().Clone());
 
     mimeTypes.push_back(RAW_MIMETYPE().Clone());
     mimeTypes.push_back(POINTSET_MIMETYPE().Clone());
     return mimeTypes;
   }
 
   CustomMimeType IOMimeTypes::VTK_IMAGE_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_IMAGE_NAME());
     mimeType.AddExtension("vti");
     mimeType.SetCategory(CATEGORY_IMAGES());
     mimeType.SetComment("VTK Image");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::VTK_IMAGE_LEGACY_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_IMAGE_LEGACY_NAME());
     mimeType.AddExtension("vtk");
     mimeType.SetCategory(CATEGORY_IMAGES());
     mimeType.SetComment("VTK Legacy Image");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::VTK_PARALLEL_IMAGE_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_PARALLEL_IMAGE_NAME());
     mimeType.AddExtension("pvti");
     mimeType.SetCategory(CATEGORY_IMAGES());
     mimeType.SetComment("VTK Parallel Image");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::VTK_POLYDATA_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_POLYDATA_NAME());
     mimeType.AddExtension("vtp");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("VTK PolyData");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::VTK_POLYDATA_LEGACY_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_POLYDATA_LEGACY_NAME());
     mimeType.AddExtension("vtk");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("VTK Legacy PolyData");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::VTK_PARALLEL_POLYDATA_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_PARALLEL_POLYDATA_NAME());
     mimeType.AddExtension("pvtp");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("VTK Parallel PolyData");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::STEREOLITHOGRAPHY_MIMETYPE()
   {
     CustomMimeType mimeType(STEREOLITHOGRAPHY_NAME());
     mimeType.AddExtension("stl");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("Stereolithography");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::WAVEFRONT_OBJ_MIMETYPE()
   {
     CustomMimeType mimeType(WAVEFRONT_OBJ_NAME());
     mimeType.AddExtension("obj");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("Wavefront OBJ");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::STANFORD_PLY_MIMETYPE()
   {
     CustomMimeType mimeType(STANFORD_PLY_NAME());
     mimeType.AddExtension("ply");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("Stanford PLY");
     return mimeType;
   }
 
   std::string IOMimeTypes::STEREOLITHOGRAPHY_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".stl";
     return name;
   }
 
   std::string IOMimeTypes::WAVEFRONT_OBJ_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".obj";
     return name;
   }
 
   std::string IOMimeTypes::STANFORD_PLY_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".ply";
     return name;
   }
 
   std::string IOMimeTypes::DEFAULT_BASE_NAME()
   {
     static std::string name = "application/vnd.mitk";
     return name;
   }
 
   std::string IOMimeTypes::CATEGORY_IMAGES()
   {
     static std::string cat = "Images";
     return cat;
   }
 
   std::string IOMimeTypes::CATEGORY_SURFACES()
   {
     static std::string cat = "Surfaces";
     return cat;
   }
 
   std::string IOMimeTypes::VTK_IMAGE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.image";
     return name;
   }
 
   std::string IOMimeTypes::VTK_IMAGE_LEGACY_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.image.legacy";
     return name;
   }
 
   std::string IOMimeTypes::VTK_PARALLEL_IMAGE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.parallel.image";
     return name;
   }
 
   std::string IOMimeTypes::VTK_POLYDATA_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.polydata";
     return name;
   }
 
   std::string IOMimeTypes::VTK_POLYDATA_LEGACY_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.polydata.legacy";
     return name;
   }
 
   std::string IOMimeTypes::VTK_PARALLEL_POLYDATA_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.parallel.polydata";
     return name;
   }
 
   CustomMimeType IOMimeTypes::NRRD_MIMETYPE()
   {
     CustomMimeType mimeType(NRRD_MIMETYPE_NAME());
     mimeType.AddExtension("nrrd");
     mimeType.AddExtension("nhdr");
     mimeType.SetCategory("Images");
     mimeType.SetComment("NRRD");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::NIFTI_MIMETYPE()
   {
     CustomMimeType mimeType(NIFTI_MIMETYPE_NAME());
     mimeType.AddExtension("nii");
     mimeType.AddExtension("nii.gz");
     mimeType.AddExtension("hdr");
     mimeType.AddExtension("hdr.gz");
     mimeType.AddExtension("img");
     mimeType.AddExtension("img.gz");
     mimeType.AddExtension("nia");
     mimeType.SetCategory("Images");
     mimeType.SetComment("Nifti");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::RAW_MIMETYPE()
   {
     CustomMimeType mimeType(RAW_MIMETYPE_NAME());
     mimeType.AddExtension("raw");
     mimeType.SetCategory("Images");
     mimeType.SetComment("Raw data");
     return mimeType;
   }
 
   IOMimeTypes::DicomMimeType IOMimeTypes::DICOM_MIMETYPE() { return DicomMimeType(); }
   std::string IOMimeTypes::NRRD_MIMETYPE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".image.nrrd";
     return name;
   }
 
   std::string IOMimeTypes::NIFTI_MIMETYPE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".image.nifti";
     return name;
   }
 
   std::string IOMimeTypes::RAW_MIMETYPE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".image.raw";
     return name;
   }
 
   std::string IOMimeTypes::DICOM_MIMETYPE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".image.dicom";
     return name;
   }
 
   CustomMimeType IOMimeTypes::POINTSET_MIMETYPE()
   {
     CustomMimeType mimeType(POINTSET_MIMETYPE_NAME());
     mimeType.AddExtension("mps");
     mimeType.SetCategory("Point Sets");
     mimeType.SetComment("MITK Point Set");
     return mimeType;
   }
 
   std::string IOMimeTypes::POINTSET_MIMETYPE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".pointset";
     return name;
   }
 
   CustomMimeType IOMimeTypes::GEOMETRY_DATA_MIMETYPE()
   {
     mitk::CustomMimeType mimeType(DEFAULT_BASE_NAME() + ".geometrydata");
     mimeType.AddExtension("mitkgeometry");
     mimeType.SetCategory("Geometries");
     mimeType.SetComment("GeometryData object");
     return mimeType;
   }
 }