/// <summary> /// Answer to a REST request. This function answers to a REST request with the content of a memory buffer. /// </summary> /// <param name="context">OrthancPluginContext* - The Orthanc plugin context, as received by OrthancPluginInitialize().</param> /// <param name="output">OrthancPluginRestOutput* - The HTTP connection to the client application.</param> /// <param name="answer">const char* - Pointer to the memory buffer containing the answer.</param> /// <param name="answerSize">uint32_t - Number of bytes of the answer.</param> /// <param name="mimeType">const char* - The MIME type of the answer.</param> public static void OrthancPluginAnswerBuffer(ref OrthancPluginContext context, IntPtr output, IntPtr answer, uint answerSize, IntPtr mimeType) { IntPtr ptr = IntPtr.Zero; try { _OrthancPluginAnswerBuffer pr = new _OrthancPluginAnswerBuffer(); pr.output = output; pr.answer = answer; pr.answerSize = answerSize; pr.mimeType = mimeType; int size = Marshal.SizeOf(pr); ptr = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(pr, ptr, true); context.InvokeService(ref context, _OrthancPluginService._OrthancPluginService_AnswerBuffer, ptr); } catch (Exception ex) { OrthancPluginLogError(ref context, ex.ToString()); } finally { Marshal.FreeHGlobal(ptr); } }
public static int OrthancPluginCheckVersion(ref OrthancPluginContext context) { int major, minor, revision; string ver = Marshal.PtrToStringAnsi(context.orthancVersion); if (ver != "mainline") return 1; string[] split = ver.Split('.'); if (split.Length != 3) return 0; major = Convert.ToInt32(split[0]); minor = Convert.ToInt32(split[1]); revision = Convert.ToInt32(split[2]); if (major > ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER) return 0; if (minor > ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER) return 1; if (minor < ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER) return 0; if (revision >= ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER) return 1; return 0; }
public static int OrthancPluginInitialize(ref OrthancPluginContext c) { TestPlugin.Context = c; IntPtr ptrPathApi = IntPtr.Zero; try { ptrPathApi = Marshal.StringToHGlobalAnsi("/hello"); Callbacks.OrthancPluginRestCallback callback = new PluginsCore.Callbacks.OrthancPluginRestCallback(Callback_OrthancPluginRestCallback); OrthancCPlugin.OrthancPluginRegisterRestCallback(ref TestPlugin.Context, ptrPathApi, callback); return 0; } catch (Exception ex) { Log.Message(ex.ToString()); OrthancCPlugin.OrthancPluginLogError(ref c, ex.ToString()); return -1; } finally { Marshal.FreeHGlobal(ptrPathApi); } }
/// <summary> /// Remove a file from the storage area. /// This function removes a given file from the storage area that is currently used by Orthanc. /// </summary> /// <param name="context">OrthancPluginContext* - The Orthanc plugin context, as received by OrthancPluginInitialize().</param> /// <param name="storageArea">OrthancPluginStorageArea* - The storage area.</param> /// <param name="uuid">const char* - The identifier of the file to be removed.</param> /// <param name="type">OrthancPluginContentType - The type of the file content.</param> /// <returns>0 if success, other value if error.</returns> public static OrthancPluginErrorCode OrthancPluginStorageAreaRemove(ref OrthancPluginContext context, IntPtr storageArea, IntPtr uuid, OrthancPluginContentType type) { IntPtr ptr = IntPtr.Zero; try { _OrthancPluginStorageAreaRemove pr = new _OrthancPluginStorageAreaRemove(); pr.storageArea = storageArea; pr.uuid = uuid; pr.type = type; int size = Marshal.SizeOf(pr); ptr = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(pr, ptr, true); return context.InvokeService(ref context, _OrthancPluginService._OrthancPluginService_StorageAreaRemove, ptr); } catch (Exception ex) { Log.Message(ex.ToString()); OrthancPluginLogError(ref context, ex.ToString()); return OrthancPluginErrorCode.OrthancPluginErrorCode_InternalError; } finally { Marshal.FreeHGlobal(ptr); } }
public static void OrthancPluginSetDescription(ref OrthancPluginContext context, string description) { _OrthancPluginSetPluginProperty pr = new _OrthancPluginSetPluginProperty(); pr.plugin = TestPlugin.OrthancPluginGetName(); pr.property = _OrthancPluginProperty._OrthancPluginProperty_Description; pr.value = description; int size = Marshal.SizeOf(typeof(_OrthancPluginSetPluginProperty)); IntPtr ptr = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(pr, ptr, true); try { context.InvokeService(ref context, _OrthancPluginService._OrthancPluginService_SetPluginProperty, ptr); } catch (Exception ex) { OrthancPluginLogError(ref context, ex.ToString()); } finally { Marshal.FreeHGlobal(ptr); } }
/// <summary> /// Make a GET call to the Orthanc REST API, with custom HTTP headers. /// Make a GET call to the Orthanc REST API with extended parameters. /// The result to the query is stored into a newly allocated memory buffer. /// </summary> /// <param name="context">OrthancPluginContext* - The Orthanc plugin context, as received by OrthancPluginInitialize().</param> /// <param name="target">OrthancPluginMemoryBuffer* - The target memory buffer. It must be freed with OrthancPluginFreeMemoryBuffer().</param> /// <param name="uri">const char* - The URI in the built-in Orthanc API.</param> /// <param name="headersCount">uint32_t - The number of HTTP headers.</param> /// <param name="headersKeys">const char* const* - Array containing the keys of the HTTP headers.</param> /// <param name="headersValues">const char* const* - Array containing the values of the HTTP headers.</param> /// <param name="afterPlugins">int32_t - If 0, the built-in API of Orthanc is used. If 1, the API is tainted by the plugins.</param> /// <returns>0 if success, or the error code if failure.</returns> public static OrthancPluginErrorCode OrthancPluginRestApiGet2(ref OrthancPluginContext context, IntPtr target, IntPtr uri, uint headersCount, IntPtr headersKeys, IntPtr headersValues, int afterPlugins) { IntPtr ptr = IntPtr.Zero; try { _OrthancPluginRestApiGet2 pr = new _OrthancPluginRestApiGet2(); pr.target = target; pr.uri = uri; pr.headersCount = headersCount; pr.headersKeys = headersKeys; pr.headersValues = headersValues; pr.afterPlugins = afterPlugins; int size = Marshal.SizeOf(pr); ptr = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(pr, ptr, true); return context.InvokeService(ref context, _OrthancPluginService._OrthancPluginService_RestApiGet2, ptr); } catch (Exception ex) { Log.Message(ex.ToString()); OrthancPluginLogError(ref context, ex.ToString()); return OrthancPluginErrorCode.OrthancPluginErrorCode_InternalError; } finally { Marshal.FreeHGlobal(ptr); } }
/// <summary> /// Register a callback to handle modality worklists requests. /// </summary> /// <param name="context">OrthancPluginContext*</param> /// <param name="callback">OrthancPluginWorklistCallback</param> /// <returns></returns> public static OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(ref OrthancPluginContext context, Callbacks.OrthancPluginWorklistCallback callback) { IntPtr ptr = IntPtr.Zero; try { _OrthancPluginWorklistCallback pr = new _OrthancPluginWorklistCallback(); pr.callback = callback; int size = Marshal.SizeOf(pr); ptr = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(pr, ptr, true); return context.InvokeService(ref context, _OrthancPluginService._OrthancPluginService_RegisterWorklistCallback, ptr); } catch (Exception ex) { OrthancPluginLogError(ref context, ex.ToString()); return OrthancPluginErrorCode.OrthancPluginErrorCode_InternalError; } finally { Marshal.FreeHGlobal(ptr); } }
public static void OrthancPluginFreeMemoryBuffer(ref OrthancPluginContext context, IntPtr buffer) { context.Free(buffer); }
/// <summary> /// Mark the set of worklist answers as incomplete. /// </summary> /// <param name="context">OrthancPluginContext*</param> /// <param name="answers">OrthancPluginWorklistAnswers*</param> /// <returns></returns> public static OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(ref OrthancPluginContext context, IntPtr answers) { IntPtr ptr = IntPtr.Zero; try { _OrthancPluginWorklistAnswersOperation pr = new _OrthancPluginWorklistAnswersOperation(); pr.answers = answers; pr.query = IntPtr.Zero; pr.dicom = IntPtr.Zero; pr.size = 0; int size = Marshal.SizeOf(pr); ptr = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(pr, ptr, true); return context.InvokeService(ref context, _OrthancPluginService._OrthancPluginService_WorklistMarkIncomplete, ptr); } catch (Exception ex) { OrthancPluginLogError(ref context, ex.ToString()); return OrthancPluginErrorCode.OrthancPluginErrorCode_InternalError; } finally { Marshal.FreeHGlobal(ptr); } }
/// <summary> /// Declare a custom error code for this plugin. /// This function declares a custom error code that can be generated /// by this plugin. This declaration is used to enrich the body of /// the HTTP answer in the case of an error, and to set the proper HTTP status code. /// </summary> /// <param name="context">OrthancPluginContext* - The Orthanc plugin context, as received by OrthancPluginInitialize().</param> /// <param name="code">int32_t - The error code that is internal to this plugin.</param> /// <param name="httpStatus">uint16_t - The HTTP status corresponding to this error.</param> /// <param name="message">const char* - The description of the error.</param> /// <returns>The error code that has been assigned inside the Orthanc core.</returns> public static OrthancPluginErrorCode OrthancPluginRegisterErrorCode(ref OrthancPluginContext context, Int32 code, UInt16 httpStatus, IntPtr message) { IntPtr ptr = IntPtr.Zero; try { _OrthancPluginRegisterErrorCode pr = new _OrthancPluginRegisterErrorCode(); pr.code = code; pr.httpStatus = httpStatus; pr.message = message; int size = Marshal.SizeOf(pr); ptr = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(pr, ptr, true); if (context.InvokeService(ref context, _OrthancPluginService._OrthancPluginService_RegisterErrorCode, ptr) == OrthancPluginErrorCode.OrthancPluginErrorCode_Success) { pr = (_OrthancPluginRegisterErrorCode)Marshal.PtrToStructure(ptr, typeof(_OrthancPluginRegisterErrorCode)); Int32 newCode = Marshal.ReadInt32(pr.target); return (OrthancPluginErrorCode)newCode; } else { return OrthancPluginErrorCode.OrthancPluginErrorCode_Plugin; } } catch (Exception ex) { Log.Message(ex.ToString()); OrthancPluginLogError(ref context, ex.ToString()); return OrthancPluginErrorCode.OrthancPluginErrorCode_Plugin; } finally { Marshal.FreeHGlobal(ptr); } }
/// <summary> /// Register a new tag into the DICOM dictionary. /// This function declares a new tag in the dictionary of DICOM tags /// that are known to Orthanc. This function should be used in the /// OrthancPluginInitialize() callback. /// </summary> /// <param name="context">OrthancPluginContext* - The Orthanc plugin context, as received by OrthancPluginInitialize().</param> /// <param name="group">uint16_t - The group of the tag.</param> /// <param name="element">uint16_t - The element of the tag.</param> /// <param name="vr">OrthancPluginValueRepresentation - The value representation of the tag.</param> /// <param name="name">const char* - The nickname of the tag.</param> /// <param name="minMultiplicity">uint32_t - The minimum multiplicity of the tag (must be above 0).</param> /// <param name="maxMultiplicity">uint32_t - The maximum multiplicity of the tag. A value of 0 means an arbitrary multiplicity ("<tt>n</tt>").</param> /// <returns>0 if success, other value if error.</returns> public static OrthancPluginErrorCode OrthancPluginRegisterDictionaryTag(ref OrthancPluginContext context, UInt16 group, UInt16 element, OrthancPluginValueRepresentation vr, IntPtr name, UInt32 minMultiplicity, UInt32 maxMultiplicity) { IntPtr ptr = IntPtr.Zero; try { _OrthancPluginRegisterDictionaryTag pr = new _OrthancPluginRegisterDictionaryTag(); pr.group = group; pr.element = element; pr.vr = vr; pr.name = name; pr.minMultiplicity = minMultiplicity; pr.maxMultiplicity = maxMultiplicity; int size = Marshal.SizeOf(pr); ptr = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(pr, ptr, true); return context.InvokeService(ref context, _OrthancPluginService._OrthancPluginService_RegisterDictionaryTag, ptr); } catch (Exception ex) { Log.Message(ex.ToString()); OrthancPluginLogError(ref context, ex.ToString()); return OrthancPluginErrorCode.OrthancPluginErrorCode_InternalError; } finally { Marshal.FreeHGlobal(ptr); } }
/// <summary> /// Reconstruct the main DICOM tags. /// This function requests the Orthanc core to reconstruct the main DICOM tags of all the resources of the given type. /// This function can only be used as a part of the upgrade of a custom database back-end. /// (cf. OrthancPlugins::IDatabaseBackend::UpgradeDatabase). /// A database transaction will be automatically setup. /// </summary> /// <param name="context">OrthancPluginContext* - The Orthanc plugin context, as received by OrthancPluginInitialize().</param> /// <param name="storageArea">OrthancPluginStorageArea* - The storage area.</param> /// <param name="level">OrthancPluginResourceType - The type of the resources of interest.</param> /// <returns>0 if success, other value if error.</returns> public static OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(ref OrthancPluginContext context, IntPtr storageArea, OrthancPluginResourceType level) { IntPtr ptr = IntPtr.Zero; try { _OrthancPluginReconstructMainDicomTags pr = new _OrthancPluginReconstructMainDicomTags(); pr.level = level; pr.storageArea = storageArea; int size = Marshal.SizeOf(pr); ptr = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(pr, ptr, true); return context.InvokeService(ref context, _OrthancPluginService._OrthancPluginService_ReconstructMainDicomTags, ptr); } catch (Exception ex) { Log.Message(ex.ToString()); OrthancPluginLogError(ref context, ex.ToString()); return OrthancPluginErrorCode.OrthancPluginErrorCode_InternalError; } finally { Marshal.FreeHGlobal(ptr); } }
public static void OrthancPluginLogWarning(ref OrthancPluginContext context, IntPtr message) { context.InvokeService(ref context, PluginsCore.Enums._OrthancPluginService._OrthancPluginService_LogWarning, message); }
public static void OrthancPluginLogWarning(ref OrthancPluginContext context, string message) { IntPtr ptr = IntPtr.Zero; try { ptr = Marshal.StringToHGlobalAnsi(message); OrthancCPlugin.OrthancPluginLogWarning(ref context, ptr); } finally { Marshal.FreeHGlobal(ptr); } }
public static void OrthancPluginFreeString(ref OrthancPluginContext context, IntPtr str) { if (str != IntPtr.Zero) { context.Free(str); } }
/// <summary> /// Retrieve the worklist query as a DICOM file. /// </summary> /// <param name="context">OrthancPluginContext* </param> /// <param name="target">OrthancPluginMemoryBuffer*</param> /// <param name="query">const OrthancPluginWorklistQuery*</param> /// <returns></returns> public static OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(ref OrthancPluginContext context, IntPtr target, IntPtr query) { IntPtr ptr = IntPtr.Zero; try { _OrthancPluginWorklistQueryOperation pr = new _OrthancPluginWorklistQueryOperation(); pr.query = query; pr.dicom = IntPtr.Zero; pr.size = 0; pr.isMatch = IntPtr.Zero; pr.target = target; int size = Marshal.SizeOf(pr); ptr = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(pr, ptr, true); return context.InvokeService(ref context, _OrthancPluginService._OrthancPluginService_WorklistGetDicomQuery, ptr); } catch (Exception ex) { OrthancPluginLogError(ref context, ex.ToString()); return OrthancPluginErrorCode.OrthancPluginErrorCode_InternalError; } finally { Marshal.FreeHGlobal(ptr); } }
/// <summary> /// Test whether a worklist matches the query. /// </summary> /// <param name="context">OrthancPluginContext*</param> /// <param name="query">const OrthancPluginWorklistQuery*</param> /// <param name="dicom">const void*</param> /// <param name="size">uint32_t</param> /// <returns></returns> public static int OrthancPluginWorklistIsMatch(ref OrthancPluginContext context, IntPtr query, IntPtr dicom, uint size) { IntPtr ptr = IntPtr.Zero; try { int isMatch = 0; IntPtr ptrIsMatch = new IntPtr(isMatch); _OrthancPluginWorklistQueryOperation pr = new _OrthancPluginWorklistQueryOperation(); pr.query = query; pr.dicom = dicom; pr.size = size; pr.isMatch = ptrIsMatch; pr.target = IntPtr.Zero; int ptrSize = Marshal.SizeOf(pr); ptr = Marshal.AllocHGlobal(ptrSize); Marshal.StructureToPtr(pr, ptr, true); if (context.InvokeService(ref context, _OrthancPluginService._OrthancPluginService_WorklistIsMatch, ptr) == OrthancPluginErrorCode.OrthancPluginErrorCode_Success) { pr = (_OrthancPluginWorklistQueryOperation)Marshal.PtrToStructure(ptr, typeof(_OrthancPluginWorklistQueryOperation)); return pr.isMatch.ToInt32(); } return 0; } catch (Exception ex) { OrthancPluginLogError(ref context, ex.ToString()); return -1; } finally { Marshal.FreeHGlobal(ptr); } }
/// <summary> /// Register a callback for received instances. /// This function registers a callback function that is called /// whenever a new DICOM instance is stored into the Orthanc core. /// </summary> /// <param name="context">OrthancPluginContext* - The Orthanc plugin context, as received by OrthancPluginInitialize().</param> /// <param name="callback">OrthancPluginOnStoredInstanceCallback - The callback function.</param> public static void OrthancPluginRegisterOnStoredInstanceCallback(ref OrthancPluginContext context, Orthanc.CSharp.PluginsCore.Callbacks.OrthancPluginOnStoredInstanceCallback callback) { IntPtr ptr = IntPtr.Zero; try { _OrthancPluginOnStoredInstanceCallback pr = new _OrthancPluginOnStoredInstanceCallback(); pr.callback = callback; int size = Marshal.SizeOf(pr); ptr = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(pr, ptr, true); context.InvokeService(ref context, _OrthancPluginService._OrthancPluginService_RegisterOnStoredInstanceCallback, ptr); } catch (Exception ex) { Log.Message(ex.ToString()); OrthancPluginLogError(ref context, ex.ToString()); } finally { Marshal.FreeHGlobal(ptr); } }
/// <summary> /// Register a REST callback, without locking. /// </summary> /// <param name="context">OrthancPluginContext*</param> /// <param name="pathRegularExpression">const char*</param> /// <param name="callback">OrthancPluginRestCallback</param> public static void OrthancPluginRegisterRestCallbackNoLock(ref OrthancPluginContext context, IntPtr pathRegularExpression, Callbacks.OrthancPluginRestCallback callback) { IntPtr ptr = IntPtr.Zero; try { _OrthancPluginRestCallback pr = new _OrthancPluginRestCallback(); pr.pathRegularExpression = pathRegularExpression; pr.callback = callback; int size = Marshal.SizeOf(pr); ptr = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(pr, ptr, true); context.InvokeService(ref context, _OrthancPluginService._OrthancPluginService_RegisterRestCallbackNoLock, ptr); } catch (Exception ex) { OrthancPluginLogError(ref context, ex.ToString()); } finally { Marshal.FreeHGlobal(ptr); } }
/// <summary> /// Format a DICOM instance as a JSON string. /// This function formats a DICOM instance that is stored in Orthanc, /// and outputs a JSON string representing the tags of this DICOM instance. /// </summary> /// <param name="context">OrthancPluginContext* - The Orthanc plugin context, as received by OrthancPluginInitialize().</param> /// <param name="instanceId">const char* - The Orthanc identifier of the instance.</param> /// <param name="format">OrthancPluginDicomToJsonFormat - The output format.</param> /// <param name="flags">OrthancPluginDicomToJsonFlags - Flags governing the output.</param> /// <param name="maxStringLength">uint32_t - The maximum length of a field. Too long fields will be output as "null". The 0 value means no maximum length.</param> /// <returns>char* - The NULL value if the case of an error, or the JSON string. This string must be freed by OrthancPluginFreeString().</returns> public static IntPtr OrthancPluginDicomInstanceToJson(ref OrthancPluginContext context, IntPtr instanceId, OrthancPluginDicomToJsonFormat format, OrthancPluginDicomToJsonFlags flags, uint maxStringLength) { IntPtr ptr = IntPtr.Zero; try { _OrthancPluginDicomToJson pr = new _OrthancPluginDicomToJson(); pr.instanceId = instanceId; pr.format = format; pr.flags = flags; pr.maxStringLength = maxStringLength; int size = Marshal.SizeOf(pr); ptr = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(pr, ptr, true); if (context.InvokeService(ref context, _OrthancPluginService._OrthancPluginService_DicomInstanceToJson, ptr) != OrthancPluginErrorCode.OrthancPluginErrorCode_Success) { return IntPtr.Zero; } else { pr = (_OrthancPluginDicomToJson)Marshal.PtrToStructure(ptr, typeof(_OrthancPluginDicomToJson)); return pr.result; } } catch (Exception ex) { Log.Message(ex.ToString()); OrthancPluginLogError(ref context, ex.ToString()); return IntPtr.Zero; } finally { Marshal.FreeHGlobal(ptr); } }