orthanc: OrthancServer/OrthancRestApi/OrthancRestAnonymizeModify.cpp comparison

comparison OrthancServer/OrthancRestApi/OrthancRestAnonymizeModify.cpp @ 1564:1b7def486e62

creation of DICOM series

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Fri, 21 Aug 2015 15:01:21 +0200
parents	2084b7c20478
children	4b23310eb7e8

comparison

equal deleted inserted replaced

-:9bb416445319
+:1b7def486e62
 #include "../../Core/Uuid.h"
 #include "../FromDcmtkBridge.h"
 #include "../ServerContext.h"
 #include "../OrthancInitialization.h"
+#include <boost/lexical_cast.hpp>
 namespace Orthanc
 {
 // Modification of DICOM instances ------------------------------------------
 enum TagOperation
 changeType, resourceType, call);
 }
 }
+static bool StoreCreatedInstance(std::string& id /* out */,
+ServerContext& context,
+ParsedDicomFile& dicom)
+{
+DicomInstanceToStore toStore;
+toStore.SetParsedDicomFile(dicom);
+StoreStatus status = context.Store(id, toStore);
+if (status == StoreStatus_Failure)
+{
+LOG(ERROR) << "Error while storing a manually-created instance";
+return false;
+}
+else
+{
+return true;
+}
+}
 static bool CreateDicomV1(ParsedDicomFile& dicom,
 const Json::Value& request)
 {
 // curl http://localhost:8042/tools/create-dicom -X POST -d '{"PatientName":"Hello^World"}'
 // curl http://localhost:8042/tools/create-dicom -X POST -d '{"PatientName":"Hello^World","PixelData":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAAAAAA6mKC9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3gUGDDcB53FulQAAAElJREFUGNNtj0sSAEEEQ1+U+185s1CtmRkblQ9CZldsKHJDk6DLGLJa6chjh0ooQmpjXMM86zPwydGEj6Ed/UGykkEM8X+p3u8/8LcOJIWLGeMAAAAASUVORK5CYII="}'
 return true;
 }
