diff --git a/Modules/DicomRT/CMakeLists.txt b/Modules/DicomRT/CMakeLists.txt
index ecfcceffbd..7fe08ffd4e 100644
--- a/Modules/DicomRT/CMakeLists.txt
+++ b/Modules/DicomRT/CMakeLists.txt
@@ -1,10 +1,10 @@
 if(NOT DEFINED DCMTK_dcmrt_LIBRARY OR DCMTK_dcmrt_LIBRARY)
   mitk_create_module(
-    DEPENDS MitkSceneSerializationBase MitkDICOMReader MitkDICOMReaderServices
+    DEPENDS MitkSceneSerializationBase MitkDICOMReader
     PACKAGE_DEPENDS PUBLIC DCMTK
   )
   add_subdirectory(autoload/IO)
   add_subdirectory(test)
 else()
   message("MITK DicomRT Support disabled because the DCMTK dcmrt library not found")
 endif()
diff --git a/Modules/DicomRT/autoload/IO/CMakeLists.txt b/Modules/DicomRT/autoload/IO/CMakeLists.txt
index d133f9af17..d449c318cf 100644
--- a/Modules/DicomRT/autoload/IO/CMakeLists.txt
+++ b/Modules/DicomRT/autoload/IO/CMakeLists.txt
@@ -1,9 +1,8 @@
 MITK_CREATE_MODULE(DicomRTIO
   INCLUDE_DIRS
     PRIVATE src/IO
   DEPENDS
     PUBLIC MitkDicomRT MitkContourModel
-    PRIVATE MitkDICOMReaderServices
   PACKAGE_DEPENDS PUBLIC DCMTK
   AUTOLOAD_WITH MitkCore
 )
