 |
Orthanc Plugin SDK
1.6.1
Documentation of the plugin interface of Orthanc
|
119 # define ORTHANC_PLUGINS_API __declspec(dllexport)
121 # define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default")))
123 # define ORTHANC_PLUGINS_API
126 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
127 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 6
128 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 1
131 #if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
132 #define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
133 (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
134 (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
135 (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
136 (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
137 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
156 #ifndef ORTHANC_PLUGIN_INLINE
157 # if __STDC_VERSION__ >= 199901L
159 # define ORTHANC_PLUGIN_INLINE static inline
160 # elif defined(__cplusplus)
162 # define ORTHANC_PLUGIN_INLINE static inline
163 # elif defined(__GNUC__)
165 # define ORTHANC_PLUGIN_INLINE static __inline
166 # elif defined(_MSC_VER)
168 # define ORTHANC_PLUGIN_INLINE static __inline
170 # error Your compiler is not known to support the "inline" keyword
310 _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
318 ORTHANC_PLUGINS_API
const char* OrthancPluginGetName();
331 _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
349 uint32_t groupsCount;
354 const char*
const* groups;
364 const char*
const* getKeys;
369 const char*
const* getValues;
389 uint32_t headersCount;
394 const char*
const* headersKeys;
399 const char*
const* headersValues;
407 _OrthancPluginService_LogInfo = 1,
408 _OrthancPluginService_LogWarning = 2,
409 _OrthancPluginService_LogError = 3,
410 _OrthancPluginService_GetOrthancPath = 4,
411 _OrthancPluginService_GetOrthancDirectory = 5,
412 _OrthancPluginService_GetConfigurationPath = 6,
413 _OrthancPluginService_SetPluginProperty = 7,
414 _OrthancPluginService_GetGlobalProperty = 8,
415 _OrthancPluginService_SetGlobalProperty = 9,
416 _OrthancPluginService_GetCommandLineArgumentsCount = 10,
417 _OrthancPluginService_GetCommandLineArgument = 11,
418 _OrthancPluginService_GetExpectedDatabaseVersion = 12,
419 _OrthancPluginService_GetConfiguration = 13,
420 _OrthancPluginService_BufferCompression = 14,
421 _OrthancPluginService_ReadFile = 15,
422 _OrthancPluginService_WriteFile = 16,
423 _OrthancPluginService_GetErrorDescription = 17,
424 _OrthancPluginService_CallHttpClient = 18,
425 _OrthancPluginService_RegisterErrorCode = 19,
426 _OrthancPluginService_RegisterDictionaryTag = 20,
427 _OrthancPluginService_DicomBufferToJson = 21,
428 _OrthancPluginService_DicomInstanceToJson = 22,
429 _OrthancPluginService_CreateDicom = 23,
430 _OrthancPluginService_ComputeMd5 = 24,
431 _OrthancPluginService_ComputeSha1 = 25,
432 _OrthancPluginService_LookupDictionary = 26,
433 _OrthancPluginService_CallHttpClient2 = 27,
434 _OrthancPluginService_GenerateUuid = 28,
435 _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
436 _OrthancPluginService_AutodetectMimeType = 30,
437 _OrthancPluginService_SetMetricsValue = 31,
438 _OrthancPluginService_EncodeDicomWebJson = 32,
439 _OrthancPluginService_EncodeDicomWebXml = 33,
440 _OrthancPluginService_ChunkedHttpClient = 34,
441 _OrthancPluginService_GetTagName = 35,
444 _OrthancPluginService_RegisterRestCallback = 1000,
445 _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
446 _OrthancPluginService_RegisterStorageArea = 1002,
447 _OrthancPluginService_RegisterOnChangeCallback = 1003,
448 _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
449 _OrthancPluginService_RegisterWorklistCallback = 1005,
450 _OrthancPluginService_RegisterDecodeImageCallback = 1006,
451 _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
452 _OrthancPluginService_RegisterFindCallback = 1008,
453 _OrthancPluginService_RegisterMoveCallback = 1009,
454 _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
455 _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
456 _OrthancPluginService_RegisterChunkedRestCallback = 1012,
457 _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
458 _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
461 _OrthancPluginService_AnswerBuffer = 2000,
462 _OrthancPluginService_CompressAndAnswerPngImage = 2001,
463 _OrthancPluginService_Redirect = 2002,
464 _OrthancPluginService_SendHttpStatusCode = 2003,
465 _OrthancPluginService_SendUnauthorized = 2004,
466 _OrthancPluginService_SendMethodNotAllowed = 2005,
467 _OrthancPluginService_SetCookie = 2006,
468 _OrthancPluginService_SetHttpHeader = 2007,
469 _OrthancPluginService_StartMultipartAnswer = 2008,
470 _OrthancPluginService_SendMultipartItem = 2009,
471 _OrthancPluginService_SendHttpStatus = 2010,
472 _OrthancPluginService_CompressAndAnswerImage = 2011,
473 _OrthancPluginService_SendMultipartItem2 = 2012,
474 _OrthancPluginService_SetHttpErrorDetails = 2013,
477 _OrthancPluginService_GetDicomForInstance = 3000,
478 _OrthancPluginService_RestApiGet = 3001,
479 _OrthancPluginService_RestApiPost = 3002,
480 _OrthancPluginService_RestApiDelete = 3003,
481 _OrthancPluginService_RestApiPut = 3004,
482 _OrthancPluginService_LookupPatient = 3005,
483 _OrthancPluginService_LookupStudy = 3006,
484 _OrthancPluginService_LookupSeries = 3007,
485 _OrthancPluginService_LookupInstance = 3008,
486 _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
487 _OrthancPluginService_RestApiGetAfterPlugins = 3010,
488 _OrthancPluginService_RestApiPostAfterPlugins = 3011,
489 _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
490 _OrthancPluginService_RestApiPutAfterPlugins = 3013,
491 _OrthancPluginService_ReconstructMainDicomTags = 3014,
492 _OrthancPluginService_RestApiGet2 = 3015,
495 _OrthancPluginService_GetInstanceRemoteAet = 4000,
496 _OrthancPluginService_GetInstanceSize = 4001,
497 _OrthancPluginService_GetInstanceData = 4002,
498 _OrthancPluginService_GetInstanceJson = 4003,
499 _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
500 _OrthancPluginService_HasInstanceMetadata = 4005,
501 _OrthancPluginService_GetInstanceMetadata = 4006,
502 _OrthancPluginService_GetInstanceOrigin = 4007,
503 _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
504 _OrthancPluginService_HasInstancePixelData = 4009,
507 _OrthancPluginService_RegisterDatabaseBackend = 5000,
508 _OrthancPluginService_DatabaseAnswer = 5001,
509 _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
510 _OrthancPluginService_StorageAreaCreate = 5003,
511 _OrthancPluginService_StorageAreaRead = 5004,
512 _OrthancPluginService_StorageAreaRemove = 5005,
515 _OrthancPluginService_GetImagePixelFormat = 6000,
516 _OrthancPluginService_GetImageWidth = 6001,
517 _OrthancPluginService_GetImageHeight = 6002,
518 _OrthancPluginService_GetImagePitch = 6003,
519 _OrthancPluginService_GetImageBuffer = 6004,
520 _OrthancPluginService_UncompressImage = 6005,
521 _OrthancPluginService_FreeImage = 6006,
522 _OrthancPluginService_CompressImage = 6007,
523 _OrthancPluginService_ConvertPixelFormat = 6008,
524 _OrthancPluginService_GetFontsCount = 6009,
525 _OrthancPluginService_GetFontInfo = 6010,
526 _OrthancPluginService_DrawText = 6011,
527 _OrthancPluginService_CreateImage = 6012,
528 _OrthancPluginService_CreateImageAccessor = 6013,
529 _OrthancPluginService_DecodeDicomImage = 6014,
532 _OrthancPluginService_WorklistAddAnswer = 7000,
533 _OrthancPluginService_WorklistMarkIncomplete = 7001,
534 _OrthancPluginService_WorklistIsMatch = 7002,
535 _OrthancPluginService_WorklistGetDicomQuery = 7003,
536 _OrthancPluginService_FindAddAnswer = 7004,
537 _OrthancPluginService_FindMarkIncomplete = 7005,
538 _OrthancPluginService_GetFindQuerySize = 7006,
539 _OrthancPluginService_GetFindQueryTag = 7007,
540 _OrthancPluginService_GetFindQueryTagName = 7008,
541 _OrthancPluginService_GetFindQueryValue = 7009,
542 _OrthancPluginService_CreateFindMatcher = 7010,
543 _OrthancPluginService_FreeFindMatcher = 7011,
544 _OrthancPluginService_FindMatcherIsMatch = 7012,
547 _OrthancPluginService_GetPeers = 8000,
548 _OrthancPluginService_FreePeers = 8001,
549 _OrthancPluginService_GetPeersCount = 8003,
550 _OrthancPluginService_GetPeerName = 8004,
551 _OrthancPluginService_GetPeerUrl = 8005,
552 _OrthancPluginService_CallPeerApi = 8006,
553 _OrthancPluginService_GetPeerUserProperty = 8007,
556 _OrthancPluginService_CreateJob = 9000,
557 _OrthancPluginService_FreeJob = 9001,
558 _OrthancPluginService_SubmitJob = 9002,
559 _OrthancPluginService_RegisterJobsUnserializer = 9003,
561 _OrthancPluginService_INTERNAL = 0x7fffffff
562 } _OrthancPluginService;
567 _OrthancPluginProperty_Description = 1,
568 _OrthancPluginProperty_RootUri = 2,
569 _OrthancPluginProperty_OrthancExplorer = 3,
571 _OrthancPluginProperty_INTERNAL = 0x7fffffff
572 } _OrthancPluginProperty;
664 _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
678 _OrthancPluginContentType_INTERNAL = 0x7fffffff
694 _OrthancPluginResourceType_INTERNAL = 0x7fffffff
722 _OrthancPluginChangeType_INTERNAL = 0x7fffffff
737 _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
751 _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
789 _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
804 _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
815 OrthancPluginDicomToJsonFlags_None = 0,
823 _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
834 OrthancPluginCreateDicomFlags_None = 0,
838 _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
854 _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
870 _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
885 _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
1116 const char* instanceId);
1127 const char* resourceId);
1138 const uint32_t size,
1139 uint32_t frameIndex);
1160 const char* bulkDataUri);
1178 const void* content,
1242 const char* issuerAet,
1243 const char* calledAet);
1270 uint32_t headersCount,
1271 const char*
const* headersKeys,
1272 const char*
const* headersValues);
1301 uint32_t headersCount,
1302 const char*
const* headersKeys,
1303 const char*
const* headersValues,
1304 uint32_t getArgumentsCount,
1305 const char*
const* getArgumentsKeys,
1306 const char*
const* getArgumentsValues);
1327 const char* issuerAet,
1328 const char* calledAet);
1367 typedef void* (*OrthancPluginMoveCallback) (
1369 const char* patientId,
1370 const char* accessionNumber,
1371 const char* studyInstanceUid,
1372 const char* seriesInstanceUid,
1373 const char* sopInstanceUid,
1374 const char* originatorAet,
1375 const char* sourceAet,
1376 const char* targetAet,
1377 uint16_t originatorId);
1462 typedef const char* (*OrthancPluginJobGetContent) (
void* job);
1480 typedef const char* (*OrthancPluginJobGetSerialized) (
void* job);
1552 typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (
const char* jobType,
1553 const char* serialized);
1601 uint32_t levelDepth,
1602 const uint16_t* levelTagGroup,
1603 const uint16_t* levelTagElement,
1604 const uint32_t* levelIndex,
1606 uint16_t tagElement,
1614 typedef struct _OrthancPluginContext_t
1616 void* pluginsManager;
1617 const char* orthancVersion;
1620 _OrthancPluginService service,
1621 const void* params);
1634 uint32_t minMultiplicity;
1635 uint32_t maxMultiplicity;
1682 int expectedRevision)
1684 int major, minor, revision;
1688 sizeof(int32_t) !=
sizeof(_OrthancPluginService) ||
1689 sizeof(int32_t) !=
sizeof(_OrthancPluginProperty) ||
1713 if (!strcmp(context->orthancVersion,
"mainline"))
1725 (context->orthancVersion,
"%4d.%4d.%4d", &major, &minor, &revision) != 3)
1732 if (major > expectedMajor)
1737 if (major < expectedMajor)
1744 if (minor > expectedMinor)
1749 if (minor < expectedMinor)
1756 if (revision >= expectedRevision)
1788 ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1789 ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1790 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1806 context->Free(buffer->
data);
1820 const char* message)
1822 context->InvokeService(context, _OrthancPluginService_LogError, message);
1836 const char* message)
1838 context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1852 const char* message)
1854 context->InvokeService(context, _OrthancPluginService_LogInfo, message);
1861 const char* pathRegularExpression;
1863 } _OrthancPluginRestCallback;
1888 const char* pathRegularExpression,
1891 _OrthancPluginRestCallback params;
1892 params.pathRegularExpression = pathRegularExpression;
1893 params.callback = callback;
1894 context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, ¶ms);
1928 const char* pathRegularExpression,
1931 _OrthancPluginRestCallback params;
1932 params.pathRegularExpression = pathRegularExpression;
1933 params.callback = callback;
1934 context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, ¶ms);
1942 } _OrthancPluginOnStoredInstanceCallback;
1958 _OrthancPluginOnStoredInstanceCallback params;
1959 params.callback = callback;
1961 context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, ¶ms);
1970 uint32_t answerSize;
1971 const char* mimeType;
1972 } _OrthancPluginAnswerBuffer;
1990 uint32_t answerSize,
1991 const char* mimeType)
1993 _OrthancPluginAnswerBuffer params;
1994 params.output = output;
1995 params.answer = answer;
1996 params.answerSize = answerSize;
1997 params.mimeType = mimeType;
1998 context->InvokeService(context, _OrthancPluginService_AnswerBuffer, ¶ms);
2010 } _OrthancPluginCompressAndAnswerPngImage;
2022 } _OrthancPluginCompressAndAnswerImage;
2052 _OrthancPluginCompressAndAnswerImage params;
2053 params.output = output;
2055 params.pixelFormat = format;
2056 params.width = width;
2057 params.height = height;
2058 params.pitch = pitch;
2059 params.buffer = buffer;
2061 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, ¶ms);
2069 const char* instanceId;
2070 } _OrthancPluginGetDicomForInstance;
2087 const char* instanceId)
2089 _OrthancPluginGetDicomForInstance params;
2090 params.target = target;
2091 params.instanceId = instanceId;
2092 return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, ¶ms);
2101 } _OrthancPluginRestApiGet;
2122 _OrthancPluginRestApiGet params;
2123 params.target = target;
2125 return context->InvokeService(context, _OrthancPluginService_RestApiGet, ¶ms);
2152 _OrthancPluginRestApiGet params;
2153 params.target = target;
2155 return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, ¶ms);
2166 } _OrthancPluginRestApiPostPut;
2191 _OrthancPluginRestApiPostPut params;
2192 params.target = target;
2195 params.bodySize = bodySize;
2196 return context->InvokeService(context, _OrthancPluginService_RestApiPost, ¶ms);
2226 _OrthancPluginRestApiPostPut params;
2227 params.target = target;
2230 params.bodySize = bodySize;
2231 return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, ¶ms);
2252 return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2275 return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2303 _OrthancPluginRestApiPostPut params;
2304 params.target = target;
2307 params.bodySize = bodySize;
2308 return context->InvokeService(context, _OrthancPluginService_RestApiPut, ¶ms);
2339 _OrthancPluginRestApiPostPut params;
2340 params.target = target;
2343 params.bodySize = bodySize;
2344 return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, ¶ms);
2352 const char* argument;
2353 } _OrthancPluginOutputPlusArgument;
2369 const char* redirection)
2371 _OrthancPluginOutputPlusArgument params;
2372 params.output = output;
2373 params.argument = redirection;
2374 context->InvokeService(context, _OrthancPluginService_Redirect, ¶ms);
2382 const char* argument;
2383 } _OrthancPluginRetrieveDynamicString;
2400 const char* patientID)
2404 _OrthancPluginRetrieveDynamicString params;
2405 params.result = &result;
2406 params.argument = patientID;
2435 const char* studyUID)
2439 _OrthancPluginRetrieveDynamicString params;
2440 params.result = &result;
2441 params.argument = studyUID;
2470 const char* accessionNumber)
2474 _OrthancPluginRetrieveDynamicString params;
2475 params.result = &result;
2476 params.argument = accessionNumber;
2505 const char* seriesUID)
2509 _OrthancPluginRetrieveDynamicString params;
2510 params.result = &result;
2511 params.argument = seriesUID;
2540 const char* sopInstanceUID)
2544 _OrthancPluginRetrieveDynamicString params;
2545 params.result = &result;
2546 params.argument = sopInstanceUID;
2565 } _OrthancPluginSendHttpStatusCode;
2588 _OrthancPluginSendHttpStatusCode params;
2589 params.output = output;
2590 params.status = status;
2591 context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, ¶ms);
2611 _OrthancPluginOutputPlusArgument params;
2612 params.output = output;
2613 params.argument = realm;
2614 context->InvokeService(context, _OrthancPluginService_SendUnauthorized, ¶ms);
2632 const char* allowedMethods)
2634 _OrthancPluginOutputPlusArgument params;
2635 params.output = output;
2636 params.argument = allowedMethods;
2637 context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, ¶ms);
2646 } _OrthancPluginSetHttpHeader;
2665 _OrthancPluginSetHttpHeader params;
2666 params.output = output;
2667 params.key = cookie;
2668 params.value = value;
2669 context->InvokeService(context, _OrthancPluginService_SetCookie, ¶ms);
2690 _OrthancPluginSetHttpHeader params;
2691 params.output = output;
2693 params.value = value;
2694 context->InvokeService(context, _OrthancPluginService_SetHttpHeader, ¶ms);
2700 char** resultStringToFree;
2701 const char** resultString;
2702 int64_t* resultInt64;
2706 } _OrthancPluginAccessDicomInstance;
2726 _OrthancPluginAccessDicomInstance params;
2727 memset(¶ms, 0,
sizeof(params));
2728 params.resultString = &result;
2729 params.instance = instance;
2759 _OrthancPluginAccessDicomInstance params;
2760 memset(¶ms, 0,
sizeof(params));
2761 params.resultInt64 = &size;
2762 params.instance = instance;
2792 _OrthancPluginAccessDicomInstance params;
2793 memset(¶ms, 0,
sizeof(params));
2794 params.resultString = &result;
2795 params.instance = instance;
2828 _OrthancPluginAccessDicomInstance params;
2829 memset(¶ms, 0,
sizeof(params));
2830 params.resultStringToFree = &result;
2831 params.instance = instance;
2866 _OrthancPluginAccessDicomInstance params;
2867 memset(¶ms, 0,
sizeof(params));
2868 params.resultStringToFree = &result;
2869 params.instance = instance;
2902 const char* metadata)
2906 _OrthancPluginAccessDicomInstance params;
2907 memset(¶ms, 0,
sizeof(params));
2908 params.resultInt64 = &result;
2909 params.instance = instance;
2910 params.key = metadata;
2919 return (result != 0);
2943 const char* metadata)
2947 _OrthancPluginAccessDicomInstance params;
2948 memset(¶ms, 0,
sizeof(params));
2949 params.resultString = &result;
2950 params.instance = instance;
2951 params.key = metadata;
2972 } _OrthancPluginRegisterStorageArea;
2994 _OrthancPluginRegisterStorageArea params;
2995 params.create = create;
2997 params.remove = remove;
3000 params.free = ::free;
3005 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, ¶ms);
3024 _OrthancPluginRetrieveDynamicString params;
3025 params.result = &result;
3026 params.argument = NULL;
3054 _OrthancPluginRetrieveDynamicString params;
3055 params.result = &result;
3056 params.argument = NULL;
3089 _OrthancPluginRetrieveDynamicString params;
3090 params.result = &result;
3091 params.argument = NULL;
3109 } _OrthancPluginOnChangeCallback;
3131 _OrthancPluginOnChangeCallback params;
3132 params.callback = callback;
3134 context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, ¶ms);
3142 _OrthancPluginProperty property;
3144 } _OrthancPluginSetPluginProperty;
3162 _OrthancPluginSetPluginProperty params;
3163 params.plugin = OrthancPluginGetName();
3164 params.property = _OrthancPluginProperty_RootUri;
3167 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms);
3182 const char* description)
3184 _OrthancPluginSetPluginProperty params;
3185 params.plugin = OrthancPluginGetName();
3186 params.property = _OrthancPluginProperty_Description;
3187 params.value = description;
3189 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms);
3204 const char* javascript)
3206 _OrthancPluginSetPluginProperty params;
3207 params.plugin = OrthancPluginGetName();
3208 params.property = _OrthancPluginProperty_OrthancExplorer;
3209 params.value = javascript;
3211 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms);
3220 } _OrthancPluginGlobalProperty;
3239 const char* defaultValue)
3243 _OrthancPluginGlobalProperty params;
3244 params.result = &result;
3245 params.property = property;
3246 params.value = defaultValue;
3280 _OrthancPluginGlobalProperty params;
3281 params.result = NULL;
3282 params.property = property;
3283 params.value = value;
3285 return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, ¶ms);
3292 int32_t *resultInt32;
3293 uint32_t *resultUint32;
3294 int64_t *resultInt64;
3295 uint64_t *resultUint64;
3296 } _OrthancPluginReturnSingleValue;
3311 _OrthancPluginReturnSingleValue params;
3312 memset(¶ms, 0,
sizeof(params));
3313 params.resultUint32 = &count;
3346 _OrthancPluginGlobalProperty params;
3347 params.result = &result;
3348 params.property = (int32_t) argument;
3349 params.value = NULL;
3377 _OrthancPluginReturnSingleValue params;
3378 memset(¶ms, 0,
sizeof(params));
3379 params.resultUint32 = &count;
3409 _OrthancPluginRetrieveDynamicString params;
3410 params.result = &result;
3411 params.argument = NULL;
3429 const char* subType;
3430 const char* contentType;
3431 } _OrthancPluginStartMultipartAnswer;
3449 const char* subType,
3450 const char* contentType)
3452 _OrthancPluginStartMultipartAnswer params;
3453 params.output = output;
3454 params.subType = subType;
3455 params.contentType = contentType;
3456 return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, ¶ms);
3479 uint32_t answerSize)
3481 _OrthancPluginAnswerBuffer params;
3482 params.output = output;
3483 params.answer = answer;
3484 params.answerSize = answerSize;
3485 params.mimeType = NULL;
3486 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, ¶ms);
3498 } _OrthancPluginBufferCompression;
3525 _OrthancPluginBufferCompression params;
3526 params.target = target;
3527 params.source = source;
3529 params.compression = compression;
3530 params.uncompress = uncompress;
3532 return context->InvokeService(context, _OrthancPluginService_BufferCompression, ¶ms);
3541 } _OrthancPluginReadFile;
3559 _OrthancPluginReadFile params;
3560 params.target = target;
3562 return context->InvokeService(context, _OrthancPluginService_ReadFile, ¶ms);
3572 } _OrthancPluginWriteFile;
3591 _OrthancPluginWriteFile params;
3595 return context->InvokeService(context, _OrthancPluginService_WriteFile, ¶ms);
3602 const char** target;
3604 } _OrthancPluginGetErrorDescription;
3620 const char* result = NULL;
3622 _OrthancPluginGetErrorDescription params;
3623 params.target = &result;
3624 params.error = error;
3629 return "Unknown error code";
3645 } _OrthancPluginSendHttpStatus;
3676 _OrthancPluginSendHttpStatus params;
3677 params.output = output;
3678 params.status = status;
3680 params.bodySize = bodySize;
3681 context->InvokeService(context, _OrthancPluginService_SendHttpStatus, ¶ms);
3689 uint32_t* resultUint32;
3691 void** resultBuffer;
3692 } _OrthancPluginGetImageInfo;
3711 _OrthancPluginGetImageInfo params;
3712 memset(¶ms, 0,
sizeof(params));
3713 params.image = image;
3714 params.resultPixelFormat = ⌖
3744 _OrthancPluginGetImageInfo params;
3745 memset(¶ms, 0,
sizeof(params));
3746 params.image = image;
3747 params.resultUint32 = &width;
3777 _OrthancPluginGetImageInfo params;
3778 memset(¶ms, 0,
sizeof(params));
3779 params.image = image;
3780 params.resultUint32 = &height;
3812 _OrthancPluginGetImageInfo params;
3813 memset(¶ms, 0,
sizeof(params));
3814 params.image = image;
3815 params.resultUint32 = &pitch;
3844 void* target = NULL;
3846 _OrthancPluginGetImageInfo params;
3847 memset(¶ms, 0,
sizeof(params));
3848 params.resultBuffer = ⌖
3849 params.image = image;
3868 } _OrthancPluginUncompressImage;
3891 _OrthancPluginUncompressImage params;
3892 memset(¶ms, 0,
sizeof(params));
3893 params.target = ⌖
3896 params.format = format;
3914 } _OrthancPluginFreeImage;
3929 _OrthancPluginFreeImage params;
3930 params.image = image;
3932 context->InvokeService(context, _OrthancPluginService_FreeImage, ¶ms);
3948 } _OrthancPluginCompressImage;
3979 _OrthancPluginCompressImage params;
3980 memset(¶ms, 0,
sizeof(params));
3981 params.target = target;
3983 params.pixelFormat = format;
3984 params.width = width;
3985 params.height = height;
3986 params.pitch = pitch;
3987 params.buffer = buffer;
3990 return context->InvokeService(context, _OrthancPluginService_CompressImage, ¶ms);
4025 _OrthancPluginCompressImage params;
4026 memset(¶ms, 0,
sizeof(params));
4027 params.target = target;
4029 params.pixelFormat = format;
4030 params.width = width;
4031 params.height = height;
4032 params.pitch = pitch;
4033 params.buffer = buffer;
4034 params.quality = quality;
4036 return context->InvokeService(context, _OrthancPluginService_CompressImage, ¶ms);
4072 _OrthancPluginCompressAndAnswerImage params;
4073 params.output = output;
4075 params.pixelFormat = format;
4076 params.width = width;
4077 params.height = height;
4078 params.pitch = pitch;
4079 params.buffer = buffer;
4080 params.quality = quality;
4081 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, ¶ms);
4092 const char* username;
4093 const char* password;
4096 } _OrthancPluginCallHttpClient;
4119 const char* username,
4120 const char* password)
4122 _OrthancPluginCallHttpClient params;
4123 memset(¶ms, 0,
sizeof(params));
4125 params.target = target;
4128 params.username = username;
4129 params.password = password;
4131 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
4159 const char* username,
4160 const char* password)
4162 _OrthancPluginCallHttpClient params;
4163 memset(¶ms, 0,
sizeof(params));
4165 params.target = target;
4169 params.bodySize = bodySize;
4170 params.username = username;
4171 params.password = password;
4173 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
4201 const char* username,
4202 const char* password)
4204 _OrthancPluginCallHttpClient params;
4205 memset(¶ms, 0,
sizeof(params));
4207 params.target = target;
4211 params.bodySize = bodySize;
4212 params.username = username;
4213 params.password = password;
4215 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
4236 const char* username,
4237 const char* password)
4239 _OrthancPluginCallHttpClient params;
4240 memset(¶ms, 0,
sizeof(params));
4244 params.username = username;
4245 params.password = password;
4247 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
4257 } _OrthancPluginConvertPixelFormat;
4278 _OrthancPluginConvertPixelFormat params;
4279 params.target = ⌖
4280 params.source = source;
4281 params.targetFormat = targetFormat;
4311 _OrthancPluginReturnSingleValue params;
4312 memset(¶ms, 0,
sizeof(params));
4313 params.resultUint32 = &count;
4334 } _OrthancPluginGetFontInfo;
4350 const char* result = NULL;
4352 _OrthancPluginGetFontInfo params;
4353 memset(¶ms, 0,
sizeof(params));
4354 params.name = &result;
4355 params.fontIndex = fontIndex;
4384 _OrthancPluginGetFontInfo params;
4385 memset(¶ms, 0,
sizeof(params));
4386 params.size = &result;
4387 params.fontIndex = fontIndex;
4405 const char* utf8Text;
4411 } _OrthancPluginDrawText;
4435 const char* utf8Text,
4442 _OrthancPluginDrawText params;
4443 memset(¶ms, 0,
sizeof(params));
4444 params.image = image;
4445 params.fontIndex = fontIndex;
4446 params.utf8Text = utf8Text;
4453 return context->InvokeService(context, _OrthancPluginService_DrawText, ¶ms);
4462 const void* content;
4465 } _OrthancPluginStorageAreaCreate;
4487 const void* content,
4491 _OrthancPluginStorageAreaCreate params;
4492 params.storageArea = storageArea;
4494 params.content = content;
4498 return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, ¶ms);
4508 } _OrthancPluginStorageAreaRead;
4532 _OrthancPluginStorageAreaRead params;
4533 params.target = target;
4534 params.storageArea = storageArea;
4538 return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, ¶ms);
4547 } _OrthancPluginStorageAreaRemove;
4568 _OrthancPluginStorageAreaRemove params;
4569 params.storageArea = storageArea;
4573 return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, ¶ms);
4582 uint16_t httpStatus;
4583 const char* message;
4584 } _OrthancPluginRegisterErrorCode;
4604 uint16_t httpStatus,
4605 const char* message)
4609 _OrthancPluginRegisterErrorCode params;
4610 params.target = ⌖
4612 params.httpStatus = httpStatus;
4613 params.message = message;
4634 uint32_t minMultiplicity;
4635 uint32_t maxMultiplicity;
4636 } _OrthancPluginRegisterDictionaryTag;
4663 uint32_t minMultiplicity,
4664 uint32_t maxMultiplicity)
4666 _OrthancPluginRegisterDictionaryTag params;
4667 params.group = group;
4668 params.element = element;
4671 params.minMultiplicity = minMultiplicity;
4672 params.maxMultiplicity = maxMultiplicity;
4674 return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, ¶ms);
4685 uint32_t minMultiplicity;
4686 uint32_t maxMultiplicity;
4687 const char* privateCreator;
4688 } _OrthancPluginRegisterPrivateDictionaryTag;
4716 uint32_t minMultiplicity,
4717 uint32_t maxMultiplicity,
4718 const char* privateCreator)
4720 _OrthancPluginRegisterPrivateDictionaryTag params;
4721 params.group = group;
4722 params.element = element;
4725 params.minMultiplicity = minMultiplicity;
4726 params.maxMultiplicity = maxMultiplicity;
4727 params.privateCreator = privateCreator;
4729 return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, ¶ms);
4738 } _OrthancPluginReconstructMainDicomTags;
4759 _OrthancPluginReconstructMainDicomTags params;
4760 params.level = level;
4761 params.storageArea = storageArea;
4763 return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, ¶ms);
4770 const char* instanceId;
4775 uint32_t maxStringLength;
4776 } _OrthancPluginDicomToJson;
4804 uint32_t maxStringLength)
4808 _OrthancPluginDicomToJson params;
4809 memset(¶ms, 0,
sizeof(params));
4810 params.result = &result;
4811 params.buffer = buffer;
4813 params.format = format;
4814 params.flags = flags;
4815 params.maxStringLength = maxStringLength;
4849 const char* instanceId,
4852 uint32_t maxStringLength)
4856 _OrthancPluginDicomToJson params;
4857 memset(¶ms, 0,
sizeof(params));
4858 params.result = &result;
4859 params.instanceId = instanceId;
4860 params.format = format;
4861 params.flags = flags;
4862 params.maxStringLength = maxStringLength;
4880 uint32_t headersCount;
4881 const char*
const* headersKeys;
4882 const char*
const* headersValues;
4883 int32_t afterPlugins;
4884 } _OrthancPluginRestApiGet2;
4909 uint32_t headersCount,
4910 const char*
const* headersKeys,
4911 const char*
const* headersValues,
4912 int32_t afterPlugins)
4914 _OrthancPluginRestApiGet2 params;
4915 params.target = target;
4917 params.headersCount = headersCount;
4918 params.headersKeys = headersKeys;
4919 params.headersValues = headersValues;
4920 params.afterPlugins = afterPlugins;
4922 return context->InvokeService(context, _OrthancPluginService_RestApiGet2, ¶ms);
4930 } _OrthancPluginWorklistCallback;
4947 _OrthancPluginWorklistCallback params;
4948 params.callback = callback;
4950 return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, ¶ms);
4961 } _OrthancPluginWorklistAnswersOperation;
4986 _OrthancPluginWorklistAnswersOperation params;
4987 params.answers = answers;
4988 params.query = query;
4989 params.dicom = dicom;
4992 return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, ¶ms);
5013 _OrthancPluginWorklistAnswersOperation params;
5014 params.answers = answers;
5015 params.query = NULL;
5016 params.dicom = NULL;
5019 return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, ¶ms);
5030 } _OrthancPluginWorklistQueryOperation;
5053 int32_t isMatch = 0;
5055 _OrthancPluginWorklistQueryOperation params;
5056 params.query = query;
5057 params.dicom = dicom;
5059 params.isMatch = &isMatch;
5060 params.target = NULL;
5091 _OrthancPluginWorklistQueryOperation params;
5092 params.query = query;
5093 params.dicom = NULL;
5095 params.isMatch = NULL;
5096 params.target = target;
5098 return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, ¶ms);
5118 _OrthancPluginAccessDicomInstance params;
5119 memset(¶ms, 0,
sizeof(params));
5120 params.resultOrigin = &origin;
5121 params.instance = instance;
5141 } _OrthancPluginCreateDicom;
5168 _OrthancPluginCreateDicom params;
5169 params.target = target;
5171 params.pixelData = pixelData;
5172 params.flags = flags;
5174 return context->InvokeService(context, _OrthancPluginService_CreateDicom, ¶ms);
5181 } _OrthancPluginDecodeImageCallback;
5198 _OrthancPluginDecodeImageCallback params;
5199 params.callback = callback;
5201 return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, ¶ms);
5214 const void* constBuffer;
5215 uint32_t bufferSize;
5216 uint32_t frameIndex;
5217 } _OrthancPluginCreateImage;
5240 _OrthancPluginCreateImage params;
5241 memset(¶ms, 0,
sizeof(params));
5242 params.target = ⌖
5243 params.format = format;
5244 params.width = width;
5245 params.height = height;
5285 _OrthancPluginCreateImage params;
5286 memset(¶ms, 0,
sizeof(params));
5287 params.target = ⌖
5288 params.format = format;
5289 params.width = width;
5290 params.height = height;
5291 params.pitch = pitch;
5292 params.buffer = buffer;
5323 uint32_t bufferSize,
5324 uint32_t frameIndex)
5328 _OrthancPluginCreateImage params;
5329 memset(¶ms, 0,
sizeof(params));
5330 params.target = ⌖
5331 params.constBuffer = buffer;
5332 params.bufferSize = bufferSize;
5333 params.frameIndex = frameIndex;
5352 } _OrthancPluginComputeHash;
5373 _OrthancPluginComputeHash params;
5374 params.result = &result;
5375 params.buffer = buffer;
5409 _OrthancPluginComputeHash params;
5410 params.result = &result;
5411 params.buffer = buffer;
5431 } _OrthancPluginLookupDictionary;
5453 _OrthancPluginLookupDictionary params;
5454 params.target = target;
5456 return context->InvokeService(context, _OrthancPluginService_LookupDictionary, ¶ms);
5465 uint32_t answerSize;
5466 uint32_t headersCount;
5467 const char*
const* headersKeys;
5468 const char*
const* headersValues;
5469 } _OrthancPluginSendMultipartItem2;
5495 uint32_t answerSize,
5496 uint32_t headersCount,
5497 const char*
const* headersKeys,
5498 const char*
const* headersValues)
5500 _OrthancPluginSendMultipartItem2 params;
5501 params.output = output;
5502 params.answer = answer;
5503 params.answerSize = answerSize;
5504 params.headersCount = headersCount;
5505 params.headersKeys = headersKeys;
5506 params.headersValues = headersValues;
5508 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, ¶ms);
5515 } _OrthancPluginIncomingHttpRequestFilter;
5533 _OrthancPluginIncomingHttpRequestFilter params;
5534 params.callback = callback;
5536 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, ¶ms);
5545 uint16_t* httpStatus;
5548 uint32_t headersCount;
5549 const char*
const* headersKeys;
5550 const char*
const* headersValues;
5553 const char* username;
5554 const char* password;
5556 const char* certificateFile;
5557 const char* certificateKeyFile;
5558 const char* certificateKeyPassword;
5560 } _OrthancPluginCallHttpClient2;
5607 uint16_t* httpStatus,
5610 uint32_t headersCount,
5611 const char*
const* headersKeys,
5612 const char*
const* headersValues,
5615 const char* username,
5616 const char* password,
5618 const char* certificateFile,
5619 const char* certificateKeyFile,
5620 const char* certificateKeyPassword,
5623 _OrthancPluginCallHttpClient2 params;
5624 memset(¶ms, 0,
sizeof(params));
5626 params.answerBody = answerBody;
5627 params.answerHeaders = answerHeaders;
5628 params.httpStatus = httpStatus;
5629 params.method = method;
5631 params.headersCount = headersCount;
5632 params.headersKeys = headersKeys;
5633 params.headersValues = headersValues;
5635 params.bodySize = bodySize;
5636 params.username = username;
5637 params.password = password;
5638 params.timeout = timeout;
5639 params.certificateFile = certificateFile;
5640 params.certificateKeyFile = certificateKeyFile;
5641 params.certificateKeyPassword = certificateKeyPassword;
5642 params.pkcs11 = pkcs11;
5644 return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, ¶ms);
5663 _OrthancPluginRetrieveDynamicString params;
5664 params.result = &result;
5665 params.argument = NULL;
5684 } _OrthancPluginFindCallback;
5701 _OrthancPluginFindCallback params;
5702 params.callback = callback;
5704 return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, ¶ms);
5715 uint32_t *resultUint32;
5716 uint16_t *resultGroup;
5717 uint16_t *resultElement;
5718 char **resultString;
5719 } _OrthancPluginFindOperation;
5742 _OrthancPluginFindOperation params;
5743 memset(¶ms, 0,
sizeof(params));
5744 params.answers = answers;
5745 params.dicom = dicom;
5748 return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, ¶ms);
5769 _OrthancPluginFindOperation params;
5770 memset(¶ms, 0,
sizeof(params));
5771 params.answers = answers;
5773 return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, ¶ms);
5795 _OrthancPluginFindOperation params;
5796 memset(¶ms, 0,
sizeof(params));
5797 params.query = query;
5798 params.resultUint32 = &count;
5833 _OrthancPluginFindOperation params;
5834 memset(¶ms, 0,
sizeof(params));
5835 params.query = query;
5836 params.index = index;
5837 params.resultGroup = group;
5838 params.resultElement = element;
5840 return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, ¶ms);
5864 _OrthancPluginFindOperation params;
5865 memset(¶ms, 0,
sizeof(params));
5866 params.query = query;
5867 params.index = index;
5868 params.resultString = &result;
5902 _OrthancPluginFindOperation params;
5903 memset(¶ms, 0,
sizeof(params));
5904 params.query = query;
5905 params.index = index;
5906 params.resultString = &result;
5928 } _OrthancPluginMoveCallback;
5950 _OrthancPluginMoveCallback params;
5951 params.callback = callback;
5952 params.getMoveSize = getMoveSize;
5953 params.applyMove = applyMove;
5954 params.freeMove = freeMove;
5956 return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, ¶ms);
5966 } _OrthancPluginCreateFindMatcher;
5989 _OrthancPluginCreateFindMatcher params;
5990 memset(¶ms, 0,
sizeof(params));
5991 params.target = ⌖
5992 params.query = query;
6009 } _OrthancPluginFreeFindMatcher;
6024 _OrthancPluginFreeFindMatcher params;
6025 params.matcher = matcher;
6027 context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, ¶ms);
6037 } _OrthancPluginFindMatcherIsMatch;
6059 int32_t isMatch = 0;
6061 _OrthancPluginFindMatcherIsMatch params;
6062 params.matcher = matcher;
6063 params.dicom = dicom;
6065 params.isMatch = &isMatch;
6082 } _OrthancPluginIncomingHttpRequestFilter2;
6099 _OrthancPluginIncomingHttpRequestFilter2 params;
6100 params.callback = callback;
6102 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, ¶ms);
6110 } _OrthancPluginGetPeers;
6128 _OrthancPluginGetPeers params;
6129 memset(¶ms, 0,
sizeof(params));
6130 params.peers = &peers;
6146 } _OrthancPluginFreePeers;
6161 _OrthancPluginFreePeers params;
6162 params.peers = peers;
6164 context->InvokeService(context, _OrthancPluginService_FreePeers, ¶ms);
6172 } _OrthancPluginGetPeersCount;
6191 uint32_t target = 0;
6193 _OrthancPluginGetPeersCount params;
6194 memset(¶ms, 0,
sizeof(params));
6195 params.target = ⌖
6196 params.peers = peers;
6212 const char** target;
6215 const char* userProperty;
6216 } _OrthancPluginGetPeerProperty;
6240 const char* target = NULL;
6242 _OrthancPluginGetPeerProperty params;
6243 memset(¶ms, 0,
sizeof(params));
6244 params.target = ⌖
6245 params.peers = peers;
6246 params.peerIndex = peerIndex;
6247 params.userProperty = NULL;
6281 const char* target = NULL;
6283 _OrthancPluginGetPeerProperty params;
6284 memset(¶ms, 0,
sizeof(params));
6285 params.target = ⌖
6286 params.peers = peers;
6287 params.peerIndex = peerIndex;
6288 params.userProperty = NULL;
6326 const char* userProperty)
6328 const char* target = NULL;
6330 _OrthancPluginGetPeerProperty params;
6331 memset(¶ms, 0,
sizeof(params));
6332 params.target = ⌖
6333 params.peers = peers;
6334 params.peerIndex = peerIndex;
6335 params.userProperty = userProperty;
6354 uint16_t* httpStatus;
6359 uint32_t additionalHeadersCount;
6360 const char*
const* additionalHeadersKeys;
6361 const char*
const* additionalHeadersValues;
6365 } _OrthancPluginCallPeerApi;
6406 uint16_t* httpStatus,
6411 uint32_t additionalHeadersCount,
6412 const char*
const* additionalHeadersKeys,
6413 const char*
const* additionalHeadersValues,
6418 _OrthancPluginCallPeerApi params;
6419 memset(¶ms, 0,
sizeof(params));
6421 params.answerBody = answerBody;
6422 params.answerHeaders = answerHeaders;
6423 params.httpStatus = httpStatus;
6424 params.peers = peers;
6425 params.peerIndex = peerIndex;
6426 params.method = method;
6428 params.additionalHeadersCount = additionalHeadersCount;
6429 params.additionalHeadersKeys = additionalHeadersKeys;
6430 params.additionalHeadersValues = additionalHeadersValues;
6432 params.bodySize = bodySize;
6433 params.timeout = timeout;
6435 return context->InvokeService(context, _OrthancPluginService_CallPeerApi, ¶ms);
6454 } _OrthancPluginCreateJob;
6501 _OrthancPluginCreateJob params;
6502 memset(¶ms, 0,
sizeof(params));
6504 params.target = ⌖
6506 params.finalize = finalize;
6508 params.getProgress = getProgress;
6509 params.getContent = getContent;
6510 params.getSerialized = getSerialized;
6513 params.reset = reset;
6531 } _OrthancPluginFreeJob;
6546 _OrthancPluginFreeJob params;
6549 context->InvokeService(context, _OrthancPluginService_FreeJob, ¶ms);
6559 } _OrthancPluginSubmitJob;
6579 char* resultId = NULL;
6581 _OrthancPluginSubmitJob params;
6582 memset(¶ms, 0,
sizeof(params));
6584 params.resultId = &resultId;
6586 params.priority = priority;
6605 } _OrthancPluginJobsUnserializer;
6623 _OrthancPluginJobsUnserializer params;
6624 params.unserializer = unserializer;
6626 context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, ¶ms);
6634 const char* details;
6636 } _OrthancPluginSetHttpErrorDetails;
6658 const char* details,
6661 _OrthancPluginSetHttpErrorDetails params;
6662 params.output = output;
6663 params.details = details;
6665 context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, ¶ms);
6672 const char** result;
6673 const char* argument;
6674 } _OrthancPluginRetrieveStaticString;
6691 const char* result = NULL;
6693 _OrthancPluginRetrieveStaticString params;
6694 params.result = &result;
6695 params.argument = path;
6715 } _OrthancPluginSetMetricsValue;
6737 _OrthancPluginSetMetricsValue params;
6739 params.value = value;
6741 context->InvokeService(context, _OrthancPluginService_SetMetricsValue, ¶ms);
6749 } _OrthancPluginRegisterRefreshMetricsCallback;
6765 _OrthancPluginRegisterRefreshMetricsCallback params;
6766 params.callback = callback;
6767 context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, ¶ms);
6779 } _OrthancPluginEncodeDicomWeb;
6802 char* target = NULL;
6804 _OrthancPluginEncodeDicomWeb params;
6805 params.target = ⌖
6806 params.dicom = dicom;
6807 params.dicomSize = dicomSize;
6808 params.callback = callback;
6843 char* target = NULL;
6845 _OrthancPluginEncodeDicomWeb params;
6846 params.target = ⌖
6847 params.dicom = dicom;
6848 params.dicomSize = dicomSize;
6849 params.callback = callback;
6953 typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (
void* request);
6977 uint16_t* httpStatus;
6980 uint32_t headersCount;
6981 const char*
const* headersKeys;
6982 const char*
const* headersValues;
6988 const char* username;
6989 const char* password;
6991 const char* certificateFile;
6992 const char* certificateKeyFile;
6993 const char* certificateKeyPassword;
6995 } _OrthancPluginChunkedHttpClient;
7053 uint16_t* httpStatus,
7056 uint32_t headersCount,
7057 const char*
const* headersKeys,
7058 const char*
const* headersValues,
7064 const char* username,
7065 const char* password,
7067 const char* certificateFile,
7068 const char* certificateKeyFile,
7069 const char* certificateKeyPassword,
7072 _OrthancPluginChunkedHttpClient params;
7073 memset(¶ms, 0,
sizeof(params));
7076 params.httpStatus = httpStatus;
7077 params.method = method;
7079 params.headersCount = headersCount;
7080 params.headersKeys = headersKeys;
7081 params.headersValues = headersValues;
7082 params.username = username;
7083 params.password = password;
7084 params.timeout = timeout;
7085 params.certificateFile = certificateFile;
7086 params.certificateKeyFile = certificateKeyFile;
7087 params.certificateKeyPassword = certificateKeyPassword;
7088 params.pkcs11 = pkcs11;
7091 params.answer = answer;
7092 params.answerAddChunk = answerAddChunk;
7093 params.answerAddHeader = answerAddHeader;
7094 params.request = request;
7095 params.requestIsDone = requestIsDone;
7096 params.requestChunkData = requestChunkData;
7097 params.requestChunkSize = requestChunkSize;
7098 params.requestNext = requestNext;
7100 return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, ¶ms);
7190 const char* pathRegularExpression;
7198 } _OrthancPluginChunkedRestCallback;
7232 const char* pathRegularExpression,
7241 _OrthancPluginChunkedRestCallback params;
7242 params.pathRegularExpression = pathRegularExpression;
7243 params.getHandler = getHandler;
7244 params.postHandler = postHandler;
7245 params.deleteHandler = deleteHandler;
7246 params.putHandler = putHandler;
7247 params.addChunk = addChunk;
7248 params.execute = execute;
7249 params.finalize = finalize;
7251 context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, ¶ms);
7263 const char* privateCreator;
7264 } _OrthancPluginGetTagName;
7285 const char* privateCreator)
7289 _OrthancPluginGetTagName params;
7290 params.result = &result;
7291 params.group = group;
7292 params.element = element;
7293 params.privateCreator = privateCreator;
7339 const char* transactionUid,
7340 const char*
const* sopClassUids,
7341 const char*
const* sopInstanceUids,
7342 uint32_t countInstances,
7343 const char* remoteAet,
7344 const char* calledAet);
7382 const char* sopClassUid,
7383 const char* sopInstanceUid);
7391 } _OrthancPluginRegisterStorageCommitmentScpCallback;
7412 _OrthancPluginRegisterStorageCommitmentScpCallback params;
7413 params.factory = factory;
7414 params.destructor = destructor;
7415 params.lookup = lookup;
7416 return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, ¶ms);
7443 } _OrthancPluginIncomingDicomInstanceFilter;
7461 _OrthancPluginIncomingDicomInstanceFilter params;
7462 params.callback = callback;
7464 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, ¶ms);
7487 _OrthancPluginAccessDicomInstance params;
7488 memset(¶ms, 0,
sizeof(params));
7489 params.resultStringToFree = &result;
7490 params.instance = instance;
7520 int64_t hasPixelData;
7522 _OrthancPluginAccessDicomInstance params;
7523 memset(¶ms, 0,
sizeof(params));
7524 params.resultInt64 = &hasPixelData;
7525 params.instance = instance;
7536 return hasPixelData;
Definition: OrthancCPlugin.h:706
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4268
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1389
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1780
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2750
Definition: OrthancCPlugin.h:731
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:1951
Definition: OrthancCPlugin.h:714
void OrthancPluginSendHttpStatus(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status, const char *body, uint32_t bodySize)
Send a HTTP status, with a custom body.
Definition: OrthancCPlugin.h:3666
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5733
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:1983
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:617
Definition: OrthancCPlugin.h:711
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2245
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2717
OrthancPluginErrorCode OrthancPluginRestApiPutAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a PUT call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2329
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:7513
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:651
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:643
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5229
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2500
Definition: OrthancCPlugin.h:713
void OrthancPluginCompressAndAnswerJpegImage(OrthancPluginContext *context, OrthancPluginRestOutput *output, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, const void *buffer, uint8_t quality)
Answer to a REST request with a JPEG image.
Definition: OrthancCPlugin.h:4059
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:742
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4522
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5191
OrthancPluginErrorCode OrthancPluginRestApiPostAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a POST call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2216
Definition: OrthancCPlugin.h:702
const char * OrthancPluginGetInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Get the value of some metadata associated with a given DICOM instance.
Definition: OrthancCPlugin.h:2937
The parameters of a REST request.
Definition: OrthancCPlugin.h:336
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3735
Definition: OrthancCPlugin.h:704
OrthancPluginErrorCode(* OrthancPluginWorklistCallback)(OrthancPluginWorklistAnswers *answers, const OrthancPluginWorklistQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle the C-Find SCP requests for worklists.
Definition: OrthancCPlugin.h:1236
Definition: OrthancCPlugin.h:716
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3803
OrthancPluginErrorCode OrthancPluginRegisterStorageCommitmentScpCallback(OrthancPluginContext *context, OrthancPluginStorageCommitmentFactory factory, OrthancPluginStorageCommitmentDestructor destructor, OrthancPluginStorageCommitmentLookup lookup)
Register a callback to handle incoming requests to the storage commitment SCP.
Definition: OrthancCPlugin.h:7403
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1100
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4751
OrthancPluginErrorCode OrthancPluginGetFindQueryTag(OrthancPluginContext *context, uint16_t *group, uint16_t *element, const OrthancPluginFindQuery *query, uint32_t index)
Get one tag in a C-Find query.
Definition: OrthancCPlugin.h:5823
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:727
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5526
OrthancPluginErrorCode OrthancPluginCompressPngImage(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, const void *buffer)
Encode a PNG image.
Definition: OrthancCPlugin.h:3967
Definition: OrthancCPlugin.h:705
OrthancPluginErrorCode OrthancPluginDrawText(OrthancPluginContext *context, OrthancPluginImage *image, uint32_t fontIndex, const char *utf8Text, int32_t x, int32_t y, uint8_t r, uint8_t g, uint8_t b)
Draw text on an image.
Definition: OrthancCPlugin.h:4428
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition: OrthancCPlugin.h:7478
OrthancPluginErrorCode OrthancPluginWorklistAddAnswer(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Add one answer to some modality worklist request.
Definition: OrthancCPlugin.h:4976
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:585
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:1027
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2580
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2268
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1567
Definition: OrthancCPlugin.h:619
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6092
OrthancPluginErrorCode OrthancPluginRestApiGet2(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, int32_t afterPlugins)
Make a GET call to the Orthanc REST API, with custom HTTP headers.
Definition: OrthancCPlugin.h:4902
OrthancPluginErrorCode(* OrthancPluginOnChangeCallback)(OrthancPluginChangeType changeType, OrthancPluginResourceType resourceType, const char *resourceId)
Signature of a callback function that is triggered when a change happens to some DICOM resource.
Definition: OrthancCPlugin.h:1121
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2465
Definition: OrthancCPlugin.h:730
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1035
Definition: OrthancCPlugin.h:745
void(* OrthancPluginDicomWebSetBinaryNode)(OrthancPluginDicomWebNode *node, OrthancPluginDicomWebBinaryMode mode, const char *bulkDataUri)
Signature of a function to set the content of a node encoding a binary DICOM tag, into a JSON or XML ...
Definition: OrthancCPlugin.h:1154
OrthancPluginErrorCode(* OrthancPluginOnStoredInstanceCallback)(const OrthancPluginDicomInstance *instance, const char *instanceId)
Signature of a callback function that is triggered when Orthanc stores a new DICOM instance.
Definition: OrthancCPlugin.h:1111
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2114
Definition: OrthancCPlugin.h:729
Color image in RGB48 format.
Definition: OrthancCPlugin.h:627
void OrthancPluginCompressAndAnswerPngImage(OrthancPluginContext *context, OrthancPluginRestOutput *output, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, const void *buffer)
Answer to a REST request with a PNG image.
Definition: OrthancCPlugin.h:2040
Definition: OrthancCPlugin.h:710
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1173
OrthancPluginErrorCode OrthancPluginSendMultipartItem(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize)
Send an item as a part of some HTTP multipart answer.
Definition: OrthancCPlugin.h:3472
Definition: OrthancCPlugin.h:732
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3443
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:2857
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:3837
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1217
OrthancPluginErrorCode OrthancPluginRestApiPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a PUT call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2293
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4303
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instance.
Definition: OrthancCPlugin.h:7454
Definition: OrthancCPlugin.h:709
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2819
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3369
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3124
Definition: OrthancCPlugin.h:712
Definition: OrthancCPlugin.h:707
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:4940
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4375
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3272
OrthancPluginErrorCode(* OrthancPluginDecodeImageCallback)(OrthancPluginImage **target, const void *dicom, const uint32_t size, uint32_t frameIndex)
Signature of a callback function to decode a DICOM instance as an image.
Definition: OrthancCPlugin.h:1132
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:1883
Definition: OrthancCPlugin.h:703
void *(* OrthancPluginMoveCallback)(OrthancPluginResourceType resourceType, const char *patientId, const char *accessionNumber, const char *studyInstanceUid, const char *seriesInstanceUid, const char *sopInstanceUid, const char *originatorAet, const char *sourceAet, const char *targetAet, uint16_t originatorId)
Callback to handle incoming C-Move SCP requests.
Definition: OrthancCPlugin.h:1364
Definition: OrthancCPlugin.h:746
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3233
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:3768
Color image in RGB24 format.
Definition: OrthancCPlugin.h:609
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1059
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:989
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:601
OrthancPluginErrorCode OrthancPluginCompressJpegImage(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, const void *buffer, uint8_t quality)
Encode a JPEG image.
Definition: OrthancCPlugin.h:4012
OrthancPluginErrorCode OrthancPluginStorageAreaCreate(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, const void *content, uint64_t size, OrthancPluginContentType type)
Create a file inside the storage area.
Definition: OrthancCPlugin.h:4480
OrthancPluginErrorCode(* OrthancPluginStorageCommitmentLookup)(OrthancPluginStorageCommitmentFailureReason *target, void *handler, const char *sopClassUid, const char *sopInstanceUid)
Callback to get the status of one DICOM instance in the storage commitment SCP.
Definition: OrthancCPlugin.h:7376
void OrthancPluginRegisterChunkedRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback getHandler, OrthancPluginServerChunkedRequestReaderFactory postHandler, OrthancPluginRestCallback deleteHandler, OrthancPluginServerChunkedRequestReaderFactory putHandler, OrthancPluginServerChunkedRequestReaderAddChunk addChunk, OrthancPluginServerChunkedRequestReaderExecute execute, OrthancPluginServerChunkedRequestReaderFinalize finalize)
Register a REST callback to handle chunked HTTP transfers.
Definition: OrthancCPlugin.h:7227
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:5940
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6616
Definition: OrthancCPlugin.h:717
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:659
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3702
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1144
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2363
char * OrthancPluginGetFindQueryTagName(OrthancPluginContext *context, const OrthancPluginFindQuery *query, uint32_t index)
Get the symbolic name of one tag in a C-Find query.
Definition: OrthancCPlugin.h:5854
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5006
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1199
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1549
Definition: OrthancCPlugin.h:715
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:984
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1043
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5694
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1019
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5109
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1321
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:3922
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1418
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4343
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2656
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1404
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:635
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:6758
Definition: OrthancCPlugin.h:708
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1626
OrthancPluginImage * OrthancPluginCreateImageAccessor(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, void *buffer)
Create an image pointing to a memory buffer.
Definition: OrthancCPlugin.h:5272
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2395
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2535
OrthancPluginChangeType
Definition: OrthancCPlugin.h:700
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:3880
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:1923
int OrthancPluginCheckVersionAdvanced(OrthancPluginContext *context, int expectedMajor, int expectedMinor, int expectedRevision)
Check that the version of the hosting Orthanc is above a given version.
Definition: OrthancCPlugin.h:1675
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:5044
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:994
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4559
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5786
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:5762
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1051
void(* OrthancPluginDicomWebBinaryCallback)(OrthancPluginDicomWebNode *node, OrthancPluginDicomWebSetBinaryNode setter, uint32_t levelDepth, const uint16_t *levelTagGroup, const uint16_t *levelTagElement, const uint32_t *levelIndex, uint16_t tagGroup, uint16_t tagElement, OrthancPluginValueRepresentation vr)
Callback executed to encode a binary tag in DICOMweb.
Definition: OrthancCPlugin.h:1595
OrthancPluginErrorCode OrthancPluginBufferCompression(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const void *source, uint32_t size, OrthancPluginCompressionType compression, uint8_t uncompress)
Compress or decompress a buffer.
Definition: OrthancCPlugin.h:3514
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2783
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2081
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5083
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:6652
OrthancPluginErrorCode OrthancPluginRestApiPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a POST call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2181
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:2985
OrthancPluginErrorCode(* OrthancPluginStorageCommitmentFactory)(void **handler, const char *jobId, const char *transactionUid, const char *const *sopClassUids, const char *const *sopInstanceUids, uint32_t countInstances, const char *remoteAet, const char *calledAet)
Callback executed by the storage commitment SCP.
Definition: OrthancCPlugin.h:7333
OrthancPluginErrorCode OrthancPluginRestApiGetAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2144
OrthancPluginErrorCode OrthancPluginSendMultipartItem2(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues)
Send an item as a part of some HTTP multipart answer, with custom headers.
Definition: OrthancCPlugin.h:5488
char * OrthancPluginGetFindQueryValue(OrthancPluginContext *context, const OrthancPluginFindQuery *query, uint32_t index)
Get the value associated with one tag in a C-Find query.
Definition: OrthancCPlugin.h:5892
Definition: OrthancCPlugin.h:744
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:577
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2603
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:593
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2626
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7355
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2681
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2430
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:2896
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5317