diff --git a/Modules/CEST/autoload/IO/mitkCESTGenericDICOMReaderService.cpp b/Modules/CEST/autoload/IO/mitkCESTGenericDICOMReaderService.cpp
index bd6f8fa1a4..0c624b8baf 100644
--- a/Modules/CEST/autoload/IO/mitkCESTGenericDICOMReaderService.cpp
+++ b/Modules/CEST/autoload/IO/mitkCESTGenericDICOMReaderService.cpp
@@ -1,261 +1,286 @@
 /*============================================================================
 
 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 "mitkCESTGenericDICOMReaderService.h"
 
 #include "mitkIOMimeTypes.h"
+#include <mitkExtractCESTOffset.h>
 #include <mitkCustomTagParser.h>
 #include <mitkDICOMDCMTKTagScanner.h>
 #include <mitkDICOMFileReaderSelector.h>
 #include "mitkCESTImageNormalizationFilter.h"
 
 #include "itksys/SystemTools.hxx"
 
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 
 #include <boost/property_tree/json_parser.hpp>
 #include <boost/property_tree/ptree.hpp>
 
 namespace mitk
 {
   CESTDICOMManualReaderService::CESTDICOMManualReaderService(const CustomMimeType& mimeType, const std::string& description)
     : BaseDICOMReaderService(mimeType, description)
   {
     IFileIO::Options options;
     options["B1 amplitude"] = 0.0;
     options["CEST frequency [Hz]"] = 0.0;
     options["Pulse duration [us]"] = 0.0;
     options["Duty cycle [%]"] = 0.0;
     std::vector<std::string> normalizationStrategy;
     normalizationStrategy.push_back("Automatic");
     normalizationStrategy.push_back("No");
     options["Normalize data"] = normalizationStrategy;
 
     this->SetDefaultOptions(options);
 
     this->RegisterService();
   }
 
   CESTDICOMManualReaderService::CESTDICOMManualReaderService(const mitk::CESTDICOMManualReaderService& other)
     : BaseDICOMReaderService(other)
   {
   }
 
   void ExtractOptionFromPropertyTree(const std::string& key, boost::property_tree::ptree& root, std::map<std::string, us::Any>& options)
   {
     auto finding = root.find(key);
     if (finding != root.not_found())
     {
       options[key] = finding->second.get_value<double>();
     }
   }
 
   IFileIO::Options ExtractOptionsFromFile(const std::string& file)
   {
     boost::property_tree::ptree root;
 
     try
     {
       boost::property_tree::read_json(file, root, std::locale("C"));
     }
     catch (const boost::property_tree::json_parser_error & e)
     {
       MITK_WARN << "Could not parse CEST meta file. Fall back to default values. Error was:\n" << e.what();
     }
 
     IFileIO::Options options;
     ExtractOptionFromPropertyTree(CEST_PROPERTY_NAME_FREQ(),root, options);
     ExtractOptionFromPropertyTree(CEST_PROPERTY_NAME_B1Amplitude(), root, options);
     ExtractOptionFromPropertyTree(CEST_PROPERTY_NAME_PULSEDURATION(), root, options);
     ExtractOptionFromPropertyTree(CEST_PROPERTY_NAME_DutyCycle(), root, options);
     ExtractOptionFromPropertyTree(CEST_PROPERTY_NAME_OFFSETS(), root, options);
     ExtractOptionFromPropertyTree(CEST_PROPERTY_NAME_TREC(), root, options);
 
     return options;
   }
 
   void TransferOption(const mitk::IFileIO::Options& sourceOptions, const std::string& sourceName, mitk::IFileIO::Options& options, const std::string& newName)
   {
     auto sourceFinding = sourceOptions.find(sourceName);
     auto finding = options.find(newName);
 
     bool replaceValue = finding == options.end();
     if (!replaceValue)
     {
       replaceValue = us::any_cast<double>(finding->second) == 0.;
     }
 
     if (sourceFinding != sourceOptions.end() && us::any_cast<double>(sourceFinding->second) != 0. && replaceValue)
     {
       options[newName] = sourceFinding->second;
     }
   }
   
   std::string CESTDICOMManualReaderService::GetCESTMetaFilePath() const
   {
     auto dir = itksys::SystemTools::GetFilenamePath(this->GetInputLocation());
     std::string metafile = dir + "/" + "CEST_META.json";
     return metafile;
   }
 
   std::string CESTDICOMManualReaderService::GetTRECFilePath() const
   {
     auto dir = itksys::SystemTools::GetFilenamePath(this->GetInputLocation());
     std::string metafile = dir + "/" + "TREC.txt";
     return metafile;
   }
 
   std::string CESTDICOMManualReaderService::GetLISTFilePath() const
   {
     auto dir = itksys::SystemTools::GetFilenamePath(this->GetInputLocation());
     std::string metafile = dir + "/" + "LIST.txt";
     return metafile;
   }
 
 
   IFileIO::Options CESTDICOMManualReaderService::GetOptions() const
   {
     auto options = AbstractFileReader::GetOptions();
     if (!this->GetInputLocation().empty())
     {
       auto fileOptions = ExtractOptionsFromFile(this->GetCESTMetaFilePath());
 
       TransferOption(fileOptions, CEST_PROPERTY_NAME_FREQ(), options, "CEST frequency [Hz]");
       TransferOption(fileOptions, CEST_PROPERTY_NAME_B1Amplitude(), options, "B1 amplitude");
       TransferOption(fileOptions, CEST_PROPERTY_NAME_PULSEDURATION(), options, "Pulse duration [us]");
       TransferOption(fileOptions, CEST_PROPERTY_NAME_DutyCycle(), options, "Duty cycle [%]");
     }
     return options;
   }
 
   us::Any CESTDICOMManualReaderService::GetOption(const std::string& name) const
   {
     this->GetOptions(); //ensure (default) options are set.
     return AbstractFileReader::GetOption(name);
   }
 
   DICOMFileReader::Pointer CESTDICOMManualReaderService::GetReader(const mitk::StringList& relevantFiles) const
   {
     mitk::DICOMFileReaderSelector::Pointer selector = mitk::DICOMFileReaderSelector::New();
 
     selector->LoadBuiltIn3DnTConfigs();
     selector->SetInputFiles(relevantFiles);
 
     mitk::DICOMFileReader::Pointer reader = selector->GetFirstReaderWithMinimumNumberOfOutputImages();
     if (reader.IsNotNull())
     {
       //reset tag cache to ensure that additional tags of interest
       //will be regarded by the reader if set later on.
       reader->SetTagCache(nullptr);
     }
 
     return reader;
   };
 
   std::vector<itk::SmartPointer<BaseData>> CESTDICOMManualReaderService::Read()
   {
     std::vector<BaseData::Pointer> result;
     std::vector<BaseData::Pointer> dicomResult = BaseDICOMReaderService::Read();
 
     const Options userOptions = this->GetOptions();
 
     const std::string normalizationStrategy = userOptions.find("Normalize data")->second.ToString();
 
     for (auto &item : dicomResult)
     {
       auto fileOptions = ExtractOptionsFromFile(this->GetCESTMetaFilePath());
       IFileIO::Options options;
       TransferOption(userOptions, "CEST frequency [Hz]", options, CEST_PROPERTY_NAME_FREQ());
       TransferOption(userOptions, "B1 amplitude", options, CEST_PROPERTY_NAME_B1Amplitude());
       TransferOption(userOptions, "Pulse duration [us]", options, CEST_PROPERTY_NAME_PULSEDURATION());
       TransferOption(userOptions, "Duty cycle [%]", options, CEST_PROPERTY_NAME_DutyCycle());
       TransferOption(fileOptions, CEST_PROPERTY_NAME_FREQ(), options, CEST_PROPERTY_NAME_FREQ());
       TransferOption(fileOptions, CEST_PROPERTY_NAME_B1Amplitude(), options, CEST_PROPERTY_NAME_B1Amplitude());
       TransferOption(fileOptions, CEST_PROPERTY_NAME_PULSEDURATION(), options, CEST_PROPERTY_NAME_PULSEDURATION());
       TransferOption(fileOptions, CEST_PROPERTY_NAME_DutyCycle(), options, CEST_PROPERTY_NAME_DutyCycle());
 
       TransferOption(fileOptions, CEST_PROPERTY_NAME_OFFSETS(), options, CEST_PROPERTY_NAME_OFFSETS());
       TransferOption(fileOptions, CEST_PROPERTY_NAME_TREC(), options, CEST_PROPERTY_NAME_TREC());
 
       auto trecValues = CustomTagParser::ReadListFromFile(this->GetTRECFilePath());
       auto offsetValues = CustomTagParser::ReadListFromFile(this->GetLISTFilePath());
 
       bool isCEST = !offsetValues.empty();
       bool isT1 = !trecValues.empty();
 
       if (!isCEST && !isT1)
       {//check if there are settings in the metafile
         auto finding = fileOptions.find(CEST_PROPERTY_NAME_OFFSETS());
         if (finding != fileOptions.end())
         {
           isCEST = true;
           offsetValues = finding->second.ToString();
         };
 
         finding = fileOptions.find(CEST_PROPERTY_NAME_TREC());
         if (finding != fileOptions.end())
         {
           isT1 = true;
           trecValues = finding->second.ToString();
         };
       }
 
       if (isCEST)
       {
         MITK_INFO << "CEST image detected due to LIST.txt or offset property in CEST_META.json";
         options[CEST_PROPERTY_NAME_OFFSETS()] = offsetValues;
       }
       else if (isT1)
       {
         MITK_INFO << "T1 image detected due to TREC.txt or trec property in CEST_META.json";
         options[CEST_PROPERTY_NAME_TREC()] = trecValues;
       }
       else
       {
         mitkThrow() << "Cannot load CEST/T1 file. No CEST offsets or T1 trec values specified. LIST.txt/TREC.txt or information in CEST_META.json is missing.";
       }
 
       for (const auto& option : options)
       {
         item->GetPropertyList()->SetStringProperty(option.first.c_str(), option.second.ToString().c_str());
       }
 
       auto image = dynamic_cast<mitk::Image*>(item.GetPointer());
+
+      if (isCEST)
+      {
+        try
+        {
+          auto offsets = ExtractCESTOffset(image);
+        }
+        catch (...)
+        {
+          mitkThrow() << "Cannot load CEST file. Number of CEST offsets do not equal the number of image time steps. Image time steps: " << image->GetTimeSteps() << "; offset values: " << offsetValues;
+        }
+      }
+      else if (isT1)
+      {
+        try
+        {
+          auto t1s = ExtractCESTT1Time(image);
+        }
+        catch (...)
+        {
+          mitkThrow() << "Cannot load T1 file. Number of T1 times do not equal the number of image time steps. Image time steps: " << image->GetTimeSteps() << "; T1 values: " << trecValues;
+        }
+      }
+
       if (normalizationStrategy == "Automatic" && mitk::IsNotNormalizedCESTImage(image))
       {
         MITK_INFO << "Unnormalized CEST image was loaded and will be normalized automatically.";
         auto normalizationFilter = mitk::CESTImageNormalizationFilter::New();
         normalizationFilter->SetInput(image);
         normalizationFilter->Update();
         auto normalizedImage = normalizationFilter->GetOutput();
 
         auto nameProp = item->GetProperty("name");
         if (!nameProp)
         {
           mitkThrow() << "Cannot load CEST file. Property \"name\" is missing after BaseDICOMReaderService::Read().";
         }
         normalizedImage->SetProperty("name", mitk::StringProperty::New(nameProp->GetValueAsString() + "_normalized"));
         result.push_back(normalizedImage);
       }
       else
       {
         result.push_back(item);
       }
     }
 
     return result;
   }
 
   CESTDICOMManualReaderService *CESTDICOMManualReaderService::Clone() const { return new CESTDICOMManualReaderService(*this); }
 }