diff --git a/CMakeExternals/MITKData.cmake b/CMakeExternals/MITKData.cmake
index 15488758af..e5626453b7 100644
--- a/CMakeExternals/MITKData.cmake
+++ b/CMakeExternals/MITKData.cmake
@@ -1,37 +1,37 @@
#-----------------------------------------------------------------------------
# MITK Data
#-----------------------------------------------------------------------------
# Sanity checks
if(DEFINED MITK_DATA_DIR AND NOT EXISTS ${MITK_DATA_DIR})
message(FATAL_ERROR "MITK_DATA_DIR variable is defined but corresponds to non-existing directory")
endif()
set(proj MITK-Data)
set(proj_DEPENDENCIES)
set(MITK-Data_DEPENDS ${proj})
if(BUILD_TESTING)
- set(revision_tag 7968c5c0) # first 8 characters of hash-tag
+ set(revision_tag 4e3195a3) # first 8 characters of hash-tag
# ^^^^^^^^ these are just to check correct length of hash part
ExternalProject_Add(${proj}
SOURCE_DIR ${proj}
GIT_REPOSITORY https://phabricator.mitk.org/source/mitkdata.git
GIT_TAG ${revision_tag}
# URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/mitk-data_${revision_tag}.tar.gz
UPDATE_COMMAND ""
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND ""
DEPENDS ${proj_DEPENDENCIES}
)
set(MITK_DATA_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj})
else()
mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
endif(BUILD_TESTING)
diff --git a/Modules/CEST/include/mitkCustomTagParser.h b/Modules/CEST/include/mitkCustomTagParser.h
index ef5671e2a0..7a53928ef1 100644
--- a/Modules/CEST/include/mitkCustomTagParser.h
+++ b/Modules/CEST/include/mitkCustomTagParser.h
@@ -1,120 +1,123 @@
/*===================================================================
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 MITKCUSTOMTAGPARSER_H
#define MITKCUSTOMTAGPARSER_H
#include<mitkPropertyList.h>
#include<mitkTemporoSpatialStringProperty.h>
#include <MitkCESTExports.h>
namespace mitk
{
/**
The custom tag parser can be used to parse the custom dicom tag of the siemens private tag
(0x0029, 0x1020) to extract relevant CEST data.
An initial parsing determines whether the provided string belongs to CEST data at all.
If the "tSequenceFileName" is of the format "{WHATEVER}CEST_Rev####" it is assumed that the
data is indeed CEST data and was taken with revision #### (not limited to four digits).
Which custom parameters to save and to which property name can be controlled by a json file.
This file can be either provided as a resource for the MitkCEST module during compilation or
placed next to the MitkCEST library in your binary folder.
The expected format for the file "REVISIONNUMBER.json": <br>
{ <br>
"REVISIONNUMBER" : "revision_json", <br>
"sWiPMemBlock.alFree[1]" : "AdvancedMode", <br>
"sWiPMemBlock.alFree[2]" : "RetreatMode" <br>
} <br>
where :
<ul>
<li> REVISIONNUMBER is the revision number of this json parameter mapping (files with non digit characters in their
name will be ignored)
<li> sWiPMemBlock.alFree[1] is the name of one parameter in the private dicom tag
<li> AdvancedMode is the name of the property the content of sWiPMemBlock.alFree[1] should be saved to
</ul>
\note It is assumed that the entire content of tag (0x0029, 0x1020) is provided and that it es hex encoded
(12\23\04...).
If the sampling type is list it will try to access LIST.txt at the location provided in the constructor to
read the offsets.
*/
class MITKCEST_EXPORT CustomTagParser
{
public:
/// the constructor expects a path to one of the files to be loaded or the directory of the dicom files
CustomTagParser(std::string relevantFile);
/// parse the provided dicom property and return a property list based on the closest revision parameter mapping
mitk::PropertyList::Pointer ParseDicomProperty(mitk::TemporoSpatialStringProperty *dicomProperty);
/// parse the provided string and return a property list based on the closest revision parameter mapping
mitk::PropertyList::Pointer ParseDicomPropertyString(std::string dicomPropertyString);
void SetParseStrategy(std::string parseStrategy);
void SetRevisionMappingStrategy(std::string revisionMappingStrategy);
/// name of the property for the offsets, including normalization offsets
static const std::string m_OffsetsPropertyName;
/// name of the property for the data acquisition revision
static const std::string m_RevisionPropertyName;
/// name of the property for the json parameter mapping revision
static const std::string m_JSONRevisionPropertyName;
/// prefix for all CEST related property names
static const std::string m_CESTPropertyPrefix;
protected:
std::string GetRevisionAppropriateJSONString(std::string revisionString);
void GetClosestLowerRevision(std::string revisionString);
std::string GetClosestLowerRevision(std::string revisionString, std::vector<int> availableRevisionsVector);
+
+ /// Decides whether or not the image is likely to be a T1Map, if not it is assumed to be a CEST sequence
+ bool IsT1Sequence(std::string preparationType, std::string recoveryMode, std::string spoilingType, std::string revisionString);
/// Get a string filled with the properly formated offsets based on the sampling type and offset
std::string GetOffsetString(std::string samplingType, std::string offset, std::string measurements);
/// returns a vector revision numbers of all REVISIONNUMBER.json found beside the MitkCEST library
std::vector<int> GetExternalRevisions();
/// returns a vector revision numbers of all REVISIONNUMBER.json provided as resources during the compile
std::vector<int> GetInternalRevisions();
/// returns the path where external jsons are expected to be located
std::string GetExternalJSONDirectory();
/// the closest lower revision provided as resource, empty if none found
std::string m_ClosestInternalRevision;
/// the closest lower revision provided as a json beside the library, empty if none found
std::string m_ClosestExternalRevision;
/// revision independent mapping to inject into the revision dependent json string
static const std::string m_RevisionIndependentMapping;
/// default revision dependent json string if none is found
static const std::string m_DefaultJsonString;
/// path to the dicom data
std::string m_DicomDataPath;
/// Should the kind of data be automatically determined or should it be parsed as a specific one
std::string m_ParseStrategy;
/// How to handle parameter mapping based on absent revision jsons
std::string m_RevisionMappingStrategy;
};
}
#endif // MITKCUSTOMTAGPARSER_H
diff --git a/Modules/CEST/src/mitkCustomTagParser.cpp b/Modules/CEST/src/mitkCustomTagParser.cpp
index 0420b8d750..635d3e1165 100644
--- a/Modules/CEST/src/mitkCustomTagParser.cpp
+++ b/Modules/CEST/src/mitkCustomTagParser.cpp
@@ -1,684 +1,756 @@
/*===================================================================
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 "mitkCustomTagParser.h"
#include <mitkProperties.h>
#include <mitkStringProperty.h>
#include <mitkLocaleSwitch.h>
#include "mitkIPropertyPersistence.h"
#include "usGetModuleContext.h"
#include "usModule.h"
#include "usModuleContext.h"
#include "usModuleResource.h"
#include "usModuleResourceStream.h"
#include <itksys/SystemTools.hxx>
#include <Poco/Glob.h>
#include <boost/algorithm/string.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/tokenizer.hpp>
#include <algorithm>
#include <map>
namespace
{
mitk::IPropertyPersistence *GetPersistenceService()
{
mitk::IPropertyPersistence *result = nullptr;
std::vector<us::ServiceReference<mitk::IPropertyPersistence>> persRegisters =
us::GetModuleContext()->GetServiceReferences<mitk::IPropertyPersistence>();
if (!persRegisters.empty())
{
if (persRegisters.size() > 1)
{
MITK_WARN << "Multiple property description services found. Using just one.";
}
result = us::GetModuleContext()->GetService<mitk::IPropertyPersistence>(persRegisters.front());
}
return result;
};
}
const std::string mitk::CustomTagParser::m_CESTPropertyPrefix = "CEST.";
const std::string mitk::CustomTagParser::m_OffsetsPropertyName = m_CESTPropertyPrefix + "Offsets";
const std::string mitk::CustomTagParser::m_RevisionPropertyName = m_CESTPropertyPrefix + "Revision";
const std::string mitk::CustomTagParser::m_JSONRevisionPropertyName = m_CESTPropertyPrefix + "revision_json";
const std::string mitk::CustomTagParser::m_RevisionIndependentMapping =
"\n"
" \"sProtConsistencyInfo.tSystemType\" : \"SysType\",\n"
" \"sProtConsistencyInfo.flNominalB0\" : \"NominalB0\",\n"
" \"sTXSPEC.asNucleusInfo[0].lFrequency\" : \"FREQ\",\n"
" \"sTXSPEC.asNucleusInfo[0].flReferenceAmplitude\" : \"RefAmp\",\n"
" \"alTR[0]\" : \"TR\",\n"
" \"alTE[0]\" : \"TE\",\n"
" \"lAverages\" : \"averages\",\n"
" \"lRepetitions\" : \"repetitions\",\n"
" \"adFlipAngleDegree[0]\" : \"ImageFlipAngle\",\n"
" \"lTotalScanTimeSec\" : \"TotalScanTime\",";
const std::string mitk::CustomTagParser::m_DefaultJsonString =
"{\n"
" \"default mapping, corresponds to revision 1416\" : \"revision_json\",\n"
" \"sWiPMemBlock.alFree[1]\" : \"AdvancedMode\",\n"
" \"sWiPMemBlock.alFree[2]\" : \"RecoveryMode\",\n"
" \"sWiPMemBlock.alFree[3]\" : \"DoubleIrrMode\",\n"
" \"sWiPMemBlock.alFree[4]\" : \"BinomMode\",\n"
" \"sWiPMemBlock.alFree[5]\" : \"MtMode\",\n"
" \"sWiPMemBlock.alFree[6]\" : \"PreparationType\",\n"
" \"sWiPMemBlock.alFree[7]\" : \"PulseType\",\n"
" \"sWiPMemBlock.alFree[8]\" : \"SamplingType\",\n"
" \"sWiPMemBlock.alFree[9]\" : \"SpoilingType\",\n"
" \"sWiPMemBlock.alFree[10]\" : \"measurements\",\n"
" \"sWiPMemBlock.alFree[11]\" : \"NumberOfPulses\",\n"
" \"sWiPMemBlock.alFree[12]\" : \"NumberOfLockingPulses\",\n"
" \"sWiPMemBlock.alFree[13]\" : \"PulseDuration\",\n"
" \"sWiPMemBlock.alFree[14]\" : \"DutyCycle\",\n"
" \"sWiPMemBlock.alFree[15]\" : \"RecoveryTime\",\n"
" \"sWiPMemBlock.alFree[16]\" : \"RecoveryTimeM0\",\n"
" \"sWiPMemBlock.alFree[17]\" : \"ReadoutDelay\",\n"
" \"sWiPMemBlock.alFree[18]\" : \"BinomDuration\",\n"
" \"sWiPMemBlock.alFree[19]\" : \"BinomDistance\",\n"
" \"sWiPMemBlock.alFree[20]\" : \"BinomNumberofPulses\",\n"
" \"sWiPMemBlock.alFree[21]\" : \"BinomPreRepetions\",\n"
" \"sWiPMemBlock.alFree[22]\" : \"BinomType\",\n"
" \"sWiPMemBlock.adFree[1]\" : \"Offset\",\n"
" \"sWiPMemBlock.adFree[2]\" : \"B1Amplitude\",\n"
" \"sWiPMemBlock.adFree[3]\" : \"AdiabaticPulseMu\",\n"
" \"sWiPMemBlock.adFree[4]\" : \"AdiabaticPulseBW\",\n"
" \"sWiPMemBlock.adFree[5]\" : \"AdiabaticPulseLength\",\n"
" \"sWiPMemBlock.adFree[6]\" : \"AdiabaticPulseAmp\",\n"
" \"sWiPMemBlock.adFree[7]\" : \"FermiSlope\",\n"
" \"sWiPMemBlock.adFree[8]\" : \"FermiFWHM\",\n"
" \"sWiPMemBlock.adFree[9]\" : \"DoubleIrrDuration\",\n"
" \"sWiPMemBlock.adFree[10]\" : \"DoubleIrrAmplitude\",\n"
" \"sWiPMemBlock.adFree[11]\" : \"DoubleIrrRepetitions\",\n"
" \"sWiPMemBlock.adFree[12]\" : \"DoubleIrrPreRepetitions\"\n"
"}";
mitk::CustomTagParser::CustomTagParser(std::string relevantFile) : m_ClosestInternalRevision(""), m_ClosestExternalRevision("")
{
std::string pathToDirectory;
std::string fileName;
itksys::SystemTools::SplitProgramPath(relevantFile, pathToDirectory, fileName);
m_DicomDataPath = pathToDirectory;
m_ParseStrategy = "Automatic";
m_RevisionMappingStrategy = "Fuzzy";
}
+bool mitk::CustomTagParser::IsT1Sequence(std::string preparationType,
+ std::string recoveryMode,
+ std::string spoilingType,
+ std::string revisionString)
+{
+ bool isT1 = false;
+
+ // if a forced parse strategy is set, use that one
+ if ("T1" == m_ParseStrategy)
+ {
+ return true;
+ }
+ if ("CEST/WASABI" == m_ParseStrategy)
+ {
+ return false;
+ }
+
+ if (("T1Recovery" == preparationType) || ("T1Inversion" == preparationType))
+ {
+ isT1 = true;
+ }
+
+ // How to interpret the recoveryMode depends on the age of the sequence
+ // older sequences use 0 = false and 1 = true, newer ones 1 = false and 2 = true.
+ // A rough rule of thumb is to assume that if the SpoilingType is 0, then the first
+ // convention is chosen, if it is 1, then the second applies. Otherwise
+ // we assume revision 1485 and newer to follow the new convention.
+ // This unfortunate heuristic is due to somewhat arbitrary CEST sequence implementations.
+ if (!isT1)
+ {
+ std::string thisIsTrue = "0";
+ std::string thisIsFalse = "1";
+ if ("0" == spoilingType)
+ {
+ thisIsFalse = "0";
+ thisIsTrue = "1";
+ }
+ else if ("1" == spoilingType)
+ {
+ thisIsFalse = "1";
+ thisIsTrue = "2";
+ }
+ else
+ {
+ if (std::stoi(revisionString) - 1485 < 0)
+ {
+ thisIsFalse = "0";
+ thisIsTrue = "1";
+ }
+ else
+ {
+ thisIsFalse = "1";
+ thisIsTrue = "2";
+ }
+ }
+
+ if (thisIsFalse == recoveryMode)
+ {
+ isT1 = false;
+ }
+ else if (thisIsTrue == recoveryMode)
+ {
+ isT1 = true;
+ }
+
+ }
+
+ return isT1;
+}
+
mitk::PropertyList::Pointer mitk::CustomTagParser::ParseDicomPropertyString(std::string dicomPropertyString)
{
auto results = mitk::PropertyList::New();
if ("" == dicomPropertyString)
{
- MITK_ERROR << "Could not parse empty custom dicom string";
+ //MITK_ERROR << "Could not parse empty custom dicom string";
return results;
}
std::map<std::string, std::string> privateParameters;
// convert hex to ascii
// the Siemens private tag contains the information like this
// "43\52\23\34" we jump over each \ and convert the number
int len = dicomPropertyString.length();
std::string asciiString;
for (int i = 0; i < len; i += 3)
{
std::string byte = dicomPropertyString.substr(i, 2);
auto chr = (char)(int)strtol(byte.c_str(), nullptr, 16);
asciiString.push_back(chr);
}
// extract parameter list
std::size_t beginning = asciiString.find("### ASCCONV BEGIN ###") + 21;
std::size_t ending = asciiString.find("### ASCCONV END ###");
std::string parameterListString = asciiString.substr(beginning, ending - beginning);
boost::replace_all(parameterListString, "\r\n", "\n");
boost::char_separator<char> newlineSeparator("\n");
boost::tokenizer<boost::char_separator<char>> parameters(parameterListString, newlineSeparator);
for (const auto ¶meter : parameters)
{
std::vector<std::string> parts;
boost::split(parts, parameter, boost::is_any_of("="));
if (parts.size() == 2)
{
parts[0].erase(std::remove(parts[0].begin(), parts[0].end(), ' '), parts[0].end());
parts[1].erase(parts[1].begin(), parts[1].begin() + 1); // first character is a space
privateParameters[parts[0]] = parts[1];
}
}
// determine what revision we are using to handle parameters appropriately
std::string revisionPrefix = "CEST_Rev";
std::string lowerRevisionPrefix = revisionPrefix;
std::string lowerParameter = privateParameters["tSequenceFileName"];
std::transform(lowerRevisionPrefix.begin(), lowerRevisionPrefix.end(), lowerRevisionPrefix.begin(), ::tolower );
std::transform(lowerParameter.begin(), lowerParameter.end(), lowerParameter.begin(), ::tolower);
std::size_t foundPosition = lowerParameter.find(lowerRevisionPrefix);
if (foundPosition == std::string::npos)
{
MITK_ERROR << "Could not find revision information.";
return results;
}
std::string revisionString =
privateParameters["tSequenceFileName"].substr(foundPosition + revisionPrefix.length(), std::string::npos);
std::size_t firstNonNumber = revisionString.find_first_not_of("0123456789");
revisionString.erase(firstNonNumber, std::string::npos);
results->SetProperty(m_RevisionPropertyName, mitk::StringProperty::New(revisionString));
std::string jsonString = GetRevisionAppropriateJSONString(revisionString);
boost::property_tree::ptree root;
std::istringstream jsonStream(jsonString);
try
{
boost::property_tree::read_json(jsonStream, root);
}
catch (boost::property_tree::json_parser_error e)
{
mitkThrow() << "Could not parse json file. Error was:\n" << e.what();
}
for (auto it : root)
{
if (it.second.empty())
{
std::string propertyName = m_CESTPropertyPrefix + it.second.data();
if (m_JSONRevisionPropertyName == propertyName)
{
results->SetProperty(propertyName, mitk::StringProperty::New(it.first));
}
else
{
results->SetProperty(propertyName, mitk::StringProperty::New(privateParameters[it.first]));
}
}
else
{
MITK_ERROR << "Currently no support for nested dicom tag descriptors in json file.";
}
}
std::string sampling = "";
std::string offset = "";
std::string measurements = "";
bool hasSamplingInformation = results->GetStringProperty("CEST.SamplingType", sampling);
results->GetStringProperty("CEST.Offset", offset);
results->GetStringProperty("CEST.measurements", measurements);
if ("" == measurements)
{
std::string stringRepetitions = "";
std::string stringAverages = "";
results->GetStringProperty("CEST.repetitions", stringRepetitions);
results->GetStringProperty("CEST.averages", stringAverages);
std::stringstream measurementStream;
try
{
measurementStream << std::stoi(stringRepetitions) + std::stoi(stringAverages);
measurements = measurementStream.str();
MITK_INFO << "Could not find measurements, assuming repetitions + averages. Which is: " << measurements;
}
catch (const std::invalid_argument &ia)
{
MITK_ERROR
<< "Could not find measurements, fallback assumption of repetitions + averages could not be determined either: "
<< ia.what();
}
}
std::string preparationType = "";
std::string recoveryMode = "";
+ std::string spoilingType = "";
results->GetStringProperty("CEST.PreparationType", preparationType);
results->GetStringProperty("CEST.RecoveryMode", recoveryMode);
+ results->GetStringProperty("CEST.SpoilingType", spoilingType);
- if ((("T1Recovery" == preparationType) || ("T1Inversion" == preparationType) || ("1" == recoveryMode) || ("T1" == m_ParseStrategy)) && !("CEST/WASABI" == m_ParseStrategy))
+ if (this->IsT1Sequence(preparationType, recoveryMode, spoilingType, revisionString))
{
MITK_INFO << "Parsed as T1 image";
mitk::LocaleSwitch localeSwitch("C");
std::stringstream trecStream;
std::string trecPath = m_DicomDataPath + "/TREC.txt";
std::ifstream list(trecPath.c_str());
if (list.good())
{
std::string currentTime;
while (std::getline(list, currentTime))
{
trecStream << currentTime << " ";
}
}
else
{
MITK_WARN << "Assumed T1, but could not load TREC at " << trecPath;
}
results->SetStringProperty("CEST.TREC", trecStream.str().c_str());
}
else
{
MITK_INFO << "Parsed as CEST or WASABI image";
}
if (hasSamplingInformation)
{
std::string offsets = GetOffsetString(sampling, offset, measurements);
results->SetStringProperty(m_OffsetsPropertyName.c_str(), offsets.c_str());
}
else
{
MITK_WARN << "Could not determine sampling type.";
}
//persist all properties
mitk::IPropertyPersistence *persSrv = GetPersistenceService();
if (persSrv)
{
auto propertyMap = results->GetMap();
for (auto const &prop : *propertyMap)
{
PropertyPersistenceInfo::Pointer info = PropertyPersistenceInfo::New();
std::string key = prop.first;
std::replace(key.begin(), key.end(), '.', '_');
info->SetNameAndKey(prop.first, key);
persSrv->AddInfo(info);
}
}
return results;
}
mitk::PropertyList::Pointer mitk::CustomTagParser::ParseDicomProperty(mitk::TemporoSpatialStringProperty *dicomProperty)
{
if (!dicomProperty)
{
MITK_ERROR << "DICOM property empty";
}
auto results = mitk::PropertyList::New();
if (dicomProperty)
{
results = ParseDicomPropertyString(dicomProperty->GetValue());
}
return results;
}
std::vector<int> mitk::CustomTagParser::GetInternalRevisions()
{
const std::vector<us::ModuleResource> configs =
us::GetModuleContext()->GetModule()->FindResources("/", "*.json", false);
std::vector<int> availableRevisionsVector;
for (auto const resource : configs)
{
availableRevisionsVector.push_back(std::stoi(resource.GetBaseName()));
}
return availableRevisionsVector;
}
std::vector<int> mitk::CustomTagParser::GetExternalRevisions()
{
std::string stringToJSONDirectory = GetExternalJSONDirectory();
std::string prospectiveJsonsPath = stringToJSONDirectory + "/*.json";
std::set<std::string> JsonFiles;
Poco::Glob::glob(prospectiveJsonsPath, JsonFiles, Poco::Glob::GLOB_CASELESS);
std::vector<int> availableRevisionsVector;
for (auto const jsonpath : JsonFiles)
{
std::string jsonDir;
std::string jsonName;
itksys::SystemTools::SplitProgramPath(jsonpath, jsonDir, jsonName);
std::string revision = itksys::SystemTools::GetFilenameWithoutExtension(jsonName);
// disregard jsons which contain letters in their name
bool onlyNumbers = (revision.find_first_not_of("0123456789") == std::string::npos);
if(onlyNumbers)
{
availableRevisionsVector.push_back(std::stoi(revision));
}
}
return availableRevisionsVector;
}
std::string mitk::CustomTagParser::GetClosestLowerRevision(std::string revisionString, std::vector<int> availableRevisionsVector)
{
// descending order
std::sort(availableRevisionsVector.begin(), availableRevisionsVector.end(), std::greater<>());
int revision = std::stoi(revisionString);
int index = 0;
int numberOfRevisions = availableRevisionsVector.size();
while (index < numberOfRevisions)
{
// current mapping still has a higher revision number
if ((availableRevisionsVector[index] - revision) > 0)
{
++index;
}
else
{
break;
}
}
if (index < numberOfRevisions)
{
std::stringstream foundRevisionStream;
foundRevisionStream << availableRevisionsVector[index];
return foundRevisionStream.str();
}
return "";
}
void mitk::CustomTagParser::GetClosestLowerRevision(std::string revisionString)
{
m_ClosestInternalRevision = GetClosestLowerRevision(revisionString, GetInternalRevisions());
m_ClosestExternalRevision = GetClosestLowerRevision(revisionString, GetExternalRevisions());
if ("Strict" == m_RevisionMappingStrategy && !((0 == m_ClosestInternalRevision.compare(revisionString)) ||
(0 == m_ClosestExternalRevision.compare(revisionString))))
{ // strict revision mapping and neither revision does match the dicom meta data
std::stringstream errorMessageStream;
errorMessageStream << "\nCould not parse dicom data in strict mode, data revision " << revisionString
<< " has no known matching parameter mapping. To use the closest known older parameter mapping select the "
<< "\"Fuzzy\" revision mapping option when loading the data.\n"
<< "\nCurrently known revision mappings are:\n Precompiled:";
for (const auto revision : GetInternalRevisions())
{
errorMessageStream << " " << revision;
}
errorMessageStream << "\n External:";
for (const auto revision : GetExternalRevisions())
{
errorMessageStream << " " << revision;
}
errorMessageStream << "\n\nExternal revision mapping descriptions should be located at\n\n";
std::string stringToJSONDirectory = GetExternalJSONDirectory();
errorMessageStream << stringToJSONDirectory;
errorMessageStream << "\n\nTo provide an external mapping for this revision create a " << revisionString
<< ".json there. You might need to create the directory first.";
mitkThrow() << errorMessageStream.str();
}
}
std::string mitk::CustomTagParser::GetRevisionAppropriateJSONString(std::string revisionString)
{
std::string returnValue = "";
if ("" == revisionString)
{
MITK_WARN << "Could not extract revision";
}
else
{
GetClosestLowerRevision(revisionString);
bool useExternal = false;
bool useInternal = false;
if ("" != m_ClosestExternalRevision)
{
useExternal = true;
}
if ("" != m_ClosestInternalRevision)
{
useInternal = true;
}
if (useExternal && useInternal)
{
if (std::stoi(m_ClosestInternalRevision) > std::stoi(m_ClosestExternalRevision))
{
useExternal = false;
}
}
if (useExternal)
{
std::string stringToJSONDirectory = GetExternalJSONDirectory();
std::string prospectiveJsonPath = stringToJSONDirectory + "/" + m_ClosestExternalRevision + ".json";
std::ifstream externalJSON(prospectiveJsonPath.c_str());
if (externalJSON.good())
{
MITK_INFO << "Found external json for CEST parameters at " << prospectiveJsonPath;
std::stringstream buffer;
buffer << externalJSON.rdbuf();
returnValue = buffer.str();
useInternal = false;
}
}
if (useInternal)
{
std::string filename = m_ClosestInternalRevision + ".json";
us::ModuleResource jsonResource = us::GetModuleContext()->GetModule()->GetResource(filename);
if (jsonResource.IsValid() && jsonResource.IsFile())
{
MITK_INFO << "Found no external json for CEST parameters. Closest internal mapping is for revision "
<< m_ClosestInternalRevision;
us::ModuleResourceStream jsonStream(jsonResource);
std::stringstream buffer;
buffer << jsonStream.rdbuf();
returnValue = buffer.str();
}
}
}
if ("" == returnValue)
{
MITK_WARN << "Could not identify parameter mapping for the given revision " << revisionString
<< ", using default mapping.";
returnValue = m_DefaultJsonString;
}
// inject the revision independent mapping before the first newline
{
returnValue.insert(returnValue.find("\n"), m_RevisionIndependentMapping);
}
return returnValue;
}
std::string mitk::CustomTagParser::GetOffsetString(std::string samplingType, std::string offset, std::string measurements)
{
mitk::LocaleSwitch localeSwitch("C");
std::stringstream results;
std::string normalizationIndicatingOffset = "-300";
double offsetDouble = 0.0;
int measurementsInt = 0;
bool validOffset = false;
bool validMeasurements = false;
if ("" != offset)
{
validOffset = true;
offsetDouble = std::stod(offset);
}
if ("" != measurements)
{
validMeasurements = true;
measurementsInt = std::stoi(measurements);
}
std::vector<double> offsetVector;
if (validOffset && validMeasurements)
{
for (int step = 0; step < measurementsInt -1; ++step)
{
double currentOffset = -offsetDouble + 2 * step * offsetDouble / (measurementsInt - 2.0);
offsetVector.push_back(currentOffset);
}
}
else
{
MITK_WARN << "Invalid offset or measurements, offset calculation will only work for list sampling type.";
}
if (samplingType == "1" || samplingType == "Regular")
{
if (validOffset && validMeasurements)
{
results << normalizationIndicatingOffset << " ";
for (const auto& entry : offsetVector)
{
results << entry << " ";
}
}
}
else if (samplingType == "2" || samplingType == "Alternating")
{
if (validOffset && validMeasurements)
{
results << normalizationIndicatingOffset << " ";
for (auto& entry : offsetVector)
{
entry = std::abs(entry);
}
std::sort(offsetVector.begin(), offsetVector.end(), std::greater<>());
for (unsigned int index = 0; index < offsetVector.size(); ++index)
{
offsetVector[index] = std::pow(-1, index) * offsetVector[index];
}
for (auto& entry : offsetVector)
{
results << entry << " ";
}
}
}
else if (samplingType == "3" || samplingType == "List")
{
std::string listPath = m_DicomDataPath + "/LIST.txt";
std::ifstream list(listPath.c_str());
if (list.good())
{
std::string currentOffset;
while (std::getline(list, currentOffset))
{
results << currentOffset << " ";
}
}
else
{
MITK_ERROR << "Could not load list at " << listPath;
}
}
else if (samplingType == "4" || samplingType == "SingleOffset")
{
if (validOffset && validMeasurements)
{
results << normalizationIndicatingOffset << " ";
for (int step = 0; step < measurementsInt - 1; ++step)
{
results << offsetDouble << " ";
}
}
}
else
{
MITK_WARN << "Encountered unknown sampling type.";
}
std::string resultString = results.str();
// replace multiple spaces by a single space
std::string::iterator newEnditerator =
std::unique(resultString.begin(), resultString.end(),
[=](char lhs, char rhs) { return (lhs == rhs) && (lhs == ' '); }
);
resultString.erase(newEnditerator, resultString.end());
if ((resultString.length() > 0) && (resultString.at(resultString.length() - 1) == ' '))
{
resultString.erase(resultString.end() - 1, resultString.end());
}
if ((resultString.length() > 0) && (resultString.at(0) == ' '))
{
resultString.erase(resultString.begin(), ++(resultString.begin()));
}
return resultString;
}
void mitk::CustomTagParser::SetParseStrategy(std::string parseStrategy)
{
m_ParseStrategy = parseStrategy;
}
void mitk::CustomTagParser::SetRevisionMappingStrategy(std::string revisionMappingStrategy)
{
m_RevisionMappingStrategy = revisionMappingStrategy;
}
std::string mitk::CustomTagParser::GetExternalJSONDirectory()
{
std::string moduleLocation = us::GetModuleContext()->GetModule()->GetLocation();
std::string stringToModule;
std::string libraryName;
itksys::SystemTools::SplitProgramPath(moduleLocation, stringToModule, libraryName);
std::stringstream jsonDirectory;
jsonDirectory << stringToModule << "/CESTRevisionMapping";
return jsonDirectory.str();
}
diff --git a/Modules/CEST/test/mitkCESTDICOMReaderServiceTest.cpp b/Modules/CEST/test/mitkCESTDICOMReaderServiceTest.cpp
index 4b0dd0710f..3f0f946877 100644
--- a/Modules/CEST/test/mitkCESTDICOMReaderServiceTest.cpp
+++ b/Modules/CEST/test/mitkCESTDICOMReaderServiceTest.cpp
@@ -1,69 +1,81 @@
/*===================================================================
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.
===================================================================*/
// Testing
#include "mitkTestFixture.h"
#include "mitkTestingMacros.h"
// std includes
#include <string>
// MITK includes
#include <mitkImage.h>
#include <mitkIOUtil.h>
#include <mitkTemporoSpatialStringProperty.h>
// VTK includes
#include <vtkDebugLeaks.h>
class mitkCESTDICOMReaderServiceTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkCESTDICOMReaderServiceTestSuite);
// Test the dicom property parsing
MITK_TEST(LoadCESTDICOMData_Success);
+ MITK_TEST(LoadT1DICOMData_Success);
CPPUNIT_TEST_SUITE_END();
private:
public:
void setUp() override
{
}
void tearDown() override
{
}
void LoadCESTDICOMData_Success()
{
mitk::IFileReader::Options options;
- options["Force type"] = std::string( "CEST/WASABI" );
+ options["Force type"] = std::string( "Automatic" );
options["Revision mapping"] = std::string( "Strict" );
mitk::Image::Pointer cestImage = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("CEST/B1=0.6MUT/MEI_NER_PHANTOM.MR.E0202_MEISSNER.0587.0001.2017.10.25.22.11.10.373351.41828677.IMA"), options);
CPPUNIT_ASSERT_MESSAGE("Make certain offsets have been correctly loaded for CEST image." ,cestImage->GetProperty("CEST.Offsets")->GetValueAsString() == "-300 2 -2 1.92982 -1.92982 1.85965 -1.85965 1.78947 -1.78947 1.7193 -1.7193 1.64912 -1.64912 1.57895 -1.57895 1.50877 -1.50877 1.4386 -1.4386 1.36842 -1.36842 1.29825 -1.29825 1.22807 -1.22807 1.15789 -1.15789 1.08772 -1.08772 1.01754 -1.01754 0.947368 -0.947368 0.877193 -0.877193 0.807018 -0.807018 0.736842 -0.736842 0.666667 -0.666667 0.596491 -0.596491 0.526316 -0.526316 0.45614 -0.45614 0.385965 -0.385965 0.315789 -0.315789 0.245614 -0.245614 0.175439 -0.175439 0.105263 -0.105263 0.0350877 -0.0350877");
std::string temp;
CPPUNIT_ASSERT_MESSAGE("Make certain image is not loaded as T1.", !cestImage->GetPropertyList()->GetStringProperty("CEST.TREC", temp));
}
+ void LoadT1DICOMData_Success()
+ {
+ mitk::IFileReader::Options options;
+ options["Force type"] = std::string("Automatic");
+ options["Revision mapping"] = std::string("Strict");
+
+ mitk::Image::Pointer cestImage = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("CEST/T1MAP/MEI_NER_PHANTOM.MR.E0202_MEISSNER.0279.0001.2017.10.25.20.21.27.996834.41803047.IMA"), options);
+ std::string temp;
+ CPPUNIT_ASSERT_MESSAGE("Make certain image is loaded as T1.", cestImage->GetPropertyList()->GetStringProperty("CEST.TREC", temp));
+ }
+
};
MITK_TEST_SUITE_REGISTRATION(mitkCESTDICOMReaderService)