bool InstanceInformationAdapter::Create(std::string& content,
const std::string& instanceId)
{
std::string message = "Creating spatial information for instance: " + instanceId;
OrthancPluginLogInfo(context_, message.c_str());
std::string uri = "/instances/" + instanceId;
Json::Value instance, tags;
if (!GetJsonFromOrthanc(instance, context_, uri) ||
!GetJsonFromOrthanc(tags, context_, uri + "/tags?simplify") ||
instance.type() != Json::objectValue ||
tags.type() != Json::objectValue)
{
return false;
}
InstanceInformation info;
if (tags.isMember(IMAGE_ORIENTATION_PATIENT) &&
tags.isMember(IMAGE_POSITION_PATIENT) &&
tags[IMAGE_ORIENTATION_PATIENT].type() == Json::stringValue &&
tags[IMAGE_POSITION_PATIENT].type() == Json::stringValue)
{
std::vector<float> cosines, position;
if (TokenizeVector(cosines, tags[IMAGE_ORIENTATION_PATIENT].asString(), 6) &&
TokenizeVector(position, tags[IMAGE_POSITION_PATIENT].asString(), 3))
{
std::vector<float> normal(3);
normal[0] = cosines[1] * cosines[5] - cosines[2] * cosines[4];
normal[1] = cosines[2] * cosines[3] - cosines[0] * cosines[5];
normal[2] = cosines[0] * cosines[4] - cosines[1] * cosines[3];
info.SetPosition(normal, position);
}
}
if (instance.isMember(INDEX_IN_SERIES) &&
instance[INDEX_IN_SERIES].type() == Json::intValue)
{
info.SetIndexInSeries(instance[INDEX_IN_SERIES].asInt());
}
info.Serialize(content);
return true;
}
Instance(ServerIndex& index,
const std::string& instanceId) :
instanceId_(instanceId),
framesCount_(1)
{
DicomMap instance;
if (!index.GetMainDicomTags(instance, instanceId, ResourceType_Instance, ResourceType_Instance))
{
throw OrthancException(ErrorCode_UnknownResource);
}
const DicomValue* frames = instance.TestAndGetValue(DICOM_TAG_NUMBER_OF_FRAMES);
if (frames != NULL &&
!frames->IsNull() &&
!frames->IsBinary())
{
try
{
framesCount_ = boost::lexical_cast<unsigned int>(frames->GetContent());
}
catch (boost::bad_lexical_cast&)
{
}
}
std::vector<float> tmp;
hasPosition_ = TokenizeVector(tmp, instance, DICOM_TAG_IMAGE_POSITION_PATIENT, 3);
if (hasPosition_)
{
position_[0] = tmp[0];
position_[1] = tmp[1];
position_[2] = tmp[2];
}
std::string s;
hasIndexInSeries_ = false;
try
{
if (index.LookupMetadata(s, instanceId, MetadataType_Instance_IndexInSeries))
{
indexInSeries_ = boost::lexical_cast<size_t>(s);
hasIndexInSeries_ = true;
}
}
catch (boost::bad_lexical_cast&)
{
}
}
static bool TokenizeVector(std::vector<float>& result,
const DicomMap& map,
const DicomTag& tag,
unsigned int expectedSize)
{
const DicomValue* value = map.TestAndGetValue(tag);
if (value == NULL ||
value->IsNull() ||
value->IsBinary())
{
return false;
}
else
{
return TokenizeVector(result, value->GetContent(), expectedSize);
}
}
void SliceOrdering::ComputeNormal()
{
DicomMap series;
if (!index_.GetMainDicomTags(series, seriesId_, ResourceType_Series, ResourceType_Series))
{
throw OrthancException(ErrorCode_UnknownResource);
}
std::vector<float> cosines;
hasNormal_ = TokenizeVector(cosines, series, DICOM_TAG_IMAGE_ORIENTATION_PATIENT, 6);
if (hasNormal_)
{
normal_[0] = cosines[1] * cosines[5] - cosines[2] * cosines[4];
normal_[1] = cosines[2] * cosines[3] - cosines[0] * cosines[5];
normal_[2] = cosines[0] * cosines[4] - cosines[1] * cosines[3];
}
}
