diff --git a/Modules/CEST/autoload/IO/mitkCESTGenericDICOMReaderService.cpp b/Modules/CEST/autoload/IO/mitkCESTGenericDICOMReaderService.cpp
index db6ddc6dcb..7181193335 100644
--- a/Modules/CEST/autoload/IO/mitkCESTGenericDICOMReaderService.cpp
+++ b/Modules/CEST/autoload/IO/mitkCESTGenericDICOMReaderService.cpp
@@ -1,287 +1,294 @@
 /*============================================================================
 
 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 <mitkCESTPropertyHelper.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
+    if (itksys::SystemTools::FileExists(file))
     {
-      boost::property_tree::read_json(file, root, std::locale("C"));
+      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();
+      }
     }
-    catch (const boost::property_tree::json_parser_error & e)
+    else
     {
-      MITK_WARN << "Could not parse CEST meta file. Fall back to default values. Error was:\n" << e.what();
+      MITK_DEBUG << "CEST meta file does not exist. Fall back to default values. CEST meta file path: " << file;
     }
 
     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); }
 }
diff --git a/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.cpp b/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.cpp
index e752e8a8ff..ed2c8cb5bf 100644
--- a/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.cpp
+++ b/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.cpp
@@ -1,223 +1,229 @@
 /*============================================================================
 
 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() : IOMimeTypes::BaseDicomMimeType(CEST_DICOM_MIMETYPE_NAME())
   {
     this->SetCategory(IOMimeTypes::CATEGORY_IMAGES());
     this->SetComment("CEST DICOM");
   }
 
   bool MitkCESTIOMimeTypes::MitkCESTDicomMimeType::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;
     }
 
     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;
+    bool mapNotEmpty = false;
 
-    if (byteString.empty()) {
-      return false;
-    }
-    mitk::CustomTagParser tagParser(relevantFiles[0]);
+    if (!imageFrameList.empty())
+    {
+      mitk::DICOMImageFrameInfo* firstFrame = imageFrameList.begin()->GetPointer();
+
+      std::string byteString = tagCache->GetTagValue(firstFrame, siemensCESTprivateTag).value;
 
-    auto parsedPropertyList = tagParser.ParseDicomPropertyString(byteString);
+      if (byteString.empty()) {
+        return false;
+      }
+      mitk::CustomTagParser tagParser(relevantFiles[0]);
 
-    bool mapNotEmpty = parsedPropertyList->GetMap()->size() > 0;
+      auto parsedPropertyList = tagParser.ParseDicomPropertyString(byteString);
+
+      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();
   }
 
   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;
   }
 
 }