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;
}
void Value::loadFromString(std::string const &json) {
std::stringstream jsonStream(json);
loadFromStream(jsonStream);
}
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";
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];
}
}
std::string revisionString = "";
try
{
revisionString = ExtractRevision(privateParameters["tSequenceFileName"]);
}
catch (const std::exception &e)
{
MITK_ERROR << "Cannot deduce revision information. Reason: "<< e.what();
return results;
}
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 (const 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 offset = "";
std::string measurements = "";
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_PROPERTY_NAME_PREPERATIONTYPE().c_str(), preparationType);
results->GetStringProperty(CEST_PROPERTY_NAME_RECOVERYMODE().c_str(), recoveryMode);
results->GetStringProperty(CEST_PROPERTY_NAME_SPOILINGTYPE().c_str(), spoilingType);
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_PROPERTY_NAME_TREC().c_str(), trecStream.str().c_str());
}
else
{
MITK_INFO << "Parsed as CEST or WASABI image";
std::string sampling = "";
bool hasSamplingInformation = results->GetStringProperty("CEST.SamplingType", sampling);
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;
}