diff --git a/Modules/DicomRT/autoload/IO/mitkDicomRTIOMimeTypes.cpp b/Modules/DicomRT/autoload/IO/mitkDicomRTIOMimeTypes.cpp
index 3db99ac3de..8fad1d262a 100644
--- a/Modules/DicomRT/autoload/IO/mitkDicomRTIOMimeTypes.cpp
+++ b/Modules/DicomRT/autoload/IO/mitkDicomRTIOMimeTypes.cpp
@@ -1,262 +1,261 @@
 /*============================================================================
 
 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 "mitkDicomRTIOMimeTypes.h"
 
 #include "mitkIOMimeTypes.h"
 
 #include "mitkDICOMDCMTKTagScanner.h"
 #include "mitkDICOMTagPath.h"
-#include "mitkDICOMTagsOfInterestService.h"
 #include <mitkDICOMFileReaderSelector.h>
 #include <mitkDICOMFileReader.h>
 
 #include <itksys/SystemTools.hxx>
 
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <usServiceProperties.h>
 #include <usServiceRegistration.h>
 
 namespace mitk
 {
 
 std::vector<CustomMimeType*> DicomRTIOMimeTypes::Get()
 {
   std::vector<CustomMimeType*> mimeTypes;
 
   // order matters here (descending rank for mime types)
   mimeTypes.push_back(DICOMRT_DOSE_MIMETYPE().Clone());
   mimeTypes.push_back(DICOMRT_PLAN_MIMETYPE().Clone());
   mimeTypes.push_back(DICOMRT_STRUCT_MIMETYPE().Clone());
 
   return mimeTypes;
 }
 
 // Mime Types
 
 DicomRTIOMimeTypes::RTDoseMimeType::RTDoseMimeType()
   : CustomMimeType(DICOMRT_DOSE_MIMETYPE_NAME())
 {
   std::string category = "DICOMRT";
   this->SetCategory(category);
   this->SetComment("RTDose");
 
   this->AddExtension("dcm");
 }
 
 bool DicomRTIOMimeTypes::RTDoseMimeType::AppliesTo(const std::string &path) const
 {
   bool canRead( CustomMimeType::AppliesTo(path) );
 
   if (!canRead) {
     return false;
   }
 
   if (!canReadByDicomFileReader(path)) {
     return false;
   }
 
   auto modality = GetModality(path);
 
   if (modality == "RTDOSE") {
     return true;
   }
   else {
     return false;
     }
 }
 
 std::string DicomRTIOMimeTypes::GetModality(const std::string & path)
 {
   mitk::IDICOMTagsOfInterest* toiSrv = GetDicomTagsOfInterestService();
 
   auto tagsOfInterest = toiSrv->GetTagsOfInterest();
 
   DICOMTagPathList tagsOfInterestList;
   for (const auto& tag : tagsOfInterest) {
     tagsOfInterestList.push_back(tag.first);
   }
 
   mitk::DICOMDCMTKTagScanner::Pointer scanner = mitk::DICOMDCMTKTagScanner::New();
   scanner->SetInputFiles({ path });
   scanner->AddTagPaths(tagsOfInterestList);
   scanner->Scan();
 
   mitk::DICOMDatasetAccessingImageFrameList frames = scanner->GetFrameInfoList();
   std::string modality = "";
   if (frames.empty())
     return modality;
   auto findings = frames.front()->GetTagValueAsString(DICOMTagPath(0x0008, 0x0060));
 
   modality = findings.front().value;
   return modality;
 }
 
 bool DicomRTIOMimeTypes::canReadByDicomFileReader(const std::string & filename)
 {
   mitk::DICOMFileReaderSelector::Pointer selector = mitk::DICOMFileReaderSelector::New();
   selector->LoadBuiltIn3DConfigs();
   selector->SetInputFiles({ filename });
 
   mitk::DICOMFileReader::Pointer reader = selector->GetFirstReaderWithMinimumNumberOfOutputImages();
 
   if (reader.IsNull()) {
     return false;
   }
   else {
     return true;
   }
 }
 
 DicomRTIOMimeTypes::RTDoseMimeType* DicomRTIOMimeTypes::RTDoseMimeType::Clone() const
 {
   return new RTDoseMimeType(*this);
 }
 
 DicomRTIOMimeTypes::RTStructMimeType::RTStructMimeType()
   : CustomMimeType(DICOMRT_STRUCT_MIMETYPE_NAME())
 {
   std::string category = "DICOMRT";
   this->SetCategory(category);
   this->SetComment("RTStruct");
 
   this->AddExtension("dcm");
 }
 
 bool DicomRTIOMimeTypes::RTStructMimeType::AppliesTo(const std::string &path) const
 {
   bool canRead(CustomMimeType::AppliesTo(path));
 
   if (!canRead) {
     return false;
   }
 
   auto modality = GetModality(path);
   if (modality == "RTSTRUCT") {
     return true;
   }
   else {
     return false;
   }
 }
 
 DicomRTIOMimeTypes::RTStructMimeType* DicomRTIOMimeTypes::RTStructMimeType::Clone() const
 {
   return new RTStructMimeType(*this);
 }
 
 DicomRTIOMimeTypes::RTPlanMimeType::RTPlanMimeType()
   : CustomMimeType(DICOMRT_PLAN_MIMETYPE_NAME())
 {
   std::string category = "DICOMRT";
   this->SetCategory(category);
   this->SetComment("RTPLAN");
 
   this->AddExtension("dcm");
 }
 
 bool DicomRTIOMimeTypes::RTPlanMimeType::AppliesTo(const std::string &path) const
 {
   bool canRead(CustomMimeType::AppliesTo(path));
 
   if (!canRead) {
     return false;
   }
 
   auto modality = GetModality(path);
     if (modality == "RTPLAN") {
       return true;
     }
     else {
       return false;
     }
 }
 
 DicomRTIOMimeTypes::RTPlanMimeType* DicomRTIOMimeTypes::RTPlanMimeType::Clone() const
 {
   return new RTPlanMimeType(*this);
 }
 
 
 DicomRTIOMimeTypes::RTDoseMimeType DicomRTIOMimeTypes::DICOMRT_DOSE_MIMETYPE()
 {
   return RTDoseMimeType();
 }
 
 DicomRTIOMimeTypes::RTStructMimeType DicomRTIOMimeTypes::DICOMRT_STRUCT_MIMETYPE()
 {
   return RTStructMimeType();
 }
 
 DicomRTIOMimeTypes::RTPlanMimeType DicomRTIOMimeTypes::DICOMRT_PLAN_MIMETYPE()
 {
   return RTPlanMimeType();
 }
 
 // Names
 std::string DicomRTIOMimeTypes::DICOMRT_DOSE_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".dicomrt.dose";
   return name;
 }
 
 std::string DicomRTIOMimeTypes::DICOMRT_STRUCT_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".dicomrt.struct";
   return name;
 }
 
 std::string DicomRTIOMimeTypes::DICOMRT_PLAN_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".dicomrt.plan";
   return name;
 }
 
 // Descriptions
 
 std::string DicomRTIOMimeTypes::DICOMRT_DOSE_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "RTDOSE reader";
   return description;
 }
 
 std::string DicomRTIOMimeTypes::DICOMRT_STRUCT_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "RTSTRUCT reader";
   return description;
 }
 
 std::string DicomRTIOMimeTypes::DICOMRT_PLAN_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "RTPLAN reader";
   return description;
 }
 
 mitk::IDICOMTagsOfInterest* DicomRTIOMimeTypes::GetDicomTagsOfInterestService()
 {
   mitk::IDICOMTagsOfInterest* result = nullptr;
 
   std::vector<us::ServiceReference<mitk::IDICOMTagsOfInterest> > toiRegisters = us::GetModuleContext()->GetServiceReferences<mitk::IDICOMTagsOfInterest>();
   if (!toiRegisters.empty())
   {
     if (toiRegisters.size() > 1)
     {
       MITK_WARN << "Multiple DICOM tags of interest services found. Using just one.";
     }
     result = us::GetModuleContext()->GetService<mitk::IDICOMTagsOfInterest>(toiRegisters.front());
   }
 
   return result;
 }
 
 }