orthanc: OrthancServer/Sources/OrthancRestApi/OrthancRestResources.cpp comparison

comparison OrthancServer/Sources/OrthancRestApi/OrthancRestResources.cpp @ 4697:569d9ef165b1

Added "short", "simplify" and/or "full" options to control the format of DICOM tags wherever possible

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Fri, 18 Jun 2021 16:08:35 +0200
parents	da1edb7d6332
children	d16c3c7f11ef

comparison

equal deleted inserted replaced

-:dd6274412ff4
+:569d9ef165b1
 call.GetOutput().AnswerJson(dicom);
 }
 }
-static DicomToJsonFormat GetDicomFormat(const RestApiGetCall& call)
-{
-if (call.HasArgument("simplify"))
-{
-return DicomToJsonFormat_Human;
-}
-else if (call.HasArgument("short"))
-{
-return DicomToJsonFormat_Short;
-}
-else
-{
-return DicomToJsonFormat_Full;
-}
-}
-static void AnswerDicomAsJson(RestApiGetCall& call,
-const Json::Value& dicom)
-{
-AnswerDicomAsJson(call, dicom, GetDicomFormat(call));
-}
 static void ParseSetOfTags(std::set<DicomTag>& target,
 const RestApiGetCall& call,
 const std::string& argument)
 {
 target.clear();
 static void AnswerListOfResources(RestApiOutput& output,
 ServerIndex& index,
 const std::list<std::string>& resources,
 ResourceType level,
-bool expand)
+bool expand,
+DicomToJsonFormat format)
 {
 Json::Value answer = Json::arrayValue;
 for (std::list<std::string>::const_iterator
 resource = resources.begin(); resource != resources.end(); ++resource)
 {
 if (expand)
 {
 Json::Value expanded;
-if (index.ExpandResource(expanded, *resource, level))
+if (index.ExpandResource(expanded, *resource, level, format))
 {
 answer.append(expanded);
 }
 }
 else
 template <enum ResourceType resourceType>
 static void ListResources(RestApiGetCall& call)
 {
 if (call.IsDocumentation())
 {
+OrthancRestApi::DocumentDicomFormat(call, DicomToJsonFormat_Human);
 const std::string resources = GetResourceTypeText(resourceType, true /* plural */, false /* lower case */);
 call.GetDocumentation()
 .SetTag(GetResourceTypeText(resourceType, true /* plural */, true /* upper case */))
 .SetSummary("List the available " + resources)
 .SetDescription("List the Orthanc identifiers of all the available DICOM " + resources)
 else
 {
 index.GetAllUuids(result, resourceType);
 }
+AnswerListOfResources(call.GetOutput(), index, result, resourceType, call.HasArgument("expand"),
-AnswerListOfResources(call.GetOutput(), index, result, resourceType, call.HasArgument("expand"));
+OrthancRestApi::GetDicomFormat(call, DicomToJsonFormat_Human));
 }
 template <enum ResourceType resourceType>
 static void GetSingleResource(RestApiGetCall& call)
 {
 if (call.IsDocumentation())
 {
+OrthancRestApi::DocumentDicomFormat(call, DicomToJsonFormat_Human);
 const std::string resource = GetResourceTypeText(resourceType, false /* plural */, false /* lower case */);
 call.GetDocumentation()
 .SetTag(GetResourceTypeText(resourceType, true /* plural */, true /* upper case */))
 .SetSummary("Get information about some " + resource)
 .SetDescription("Get detailed information about the DICOM " + resource + " whose Orthanc identifier is provided in the URL")
 .AddAnswerType(MimeType_Json, "Information about the DICOM " + resource)
 .SetHttpGetSample(GetDocumentationSampleResource(resourceType), true);
 return;
 }
+const DicomToJsonFormat format = OrthancRestApi::GetDicomFormat(call, DicomToJsonFormat_Human);
 Json::Value json;
-if (OrthancRestApi::GetIndex(call).ExpandResource(json, call.GetUriComponent("id", ""), resourceType))
+if (OrthancRestApi::GetIndex(call).ExpandResource(
+json, call.GetUriComponent("id", ""), resourceType, format))
 {
 call.GetOutput().AnswerJson(json);
 }
 }
 call.GetOutput().AnswerBuffer("{}", MimeType_Json);
 }
 template <DicomToJsonFormat format>
-static void GetInstanceTags(RestApiGetCall& call)
+static void GetInstanceTagsInternal(RestApiGetCall& call)
 {
-if (call.IsDocumentation())
-{
-if (format == DicomToJsonFormat_Human)
-{
-call.GetDocumentation()
-.SetTag("Instances")
-.SetSummary("Get human-readable tags")
-.SetDescription("Get the DICOM tags in human-readable format")
-.SetUriArgument("id", "Orthanc identifier of the DICOM instance of interest")
-.SetHttpGetArgument("ignore-length", RestApiCallDocumentation::Type_JsonListOfStrings,
-"Also include the DICOM tags that are provided in this list, even if their associated value is long", false)
-.AddAnswerType(MimeType_Json, "JSON object containing the DICOM tags and their associated value")
-.SetTruncatedJsonHttpGetSample("https://demo.orthanc-server.com/instances/7c92ce8e-bbf67ed2-ffa3b8c1-a3b35d94-7ff3ae26/simplified-tags", 10);
-return;
-}
-else
-{
-throw OrthancException(ErrorCode_NotImplemented);
-}
-}
 ServerContext& context = OrthancRestApi::GetContext(call);
 std::string publicId = call.GetUriComponent("id", "");
 std::set<DicomTag> ignoreTagLength;
 call.GetOutput().AnswerJson(full);
 }
 }
-static void GetInstanceTagsBis(RestApiGetCall& call)
+static void GetInstanceTags(RestApiGetCall& call)
 {
 if (call.IsDocumentation())
 {
+OrthancRestApi::DocumentDicomFormat(call, DicomToJsonFormat_Full);
 call.GetDocumentation()
 .SetTag("Instances")
 .SetSummary("Get DICOM tags")
 .SetDescription("Get the DICOM tags in the specified format. By default, the `full` format is used, which "
 "combines hexadecimal tags with human-readable description.")
 .SetUriArgument("id", "Orthanc identifier of the DICOM instance of interest")
-.SetHttpGetArgument("simplify", RestApiCallDocumentation::Type_String,
-"If present, report the DICOM tags in human-readable format "
-"(same as the `/instances/{id}/simplified-tags` route)", false)
-.SetHttpGetArgument("short", RestApiCallDocumentation::Type_String,
-"If present, report the DICOM tags indexed in hexadecimal format", false)
 .AddAnswerType(MimeType_Json, "JSON object containing the DICOM tags and their associated value")
 .SetTruncatedJsonHttpGetSample("https://demo.orthanc-server.com/instances/7c92ce8e-bbf67ed2-ffa3b8c1-a3b35d94-7ff3ae26/tags", 10);
 return;
 }
-switch (GetDicomFormat(call))
+switch (OrthancRestApi::GetDicomFormat(call, DicomToJsonFormat_Full))
 {
 case DicomToJsonFormat_Human:
-GetInstanceTags<DicomToJsonFormat_Human>(call);
+GetInstanceTagsInternal<DicomToJsonFormat_Human>(call);
 break;
 case DicomToJsonFormat_Short:
-GetInstanceTags<DicomToJsonFormat_Short>(call);
+GetInstanceTagsInternal<DicomToJsonFormat_Short>(call);
 break;
 case DicomToJsonFormat_Full:
-GetInstanceTags<DicomToJsonFormat_Full>(call);
+GetInstanceTagsInternal<DicomToJsonFormat_Full>(call);
 break;
 default:
 throw OrthancException(ErrorCode_InternalError);
 }
 }
+static void GetInstanceSimplifiedTags(RestApiGetCall& call)
+{
+if (call.IsDocumentation())
+{
+call.GetDocumentation()
+.SetTag("Instances")
+.SetSummary("Get human-readable tags")
+.SetDescription("Get the DICOM tags in human-readable format (same as the `/instances/{id}/tags?simplify` route)")
+.SetUriArgument("id", "Orthanc identifier of the DICOM instance of interest")
+.SetHttpGetArgument("ignore-length", RestApiCallDocumentation::Type_JsonListOfStrings,
+"Also include the DICOM tags that are provided in this list, even if their associated value is long", false)
+.AddAnswerType(MimeType_Json, "JSON object containing the DICOM tags and their associated value")
+.SetTruncatedJsonHttpGetSample("https://demo.orthanc-server.com/instances/7c92ce8e-bbf67ed2-ffa3b8c1-a3b35d94-7ff3ae26/simplified-tags", 10);
+return;
+}
+else
+{
+GetInstanceTagsInternal<DicomToJsonFormat_Human>(call);
+}
+}
 static void ListFrames(RestApiGetCall& call)
 {
 if (call.IsDocumentation())
 {
 call.GetDocumentation()
 static void GetSharedTags(RestApiGetCall& call)
 {
 if (call.IsDocumentation())
 {
+OrthancRestApi::DocumentDicomFormat(call, DicomToJsonFormat_Full);
 ResourceType t = StringToResourceType(call.GetFullUri()[0].c_str());
 std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
 call.GetDocumentation()
 .SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
 .SetSummary("Get shared tags")
 Json::Value sharedTags;
 if (ExtractSharedTags(sharedTags, context, publicId))
 {
 // Success: Send the value of the shared tags
-AnswerDicomAsJson(call, sharedTags);
+AnswerDicomAsJson(call, sharedTags, OrthancRestApi::GetDicomFormat(call, DicomToJsonFormat_Full));
 }
 }
-static void GetModuleInternal(RestApiGetCall& call,
-ResourceType resourceType,
-DicomModule module)
-{
-if (!((resourceType == ResourceType_Patient && module == DicomModule_Patient) ||
-(resourceType == ResourceType_Study && module == DicomModule_Patient) ||
-(resourceType == ResourceType_Study && module == DicomModule_Study) ||
-(resourceType == ResourceType_Series && module == DicomModule_Series) ||
-(resourceType == ResourceType_Instance && module == DicomModule_Instance) ||
-(resourceType == ResourceType_Instance && module == DicomModule_Image)))
-{
-throw OrthancException(ErrorCode_NotImplemented);
-}
-ServerContext& context = OrthancRestApi::GetContext(call);
-std::string publicId = call.GetUriComponent("id", "");
-std::set<DicomTag> ignoreTagLength;
-ParseSetOfTags(ignoreTagLength, call, "ignore-length");
-typedef std::set<DicomTag> ModuleTags;
-ModuleTags moduleTags;
-DicomTag::AddTagsForModule(moduleTags, module);
-Json::Value tags;
-if (resourceType != ResourceType_Instance)
-{
-// Retrieve all the instances of this patient/study/series
-typedef std::list<std::string> Instances;
-Instances instances;
-context.GetIndex().GetChildInstances(instances, publicId);
-if (instances.empty())
-{
-return;   // Error: No instance (should never happen)
-}
-// Select one child instance
-publicId = instances.front();
-}
-context.ReadDicomAsJson(tags, publicId, ignoreTagLength);
-// Filter the tags of the instance according to the module
-Json::Value result = Json::objectValue;
-for (ModuleTags::const_iterator tag = moduleTags.begin(); tag != moduleTags.end(); ++tag)
-{
-std::string s = tag->Format();
-if (tags.isMember(s))
-{
-result[s] = tags[s];
-}
-}
-AnswerDicomAsJson(call, result);
-}
 template <enum ResourceType resourceType,
 enum DicomModule module>
 static void GetModule(RestApiGetCall& call)
 m = "instance";
 break;
 default:
 throw OrthancException(ErrorCode_ParameterOutOfRange);
 }
+OrthancRestApi::DocumentDicomFormat(call, DicomToJsonFormat_Full);
 call.GetDocumentation()
 .SetTag(GetResourceTypeText(resourceType, true /* plural */, true /* upper case */))
 .SetSummary("Get " + m + " module" + std::string(resource == m ? "" : " of " + resource))
 .SetDescription("Get the " + m + " module of the DICOM " + resource + " whose Orthanc identifier is provided in the URL")
 .SetUriArgument("id", "Orthanc identifier of the " + resource + " of interest")
 .AddAnswerType(MimeType_Json, "Information about the DICOM " + resource)
 .SetHttpGetSample(GetDocumentationSampleResource(resourceType) + "/" + (*call.GetFullUri().rbegin()), true);
 return;
 }
-GetModuleInternal(call, resourceType, module);
+if (!((resourceType == ResourceType_Patient && module == DicomModule_Patient) ||
+(resourceType == ResourceType_Study && module == DicomModule_Patient) ||
+(resourceType == ResourceType_Study && module == DicomModule_Study) ||
+(resourceType == ResourceType_Series && module == DicomModule_Series) ||
+(resourceType == ResourceType_Instance && module == DicomModule_Instance) ||
+(resourceType == ResourceType_Instance && module == DicomModule_Image)))
+{
+throw OrthancException(ErrorCode_NotImplemented);
+}
+ServerContext& context = OrthancRestApi::GetContext(call);
+std::string publicId = call.GetUriComponent("id", "");
+std::set<DicomTag> ignoreTagLength;
+ParseSetOfTags(ignoreTagLength, call, "ignore-length");
+typedef std::set<DicomTag> ModuleTags;
+ModuleTags moduleTags;
+DicomTag::AddTagsForModule(moduleTags, module);
+Json::Value tags;
+if (resourceType != ResourceType_Instance)
+{
+// Retrieve all the instances of this patient/study/series
+typedef std::list<std::string> Instances;
+Instances instances;
+context.GetIndex().GetChildInstances(instances, publicId);
+if (instances.empty())
+{
+return;   // Error: No instance (should never happen)
+}
+// Select one child instance
+publicId = instances.front();
+}
+context.ReadDicomAsJson(tags, publicId, ignoreTagLength);
+// Filter the tags of the instance according to the module
+Json::Value result = Json::objectValue;
+for (ModuleTags::const_iterator tag = moduleTags.begin(); tag != moduleTags.end(); ++tag)
+{
+std::string s = tag->Format();
+if (tags.isMember(s))
+{
+result[s] = tags[s];
+}
+}
+AnswerDicomAsJson(call, result, OrthancRestApi::GetDicomFormat(call, DicomToJsonFormat_Full));
 }
 namespace
 {
 class FindVisitor : public ServerContext::ILookupVisitor
 {
 private:
 bool                    isComplete_;
 std::list<std::string>  resources_;
+DicomToJsonFormat       format_;
 public:
-FindVisitor() :
+FindVisitor(DicomToJsonFormat format) :
-isComplete_(false)
+isComplete_(false),
+format_(format)
 {
 }
 virtual bool IsDicomAsJsonNeeded() const ORTHANC_OVERRIDE
 {
 void Answer(RestApiOutput& output,
 ServerIndex& index,
 ResourceType level,
 bool expand) const
 {
-AnswerListOfResources(output, index, resources_, level, expand);
+AnswerListOfResources(output, index, resources_, level, expand, format_);
 }
 };
 }
 static const char* const KEY_QUERY = "Query";
 static const char* const KEY_SINCE = "Since";
 if (call.IsDocumentation())
 {
+OrthancRestApi::DocumentDicomFormat(call, DicomToJsonFormat_Human);
 call.GetDocumentation()
 .SetTag("System")
 .SetSummary("Look for local resources")
 .SetDescription("This URI can be used to perform a search on the content of the local Orthanc server, "
 "in a way that is similar to querying remote DICOM modalities using C-FIND SCU: "
 query.AddRestConstraint(FromDcmtkBridge::ParseTag(members[i]),
 value, caseSensitive, true);
 }
 }
-FindVisitor visitor;
+FindVisitor visitor(OrthancRestApi::GetDicomFormat(request, DicomToJsonFormat_Human));
 context.Apply(visitor, query, level, since, limit);
 visitor.Answer(call.GetOutput(), context.GetIndex(), level, expand);
 }
 }
 enum ResourceType end>
 static void GetChildResources(RestApiGetCall& call)
 {
 if (call.IsDocumentation())
 {
+OrthancRestApi::DocumentDicomFormat(call, DicomToJsonFormat_Human);
 const std::string children = GetResourceTypeText(end, true /* plural */, false /* lower case */);
 const std::string resource = GetResourceTypeText(start, false /* plural */, false /* lower case */);
 call.GetDocumentation()
 .SetTag(GetResourceTypeText(start, true /* plural */, true /* upper case */))
 .SetSummary("Get child " + children)
 a.splice(a.begin(), b);
 }
 Json::Value result = Json::arrayValue;
+const DicomToJsonFormat format = OrthancRestApi::GetDicomFormat(call, DicomToJsonFormat_Human);
 for (std::list<std::string>::const_iterator
 it = a.begin(); it != a.end(); ++it)
 {
 Json::Value resource;
-if (OrthancRestApi::GetIndex(call).ExpandResource(resource, *it, end))
+if (OrthancRestApi::GetIndex(call).ExpandResource(resource, *it, end, format))
 {
 result.append(resource);
 }
 }
 static void GetChildInstancesTags(RestApiGetCall& call)
 {
 if (call.IsDocumentation())
 {
+OrthancRestApi::DocumentDicomFormat(call, DicomToJsonFormat_Full);
 ResourceType t = StringToResourceType(call.GetFullUri()[0].c_str());
 std::string r = GetResourceTypeText(t, false /* plural */, false /* upper case */);
 call.GetDocumentation()
 .SetTag(GetResourceTypeText(t, true /* plural */, true /* upper case */))
 .SetSummary("Get tags of instances")
 return;
 }
 ServerContext& context = OrthancRestApi::GetContext(call);
 std::string publicId = call.GetUriComponent("id", "");
-DicomToJsonFormat format = GetDicomFormat(call);
+DicomToJsonFormat format = OrthancRestApi::GetDicomFormat(call, DicomToJsonFormat_Full);
 std::set<DicomTag> ignoreTagLength;
 ParseSetOfTags(ignoreTagLength, call, "ignore-length");
 // Retrieve all the instances of this patient/study/series
 {
 assert(start > end);
 if (call.IsDocumentation())
 {
+OrthancRestApi::DocumentDicomFormat(call, DicomToJsonFormat_Human);
 const std::string parent = GetResourceTypeText(end, false /* plural */, false /* lower case */);
 const std::string resource = GetResourceTypeText(start, false /* plural */, false /* lower case */);
 call.GetDocumentation()
 .SetTag(GetResourceTypeText(start, true /* plural */, true /* upper case */))
 .SetSummary("Get parent " + parent)
 currentType = GetParentResourceType(currentType);
 }
 assert(currentType == end);
+const DicomToJsonFormat format = OrthancRestApi::GetDicomFormat(call, DicomToJsonFormat_Human);
 Json::Value resource;
-if (OrthancRestApi::GetIndex(call).ExpandResource(resource, current, end))
+if (OrthancRestApi::GetIndex(call).ExpandResource(resource, current, end, format))
 {
 call.GetOutput().AnswerJson(resource);
 }
 }
 static void GetInstanceHeader(RestApiGetCall& call)
 {
 if (call.IsDocumentation())
 {
+OrthancRestApi::DocumentDicomFormat(call, DicomToJsonFormat_Full);
 call.GetDocumentation()
 .SetTag("Instances")
 .SetSummary("Get DICOM meta-header")
 .SetDescription("Get the DICOM tags in the meta-header of the DICOM instance. By default, the `full` format is used, which "
 "combines hexadecimal tags with human-readable description.")
 .SetUriArgument("id", "Orthanc identifier of the DICOM instance of interest")
-.SetHttpGetArgument("simplify", RestApiCallDocumentation::Type_String,
-"If present, report the DICOM tags in human-readable format", false)
-.SetHttpGetArgument("short", RestApiCallDocumentation::Type_String,
-"If present, report the DICOM tags indexed in hexadecimal format", false)
 .AddAnswerType(MimeType_Json, "JSON object containing the DICOM tags and their associated value")
 .SetHttpGetSample("https://demo.orthanc-server.com/instances/7c92ce8e-bbf67ed2-ffa3b8c1-a3b35d94-7ff3ae26/header", true);
 return;
 }
 ParsedDicomFile dicom(dicomContent);
 Json::Value header;
 OrthancConfiguration::DefaultDicomHeaderToJson(header, dicom);
-AnswerDicomAsJson(call, header);
+AnswerDicomAsJson(call, header, OrthancRestApi::GetDicomFormat(call, DicomToJsonFormat_Full));
 }
 static void InvalidateTags(RestApiPostCall& call)
 {
 Register("/studies/{id}/module", GetModule<ResourceType_Study, DicomModule_Study>);
 Register("/studies/{id}/module-patient", GetModule<ResourceType_Study, DicomModule_Patient>);
 Register("/instances/{id}/file", GetInstanceFile);
 Register("/instances/{id}/export", ExportInstanceFile);
-Register("/instances/{id}/tags", GetInstanceTagsBis);
+Register("/instances/{id}/tags", GetInstanceTags);
-Register("/instances/{id}/simplified-tags", GetInstanceTags<DicomToJsonFormat_Human>);
+Register("/instances/{id}/simplified-tags", GetInstanceSimplifiedTags);
 Register("/instances/{id}/frames", ListFrames);
 Register("/instances/{id}/frames/{frame}", RestApi::AutoListChildren);
 Register("/instances/{id}/frames/{frame}/preview", GetImage<ImageExtractionMode_Preview>);
 Register("/instances/{id}/frames/{frame}/rendered", GetRenderedFrame);

Mercurial > hg > orthanc

comparison OrthancServer/Sources/OrthancRestApi/OrthancRestResources.cpp @ 4697:569d9ef165b1