113 # define ORTHANC_PLUGINS_API __declspec(dllexport)
115 # define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default")))
117 # define ORTHANC_PLUGINS_API
120 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
121 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 10
122 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 0
125 #if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
126 #define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
127 (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
128 (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
129 (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
130 (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
131 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
150 #ifndef ORTHANC_PLUGIN_INLINE
151 # if __STDC_VERSION__ >= 199901L
153 # define ORTHANC_PLUGIN_INLINE static inline
154 # elif defined(__cplusplus)
156 # define ORTHANC_PLUGIN_INLINE static inline
157 # elif defined(__GNUC__)
159 # define ORTHANC_PLUGIN_INLINE static __inline
160 # elif defined(_MSC_VER)
162 # define ORTHANC_PLUGIN_INLINE static __inline
164 # error Your compiler is not known to support the "inline" keyword
309 _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
317 ORTHANC_PLUGINS_API
const char* OrthancPluginGetName();
330 _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
406 _OrthancPluginService_LogInfo = 1,
407 _OrthancPluginService_LogWarning = 2,
408 _OrthancPluginService_LogError = 3,
409 _OrthancPluginService_GetOrthancPath = 4,
410 _OrthancPluginService_GetOrthancDirectory = 5,
411 _OrthancPluginService_GetConfigurationPath = 6,
412 _OrthancPluginService_SetPluginProperty = 7,
413 _OrthancPluginService_GetGlobalProperty = 8,
414 _OrthancPluginService_SetGlobalProperty = 9,
415 _OrthancPluginService_GetCommandLineArgumentsCount = 10,
416 _OrthancPluginService_GetCommandLineArgument = 11,
417 _OrthancPluginService_GetExpectedDatabaseVersion = 12,
418 _OrthancPluginService_GetConfiguration = 13,
419 _OrthancPluginService_BufferCompression = 14,
420 _OrthancPluginService_ReadFile = 15,
421 _OrthancPluginService_WriteFile = 16,
422 _OrthancPluginService_GetErrorDescription = 17,
423 _OrthancPluginService_CallHttpClient = 18,
424 _OrthancPluginService_RegisterErrorCode = 19,
425 _OrthancPluginService_RegisterDictionaryTag = 20,
426 _OrthancPluginService_DicomBufferToJson = 21,
427 _OrthancPluginService_DicomInstanceToJson = 22,
428 _OrthancPluginService_CreateDicom = 23,
429 _OrthancPluginService_ComputeMd5 = 24,
430 _OrthancPluginService_ComputeSha1 = 25,
431 _OrthancPluginService_LookupDictionary = 26,
432 _OrthancPluginService_CallHttpClient2 = 27,
433 _OrthancPluginService_GenerateUuid = 28,
434 _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
435 _OrthancPluginService_AutodetectMimeType = 30,
436 _OrthancPluginService_SetMetricsValue = 31,
437 _OrthancPluginService_EncodeDicomWebJson = 32,
438 _OrthancPluginService_EncodeDicomWebXml = 33,
439 _OrthancPluginService_ChunkedHttpClient = 34,
440 _OrthancPluginService_GetTagName = 35,
441 _OrthancPluginService_EncodeDicomWebJson2 = 36,
442 _OrthancPluginService_EncodeDicomWebXml2 = 37,
443 _OrthancPluginService_CreateMemoryBuffer = 38,
444 _OrthancPluginService_GenerateRestApiAuthorizationToken = 39,
445 _OrthancPluginService_CreateMemoryBuffer64 = 40,
446 _OrthancPluginService_CreateDicom2 = 41,
449 _OrthancPluginService_RegisterRestCallback = 1000,
450 _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
451 _OrthancPluginService_RegisterStorageArea = 1002,
452 _OrthancPluginService_RegisterOnChangeCallback = 1003,
453 _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
454 _OrthancPluginService_RegisterWorklistCallback = 1005,
455 _OrthancPluginService_RegisterDecodeImageCallback = 1006,
456 _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
457 _OrthancPluginService_RegisterFindCallback = 1008,
458 _OrthancPluginService_RegisterMoveCallback = 1009,
459 _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
460 _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
461 _OrthancPluginService_RegisterChunkedRestCallback = 1012,
462 _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
463 _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
464 _OrthancPluginService_RegisterTranscoderCallback = 1015,
465 _OrthancPluginService_RegisterStorageArea2 = 1016,
466 _OrthancPluginService_RegisterIncomingCStoreInstanceFilter = 1017,
467 _OrthancPluginService_RegisterReceivedInstanceCallback = 1018,
470 _OrthancPluginService_AnswerBuffer = 2000,
471 _OrthancPluginService_CompressAndAnswerPngImage = 2001,
472 _OrthancPluginService_Redirect = 2002,
473 _OrthancPluginService_SendHttpStatusCode = 2003,
474 _OrthancPluginService_SendUnauthorized = 2004,
475 _OrthancPluginService_SendMethodNotAllowed = 2005,
476 _OrthancPluginService_SetCookie = 2006,
477 _OrthancPluginService_SetHttpHeader = 2007,
478 _OrthancPluginService_StartMultipartAnswer = 2008,
479 _OrthancPluginService_SendMultipartItem = 2009,
480 _OrthancPluginService_SendHttpStatus = 2010,
481 _OrthancPluginService_CompressAndAnswerImage = 2011,
482 _OrthancPluginService_SendMultipartItem2 = 2012,
483 _OrthancPluginService_SetHttpErrorDetails = 2013,
486 _OrthancPluginService_GetDicomForInstance = 3000,
487 _OrthancPluginService_RestApiGet = 3001,
488 _OrthancPluginService_RestApiPost = 3002,
489 _OrthancPluginService_RestApiDelete = 3003,
490 _OrthancPluginService_RestApiPut = 3004,
491 _OrthancPluginService_LookupPatient = 3005,
492 _OrthancPluginService_LookupStudy = 3006,
493 _OrthancPluginService_LookupSeries = 3007,
494 _OrthancPluginService_LookupInstance = 3008,
495 _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
496 _OrthancPluginService_RestApiGetAfterPlugins = 3010,
497 _OrthancPluginService_RestApiPostAfterPlugins = 3011,
498 _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
499 _OrthancPluginService_RestApiPutAfterPlugins = 3013,
500 _OrthancPluginService_ReconstructMainDicomTags = 3014,
501 _OrthancPluginService_RestApiGet2 = 3015,
502 _OrthancPluginService_CallRestApi = 3016,
505 _OrthancPluginService_GetInstanceRemoteAet = 4000,
506 _OrthancPluginService_GetInstanceSize = 4001,
507 _OrthancPluginService_GetInstanceData = 4002,
508 _OrthancPluginService_GetInstanceJson = 4003,
509 _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
510 _OrthancPluginService_HasInstanceMetadata = 4005,
511 _OrthancPluginService_GetInstanceMetadata = 4006,
512 _OrthancPluginService_GetInstanceOrigin = 4007,
513 _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
514 _OrthancPluginService_HasInstancePixelData = 4009,
515 _OrthancPluginService_CreateDicomInstance = 4010,
516 _OrthancPluginService_FreeDicomInstance = 4011,
517 _OrthancPluginService_GetInstanceFramesCount = 4012,
518 _OrthancPluginService_GetInstanceRawFrame = 4013,
519 _OrthancPluginService_GetInstanceDecodedFrame = 4014,
520 _OrthancPluginService_TranscodeDicomInstance = 4015,
521 _OrthancPluginService_SerializeDicomInstance = 4016,
522 _OrthancPluginService_GetInstanceAdvancedJson = 4017,
523 _OrthancPluginService_GetInstanceDicomWebJson = 4018,
524 _OrthancPluginService_GetInstanceDicomWebXml = 4019,
527 _OrthancPluginService_RegisterDatabaseBackend = 5000,
528 _OrthancPluginService_DatabaseAnswer = 5001,
529 _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
530 _OrthancPluginService_StorageAreaCreate = 5003,
531 _OrthancPluginService_StorageAreaRead = 5004,
532 _OrthancPluginService_StorageAreaRemove = 5005,
533 _OrthancPluginService_RegisterDatabaseBackendV3 = 5006,
536 _OrthancPluginService_GetImagePixelFormat = 6000,
537 _OrthancPluginService_GetImageWidth = 6001,
538 _OrthancPluginService_GetImageHeight = 6002,
539 _OrthancPluginService_GetImagePitch = 6003,
540 _OrthancPluginService_GetImageBuffer = 6004,
541 _OrthancPluginService_UncompressImage = 6005,
542 _OrthancPluginService_FreeImage = 6006,
543 _OrthancPluginService_CompressImage = 6007,
544 _OrthancPluginService_ConvertPixelFormat = 6008,
545 _OrthancPluginService_GetFontsCount = 6009,
546 _OrthancPluginService_GetFontInfo = 6010,
547 _OrthancPluginService_DrawText = 6011,
548 _OrthancPluginService_CreateImage = 6012,
549 _OrthancPluginService_CreateImageAccessor = 6013,
550 _OrthancPluginService_DecodeDicomImage = 6014,
553 _OrthancPluginService_WorklistAddAnswer = 7000,
554 _OrthancPluginService_WorklistMarkIncomplete = 7001,
555 _OrthancPluginService_WorklistIsMatch = 7002,
556 _OrthancPluginService_WorklistGetDicomQuery = 7003,
557 _OrthancPluginService_FindAddAnswer = 7004,
558 _OrthancPluginService_FindMarkIncomplete = 7005,
559 _OrthancPluginService_GetFindQuerySize = 7006,
560 _OrthancPluginService_GetFindQueryTag = 7007,
561 _OrthancPluginService_GetFindQueryTagName = 7008,
562 _OrthancPluginService_GetFindQueryValue = 7009,
563 _OrthancPluginService_CreateFindMatcher = 7010,
564 _OrthancPluginService_FreeFindMatcher = 7011,
565 _OrthancPluginService_FindMatcherIsMatch = 7012,
568 _OrthancPluginService_GetPeers = 8000,
569 _OrthancPluginService_FreePeers = 8001,
570 _OrthancPluginService_GetPeersCount = 8003,
571 _OrthancPluginService_GetPeerName = 8004,
572 _OrthancPluginService_GetPeerUrl = 8005,
573 _OrthancPluginService_CallPeerApi = 8006,
574 _OrthancPluginService_GetPeerUserProperty = 8007,
577 _OrthancPluginService_CreateJob = 9000,
578 _OrthancPluginService_FreeJob = 9001,
579 _OrthancPluginService_SubmitJob = 9002,
580 _OrthancPluginService_RegisterJobsUnserializer = 9003,
582 _OrthancPluginService_INTERNAL = 0x7fffffff
583 } _OrthancPluginService;
588 _OrthancPluginProperty_Description = 1,
589 _OrthancPluginProperty_RootUri = 2,
590 _OrthancPluginProperty_OrthancExplorer = 3,
592 _OrthancPluginProperty_INTERNAL = 0x7fffffff
593 } _OrthancPluginProperty;
685 _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
700 _OrthancPluginContentType_INTERNAL = 0x7fffffff
716 _OrthancPluginResourceType_INTERNAL = 0x7fffffff
747 _OrthancPluginChangeType_INTERNAL = 0x7fffffff
762 _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
776 _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
814 _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
829 _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
840 OrthancPluginDicomToJsonFlags_None = 0,
850 _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
861 OrthancPluginCreateDicomFlags_None = 0,
865 _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
881 _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
897 _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
913 _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
1016 _OrthancPluginReceivedInstanceAction_INTERNAL = 0x7fffffff
1179 const char* instanceId);
1190 const char* resourceId);
1201 const uint32_t size,
1202 uint32_t frameIndex);
1223 const char* bulkDataUri);
1241 const void* content,
1313 uint64_t rangeStart);
1349 const char* issuerAet,
1350 const char* calledAet);
1381 uint32_t headersCount,
1382 const char*
const* headersKeys,
1383 const char*
const* headersValues);
1416 uint32_t headersCount,
1417 const char*
const* headersKeys,
1418 const char*
const* headersValues,
1419 uint32_t getArgumentsCount,
1420 const char*
const* getArgumentsKeys,
1421 const char*
const* getArgumentsValues);
1442 const char* issuerAet,
1443 const char* calledAet);
1482 typedef void* (*OrthancPluginMoveCallback) (
1484 const char* patientId,
1485 const char* accessionNumber,
1486 const char* studyInstanceUid,
1487 const char* seriesInstanceUid,
1488 const char* sopInstanceUid,
1489 const char* originatorAet,
1490 const char* sourceAet,
1491 const char* targetAet,
1492 uint16_t originatorId);
1577 typedef const char* (*OrthancPluginJobGetContent) (
void* job);
1595 typedef const char* (*OrthancPluginJobGetSerialized) (
void* job);
1668 const char* serialized);
1716 uint32_t levelDepth,
1717 const uint16_t* levelTagGroup,
1718 const uint16_t* levelTagElement,
1719 const uint32_t* levelIndex,
1721 uint16_t tagElement,
1754 uint32_t levelDepth,
1755 const uint16_t* levelTagGroup,
1756 const uint16_t* levelTagElement,
1757 const uint32_t* levelIndex,
1759 uint16_t tagElement,
1768 typedef struct _OrthancPluginContext_t
1770 void* pluginsManager;
1771 const char* orthancVersion;
1774 _OrthancPluginService service,
1775 const void* params);
1836 int expectedRevision)
1838 int major, minor, revision;
1842 sizeof(int32_t) !=
sizeof(_OrthancPluginService) ||
1843 sizeof(int32_t) !=
sizeof(_OrthancPluginProperty) ||
1868 if (!strcmp(context->orthancVersion,
"mainline"))
1880 (context->orthancVersion,
"%4d.%4d.%4d", &major, &minor, &revision) != 3)
1887 if (major > expectedMajor)
1892 if (major < expectedMajor)
1899 if (minor > expectedMinor)
1904 if (minor < expectedMinor)
1911 if (revision >= expectedRevision)
1943 ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1944 ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1945 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1961 context->Free(buffer->
data);
1977 context->Free(buffer->
data);
1991 const char* message)
1993 context->InvokeService(context, _OrthancPluginService_LogError, message);
2007 const char* message)
2009 context->InvokeService(context, _OrthancPluginService_LogWarning, message);
2023 const char* message)
2025 context->InvokeService(context, _OrthancPluginService_LogInfo, message);
2032 const char* pathRegularExpression;
2034 } _OrthancPluginRestCallback;
2059 const char* pathRegularExpression,
2062 _OrthancPluginRestCallback params;
2063 params.pathRegularExpression = pathRegularExpression;
2064 params.callback = callback;
2065 context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, ¶ms);
2099 const char* pathRegularExpression,
2102 _OrthancPluginRestCallback params;
2103 params.pathRegularExpression = pathRegularExpression;
2104 params.callback = callback;
2105 context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, ¶ms);
2113 } _OrthancPluginOnStoredInstanceCallback;
2139 _OrthancPluginOnStoredInstanceCallback params;
2140 params.callback = callback;
2142 context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, ¶ms);
2151 uint32_t answerSize;
2152 const char* mimeType;
2153 } _OrthancPluginAnswerBuffer;
2171 uint32_t answerSize,
2172 const char* mimeType)
2174 _OrthancPluginAnswerBuffer params;
2175 params.output = output;
2176 params.answer = answer;
2177 params.answerSize = answerSize;
2178 params.mimeType = mimeType;
2179 context->InvokeService(context, _OrthancPluginService_AnswerBuffer, ¶ms);
2191 } _OrthancPluginCompressAndAnswerPngImage;
2203 } _OrthancPluginCompressAndAnswerImage;
2233 _OrthancPluginCompressAndAnswerImage params;
2234 params.output = output;
2236 params.pixelFormat = format;
2237 params.width = width;
2238 params.height = height;
2239 params.pitch = pitch;
2240 params.buffer = buffer;
2242 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, ¶ms);
2250 const char* instanceId;
2251 } _OrthancPluginGetDicomForInstance;
2268 const char* instanceId)
2270 _OrthancPluginGetDicomForInstance params;
2271 params.target = target;
2272 params.instanceId = instanceId;
2273 return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, ¶ms);
2282 } _OrthancPluginRestApiGet;
2303 _OrthancPluginRestApiGet params;
2304 params.target = target;
2306 return context->InvokeService(context, _OrthancPluginService_RestApiGet, ¶ms);
2333 _OrthancPluginRestApiGet params;
2334 params.target = target;
2336 return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, ¶ms);
2347 } _OrthancPluginRestApiPostPut;
2372 _OrthancPluginRestApiPostPut params;
2373 params.target = target;
2376 params.bodySize = bodySize;
2377 return context->InvokeService(context, _OrthancPluginService_RestApiPost, ¶ms);
2407 _OrthancPluginRestApiPostPut params;
2408 params.target = target;
2411 params.bodySize = bodySize;
2412 return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, ¶ms);
2433 return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2456 return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2484 _OrthancPluginRestApiPostPut params;
2485 params.target = target;
2488 params.bodySize = bodySize;
2489 return context->InvokeService(context, _OrthancPluginService_RestApiPut, ¶ms);
2520 _OrthancPluginRestApiPostPut params;
2521 params.target = target;
2524 params.bodySize = bodySize;
2525 return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, ¶ms);
2533 const char* argument;
2534 } _OrthancPluginOutputPlusArgument;
2550 const char* redirection)
2552 _OrthancPluginOutputPlusArgument params;
2553 params.output = output;
2554 params.argument = redirection;
2555 context->InvokeService(context, _OrthancPluginService_Redirect, ¶ms);
2563 const char* argument;
2564 } _OrthancPluginRetrieveDynamicString;
2581 const char* patientID)
2585 _OrthancPluginRetrieveDynamicString params;
2586 params.result = &result;
2587 params.argument = patientID;
2616 const char* studyUID)
2620 _OrthancPluginRetrieveDynamicString params;
2621 params.result = &result;
2622 params.argument = studyUID;
2651 const char* accessionNumber)
2655 _OrthancPluginRetrieveDynamicString params;
2656 params.result = &result;
2657 params.argument = accessionNumber;
2686 const char* seriesUID)
2690 _OrthancPluginRetrieveDynamicString params;
2691 params.result = &result;
2692 params.argument = seriesUID;
2721 const char* sopInstanceUID)
2725 _OrthancPluginRetrieveDynamicString params;
2726 params.result = &result;
2727 params.argument = sopInstanceUID;
2746 } _OrthancPluginSendHttpStatusCode;
2769 _OrthancPluginSendHttpStatusCode params;
2770 params.output = output;
2771 params.status = status;
2772 context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, ¶ms);
2792 _OrthancPluginOutputPlusArgument params;
2793 params.output = output;
2794 params.argument = realm;
2795 context->InvokeService(context, _OrthancPluginService_SendUnauthorized, ¶ms);
2813 const char* allowedMethods)
2815 _OrthancPluginOutputPlusArgument params;
2816 params.output = output;
2817 params.argument = allowedMethods;
2818 context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, ¶ms);
2827 } _OrthancPluginSetHttpHeader;
2846 _OrthancPluginSetHttpHeader params;
2847 params.output = output;
2848 params.key = cookie;
2849 params.value = value;
2850 context->InvokeService(context, _OrthancPluginService_SetCookie, ¶ms);
2871 _OrthancPluginSetHttpHeader params;
2872 params.output = output;
2874 params.value = value;
2875 context->InvokeService(context, _OrthancPluginService_SetHttpHeader, ¶ms);
2881 char** resultStringToFree;
2882 const char** resultString;
2883 int64_t* resultInt64;
2887 } _OrthancPluginAccessDicomInstance;
2907 _OrthancPluginAccessDicomInstance params;
2908 memset(¶ms, 0,
sizeof(params));
2909 params.resultString = &result;
2910 params.instance = instance;
2940 _OrthancPluginAccessDicomInstance params;
2941 memset(¶ms, 0,
sizeof(params));
2942 params.resultInt64 = &size;
2943 params.instance = instance;
2973 _OrthancPluginAccessDicomInstance params;
2974 memset(¶ms, 0,
sizeof(params));
2975 params.resultString = &result;
2976 params.instance = instance;
3009 _OrthancPluginAccessDicomInstance params;
3010 memset(¶ms, 0,
sizeof(params));
3011 params.resultStringToFree = &result;
3012 params.instance = instance;
3047 _OrthancPluginAccessDicomInstance params;
3048 memset(¶ms, 0,
sizeof(params));
3049 params.resultStringToFree = &result;
3050 params.instance = instance;
3083 const char* metadata)
3087 _OrthancPluginAccessDicomInstance params;
3088 memset(¶ms, 0,
sizeof(params));
3089 params.resultInt64 = &result;
3090 params.instance = instance;
3091 params.key = metadata;
3100 return (result != 0);
3124 const char* metadata)
3128 _OrthancPluginAccessDicomInstance params;
3129 memset(¶ms, 0,
sizeof(params));
3130 params.resultString = &result;
3131 params.instance = instance;
3132 params.key = metadata;
3153 } _OrthancPluginRegisterStorageArea;
3176 _OrthancPluginRegisterStorageArea params;
3177 params.create = create;
3179 params.remove = remove;
3182 params.free = ::free;
3187 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, ¶ms);
3206 _OrthancPluginRetrieveDynamicString params;
3207 params.result = &result;
3208 params.argument = NULL;
3236 _OrthancPluginRetrieveDynamicString params;
3237 params.result = &result;
3238 params.argument = NULL;
3271 _OrthancPluginRetrieveDynamicString params;
3272 params.result = &result;
3273 params.argument = NULL;
3291 } _OrthancPluginOnChangeCallback;
3317 _OrthancPluginOnChangeCallback params;
3318 params.callback = callback;
3320 context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, ¶ms);
3328 _OrthancPluginProperty property;
3330 } _OrthancPluginSetPluginProperty;
3348 _OrthancPluginSetPluginProperty params;
3349 params.plugin = OrthancPluginGetName();
3350 params.property = _OrthancPluginProperty_RootUri;
3353 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms);
3368 const char* description)
3370 _OrthancPluginSetPluginProperty params;
3371 params.plugin = OrthancPluginGetName();
3372 params.property = _OrthancPluginProperty_Description;
3373 params.value = description;
3375 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms);
3390 const char* javascript)
3392 _OrthancPluginSetPluginProperty params;
3393 params.plugin = OrthancPluginGetName();
3394 params.property = _OrthancPluginProperty_OrthancExplorer;
3395 params.value = javascript;
3397 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms);
3406 } _OrthancPluginGlobalProperty;
3425 const char* defaultValue)
3429 _OrthancPluginGlobalProperty params;
3430 params.result = &result;
3431 params.property = property;
3432 params.value = defaultValue;
3466 _OrthancPluginGlobalProperty params;
3467 params.result = NULL;
3468 params.property = property;
3469 params.value = value;
3471 return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, ¶ms);
3478 int32_t *resultInt32;
3479 uint32_t *resultUint32;
3480 int64_t *resultInt64;
3481 uint64_t *resultUint64;
3482 } _OrthancPluginReturnSingleValue;
3497 _OrthancPluginReturnSingleValue params;
3498 memset(¶ms, 0,
sizeof(params));
3499 params.resultUint32 = &count;
3532 _OrthancPluginGlobalProperty params;
3533 params.result = &result;
3534 params.property = (int32_t) argument;
3535 params.value = NULL;
3563 _OrthancPluginReturnSingleValue params;
3564 memset(¶ms, 0,
sizeof(params));
3565 params.resultUint32 = &count;
3595 _OrthancPluginRetrieveDynamicString params;
3596 params.result = &result;
3597 params.argument = NULL;
3615 const char* subType;
3616 const char* contentType;
3617 } _OrthancPluginStartMultipartAnswer;
3635 const char* subType,
3636 const char* contentType)
3638 _OrthancPluginStartMultipartAnswer params;
3639 params.output = output;
3640 params.subType = subType;
3641 params.contentType = contentType;
3642 return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, ¶ms);
3665 uint32_t answerSize)
3667 _OrthancPluginAnswerBuffer params;
3668 params.output = output;
3669 params.answer = answer;
3670 params.answerSize = answerSize;
3671 params.mimeType = NULL;
3672 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, ¶ms);
3684 } _OrthancPluginBufferCompression;
3711 _OrthancPluginBufferCompression params;
3712 params.target = target;
3713 params.source = source;
3715 params.compression = compression;
3716 params.uncompress = uncompress;
3718 return context->InvokeService(context, _OrthancPluginService_BufferCompression, ¶ms);
3727 } _OrthancPluginReadFile;
3745 _OrthancPluginReadFile params;
3746 params.target = target;
3748 return context->InvokeService(context, _OrthancPluginService_ReadFile, ¶ms);
3758 } _OrthancPluginWriteFile;
3777 _OrthancPluginWriteFile params;
3781 return context->InvokeService(context, _OrthancPluginService_WriteFile, ¶ms);
3788 const char** target;
3790 } _OrthancPluginGetErrorDescription;
3806 const char* result = NULL;
3808 _OrthancPluginGetErrorDescription params;
3809 params.target = &result;
3810 params.error = error;
3815 return "Unknown error code";
3831 } _OrthancPluginSendHttpStatus;
3862 _OrthancPluginSendHttpStatus params;
3863 params.output = output;
3864 params.status = status;
3866 params.bodySize = bodySize;
3867 context->InvokeService(context, _OrthancPluginService_SendHttpStatus, ¶ms);
3875 uint32_t* resultUint32;
3877 void** resultBuffer;
3878 } _OrthancPluginGetImageInfo;
3897 _OrthancPluginGetImageInfo params;
3898 memset(¶ms, 0,
sizeof(params));
3899 params.image = image;
3900 params.resultPixelFormat = ⌖
3930 _OrthancPluginGetImageInfo params;
3931 memset(¶ms, 0,
sizeof(params));
3932 params.image = image;
3933 params.resultUint32 = &width;
3963 _OrthancPluginGetImageInfo params;
3964 memset(¶ms, 0,
sizeof(params));
3965 params.image = image;
3966 params.resultUint32 = &height;
3998 _OrthancPluginGetImageInfo params;
3999 memset(¶ms, 0,
sizeof(params));
4000 params.image = image;
4001 params.resultUint32 = &pitch;
4030 void* target = NULL;
4032 _OrthancPluginGetImageInfo params;
4033 memset(¶ms, 0,
sizeof(params));
4034 params.resultBuffer = ⌖
4035 params.image = image;
4054 } _OrthancPluginUncompressImage;
4077 _OrthancPluginUncompressImage params;
4078 memset(¶ms, 0,
sizeof(params));
4079 params.target = ⌖
4082 params.format = format;
4100 } _OrthancPluginFreeImage;
4115 _OrthancPluginFreeImage params;
4116 params.image = image;
4118 context->InvokeService(context, _OrthancPluginService_FreeImage, ¶ms);
4134 } _OrthancPluginCompressImage;
4165 _OrthancPluginCompressImage params;
4166 memset(¶ms, 0,
sizeof(params));
4167 params.target = target;
4169 params.pixelFormat = format;
4170 params.width = width;
4171 params.height = height;
4172 params.pitch = pitch;
4173 params.buffer = buffer;
4176 return context->InvokeService(context, _OrthancPluginService_CompressImage, ¶ms);
4211 _OrthancPluginCompressImage params;
4212 memset(¶ms, 0,
sizeof(params));
4213 params.target = target;
4215 params.pixelFormat = format;
4216 params.width = width;
4217 params.height = height;
4218 params.pitch = pitch;
4219 params.buffer = buffer;
4220 params.quality = quality;
4222 return context->InvokeService(context, _OrthancPluginService_CompressImage, ¶ms);
4258 _OrthancPluginCompressAndAnswerImage params;
4259 params.output = output;
4261 params.pixelFormat = format;
4262 params.width = width;
4263 params.height = height;
4264 params.pitch = pitch;
4265 params.buffer = buffer;
4266 params.quality = quality;
4267 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, ¶ms);
4278 const char* username;
4279 const char* password;
4282 } _OrthancPluginCallHttpClient;
4305 const char* username,
4306 const char* password)
4308 _OrthancPluginCallHttpClient params;
4309 memset(¶ms, 0,
sizeof(params));
4311 params.target = target;
4314 params.username = username;
4315 params.password = password;
4317 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
4345 const char* username,
4346 const char* password)
4348 _OrthancPluginCallHttpClient params;
4349 memset(¶ms, 0,
sizeof(params));
4351 params.target = target;
4355 params.bodySize = bodySize;
4356 params.username = username;
4357 params.password = password;
4359 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
4387 const char* username,
4388 const char* password)
4390 _OrthancPluginCallHttpClient params;
4391 memset(¶ms, 0,
sizeof(params));
4393 params.target = target;
4397 params.bodySize = bodySize;
4398 params.username = username;
4399 params.password = password;
4401 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
4422 const char* username,
4423 const char* password)
4425 _OrthancPluginCallHttpClient params;
4426 memset(¶ms, 0,
sizeof(params));
4430 params.username = username;
4431 params.password = password;
4433 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
4443 } _OrthancPluginConvertPixelFormat;
4464 _OrthancPluginConvertPixelFormat params;
4465 params.target = ⌖
4466 params.source = source;
4467 params.targetFormat = targetFormat;
4497 _OrthancPluginReturnSingleValue params;
4498 memset(¶ms, 0,
sizeof(params));
4499 params.resultUint32 = &count;
4520 } _OrthancPluginGetFontInfo;
4536 const char* result = NULL;
4538 _OrthancPluginGetFontInfo params;
4539 memset(¶ms, 0,
sizeof(params));
4540 params.name = &result;
4541 params.fontIndex = fontIndex;
4570 _OrthancPluginGetFontInfo params;
4571 memset(¶ms, 0,
sizeof(params));
4572 params.size = &result;
4573 params.fontIndex = fontIndex;
4591 const char* utf8Text;
4597 } _OrthancPluginDrawText;
4621 const char* utf8Text,
4628 _OrthancPluginDrawText params;
4629 memset(¶ms, 0,
sizeof(params));
4630 params.image = image;
4631 params.fontIndex = fontIndex;
4632 params.utf8Text = utf8Text;
4639 return context->InvokeService(context, _OrthancPluginService_DrawText, ¶ms);
4648 const void* content;
4651 } _OrthancPluginStorageAreaCreate;
4675 const void* content,
4679 _OrthancPluginStorageAreaCreate params;
4680 params.storageArea = storageArea;
4682 params.content = content;
4686 return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, ¶ms);
4696 } _OrthancPluginStorageAreaRead;
4722 _OrthancPluginStorageAreaRead params;
4723 params.target = target;
4724 params.storageArea = storageArea;
4728 return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, ¶ms);
4737 } _OrthancPluginStorageAreaRemove;
4760 _OrthancPluginStorageAreaRemove params;
4761 params.storageArea = storageArea;
4765 return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, ¶ms);
4774 uint16_t httpStatus;
4775 const char* message;
4776 } _OrthancPluginRegisterErrorCode;
4796 uint16_t httpStatus,
4797 const char* message)
4801 _OrthancPluginRegisterErrorCode params;
4802 params.target = ⌖
4804 params.httpStatus = httpStatus;
4805 params.message = message;
4826 uint32_t minMultiplicity;
4827 uint32_t maxMultiplicity;
4828 } _OrthancPluginRegisterDictionaryTag;
4855 uint32_t minMultiplicity,
4856 uint32_t maxMultiplicity)
4858 _OrthancPluginRegisterDictionaryTag params;
4859 params.group = group;
4860 params.element = element;
4863 params.minMultiplicity = minMultiplicity;
4864 params.maxMultiplicity = maxMultiplicity;
4866 return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, ¶ms);
4877 uint32_t minMultiplicity;
4878 uint32_t maxMultiplicity;
4879 const char* privateCreator;
4880 } _OrthancPluginRegisterPrivateDictionaryTag;
4908 uint32_t minMultiplicity,
4909 uint32_t maxMultiplicity,
4910 const char* privateCreator)
4912 _OrthancPluginRegisterPrivateDictionaryTag params;
4913 params.group = group;
4914 params.element = element;
4917 params.minMultiplicity = minMultiplicity;
4918 params.maxMultiplicity = maxMultiplicity;
4919 params.privateCreator = privateCreator;
4921 return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, ¶ms);
4930 } _OrthancPluginReconstructMainDicomTags;
4951 _OrthancPluginReconstructMainDicomTags params;
4952 params.level = level;
4953 params.storageArea = storageArea;
4955 return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, ¶ms);
4962 const char* instanceId;
4967 uint32_t maxStringLength;
4968 } _OrthancPluginDicomToJson;
4996 uint32_t maxStringLength)
5000 _OrthancPluginDicomToJson params;
5001 memset(¶ms, 0,
sizeof(params));
5002 params.result = &result;
5003 params.buffer = buffer;
5005 params.format = format;
5006 params.flags = flags;
5007 params.maxStringLength = maxStringLength;
5041 const char* instanceId,
5044 uint32_t maxStringLength)
5048 _OrthancPluginDicomToJson params;
5049 memset(¶ms, 0,
sizeof(params));
5050 params.result = &result;
5051 params.instanceId = instanceId;
5052 params.format = format;
5053 params.flags = flags;
5054 params.maxStringLength = maxStringLength;
5072 uint32_t headersCount;
5073 const char*
const* headersKeys;
5074 const char*
const* headersValues;
5075 int32_t afterPlugins;
5076 } _OrthancPluginRestApiGet2;
5101 uint32_t headersCount,
5102 const char*
const* headersKeys,
5103 const char*
const* headersValues,
5104 int32_t afterPlugins)
5106 _OrthancPluginRestApiGet2 params;
5107 params.target = target;
5109 params.headersCount = headersCount;
5110 params.headersKeys = headersKeys;
5111 params.headersValues = headersValues;
5112 params.afterPlugins = afterPlugins;
5114 return context->InvokeService(context, _OrthancPluginService_RestApiGet2, ¶ms);
5122 } _OrthancPluginWorklistCallback;
5139 _OrthancPluginWorklistCallback params;
5140 params.callback = callback;
5142 return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, ¶ms);
5153 } _OrthancPluginWorklistAnswersOperation;
5178 _OrthancPluginWorklistAnswersOperation params;
5179 params.answers = answers;
5180 params.query = query;
5181 params.dicom = dicom;
5184 return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, ¶ms);
5205 _OrthancPluginWorklistAnswersOperation params;
5206 params.answers = answers;
5207 params.query = NULL;
5208 params.dicom = NULL;
5211 return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, ¶ms);
5222 } _OrthancPluginWorklistQueryOperation;
5245 int32_t isMatch = 0;
5247 _OrthancPluginWorklistQueryOperation params;
5248 params.query = query;
5249 params.dicom = dicom;
5251 params.isMatch = &isMatch;
5252 params.target = NULL;
5283 _OrthancPluginWorklistQueryOperation params;
5284 params.query = query;
5285 params.dicom = NULL;
5287 params.isMatch = NULL;
5288 params.target = target;
5290 return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, ¶ms);
5310 _OrthancPluginAccessDicomInstance params;
5311 memset(¶ms, 0,
sizeof(params));
5312 params.resultOrigin = &origin;
5313 params.instance = instance;
5333 } _OrthancPluginCreateDicom;
5367 _OrthancPluginCreateDicom params;
5368 params.target = target;
5370 params.pixelData = pixelData;
5371 params.flags = flags;
5373 return context->InvokeService(context, _OrthancPluginService_CreateDicom, ¶ms);
5380 } _OrthancPluginDecodeImageCallback;
5400 _OrthancPluginDecodeImageCallback params;
5401 params.callback = callback;
5403 return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, ¶ms);
5416 const void* constBuffer;
5417 uint32_t bufferSize;
5418 uint32_t frameIndex;
5419 } _OrthancPluginCreateImage;
5442 _OrthancPluginCreateImage params;
5443 memset(¶ms, 0,
sizeof(params));
5444 params.target = ⌖
5445 params.format = format;
5446 params.width = width;
5447 params.height = height;
5487 _OrthancPluginCreateImage params;
5488 memset(¶ms, 0,
sizeof(params));
5489 params.target = ⌖
5490 params.format = format;
5491 params.width = width;
5492 params.height = height;
5493 params.pitch = pitch;
5494 params.buffer = buffer;
5526 uint32_t bufferSize,
5527 uint32_t frameIndex)
5531 _OrthancPluginCreateImage params;
5532 memset(¶ms, 0,
sizeof(params));
5533 params.target = ⌖
5534 params.constBuffer = buffer;
5535 params.bufferSize = bufferSize;
5536 params.frameIndex = frameIndex;
5555 } _OrthancPluginComputeHash;
5576 _OrthancPluginComputeHash params;
5577 params.result = &result;
5578 params.buffer = buffer;
5612 _OrthancPluginComputeHash params;
5613 params.result = &result;
5614 params.buffer = buffer;
5634 } _OrthancPluginLookupDictionary;
5656 _OrthancPluginLookupDictionary params;
5657 params.target = target;
5659 return context->InvokeService(context, _OrthancPluginService_LookupDictionary, ¶ms);
5668 uint32_t answerSize;
5669 uint32_t headersCount;
5670 const char*
const* headersKeys;
5671 const char*
const* headersValues;
5672 } _OrthancPluginSendMultipartItem2;
5698 uint32_t answerSize,
5699 uint32_t headersCount,
5700 const char*
const* headersKeys,
5701 const char*
const* headersValues)
5703 _OrthancPluginSendMultipartItem2 params;
5704 params.output = output;
5705 params.answer = answer;
5706 params.answerSize = answerSize;
5707 params.headersCount = headersCount;
5708 params.headersKeys = headersKeys;
5709 params.headersValues = headersValues;
5711 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, ¶ms);
5718 } _OrthancPluginIncomingHttpRequestFilter;
5736 _OrthancPluginIncomingHttpRequestFilter params;
5737 params.callback = callback;
5739 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, ¶ms);
5748 uint16_t* httpStatus;
5751 uint32_t headersCount;
5752 const char*
const* headersKeys;
5753 const char*
const* headersValues;
5756 const char* username;
5757 const char* password;
5759 const char* certificateFile;
5760 const char* certificateKeyFile;
5761 const char* certificateKeyPassword;
5763 } _OrthancPluginCallHttpClient2;
5811 uint16_t* httpStatus,
5814 uint32_t headersCount,
5815 const char*
const* headersKeys,
5816 const char*
const* headersValues,
5819 const char* username,
5820 const char* password,
5822 const char* certificateFile,
5823 const char* certificateKeyFile,
5824 const char* certificateKeyPassword,
5827 _OrthancPluginCallHttpClient2 params;
5828 memset(¶ms, 0,
sizeof(params));
5830 params.answerBody = answerBody;
5831 params.answerHeaders = answerHeaders;
5832 params.httpStatus = httpStatus;
5833 params.method = method;
5835 params.headersCount = headersCount;
5836 params.headersKeys = headersKeys;
5837 params.headersValues = headersValues;
5839 params.bodySize = bodySize;
5840 params.username = username;
5841 params.password = password;
5842 params.timeout = timeout;
5843 params.certificateFile = certificateFile;
5844 params.certificateKeyFile = certificateKeyFile;
5845 params.certificateKeyPassword = certificateKeyPassword;
5846 params.pkcs11 = pkcs11;
5848 return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, ¶ms);
5867 _OrthancPluginRetrieveDynamicString params;
5868 params.result = &result;
5869 params.argument = NULL;
5888 } _OrthancPluginFindCallback;
5905 _OrthancPluginFindCallback params;
5906 params.callback = callback;
5908 return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, ¶ms);
5919 uint32_t *resultUint32;
5920 uint16_t *resultGroup;
5921 uint16_t *resultElement;
5922 char **resultString;
5923 } _OrthancPluginFindOperation;
5946 _OrthancPluginFindOperation params;
5947 memset(¶ms, 0,
sizeof(params));
5948 params.answers = answers;
5949 params.dicom = dicom;
5952 return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, ¶ms);
5973 _OrthancPluginFindOperation params;
5974 memset(¶ms, 0,
sizeof(params));
5975 params.answers = answers;
5977 return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, ¶ms);
5999 _OrthancPluginFindOperation params;
6000 memset(¶ms, 0,
sizeof(params));
6001 params.query = query;
6002 params.resultUint32 = &count;
6037 _OrthancPluginFindOperation params;
6038 memset(¶ms, 0,
sizeof(params));
6039 params.query = query;
6040 params.index = index;
6041 params.resultGroup = group;
6042 params.resultElement = element;
6044 return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, ¶ms);
6068 _OrthancPluginFindOperation params;
6069 memset(¶ms, 0,
sizeof(params));
6070 params.query = query;
6071 params.index = index;
6072 params.resultString = &result;
6106 _OrthancPluginFindOperation params;
6107 memset(¶ms, 0,
sizeof(params));
6108 params.query = query;
6109 params.index = index;
6110 params.resultString = &result;
6132 } _OrthancPluginMoveCallback;
6154 _OrthancPluginMoveCallback params;
6155 params.callback = callback;
6156 params.getMoveSize = getMoveSize;
6157 params.applyMove = applyMove;
6158 params.freeMove = freeMove;
6160 return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, ¶ms);
6170 } _OrthancPluginCreateFindMatcher;
6193 _OrthancPluginCreateFindMatcher params;
6194 memset(¶ms, 0,
sizeof(params));
6195 params.target = ⌖
6196 params.query = query;
6213 } _OrthancPluginFreeFindMatcher;
6228 _OrthancPluginFreeFindMatcher params;
6229 params.matcher = matcher;
6231 context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, ¶ms);
6241 } _OrthancPluginFindMatcherIsMatch;
6263 int32_t isMatch = 0;
6265 _OrthancPluginFindMatcherIsMatch params;
6266 params.matcher = matcher;
6267 params.dicom = dicom;
6269 params.isMatch = &isMatch;
6286 } _OrthancPluginIncomingHttpRequestFilter2;
6303 _OrthancPluginIncomingHttpRequestFilter2 params;
6304 params.callback = callback;
6306 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, ¶ms);
6314 } _OrthancPluginGetPeers;
6332 _OrthancPluginGetPeers params;
6333 memset(¶ms, 0,
sizeof(params));
6334 params.peers = &peers;
6350 } _OrthancPluginFreePeers;
6365 _OrthancPluginFreePeers params;
6366 params.peers = peers;
6368 context->InvokeService(context, _OrthancPluginService_FreePeers, ¶ms);
6376 } _OrthancPluginGetPeersCount;
6395 uint32_t target = 0;
6397 _OrthancPluginGetPeersCount params;
6398 memset(¶ms, 0,
sizeof(params));
6399 params.target = ⌖
6400 params.peers = peers;
6416 const char** target;
6419 const char* userProperty;
6420 } _OrthancPluginGetPeerProperty;
6444 const char* target = NULL;
6446 _OrthancPluginGetPeerProperty params;
6447 memset(¶ms, 0,
sizeof(params));
6448 params.target = ⌖
6449 params.peers = peers;
6450 params.peerIndex = peerIndex;
6451 params.userProperty = NULL;
6485 const char* target = NULL;
6487 _OrthancPluginGetPeerProperty params;
6488 memset(¶ms, 0,
sizeof(params));
6489 params.target = ⌖
6490 params.peers = peers;
6491 params.peerIndex = peerIndex;
6492 params.userProperty = NULL;
6530 const char* userProperty)
6532 const char* target = NULL;
6534 _OrthancPluginGetPeerProperty params;
6535 memset(¶ms, 0,
sizeof(params));
6536 params.target = ⌖
6537 params.peers = peers;
6538 params.peerIndex = peerIndex;
6539 params.userProperty = userProperty;
6558 uint16_t* httpStatus;
6563 uint32_t additionalHeadersCount;
6564 const char*
const* additionalHeadersKeys;
6565 const char*
const* additionalHeadersValues;
6569 } _OrthancPluginCallPeerApi;
6611 uint16_t* httpStatus,
6616 uint32_t additionalHeadersCount,
6617 const char*
const* additionalHeadersKeys,
6618 const char*
const* additionalHeadersValues,
6623 _OrthancPluginCallPeerApi params;
6624 memset(¶ms, 0,
sizeof(params));
6626 params.answerBody = answerBody;
6627 params.answerHeaders = answerHeaders;
6628 params.httpStatus = httpStatus;
6629 params.peers = peers;
6630 params.peerIndex = peerIndex;
6631 params.method = method;
6633 params.additionalHeadersCount = additionalHeadersCount;
6634 params.additionalHeadersKeys = additionalHeadersKeys;
6635 params.additionalHeadersValues = additionalHeadersValues;
6637 params.bodySize = bodySize;
6638 params.timeout = timeout;
6640 return context->InvokeService(context, _OrthancPluginService_CallPeerApi, ¶ms);
6659 } _OrthancPluginCreateJob;
6706 _OrthancPluginCreateJob params;
6707 memset(¶ms, 0,
sizeof(params));
6709 params.target = ⌖
6711 params.finalize = finalize;
6713 params.getProgress = getProgress;
6714 params.getContent = getContent;
6715 params.getSerialized = getSerialized;
6718 params.reset = reset;
6736 } _OrthancPluginFreeJob;
6751 _OrthancPluginFreeJob params;
6754 context->InvokeService(context, _OrthancPluginService_FreeJob, ¶ms);
6764 } _OrthancPluginSubmitJob;
6784 char* resultId = NULL;
6786 _OrthancPluginSubmitJob params;
6787 memset(¶ms, 0,
sizeof(params));
6789 params.resultId = &resultId;
6791 params.priority = priority;
6810 } _OrthancPluginJobsUnserializer;
6828 _OrthancPluginJobsUnserializer params;
6829 params.unserializer = unserializer;
6831 context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, ¶ms);
6839 const char* details;
6841 } _OrthancPluginSetHttpErrorDetails;
6863 const char* details,
6866 _OrthancPluginSetHttpErrorDetails params;
6867 params.output = output;
6868 params.details = details;
6870 context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, ¶ms);
6877 const char** result;
6878 const char* argument;
6879 } _OrthancPluginRetrieveStaticString;
6896 const char* result = NULL;
6898 _OrthancPluginRetrieveStaticString params;
6899 params.result = &result;
6900 params.argument = path;
6920 } _OrthancPluginSetMetricsValue;
6942 _OrthancPluginSetMetricsValue params;
6944 params.value = value;
6946 context->InvokeService(context, _OrthancPluginService_SetMetricsValue, ¶ms);
6954 } _OrthancPluginRegisterRefreshMetricsCallback;
6970 _OrthancPluginRegisterRefreshMetricsCallback params;
6971 params.callback = callback;
6972 context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, ¶ms);
6984 } _OrthancPluginEncodeDicomWeb;
7008 char* target = NULL;
7010 _OrthancPluginEncodeDicomWeb params;
7011 params.target = ⌖
7012 params.dicom = dicom;
7013 params.dicomSize = dicomSize;
7014 params.callback = callback;
7050 char* target = NULL;
7052 _OrthancPluginEncodeDicomWeb params;
7053 params.target = ⌖
7054 params.dicom = dicom;
7055 params.dicomSize = dicomSize;
7056 params.callback = callback;
7078 } _OrthancPluginEncodeDicomWeb2;
7103 char* target = NULL;
7105 _OrthancPluginEncodeDicomWeb2 params;
7106 params.target = ⌖
7107 params.dicom = dicom;
7108 params.dicomSize = dicomSize;
7109 params.callback = callback;
7110 params.payload = payload;
7147 char* target = NULL;
7149 _OrthancPluginEncodeDicomWeb2 params;
7150 params.target = ⌖
7151 params.dicom = dicom;
7152 params.dicomSize = dicomSize;
7153 params.callback = callback;
7154 params.payload = payload;
7258 typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (
void* request);
7282 uint16_t* httpStatus;
7285 uint32_t headersCount;
7286 const char*
const* headersKeys;
7287 const char*
const* headersValues;
7293 const char* username;
7294 const char* password;
7296 const char* certificateFile;
7297 const char* certificateKeyFile;
7298 const char* certificateKeyPassword;
7300 } _OrthancPluginChunkedHttpClient;
7358 uint16_t* httpStatus,
7361 uint32_t headersCount,
7362 const char*
const* headersKeys,
7363 const char*
const* headersValues,
7369 const char* username,
7370 const char* password,
7372 const char* certificateFile,
7373 const char* certificateKeyFile,
7374 const char* certificateKeyPassword,
7377 _OrthancPluginChunkedHttpClient params;
7378 memset(¶ms, 0,
sizeof(params));
7381 params.httpStatus = httpStatus;
7382 params.method = method;
7384 params.headersCount = headersCount;
7385 params.headersKeys = headersKeys;
7386 params.headersValues = headersValues;
7387 params.username = username;
7388 params.password = password;
7389 params.timeout = timeout;
7390 params.certificateFile = certificateFile;
7391 params.certificateKeyFile = certificateKeyFile;
7392 params.certificateKeyPassword = certificateKeyPassword;
7393 params.pkcs11 = pkcs11;
7396 params.answer = answer;
7397 params.answerAddChunk = answerAddChunk;
7398 params.answerAddHeader = answerAddHeader;
7399 params.request = request;
7400 params.requestIsDone = requestIsDone;
7401 params.requestChunkData = requestChunkData;
7402 params.requestChunkSize = requestChunkSize;
7403 params.requestNext = requestNext;
7405 return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, ¶ms);
7495 const char* pathRegularExpression;
7503 } _OrthancPluginChunkedRestCallback;
7537 const char* pathRegularExpression,
7546 _OrthancPluginChunkedRestCallback params;
7547 params.pathRegularExpression = pathRegularExpression;
7548 params.getHandler = getHandler;
7549 params.postHandler = postHandler;
7550 params.deleteHandler = deleteHandler;
7551 params.putHandler = putHandler;
7552 params.addChunk = addChunk;
7553 params.execute = execute;
7554 params.finalize = finalize;
7556 context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, ¶ms);
7568 const char* privateCreator;
7569 } _OrthancPluginGetTagName;
7590 const char* privateCreator)
7594 _OrthancPluginGetTagName params;
7595 params.result = &result;
7596 params.group = group;
7597 params.element = element;
7598 params.privateCreator = privateCreator;
7644 const char* transactionUid,
7645 const char*
const* sopClassUids,
7646 const char*
const* sopInstanceUids,
7647 uint32_t countInstances,
7648 const char* remoteAet,
7649 const char* calledAet);
7687 const char* sopClassUid,
7688 const char* sopInstanceUid);
7696 } _OrthancPluginRegisterStorageCommitmentScpCallback;
7717 _OrthancPluginRegisterStorageCommitmentScpCallback params;
7718 params.factory = factory;
7719 params.destructor = destructor;
7720 params.lookup = lookup;
7721 return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, ¶ms);
7758 } _OrthancPluginIncomingDicomInstanceFilter;
7776 _OrthancPluginIncomingDicomInstanceFilter params;
7777 params.callback = callback;
7779 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, ¶ms);
7814 uint16_t* dimseStatus ,
7821 } _OrthancPluginIncomingCStoreInstanceFilter;
7839 _OrthancPluginIncomingCStoreInstanceFilter params;
7840 params.callback = callback;
7842 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingCStoreInstanceFilter, ¶ms);
7882 const void* receivedDicomBuffer,
7883 uint64_t receivedDicomBufferSize,
7890 } _OrthancPluginReceivedInstanceCallback;
7916 _OrthancPluginReceivedInstanceCallback params;
7917 params.callback = callback;
7919 return context->InvokeService(context, _OrthancPluginService_RegisterReceivedInstanceCallback, ¶ms);
7941 _OrthancPluginAccessDicomInstance params;
7942 memset(¶ms, 0,
sizeof(params));
7943 params.resultStringToFree = &result;
7944 params.instance = instance;
7974 int64_t hasPixelData;
7976 _OrthancPluginAccessDicomInstance params;
7977 memset(¶ms, 0,
sizeof(params));
7978 params.resultInt64 = &hasPixelData;
7979 params.instance = instance;
7990 return (hasPixelData != 0);
8004 const char* transferSyntax;
8005 } _OrthancPluginCreateDicomInstance;
8027 _OrthancPluginCreateDicomInstance params;
8028 params.target = ⌖
8029 params.buffer = buffer;
8046 } _OrthancPluginFreeDicomInstance;
8062 _OrthancPluginFreeDicomInstance params;
8063 params.dicom = dicom;
8065 context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, ¶ms);
8071 uint32_t* targetUint32;
8074 char** targetStringToFree;
8076 uint32_t frameIndex;
8079 uint32_t maxStringLength;
8081 void* dicomWebPayload;
8082 } _OrthancPluginAccessDicomInstance2;
8101 _OrthancPluginAccessDicomInstance2 params;
8102 memset(¶ms, 0,
sizeof(params));
8103 params.targetUint32 = &count;
8104 params.instance = instance;
8139 uint32_t frameIndex)
8141 _OrthancPluginAccessDicomInstance2 params;
8142 memset(¶ms, 0,
sizeof(params));
8143 params.targetBuffer = target;
8144 params.instance = instance;
8145 params.frameIndex = frameIndex;
8147 return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, ¶ms);
8166 uint32_t frameIndex)
8170 _OrthancPluginAccessDicomInstance2 params;
8171 memset(¶ms, 0,
sizeof(params));
8172 params.targetImage = ⌖
8173 params.instance = instance;
8174 params.frameIndex = frameIndex;
8206 const char* transferSyntax)
8210 _OrthancPluginCreateDicomInstance params;
8211 params.target = ⌖
8212 params.buffer = buffer;
8214 params.transferSyntax = transferSyntax;
8245 _OrthancPluginAccessDicomInstance2 params;
8246 memset(¶ms, 0,
sizeof(params));
8247 params.targetBuffer = target;
8248 params.instance = instance;
8250 return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, ¶ms);
8277 uint32_t maxStringLength)
8279 char* result = NULL;
8281 _OrthancPluginAccessDicomInstance2 params;
8282 memset(¶ms, 0,
sizeof(params));
8283 params.targetStringToFree = &result;
8284 params.instance = instance;
8285 params.format = format;
8286 params.flags = flags;
8287 params.maxStringLength = maxStringLength;
8321 char* target = NULL;
8323 _OrthancPluginAccessDicomInstance2 params;
8324 params.targetStringToFree = ⌖
8325 params.instance = instance;
8326 params.dicomWebCallback = callback;
8327 params.dicomWebPayload = payload;
8361 char* target = NULL;
8363 _OrthancPluginAccessDicomInstance2 params;
8364 params.targetStringToFree = ⌖
8365 params.instance = instance;
8366 params.dicomWebCallback = callback;
8367 params.dicomWebPayload = payload;
8404 const char*
const* allowedSyntaxes,
8405 uint32_t countSyntaxes,
8406 uint8_t allowNewSopInstanceUid);
8412 } _OrthancPluginTranscoderCallback;
8431 _OrthancPluginTranscoderCallback params;
8432 params.callback = callback;
8434 return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, ¶ms);
8443 } _OrthancPluginCreateMemoryBuffer;
8467 _OrthancPluginCreateMemoryBuffer params;
8468 params.target = target;
8471 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, ¶ms);
8505 _OrthancPluginRetrieveDynamicString params;
8506 params.result = &result;
8507 params.argument = NULL;
8509 if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
8527 } _OrthancPluginCreateMemoryBuffer64;
8551 _OrthancPluginCreateMemoryBuffer64 params;
8552 params.target = target;
8555 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer64, ¶ms);
8565 } _OrthancPluginRegisterStorageArea2;
8590 _OrthancPluginRegisterStorageArea2 params;
8591 params.create = create;
8592 params.readWhole = readWhole;
8593 params.readRange = readRange;
8594 params.remove = remove;
8595 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea2, ¶ms);
8602 _OrthancPluginCreateDicom createDicom;
8603 const char* privateCreator;
8604 } _OrthancPluginCreateDicom2;
8636 const char* privateCreator)
8638 _OrthancPluginCreateDicom2 params;
8639 params.createDicom.target = target;
8640 params.createDicom.json = json;
8641 params.createDicom.pixelData = pixelData;
8642 params.createDicom.flags = flags;
8643 params.privateCreator = privateCreator;
8645 return context->InvokeService(context, _OrthancPluginService_CreateDicom2, ¶ms);
8657 uint16_t* httpStatus;
8660 uint32_t headersCount;
8661 const char*
const* headersKeys;
8662 const char*
const* headersValues;
8665 uint8_t afterPlugins;
8666 } _OrthancPluginCallRestApi;
8702 uint16_t* httpStatus,
8705 uint32_t headersCount,
8706 const char*
const* headersKeys,
8707 const char*
const* headersValues,
8710 uint8_t afterPlugins)
8712 _OrthancPluginCallRestApi params;
8713 memset(¶ms, 0,
sizeof(params));
8715 params.answerBody = answerBody;
8716 params.answerHeaders = answerHeaders;
8717 params.httpStatus = httpStatus;
8718 params.method = method;
8720 params.headersCount = headersCount;
8721 params.headersKeys = headersKeys;
8722 params.headersValues = headersValues;
8724 params.bodySize = bodySize;
8725 params.afterPlugins = afterPlugins;
8727 return context->InvokeService(context, _OrthancPluginService_CallRestApi, ¶ms);
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:1832
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:3170
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:2135
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:1220
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5396
OrthancPluginChangeType
Definition: OrthancCPlugin.h:726
OrthancPluginErrorCode(* OrthancPluginStorageReadWhole)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type)
Callback for reading a whole file from the storage area.
Definition: OrthancCPlugin.h:1286
OrthancPluginErrorCode OrthancPluginRegisterIncomingCStoreInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingCStoreInstanceFilter callback)
Register a callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition: OrthancCPlugin.h:7835
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1938
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:1198
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:6966
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:1713
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4754
OrthancPluginErrorCode(* OrthancPluginTranscoderCallback)(OrthancPluginMemoryBuffer *transcoded, const void *buffer, uint64_t size, const char *const *allowedSyntaxes, uint32_t countSyntaxes, uint8_t allowNewSopInstanceUid)
Signature of a callback function to transcode a DICOM instance.
Definition: OrthancCPlugin.h:8400
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6299
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1266
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:2057
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3558
OrthancPluginErrorCode OrthancPluginRegisterReceivedInstanceCallback(OrthancPluginContext *context, OrthancPluginReceivedInstanceCallback callback)
Register a callback to keep/discard/modify a DICOM instance received by Orthanc from any source (C-ST...
Definition: OrthancCPlugin.h:7912
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3313
void OrthancPluginRegisterStorageArea2(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageReadWhole readWhole, OrthancPluginStorageReadRange readRange, OrthancPluginStorageRemove remove)
Register a custom storage area, with support for range request.
Definition: OrthancCPlugin.h:8583
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1166
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1685
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition: OrthancCPlugin.h:8427
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:1177
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4946
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1327
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1239
void(* OrthancPluginDicomWebBinaryCallback2)(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, void *payload)
Callback executed to encode a binary tag in DICOMweb.
Definition: OrthancCPlugin.h:1751
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:1187
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1667
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6824
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1210
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:2097
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4715
OrthancPluginErrorCode(* OrthancPluginStorageReadRange)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type, uint64_t rangeStart)
Callback for reading a range of a file from the storage area.
Definition: OrthancCPlugin.h:1309
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:7535
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition: OrthancCPlugin.h:7772
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5732
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:4671
@ OrthancPluginChangeType_OrthancStopped
Definition: OrthancCPlugin.h:738
@ OrthancPluginChangeType_OrthancStarted
Definition: OrthancCPlugin.h:737
@ OrthancPluginChangeType_Deleted
Definition: OrthancCPlugin.h:728
@ OrthancPluginChangeType_JobFailure
Definition: OrthancCPlugin.h:745
@ OrthancPluginChangeType_NewInstance
Definition: OrthancCPlugin.h:730
@ OrthancPluginChangeType_NewPatient
Definition: OrthancCPlugin.h:731
@ OrthancPluginChangeType_JobSubmitted
Definition: OrthancCPlugin.h:743
@ OrthancPluginChangeType_NewSeries
Definition: OrthancCPlugin.h:732
@ OrthancPluginChangeType_StablePatient
Definition: OrthancCPlugin.h:734
@ OrthancPluginChangeType_UpdatedPeers
Definition: OrthancCPlugin.h:741
@ OrthancPluginChangeType_StableStudy
Definition: OrthancCPlugin.h:736
@ OrthancPluginChangeType_CompletedSeries
Definition: OrthancCPlugin.h:727
@ OrthancPluginChangeType_NewChildInstance
Definition: OrthancCPlugin.h:729
@ OrthancPluginChangeType_UpdatedAttachment
Definition: OrthancCPlugin.h:739
@ OrthancPluginChangeType_UpdatedMetadata
Definition: OrthancCPlugin.h:740
@ OrthancPluginChangeType_StableSeries
Definition: OrthancCPlugin.h:735
@ OrthancPluginChangeType_UpdatedModalities
Definition: OrthancCPlugin.h:742
@ OrthancPluginChangeType_JobSuccess
Definition: OrthancCPlugin.h:744
@ OrthancPluginChangeType_NewStudy
Definition: OrthancCPlugin.h:733
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5993
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1117
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1522
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:5969
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:6061
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7663
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:1346
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:6147
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:7641
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5901
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5278
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:7684
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:5239
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5940
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:1482
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:7711
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1125
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1109
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1439
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1507
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:5135
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5201
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:6099
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:6030
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1536
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1101
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:5171
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:7970
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:8355
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition: OrthancCPlugin.h:1077
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition: OrthancCPlugin.h:7935
OrthancPluginErrorCode OrthancPluginGetInstanceRawFrame(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Get the raw content of a frame in a DICOM instance.
Definition: OrthancCPlugin.h:8135
char * OrthancPluginGetInstanceAdvancedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomToJsonFormat format, OrthancPluginDicomToJsonFlags flags, uint32_t maxStringLength)
Format a DICOM memory buffer as a JSON string.
Definition: OrthancCPlugin.h:8272
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2967
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition: OrthancCPlugin.h:8020
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition: OrthancCPlugin.h:8095
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:8163
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5304
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2934
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:8315
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:3041
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:3003
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:3080
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:3121
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition: OrthancCPlugin.h:8058
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition: OrthancCPlugin.h:8240
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition: OrthancCPlugin.h:8202
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2901
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:602
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:4617
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:4201
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3992
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4457
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3891
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4492
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:3957
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:4111
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:4156
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5434
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:4069
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4532
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:4026
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:5477
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:771
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:1093
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:756
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3924
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:3703
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5523
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4564
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1085
@ OrthancPluginPixelFormat_RGBA32
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:641
@ OrthancPluginPixelFormat_RGB48
Color image in RGB48 format.
Definition: OrthancCPlugin.h:651
@ OrthancPluginPixelFormat_Grayscale8
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:609
@ OrthancPluginPixelFormat_SignedGrayscale16
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:625
@ OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:667
@ OrthancPluginPixelFormat_RGB24
Color image in RGB24 format.
Definition: OrthancCPlugin.h:633
@ OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:675
@ OrthancPluginPixelFormat_Unknown
Definition: OrthancCPlugin.h:643
@ OrthancPluginPixelFormat_Grayscale64
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:683
@ OrthancPluginPixelFormat_Grayscale32
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:659
@ OrthancPluginPixelFormat_Grayscale16
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:617
@ OrthancPluginImageFormat_Png
Definition: OrthancCPlugin.h:772
@ OrthancPluginImageFormat_Jpeg
Definition: OrthancCPlugin.h:773
@ OrthancPluginImageFormat_Dicom
Definition: OrthancCPlugin.h:774
@ OrthancPluginCompressionType_Gzip
Definition: OrthancCPlugin.h:759
@ OrthancPluginCompressionType_ZlibWithSize
Definition: OrthancCPlugin.h:758
@ OrthancPluginCompressionType_Zlib
Definition: OrthancCPlugin.h:757
@ OrthancPluginCompressionType_GzipWithSize
Definition: OrthancCPlugin.h:760
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:2365
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:2400
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:2513
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2614
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3461
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3422
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:2477
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2684
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2649
char * OrthancPluginGenerateRestApiAuthorizationToken(OrthancPluginContext *context)
Generate a token to grant full access to the REST API of Orthanc.
Definition: OrthancCPlugin.h:8500
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2298
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2719
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:2328
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2579
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2429
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2452
OrthancPluginErrorCode OrthancPluginCallRestApi(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, OrthancPluginHttpMethod method, const char *uri, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, const void *body, uint32_t bodySize, uint8_t afterPlugins)
Call the REST API of Orthanc with full flexibility.
Definition: OrthancCPlugin.h:8698
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:5097
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2265
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:2224
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2787
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:6860
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2810
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:2167
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2764
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2865
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2840
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2547
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:4248
OrthancPluginErrorCode OrthancPluginSendMultipartItem(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize)
Send an item as a part of some HTTP multipart answer.
Definition: OrthancCPlugin.h:3661
OrthancPluginErrorCode OrthancPluginSendMultipartItem2(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *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:5694
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3632
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:3855
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1784
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1788
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1789
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1787
uint16_t element
Definition: OrthancCPlugin.h:1786
uint16_t group
Definition: OrthancCPlugin.h:1785
The parameters of a REST request.
Definition: OrthancCPlugin.h:339
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:368
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:353
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:378
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:348
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:393
const void * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:373
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:363
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:388
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:343
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:358
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:398
A 64-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1050
uint64_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1059
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1054
A 32-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1028
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1037
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1032