-static bool CreateDicomV2(ParsedDicomFile& dicom,
+static void CreateSeries(RestApiPostCall& call,
-ServerContext& context,
+ParsedDicomFile& base /* in */,
+const Json::Value& content)
+{
+assert(content.isArray());
+assert(content.size() > 0);
+ServerContext& context = OrthancRestApi::GetContext(call);
+base.Replace(DICOM_TAG_IMAGES_IN_ACQUISITION, boost::lexical_cast<std::string>(content.size()));
+base.Replace(DICOM_TAG_NUMBER_OF_TEMPORAL_POSITIONS, "1");
+std::string someInstance;
+for (Json::ArrayIndex i = 0; i < content.size(); i++)
+{
+if (content[i].type() != Json::stringValue)
+{
+LOG(ERROR) << "The payload of the DICOM instance must be specified according to Data URI scheme";
+return;
+}
+std::auto_ptr<ParsedDicomFile> dicom(base.Clone());
+dicom->EmbedContent(content[i].asString());
+dicom->Replace(DICOM_TAG_INSTANCE_NUMBER, boost::lexical_cast<std::string>(i + 1));
+dicom->Replace(DICOM_TAG_IMAGE_INDEX, boost::lexical_cast<std::string>(i + 1));
+if (!StoreCreatedInstance(someInstance, context, *dicom))
+{
+LOG(ERROR) << "Error while creating the series";
+return;
+}
+}
+std::string series;
+if (context.GetIndex().LookupParent(series, someInstance))
+{
+OrthancRestApi::GetApi(call).AnswerStoredResource(call, series, ResourceType_Series, StoreStatus_Success);
+}
+}
+static void CreateDicomV2(RestApiPostCall& call,
 const Json::Value& request)
 {
 assert(request.isObject());
+ServerContext& context = OrthancRestApi::GetContext(call);
 if (!request.isMember("Tags") ||
 request["Tags"].type() != Json::objectValue)
 {
-return false;
+return;
 }
 Encoding encoding;
 if (request["Tags"].isMember("SpecificCharacterSet"))
 {
 const char* tmp = request["Tags"]["SpecificCharacterSet"].asCString();
 if (!GetDicomEncoding(encoding, tmp))
 {
 LOG(ERROR) << "Unknown specific character set: " << tmp;
-return false;
+return;
 }
 }
 else
 {
 std::string tmp = Configuration::GetGlobalStringParameter("DefaultEncoding", "Latin1");
 encoding = StringToEncoding(tmp.c_str());
 }
+ParsedDicomFile dicom;
 dicom.SetEncoding(encoding);
 ResourceType parentType = ResourceType_Instance;
 if (request.isMember("Parent"))
 // Locate the parent tags
 std::string parent = request["Parent"].asString();
 if (!context.GetIndex().LookupResourceType(parentType, parent))
 {
 LOG(ERROR) << "Trying to attach a new DICOM instance to an inexistent resource: " << parent;
-return false;
+return;
 }
 if (parentType == ResourceType_Instance)
 {
 LOG(ERROR) << "Trying to attach a new DICOM instance to an instance (must be a series, study or patient): " << parent;
-return false;
+return;
 }
 // Select one existing child instance of the parent resource, to
 // retrieve all its tags
 Json::Value siblingTags;
 std::list<std::string>  siblingInstances;
 context.GetIndex().GetChildInstances(siblingInstances, parent);
 if (siblingInstances.empty())
 {
-return false;   // Error: No instance (should never happen)
+return;   // Error: No instance (should never happen)
 }
 context.ReadJson(siblingTags, siblingInstances.front());
 }
 // Go up
 std::string tmp;
 if (!context.GetIndex().LookupParent(tmp, parent))
 {
-return false;
+return;
 }
 parent = tmp;
 type = GetParentResourceType(type);
 }
 {
 const std::string& name = members[i];
 if (request["Tags"][name].type() != Json::stringValue)
 {
 LOG(ERROR) << "Only string values are supported when creating DICOM instances";
-return false;
+return;
 }
 std::string value = request["Tags"][name].asString();
 DicomTag tag = FromDcmtkBridge::ParseTag(name);
 if (tag != DICOM_TAG_SPECIFIC_CHARACTER_SET)
 {
 if (dicom.HasTag(tag))
 {
 LOG(ERROR) << "Trying to override a value inherited from a parent module";
-return false;
+return;
 }
 if (tag == DICOM_TAG_PIXEL_DATA)
 {
 LOG(ERROR) << "Use \"Content\" to inject an image into a new DICOM instance";
-return false;
+return;
 }
 else
 {
 dicom.Replace(tag, Toolbox::ConvertFromUtf8(value, encoding));
 }
 }
 }
 // Inject the content (either an image, or a PDF file)
 if (request.isMember("Content"))
 {
-if (request["Content"].type() != Json::stringValue)
+const Json::Value& content = request["Content"];
+if (content.type() == Json::stringValue)
+{
+dicom.EmbedContent(request["Content"].asString());
+}
+else if (content.type() == Json::arrayValue)
+{
+if (content.size() > 0)
+{
+// Let's create a series
+CreateSeries(call, dicom, content);
+return;
+}
+}
+else
 {
 LOG(ERROR) << "The payload of the DICOM instance must be specified according to Data URI scheme";
-return false;
+return;
 }
+}
-dicom.EmbedContent(request["Content"].asString());
-}
+std::string id;
+if (StoreCreatedInstance(id, context, dicom))
+{
-return true;
+OrthancRestApi::GetApi(call).AnswerStoredResource(call, id, ResourceType_Instance, StoreStatus_Success);
+}
+return;
 }
 static void CreateDicom(RestApiPostCall& call)
 {
-ServerContext& context = OrthancRestApi::GetContext(call);
 Json::Value request;
 if (call.ParseJsonRequest(request) &&
 request.isObject())
 {
-ParsedDicomFile dicom;
+if (request.isMember("Tags"))
+{
-if (request.isMember("Tags") ?
+CreateDicomV2(call, request);
-CreateDicomV2(dicom, context, request) :
+}
-CreateDicomV1(dicom, request))
+else
 {
-DicomInstanceToStore toStore;
+// Compatibility with Orthanc <= 0.9.3
-toStore.SetParsedDicomFile(dicom);
+ServerContext& context = OrthancRestApi::GetContext(call);
+ParsedDicomFile dicom;
-std::string id;
+if (CreateDicomV1(dicom, request))
-StoreStatus status = OrthancRestApi::GetContext(call).Store(id, toStore);
+{
+std::string id;
-if (status == StoreStatus_Failure)
+if (StoreCreatedInstance(id, context, dicom))
 {
-LOG(ERROR) << "Error while storing a manually-created instance";
+OrthancRestApi::GetApi(call).AnswerStoredResource(call, id, ResourceType_Instance, StoreStatus_Success);
-return;
+}
 }
-OrthancRestApi::GetApi(call).AnswerStoredInstance(call, id, status);
 }
 }
 }

Mercurial > hg > orthanc

comparison OrthancServer/OrthancRestApi/OrthancRestAnonymizeModify.cpp @ 1564:1b7def486e62