111 # define ORTHANC_PLUGINS_API __declspec(dllexport)
113 # define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default")))
115 # define ORTHANC_PLUGINS_API
118 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
119 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 9
120 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 2
123 #if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
124 #define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
125 (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
126 (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
127 (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
128 (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
129 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
148 #ifndef ORTHANC_PLUGIN_INLINE
149 # if __STDC_VERSION__ >= 199901L
151 # define ORTHANC_PLUGIN_INLINE static inline
152 # elif defined(__cplusplus)
154 # define ORTHANC_PLUGIN_INLINE static inline
155 # elif defined(__GNUC__)
157 # define ORTHANC_PLUGIN_INLINE static __inline
158 # elif defined(_MSC_VER)
160 # define ORTHANC_PLUGIN_INLINE static __inline
162 # error Your compiler is not known to support the "inline" keyword
307 _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
315 ORTHANC_PLUGINS_API
const char* OrthancPluginGetName();
328 _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
404 _OrthancPluginService_LogInfo = 1,
405 _OrthancPluginService_LogWarning = 2,
406 _OrthancPluginService_LogError = 3,
407 _OrthancPluginService_GetOrthancPath = 4,
408 _OrthancPluginService_GetOrthancDirectory = 5,
409 _OrthancPluginService_GetConfigurationPath = 6,
410 _OrthancPluginService_SetPluginProperty = 7,
411 _OrthancPluginService_GetGlobalProperty = 8,
412 _OrthancPluginService_SetGlobalProperty = 9,
413 _OrthancPluginService_GetCommandLineArgumentsCount = 10,
414 _OrthancPluginService_GetCommandLineArgument = 11,
415 _OrthancPluginService_GetExpectedDatabaseVersion = 12,
416 _OrthancPluginService_GetConfiguration = 13,
417 _OrthancPluginService_BufferCompression = 14,
418 _OrthancPluginService_ReadFile = 15,
419 _OrthancPluginService_WriteFile = 16,
420 _OrthancPluginService_GetErrorDescription = 17,
421 _OrthancPluginService_CallHttpClient = 18,
422 _OrthancPluginService_RegisterErrorCode = 19,
423 _OrthancPluginService_RegisterDictionaryTag = 20,
424 _OrthancPluginService_DicomBufferToJson = 21,
425 _OrthancPluginService_DicomInstanceToJson = 22,
426 _OrthancPluginService_CreateDicom = 23,
427 _OrthancPluginService_ComputeMd5 = 24,
428 _OrthancPluginService_ComputeSha1 = 25,
429 _OrthancPluginService_LookupDictionary = 26,
430 _OrthancPluginService_CallHttpClient2 = 27,
431 _OrthancPluginService_GenerateUuid = 28,
432 _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
433 _OrthancPluginService_AutodetectMimeType = 30,
434 _OrthancPluginService_SetMetricsValue = 31,
435 _OrthancPluginService_EncodeDicomWebJson = 32,
436 _OrthancPluginService_EncodeDicomWebXml = 33,
437 _OrthancPluginService_ChunkedHttpClient = 34,
438 _OrthancPluginService_GetTagName = 35,
439 _OrthancPluginService_EncodeDicomWebJson2 = 36,
440 _OrthancPluginService_EncodeDicomWebXml2 = 37,
441 _OrthancPluginService_CreateMemoryBuffer = 38,
442 _OrthancPluginService_GenerateRestApiAuthorizationToken = 39,
443 _OrthancPluginService_CreateMemoryBuffer64 = 40,
444 _OrthancPluginService_CreateDicom2 = 41,
447 _OrthancPluginService_RegisterRestCallback = 1000,
448 _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
449 _OrthancPluginService_RegisterStorageArea = 1002,
450 _OrthancPluginService_RegisterOnChangeCallback = 1003,
451 _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
452 _OrthancPluginService_RegisterWorklistCallback = 1005,
453 _OrthancPluginService_RegisterDecodeImageCallback = 1006,
454 _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
455 _OrthancPluginService_RegisterFindCallback = 1008,
456 _OrthancPluginService_RegisterMoveCallback = 1009,
457 _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
458 _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
459 _OrthancPluginService_RegisterChunkedRestCallback = 1012,
460 _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
461 _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
462 _OrthancPluginService_RegisterTranscoderCallback = 1015,
463 _OrthancPluginService_RegisterStorageArea2 = 1016,
466 _OrthancPluginService_AnswerBuffer = 2000,
467 _OrthancPluginService_CompressAndAnswerPngImage = 2001,
468 _OrthancPluginService_Redirect = 2002,
469 _OrthancPluginService_SendHttpStatusCode = 2003,
470 _OrthancPluginService_SendUnauthorized = 2004,
471 _OrthancPluginService_SendMethodNotAllowed = 2005,
472 _OrthancPluginService_SetCookie = 2006,
473 _OrthancPluginService_SetHttpHeader = 2007,
474 _OrthancPluginService_StartMultipartAnswer = 2008,
475 _OrthancPluginService_SendMultipartItem = 2009,
476 _OrthancPluginService_SendHttpStatus = 2010,
477 _OrthancPluginService_CompressAndAnswerImage = 2011,
478 _OrthancPluginService_SendMultipartItem2 = 2012,
479 _OrthancPluginService_SetHttpErrorDetails = 2013,
482 _OrthancPluginService_GetDicomForInstance = 3000,
483 _OrthancPluginService_RestApiGet = 3001,
484 _OrthancPluginService_RestApiPost = 3002,
485 _OrthancPluginService_RestApiDelete = 3003,
486 _OrthancPluginService_RestApiPut = 3004,
487 _OrthancPluginService_LookupPatient = 3005,
488 _OrthancPluginService_LookupStudy = 3006,
489 _OrthancPluginService_LookupSeries = 3007,
490 _OrthancPluginService_LookupInstance = 3008,
491 _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
492 _OrthancPluginService_RestApiGetAfterPlugins = 3010,
493 _OrthancPluginService_RestApiPostAfterPlugins = 3011,
494 _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
495 _OrthancPluginService_RestApiPutAfterPlugins = 3013,
496 _OrthancPluginService_ReconstructMainDicomTags = 3014,
497 _OrthancPluginService_RestApiGet2 = 3015,
498 _OrthancPluginService_CallRestApi = 3016,
501 _OrthancPluginService_GetInstanceRemoteAet = 4000,
502 _OrthancPluginService_GetInstanceSize = 4001,
503 _OrthancPluginService_GetInstanceData = 4002,
504 _OrthancPluginService_GetInstanceJson = 4003,
505 _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
506 _OrthancPluginService_HasInstanceMetadata = 4005,
507 _OrthancPluginService_GetInstanceMetadata = 4006,
508 _OrthancPluginService_GetInstanceOrigin = 4007,
509 _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
510 _OrthancPluginService_HasInstancePixelData = 4009,
511 _OrthancPluginService_CreateDicomInstance = 4010,
512 _OrthancPluginService_FreeDicomInstance = 4011,
513 _OrthancPluginService_GetInstanceFramesCount = 4012,
514 _OrthancPluginService_GetInstanceRawFrame = 4013,
515 _OrthancPluginService_GetInstanceDecodedFrame = 4014,
516 _OrthancPluginService_TranscodeDicomInstance = 4015,
517 _OrthancPluginService_SerializeDicomInstance = 4016,
518 _OrthancPluginService_GetInstanceAdvancedJson = 4017,
519 _OrthancPluginService_GetInstanceDicomWebJson = 4018,
520 _OrthancPluginService_GetInstanceDicomWebXml = 4019,
523 _OrthancPluginService_RegisterDatabaseBackend = 5000,
524 _OrthancPluginService_DatabaseAnswer = 5001,
525 _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
526 _OrthancPluginService_StorageAreaCreate = 5003,
527 _OrthancPluginService_StorageAreaRead = 5004,
528 _OrthancPluginService_StorageAreaRemove = 5005,
529 _OrthancPluginService_RegisterDatabaseBackendV3 = 5006,
532 _OrthancPluginService_GetImagePixelFormat = 6000,
533 _OrthancPluginService_GetImageWidth = 6001,
534 _OrthancPluginService_GetImageHeight = 6002,
535 _OrthancPluginService_GetImagePitch = 6003,
536 _OrthancPluginService_GetImageBuffer = 6004,
537 _OrthancPluginService_UncompressImage = 6005,
538 _OrthancPluginService_FreeImage = 6006,
539 _OrthancPluginService_CompressImage = 6007,
540 _OrthancPluginService_ConvertPixelFormat = 6008,
541 _OrthancPluginService_GetFontsCount = 6009,
542 _OrthancPluginService_GetFontInfo = 6010,
543 _OrthancPluginService_DrawText = 6011,
544 _OrthancPluginService_CreateImage = 6012,
545 _OrthancPluginService_CreateImageAccessor = 6013,
546 _OrthancPluginService_DecodeDicomImage = 6014,
549 _OrthancPluginService_WorklistAddAnswer = 7000,
550 _OrthancPluginService_WorklistMarkIncomplete = 7001,
551 _OrthancPluginService_WorklistIsMatch = 7002,
552 _OrthancPluginService_WorklistGetDicomQuery = 7003,
553 _OrthancPluginService_FindAddAnswer = 7004,
554 _OrthancPluginService_FindMarkIncomplete = 7005,
555 _OrthancPluginService_GetFindQuerySize = 7006,
556 _OrthancPluginService_GetFindQueryTag = 7007,
557 _OrthancPluginService_GetFindQueryTagName = 7008,
558 _OrthancPluginService_GetFindQueryValue = 7009,
559 _OrthancPluginService_CreateFindMatcher = 7010,
560 _OrthancPluginService_FreeFindMatcher = 7011,
561 _OrthancPluginService_FindMatcherIsMatch = 7012,
564 _OrthancPluginService_GetPeers = 8000,
565 _OrthancPluginService_FreePeers = 8001,
566 _OrthancPluginService_GetPeersCount = 8003,
567 _OrthancPluginService_GetPeerName = 8004,
568 _OrthancPluginService_GetPeerUrl = 8005,
569 _OrthancPluginService_CallPeerApi = 8006,
570 _OrthancPluginService_GetPeerUserProperty = 8007,
573 _OrthancPluginService_CreateJob = 9000,
574 _OrthancPluginService_FreeJob = 9001,
575 _OrthancPluginService_SubmitJob = 9002,
576 _OrthancPluginService_RegisterJobsUnserializer = 9003,
578 _OrthancPluginService_INTERNAL = 0x7fffffff
579 } _OrthancPluginService;
584 _OrthancPluginProperty_Description = 1,
585 _OrthancPluginProperty_RootUri = 2,
586 _OrthancPluginProperty_OrthancExplorer = 3,
588 _OrthancPluginProperty_INTERNAL = 0x7fffffff
589 } _OrthancPluginProperty;
681 _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
696 _OrthancPluginContentType_INTERNAL = 0x7fffffff
712 _OrthancPluginResourceType_INTERNAL = 0x7fffffff
743 _OrthancPluginChangeType_INTERNAL = 0x7fffffff
758 _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
772 _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
810 _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
825 _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
836 OrthancPluginDicomToJsonFlags_None = 0,
846 _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
857 OrthancPluginCreateDicomFlags_None = 0,
861 _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
877 _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
893 _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
909 _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
1163 const char* instanceId);
1174 const char* resourceId);
1185 const uint32_t size,
1186 uint32_t frameIndex);
1207 const char* bulkDataUri);
1225 const void* content,
1297 uint64_t rangeStart);
1333 const char* issuerAet,
1334 const char* calledAet);
1365 uint32_t headersCount,
1366 const char*
const* headersKeys,
1367 const char*
const* headersValues);
1400 uint32_t headersCount,
1401 const char*
const* headersKeys,
1402 const char*
const* headersValues,
1403 uint32_t getArgumentsCount,
1404 const char*
const* getArgumentsKeys,
1405 const char*
const* getArgumentsValues);
1426 const char* issuerAet,
1427 const char* calledAet);
1466 typedef void* (*OrthancPluginMoveCallback) (
1468 const char* patientId,
1469 const char* accessionNumber,
1470 const char* studyInstanceUid,
1471 const char* seriesInstanceUid,
1472 const char* sopInstanceUid,
1473 const char* originatorAet,
1474 const char* sourceAet,
1475 const char* targetAet,
1476 uint16_t originatorId);
1561 typedef const char* (*OrthancPluginJobGetContent) (
void* job);
1579 typedef const char* (*OrthancPluginJobGetSerialized) (
void* job);
1652 const char* serialized);
1700 uint32_t levelDepth,
1701 const uint16_t* levelTagGroup,
1702 const uint16_t* levelTagElement,
1703 const uint32_t* levelIndex,
1705 uint16_t tagElement,
1738 uint32_t levelDepth,
1739 const uint16_t* levelTagGroup,
1740 const uint16_t* levelTagElement,
1741 const uint32_t* levelIndex,
1743 uint16_t tagElement,
1752 typedef struct _OrthancPluginContext_t
1754 void* pluginsManager;
1755 const char* orthancVersion;
1758 _OrthancPluginService service,
1759 const void* params);
1820 int expectedRevision)
1822 int major, minor, revision;
1826 sizeof(int32_t) !=
sizeof(_OrthancPluginService) ||
1827 sizeof(int32_t) !=
sizeof(_OrthancPluginProperty) ||
1851 if (!strcmp(context->orthancVersion,
"mainline"))
1863 (context->orthancVersion,
"%4d.%4d.%4d", &major, &minor, &revision) != 3)
1870 if (major > expectedMajor)
1875 if (major < expectedMajor)
1882 if (minor > expectedMinor)
1887 if (minor < expectedMinor)
1894 if (revision >= expectedRevision)
1926 ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1927 ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1928 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1944 context->Free(buffer->
data);
1960 context->Free(buffer->
data);
1974 const char* message)
1976 context->InvokeService(context, _OrthancPluginService_LogError, message);
1990 const char* message)
1992 context->InvokeService(context, _OrthancPluginService_LogWarning, message);
2006 const char* message)
2008 context->InvokeService(context, _OrthancPluginService_LogInfo, message);
2015 const char* pathRegularExpression;
2017 } _OrthancPluginRestCallback;
2042 const char* pathRegularExpression,
2045 _OrthancPluginRestCallback params;
2046 params.pathRegularExpression = pathRegularExpression;
2047 params.callback = callback;
2048 context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, ¶ms);
2082 const char* pathRegularExpression,
2085 _OrthancPluginRestCallback params;
2086 params.pathRegularExpression = pathRegularExpression;
2087 params.callback = callback;
2088 context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, ¶ms);
2096 } _OrthancPluginOnStoredInstanceCallback;
2122 _OrthancPluginOnStoredInstanceCallback params;
2123 params.callback = callback;
2125 context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, ¶ms);
2134 uint32_t answerSize;
2135 const char* mimeType;
2136 } _OrthancPluginAnswerBuffer;
2154 uint32_t answerSize,
2155 const char* mimeType)
2157 _OrthancPluginAnswerBuffer params;
2158 params.output = output;
2159 params.answer = answer;
2160 params.answerSize = answerSize;
2161 params.mimeType = mimeType;
2162 context->InvokeService(context, _OrthancPluginService_AnswerBuffer, ¶ms);
2174 } _OrthancPluginCompressAndAnswerPngImage;
2186 } _OrthancPluginCompressAndAnswerImage;
2216 _OrthancPluginCompressAndAnswerImage params;
2217 params.output = output;
2219 params.pixelFormat = format;
2220 params.width = width;
2221 params.height = height;
2222 params.pitch = pitch;
2223 params.buffer = buffer;
2225 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, ¶ms);
2233 const char* instanceId;
2234 } _OrthancPluginGetDicomForInstance;
2251 const char* instanceId)
2253 _OrthancPluginGetDicomForInstance params;
2254 params.target = target;
2255 params.instanceId = instanceId;
2256 return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, ¶ms);
2265 } _OrthancPluginRestApiGet;
2286 _OrthancPluginRestApiGet params;
2287 params.target = target;
2289 return context->InvokeService(context, _OrthancPluginService_RestApiGet, ¶ms);
2316 _OrthancPluginRestApiGet params;
2317 params.target = target;
2319 return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, ¶ms);
2330 } _OrthancPluginRestApiPostPut;
2355 _OrthancPluginRestApiPostPut params;
2356 params.target = target;
2359 params.bodySize = bodySize;
2360 return context->InvokeService(context, _OrthancPluginService_RestApiPost, ¶ms);
2390 _OrthancPluginRestApiPostPut params;
2391 params.target = target;
2394 params.bodySize = bodySize;
2395 return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, ¶ms);
2416 return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2439 return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2467 _OrthancPluginRestApiPostPut params;
2468 params.target = target;
2471 params.bodySize = bodySize;
2472 return context->InvokeService(context, _OrthancPluginService_RestApiPut, ¶ms);
2503 _OrthancPluginRestApiPostPut params;
2504 params.target = target;
2507 params.bodySize = bodySize;
2508 return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, ¶ms);
2516 const char* argument;
2517 } _OrthancPluginOutputPlusArgument;
2533 const char* redirection)
2535 _OrthancPluginOutputPlusArgument params;
2536 params.output = output;
2537 params.argument = redirection;
2538 context->InvokeService(context, _OrthancPluginService_Redirect, ¶ms);
2546 const char* argument;
2547 } _OrthancPluginRetrieveDynamicString;
2564 const char* patientID)
2568 _OrthancPluginRetrieveDynamicString params;
2569 params.result = &result;
2570 params.argument = patientID;
2599 const char* studyUID)
2603 _OrthancPluginRetrieveDynamicString params;
2604 params.result = &result;
2605 params.argument = studyUID;
2634 const char* accessionNumber)
2638 _OrthancPluginRetrieveDynamicString params;
2639 params.result = &result;
2640 params.argument = accessionNumber;
2669 const char* seriesUID)
2673 _OrthancPluginRetrieveDynamicString params;
2674 params.result = &result;
2675 params.argument = seriesUID;
2704 const char* sopInstanceUID)
2708 _OrthancPluginRetrieveDynamicString params;
2709 params.result = &result;
2710 params.argument = sopInstanceUID;
2729 } _OrthancPluginSendHttpStatusCode;
2752 _OrthancPluginSendHttpStatusCode params;
2753 params.output = output;
2754 params.status = status;
2755 context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, ¶ms);
2775 _OrthancPluginOutputPlusArgument params;
2776 params.output = output;
2777 params.argument = realm;
2778 context->InvokeService(context, _OrthancPluginService_SendUnauthorized, ¶ms);
2796 const char* allowedMethods)
2798 _OrthancPluginOutputPlusArgument params;
2799 params.output = output;
2800 params.argument = allowedMethods;
2801 context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, ¶ms);
2810 } _OrthancPluginSetHttpHeader;
2829 _OrthancPluginSetHttpHeader params;
2830 params.output = output;
2831 params.key = cookie;
2832 params.value = value;
2833 context->InvokeService(context, _OrthancPluginService_SetCookie, ¶ms);
2854 _OrthancPluginSetHttpHeader params;
2855 params.output = output;
2857 params.value = value;
2858 context->InvokeService(context, _OrthancPluginService_SetHttpHeader, ¶ms);
2864 char** resultStringToFree;
2865 const char** resultString;
2866 int64_t* resultInt64;
2870 } _OrthancPluginAccessDicomInstance;
2890 _OrthancPluginAccessDicomInstance params;
2891 memset(¶ms, 0,
sizeof(params));
2892 params.resultString = &result;
2893 params.instance = instance;
2923 _OrthancPluginAccessDicomInstance params;
2924 memset(¶ms, 0,
sizeof(params));
2925 params.resultInt64 = &size;
2926 params.instance = instance;
2956 _OrthancPluginAccessDicomInstance params;
2957 memset(¶ms, 0,
sizeof(params));
2958 params.resultString = &result;
2959 params.instance = instance;
2992 _OrthancPluginAccessDicomInstance params;
2993 memset(¶ms, 0,
sizeof(params));
2994 params.resultStringToFree = &result;
2995 params.instance = instance;
3030 _OrthancPluginAccessDicomInstance params;
3031 memset(¶ms, 0,
sizeof(params));
3032 params.resultStringToFree = &result;
3033 params.instance = instance;
3066 const char* metadata)
3070 _OrthancPluginAccessDicomInstance params;
3071 memset(¶ms, 0,
sizeof(params));
3072 params.resultInt64 = &result;
3073 params.instance = instance;
3074 params.key = metadata;
3083 return (result != 0);
3107 const char* metadata)
3111 _OrthancPluginAccessDicomInstance params;
3112 memset(¶ms, 0,
sizeof(params));
3113 params.resultString = &result;
3114 params.instance = instance;
3115 params.key = metadata;
3136 } _OrthancPluginRegisterStorageArea;
3159 _OrthancPluginRegisterStorageArea params;
3160 params.create = create;
3162 params.remove = remove;
3165 params.free = ::free;
3170 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, ¶ms);
3189 _OrthancPluginRetrieveDynamicString params;
3190 params.result = &result;
3191 params.argument = NULL;
3219 _OrthancPluginRetrieveDynamicString params;
3220 params.result = &result;
3221 params.argument = NULL;
3254 _OrthancPluginRetrieveDynamicString params;
3255 params.result = &result;
3256 params.argument = NULL;
3274 } _OrthancPluginOnChangeCallback;
3300 _OrthancPluginOnChangeCallback params;
3301 params.callback = callback;
3303 context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, ¶ms);
3311 _OrthancPluginProperty property;
3313 } _OrthancPluginSetPluginProperty;
3331 _OrthancPluginSetPluginProperty params;
3332 params.plugin = OrthancPluginGetName();
3333 params.property = _OrthancPluginProperty_RootUri;
3336 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms);
3351 const char* description)
3353 _OrthancPluginSetPluginProperty params;
3354 params.plugin = OrthancPluginGetName();
3355 params.property = _OrthancPluginProperty_Description;
3356 params.value = description;
3358 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms);
3373 const char* javascript)
3375 _OrthancPluginSetPluginProperty params;
3376 params.plugin = OrthancPluginGetName();
3377 params.property = _OrthancPluginProperty_OrthancExplorer;
3378 params.value = javascript;
3380 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms);
3389 } _OrthancPluginGlobalProperty;
3408 const char* defaultValue)
3412 _OrthancPluginGlobalProperty params;
3413 params.result = &result;
3414 params.property = property;
3415 params.value = defaultValue;
3449 _OrthancPluginGlobalProperty params;
3450 params.result = NULL;
3451 params.property = property;
3452 params.value = value;
3454 return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, ¶ms);
3461 int32_t *resultInt32;
3462 uint32_t *resultUint32;
3463 int64_t *resultInt64;
3464 uint64_t *resultUint64;
3465 } _OrthancPluginReturnSingleValue;
3480 _OrthancPluginReturnSingleValue params;
3481 memset(¶ms, 0,
sizeof(params));
3482 params.resultUint32 = &count;
3515 _OrthancPluginGlobalProperty params;
3516 params.result = &result;
3517 params.property = (int32_t) argument;
3518 params.value = NULL;
3546 _OrthancPluginReturnSingleValue params;
3547 memset(¶ms, 0,
sizeof(params));
3548 params.resultUint32 = &count;
3578 _OrthancPluginRetrieveDynamicString params;
3579 params.result = &result;
3580 params.argument = NULL;
3598 const char* subType;
3599 const char* contentType;
3600 } _OrthancPluginStartMultipartAnswer;
3618 const char* subType,
3619 const char* contentType)
3621 _OrthancPluginStartMultipartAnswer params;
3622 params.output = output;
3623 params.subType = subType;
3624 params.contentType = contentType;
3625 return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, ¶ms);
3648 uint32_t answerSize)
3650 _OrthancPluginAnswerBuffer params;
3651 params.output = output;
3652 params.answer = answer;
3653 params.answerSize = answerSize;
3654 params.mimeType = NULL;
3655 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, ¶ms);
3667 } _OrthancPluginBufferCompression;
3694 _OrthancPluginBufferCompression params;
3695 params.target = target;
3696 params.source = source;
3698 params.compression = compression;
3699 params.uncompress = uncompress;
3701 return context->InvokeService(context, _OrthancPluginService_BufferCompression, ¶ms);
3710 } _OrthancPluginReadFile;
3728 _OrthancPluginReadFile params;
3729 params.target = target;
3731 return context->InvokeService(context, _OrthancPluginService_ReadFile, ¶ms);
3741 } _OrthancPluginWriteFile;
3760 _OrthancPluginWriteFile params;
3764 return context->InvokeService(context, _OrthancPluginService_WriteFile, ¶ms);
3771 const char** target;
3773 } _OrthancPluginGetErrorDescription;
3789 const char* result = NULL;
3791 _OrthancPluginGetErrorDescription params;
3792 params.target = &result;
3793 params.error = error;
3798 return "Unknown error code";
3814 } _OrthancPluginSendHttpStatus;
3845 _OrthancPluginSendHttpStatus params;
3846 params.output = output;
3847 params.status = status;
3849 params.bodySize = bodySize;
3850 context->InvokeService(context, _OrthancPluginService_SendHttpStatus, ¶ms);
3858 uint32_t* resultUint32;
3860 void** resultBuffer;
3861 } _OrthancPluginGetImageInfo;
3880 _OrthancPluginGetImageInfo params;
3881 memset(¶ms, 0,
sizeof(params));
3882 params.image = image;
3883 params.resultPixelFormat = ⌖
3913 _OrthancPluginGetImageInfo params;
3914 memset(¶ms, 0,
sizeof(params));
3915 params.image = image;
3916 params.resultUint32 = &width;
3946 _OrthancPluginGetImageInfo params;
3947 memset(¶ms, 0,
sizeof(params));
3948 params.image = image;
3949 params.resultUint32 = &height;
3981 _OrthancPluginGetImageInfo params;
3982 memset(¶ms, 0,
sizeof(params));
3983 params.image = image;
3984 params.resultUint32 = &pitch;
4013 void* target = NULL;
4015 _OrthancPluginGetImageInfo params;
4016 memset(¶ms, 0,
sizeof(params));
4017 params.resultBuffer = ⌖
4018 params.image = image;
4037 } _OrthancPluginUncompressImage;
4060 _OrthancPluginUncompressImage params;
4061 memset(¶ms, 0,
sizeof(params));
4062 params.target = ⌖
4065 params.format = format;
4083 } _OrthancPluginFreeImage;
4098 _OrthancPluginFreeImage params;
4099 params.image = image;
4101 context->InvokeService(context, _OrthancPluginService_FreeImage, ¶ms);
4117 } _OrthancPluginCompressImage;
4148 _OrthancPluginCompressImage params;
4149 memset(¶ms, 0,
sizeof(params));
4150 params.target = target;
4152 params.pixelFormat = format;
4153 params.width = width;
4154 params.height = height;
4155 params.pitch = pitch;
4156 params.buffer = buffer;
4159 return context->InvokeService(context, _OrthancPluginService_CompressImage, ¶ms);
4194 _OrthancPluginCompressImage params;
4195 memset(¶ms, 0,
sizeof(params));
4196 params.target = target;
4198 params.pixelFormat = format;
4199 params.width = width;
4200 params.height = height;
4201 params.pitch = pitch;
4202 params.buffer = buffer;
4203 params.quality = quality;
4205 return context->InvokeService(context, _OrthancPluginService_CompressImage, ¶ms);
4241 _OrthancPluginCompressAndAnswerImage params;
4242 params.output = output;
4244 params.pixelFormat = format;
4245 params.width = width;
4246 params.height = height;
4247 params.pitch = pitch;
4248 params.buffer = buffer;
4249 params.quality = quality;
4250 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, ¶ms);
4261 const char* username;
4262 const char* password;
4265 } _OrthancPluginCallHttpClient;
4288 const char* username,
4289 const char* password)
4291 _OrthancPluginCallHttpClient params;
4292 memset(¶ms, 0,
sizeof(params));
4294 params.target = target;
4297 params.username = username;
4298 params.password = password;
4300 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
4328 const char* username,
4329 const char* password)
4331 _OrthancPluginCallHttpClient params;
4332 memset(¶ms, 0,
sizeof(params));
4334 params.target = target;
4338 params.bodySize = bodySize;
4339 params.username = username;
4340 params.password = password;
4342 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
4370 const char* username,
4371 const char* password)
4373 _OrthancPluginCallHttpClient params;
4374 memset(¶ms, 0,
sizeof(params));
4376 params.target = target;
4380 params.bodySize = bodySize;
4381 params.username = username;
4382 params.password = password;
4384 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
4405 const char* username,
4406 const char* password)
4408 _OrthancPluginCallHttpClient params;
4409 memset(¶ms, 0,
sizeof(params));
4413 params.username = username;
4414 params.password = password;
4416 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
4426 } _OrthancPluginConvertPixelFormat;
4447 _OrthancPluginConvertPixelFormat params;
4448 params.target = ⌖
4449 params.source = source;
4450 params.targetFormat = targetFormat;
4480 _OrthancPluginReturnSingleValue params;
4481 memset(¶ms, 0,
sizeof(params));
4482 params.resultUint32 = &count;
4503 } _OrthancPluginGetFontInfo;
4519 const char* result = NULL;
4521 _OrthancPluginGetFontInfo params;
4522 memset(¶ms, 0,
sizeof(params));
4523 params.name = &result;
4524 params.fontIndex = fontIndex;
4553 _OrthancPluginGetFontInfo params;
4554 memset(¶ms, 0,
sizeof(params));
4555 params.size = &result;
4556 params.fontIndex = fontIndex;
4574 const char* utf8Text;
4580 } _OrthancPluginDrawText;
4604 const char* utf8Text,
4611 _OrthancPluginDrawText params;
4612 memset(¶ms, 0,
sizeof(params));
4613 params.image = image;
4614 params.fontIndex = fontIndex;
4615 params.utf8Text = utf8Text;
4622 return context->InvokeService(context, _OrthancPluginService_DrawText, ¶ms);
4631 const void* content;
4634 } _OrthancPluginStorageAreaCreate;
4658 const void* content,
4662 _OrthancPluginStorageAreaCreate params;
4663 params.storageArea = storageArea;
4665 params.content = content;
4669 return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, ¶ms);
4679 } _OrthancPluginStorageAreaRead;
4705 _OrthancPluginStorageAreaRead params;
4706 params.target = target;
4707 params.storageArea = storageArea;
4711 return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, ¶ms);
4720 } _OrthancPluginStorageAreaRemove;
4743 _OrthancPluginStorageAreaRemove params;
4744 params.storageArea = storageArea;
4748 return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, ¶ms);
4757 uint16_t httpStatus;
4758 const char* message;
4759 } _OrthancPluginRegisterErrorCode;
4779 uint16_t httpStatus,
4780 const char* message)
4784 _OrthancPluginRegisterErrorCode params;
4785 params.target = ⌖
4787 params.httpStatus = httpStatus;
4788 params.message = message;
4809 uint32_t minMultiplicity;
4810 uint32_t maxMultiplicity;
4811 } _OrthancPluginRegisterDictionaryTag;
4838 uint32_t minMultiplicity,
4839 uint32_t maxMultiplicity)
4841 _OrthancPluginRegisterDictionaryTag params;
4842 params.group = group;
4843 params.element = element;
4846 params.minMultiplicity = minMultiplicity;
4847 params.maxMultiplicity = maxMultiplicity;
4849 return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, ¶ms);
4860 uint32_t minMultiplicity;
4861 uint32_t maxMultiplicity;
4862 const char* privateCreator;
4863 } _OrthancPluginRegisterPrivateDictionaryTag;
4891 uint32_t minMultiplicity,
4892 uint32_t maxMultiplicity,
4893 const char* privateCreator)
4895 _OrthancPluginRegisterPrivateDictionaryTag params;
4896 params.group = group;
4897 params.element = element;
4900 params.minMultiplicity = minMultiplicity;
4901 params.maxMultiplicity = maxMultiplicity;
4902 params.privateCreator = privateCreator;
4904 return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, ¶ms);
4913 } _OrthancPluginReconstructMainDicomTags;
4934 _OrthancPluginReconstructMainDicomTags params;
4935 params.level = level;
4936 params.storageArea = storageArea;
4938 return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, ¶ms);
4945 const char* instanceId;
4950 uint32_t maxStringLength;
4951 } _OrthancPluginDicomToJson;
4979 uint32_t maxStringLength)
4983 _OrthancPluginDicomToJson params;
4984 memset(¶ms, 0,
sizeof(params));
4985 params.result = &result;
4986 params.buffer = buffer;
4988 params.format = format;
4989 params.flags = flags;
4990 params.maxStringLength = maxStringLength;
5024 const char* instanceId,
5027 uint32_t maxStringLength)
5031 _OrthancPluginDicomToJson params;
5032 memset(¶ms, 0,
sizeof(params));
5033 params.result = &result;
5034 params.instanceId = instanceId;
5035 params.format = format;
5036 params.flags = flags;
5037 params.maxStringLength = maxStringLength;
5055 uint32_t headersCount;
5056 const char*
const* headersKeys;
5057 const char*
const* headersValues;
5058 int32_t afterPlugins;
5059 } _OrthancPluginRestApiGet2;
5084 uint32_t headersCount,
5085 const char*
const* headersKeys,
5086 const char*
const* headersValues,
5087 int32_t afterPlugins)
5089 _OrthancPluginRestApiGet2 params;
5090 params.target = target;
5092 params.headersCount = headersCount;
5093 params.headersKeys = headersKeys;
5094 params.headersValues = headersValues;
5095 params.afterPlugins = afterPlugins;
5097 return context->InvokeService(context, _OrthancPluginService_RestApiGet2, ¶ms);
5105 } _OrthancPluginWorklistCallback;
5122 _OrthancPluginWorklistCallback params;
5123 params.callback = callback;
5125 return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, ¶ms);
5136 } _OrthancPluginWorklistAnswersOperation;
5161 _OrthancPluginWorklistAnswersOperation params;
5162 params.answers = answers;
5163 params.query = query;
5164 params.dicom = dicom;
5167 return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, ¶ms);
5188 _OrthancPluginWorklistAnswersOperation params;
5189 params.answers = answers;
5190 params.query = NULL;
5191 params.dicom = NULL;
5194 return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, ¶ms);
5205 } _OrthancPluginWorklistQueryOperation;
5228 int32_t isMatch = 0;
5230 _OrthancPluginWorklistQueryOperation params;
5231 params.query = query;
5232 params.dicom = dicom;
5234 params.isMatch = &isMatch;
5235 params.target = NULL;
5266 _OrthancPluginWorklistQueryOperation params;
5267 params.query = query;
5268 params.dicom = NULL;
5270 params.isMatch = NULL;
5271 params.target = target;
5273 return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, ¶ms);
5293 _OrthancPluginAccessDicomInstance params;
5294 memset(¶ms, 0,
sizeof(params));
5295 params.resultOrigin = &origin;
5296 params.instance = instance;
5316 } _OrthancPluginCreateDicom;
5350 _OrthancPluginCreateDicom params;
5351 params.target = target;
5353 params.pixelData = pixelData;
5354 params.flags = flags;
5356 return context->InvokeService(context, _OrthancPluginService_CreateDicom, ¶ms);
5363 } _OrthancPluginDecodeImageCallback;
5383 _OrthancPluginDecodeImageCallback params;
5384 params.callback = callback;
5386 return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, ¶ms);
5399 const void* constBuffer;
5400 uint32_t bufferSize;
5401 uint32_t frameIndex;
5402 } _OrthancPluginCreateImage;
5425 _OrthancPluginCreateImage params;
5426 memset(¶ms, 0,
sizeof(params));
5427 params.target = ⌖
5428 params.format = format;
5429 params.width = width;
5430 params.height = height;
5470 _OrthancPluginCreateImage params;
5471 memset(¶ms, 0,
sizeof(params));
5472 params.target = ⌖
5473 params.format = format;
5474 params.width = width;
5475 params.height = height;
5476 params.pitch = pitch;
5477 params.buffer = buffer;
5509 uint32_t bufferSize,
5510 uint32_t frameIndex)
5514 _OrthancPluginCreateImage params;
5515 memset(¶ms, 0,
sizeof(params));
5516 params.target = ⌖
5517 params.constBuffer = buffer;
5518 params.bufferSize = bufferSize;
5519 params.frameIndex = frameIndex;
5538 } _OrthancPluginComputeHash;
5559 _OrthancPluginComputeHash params;
5560 params.result = &result;
5561 params.buffer = buffer;
5595 _OrthancPluginComputeHash params;
5596 params.result = &result;
5597 params.buffer = buffer;
5617 } _OrthancPluginLookupDictionary;
5639 _OrthancPluginLookupDictionary params;
5640 params.target = target;
5642 return context->InvokeService(context, _OrthancPluginService_LookupDictionary, ¶ms);
5651 uint32_t answerSize;
5652 uint32_t headersCount;
5653 const char*
const* headersKeys;
5654 const char*
const* headersValues;
5655 } _OrthancPluginSendMultipartItem2;
5681 uint32_t answerSize,
5682 uint32_t headersCount,
5683 const char*
const* headersKeys,
5684 const char*
const* headersValues)
5686 _OrthancPluginSendMultipartItem2 params;
5687 params.output = output;
5688 params.answer = answer;
5689 params.answerSize = answerSize;
5690 params.headersCount = headersCount;
5691 params.headersKeys = headersKeys;
5692 params.headersValues = headersValues;
5694 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, ¶ms);
5701 } _OrthancPluginIncomingHttpRequestFilter;
5719 _OrthancPluginIncomingHttpRequestFilter params;
5720 params.callback = callback;
5722 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, ¶ms);
5731 uint16_t* httpStatus;
5734 uint32_t headersCount;
5735 const char*
const* headersKeys;
5736 const char*
const* headersValues;
5739 const char* username;
5740 const char* password;
5742 const char* certificateFile;
5743 const char* certificateKeyFile;
5744 const char* certificateKeyPassword;
5746 } _OrthancPluginCallHttpClient2;
5794 uint16_t* httpStatus,
5797 uint32_t headersCount,
5798 const char*
const* headersKeys,
5799 const char*
const* headersValues,
5802 const char* username,
5803 const char* password,
5805 const char* certificateFile,
5806 const char* certificateKeyFile,
5807 const char* certificateKeyPassword,
5810 _OrthancPluginCallHttpClient2 params;
5811 memset(¶ms, 0,
sizeof(params));
5813 params.answerBody = answerBody;
5814 params.answerHeaders = answerHeaders;
5815 params.httpStatus = httpStatus;
5816 params.method = method;
5818 params.headersCount = headersCount;
5819 params.headersKeys = headersKeys;
5820 params.headersValues = headersValues;
5822 params.bodySize = bodySize;
5823 params.username = username;
5824 params.password = password;
5825 params.timeout = timeout;
5826 params.certificateFile = certificateFile;
5827 params.certificateKeyFile = certificateKeyFile;
5828 params.certificateKeyPassword = certificateKeyPassword;
5829 params.pkcs11 = pkcs11;
5831 return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, ¶ms);
5850 _OrthancPluginRetrieveDynamicString params;
5851 params.result = &result;
5852 params.argument = NULL;
5871 } _OrthancPluginFindCallback;
5888 _OrthancPluginFindCallback params;
5889 params.callback = callback;
5891 return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, ¶ms);
5902 uint32_t *resultUint32;
5903 uint16_t *resultGroup;
5904 uint16_t *resultElement;
5905 char **resultString;
5906 } _OrthancPluginFindOperation;
5929 _OrthancPluginFindOperation params;
5930 memset(¶ms, 0,
sizeof(params));
5931 params.answers = answers;
5932 params.dicom = dicom;
5935 return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, ¶ms);
5956 _OrthancPluginFindOperation params;
5957 memset(¶ms, 0,
sizeof(params));
5958 params.answers = answers;
5960 return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, ¶ms);
5982 _OrthancPluginFindOperation params;
5983 memset(¶ms, 0,
sizeof(params));
5984 params.query = query;
5985 params.resultUint32 = &count;
6020 _OrthancPluginFindOperation params;
6021 memset(¶ms, 0,
sizeof(params));
6022 params.query = query;
6023 params.index = index;
6024 params.resultGroup = group;
6025 params.resultElement = element;
6027 return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, ¶ms);
6051 _OrthancPluginFindOperation params;
6052 memset(¶ms, 0,
sizeof(params));
6053 params.query = query;
6054 params.index = index;
6055 params.resultString = &result;
6089 _OrthancPluginFindOperation params;
6090 memset(¶ms, 0,
sizeof(params));
6091 params.query = query;
6092 params.index = index;
6093 params.resultString = &result;
6115 } _OrthancPluginMoveCallback;
6137 _OrthancPluginMoveCallback params;
6138 params.callback = callback;
6139 params.getMoveSize = getMoveSize;
6140 params.applyMove = applyMove;
6141 params.freeMove = freeMove;
6143 return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, ¶ms);
6153 } _OrthancPluginCreateFindMatcher;
6176 _OrthancPluginCreateFindMatcher params;
6177 memset(¶ms, 0,
sizeof(params));
6178 params.target = ⌖
6179 params.query = query;
6196 } _OrthancPluginFreeFindMatcher;
6211 _OrthancPluginFreeFindMatcher params;
6212 params.matcher = matcher;
6214 context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, ¶ms);
6224 } _OrthancPluginFindMatcherIsMatch;
6246 int32_t isMatch = 0;
6248 _OrthancPluginFindMatcherIsMatch params;
6249 params.matcher = matcher;
6250 params.dicom = dicom;
6252 params.isMatch = &isMatch;
6269 } _OrthancPluginIncomingHttpRequestFilter2;
6286 _OrthancPluginIncomingHttpRequestFilter2 params;
6287 params.callback = callback;
6289 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, ¶ms);
6297 } _OrthancPluginGetPeers;
6315 _OrthancPluginGetPeers params;
6316 memset(¶ms, 0,
sizeof(params));
6317 params.peers = &peers;
6333 } _OrthancPluginFreePeers;
6348 _OrthancPluginFreePeers params;
6349 params.peers = peers;
6351 context->InvokeService(context, _OrthancPluginService_FreePeers, ¶ms);
6359 } _OrthancPluginGetPeersCount;
6378 uint32_t target = 0;
6380 _OrthancPluginGetPeersCount params;
6381 memset(¶ms, 0,
sizeof(params));
6382 params.target = ⌖
6383 params.peers = peers;
6399 const char** target;
6402 const char* userProperty;
6403 } _OrthancPluginGetPeerProperty;
6427 const char* target = NULL;
6429 _OrthancPluginGetPeerProperty params;
6430 memset(¶ms, 0,
sizeof(params));
6431 params.target = ⌖
6432 params.peers = peers;
6433 params.peerIndex = peerIndex;
6434 params.userProperty = NULL;
6468 const char* target = NULL;
6470 _OrthancPluginGetPeerProperty params;
6471 memset(¶ms, 0,
sizeof(params));
6472 params.target = ⌖
6473 params.peers = peers;
6474 params.peerIndex = peerIndex;
6475 params.userProperty = NULL;
6513 const char* userProperty)
6515 const char* target = NULL;
6517 _OrthancPluginGetPeerProperty params;
6518 memset(¶ms, 0,
sizeof(params));
6519 params.target = ⌖
6520 params.peers = peers;
6521 params.peerIndex = peerIndex;
6522 params.userProperty = userProperty;
6541 uint16_t* httpStatus;
6546 uint32_t additionalHeadersCount;
6547 const char*
const* additionalHeadersKeys;
6548 const char*
const* additionalHeadersValues;
6552 } _OrthancPluginCallPeerApi;
6594 uint16_t* httpStatus,
6599 uint32_t additionalHeadersCount,
6600 const char*
const* additionalHeadersKeys,
6601 const char*
const* additionalHeadersValues,
6606 _OrthancPluginCallPeerApi params;
6607 memset(¶ms, 0,
sizeof(params));
6609 params.answerBody = answerBody;
6610 params.answerHeaders = answerHeaders;
6611 params.httpStatus = httpStatus;
6612 params.peers = peers;
6613 params.peerIndex = peerIndex;
6614 params.method = method;
6616 params.additionalHeadersCount = additionalHeadersCount;
6617 params.additionalHeadersKeys = additionalHeadersKeys;
6618 params.additionalHeadersValues = additionalHeadersValues;
6620 params.bodySize = bodySize;
6621 params.timeout = timeout;
6623 return context->InvokeService(context, _OrthancPluginService_CallPeerApi, ¶ms);
6642 } _OrthancPluginCreateJob;
6689 _OrthancPluginCreateJob params;
6690 memset(¶ms, 0,
sizeof(params));
6692 params.target = ⌖
6694 params.finalize = finalize;
6696 params.getProgress = getProgress;
6697 params.getContent = getContent;
6698 params.getSerialized = getSerialized;
6701 params.reset = reset;
6719 } _OrthancPluginFreeJob;
6734 _OrthancPluginFreeJob params;
6737 context->InvokeService(context, _OrthancPluginService_FreeJob, ¶ms);
6747 } _OrthancPluginSubmitJob;
6767 char* resultId = NULL;
6769 _OrthancPluginSubmitJob params;
6770 memset(¶ms, 0,
sizeof(params));
6772 params.resultId = &resultId;
6774 params.priority = priority;
6793 } _OrthancPluginJobsUnserializer;
6811 _OrthancPluginJobsUnserializer params;
6812 params.unserializer = unserializer;
6814 context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, ¶ms);
6822 const char* details;
6824 } _OrthancPluginSetHttpErrorDetails;
6846 const char* details,
6849 _OrthancPluginSetHttpErrorDetails params;
6850 params.output = output;
6851 params.details = details;
6853 context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, ¶ms);
6860 const char** result;
6861 const char* argument;
6862 } _OrthancPluginRetrieveStaticString;
6879 const char* result = NULL;
6881 _OrthancPluginRetrieveStaticString params;
6882 params.result = &result;
6883 params.argument = path;
6903 } _OrthancPluginSetMetricsValue;
6925 _OrthancPluginSetMetricsValue params;
6927 params.value = value;
6929 context->InvokeService(context, _OrthancPluginService_SetMetricsValue, ¶ms);
6937 } _OrthancPluginRegisterRefreshMetricsCallback;
6953 _OrthancPluginRegisterRefreshMetricsCallback params;
6954 params.callback = callback;
6955 context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, ¶ms);
6967 } _OrthancPluginEncodeDicomWeb;
6991 char* target = NULL;
6993 _OrthancPluginEncodeDicomWeb params;
6994 params.target = ⌖
6995 params.dicom = dicom;
6996 params.dicomSize = dicomSize;
6997 params.callback = callback;
7033 char* target = NULL;
7035 _OrthancPluginEncodeDicomWeb params;
7036 params.target = ⌖
7037 params.dicom = dicom;
7038 params.dicomSize = dicomSize;
7039 params.callback = callback;
7061 } _OrthancPluginEncodeDicomWeb2;
7086 char* target = NULL;
7088 _OrthancPluginEncodeDicomWeb2 params;
7089 params.target = ⌖
7090 params.dicom = dicom;
7091 params.dicomSize = dicomSize;
7092 params.callback = callback;
7093 params.payload = payload;
7130 char* target = NULL;
7132 _OrthancPluginEncodeDicomWeb2 params;
7133 params.target = ⌖
7134 params.dicom = dicom;
7135 params.dicomSize = dicomSize;
7136 params.callback = callback;
7137 params.payload = payload;
7241 typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (
void* request);
7265 uint16_t* httpStatus;
7268 uint32_t headersCount;
7269 const char*
const* headersKeys;
7270 const char*
const* headersValues;
7276 const char* username;
7277 const char* password;
7279 const char* certificateFile;
7280 const char* certificateKeyFile;
7281 const char* certificateKeyPassword;
7283 } _OrthancPluginChunkedHttpClient;
7341 uint16_t* httpStatus,
7344 uint32_t headersCount,
7345 const char*
const* headersKeys,
7346 const char*
const* headersValues,
7352 const char* username,
7353 const char* password,
7355 const char* certificateFile,
7356 const char* certificateKeyFile,
7357 const char* certificateKeyPassword,
7360 _OrthancPluginChunkedHttpClient params;
7361 memset(¶ms, 0,
sizeof(params));
7364 params.httpStatus = httpStatus;
7365 params.method = method;
7367 params.headersCount = headersCount;
7368 params.headersKeys = headersKeys;
7369 params.headersValues = headersValues;
7370 params.username = username;
7371 params.password = password;
7372 params.timeout = timeout;
7373 params.certificateFile = certificateFile;
7374 params.certificateKeyFile = certificateKeyFile;
7375 params.certificateKeyPassword = certificateKeyPassword;
7376 params.pkcs11 = pkcs11;
7379 params.answer = answer;
7380 params.answerAddChunk = answerAddChunk;
7381 params.answerAddHeader = answerAddHeader;
7382 params.request = request;
7383 params.requestIsDone = requestIsDone;
7384 params.requestChunkData = requestChunkData;
7385 params.requestChunkSize = requestChunkSize;
7386 params.requestNext = requestNext;
7388 return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, ¶ms);
7478 const char* pathRegularExpression;
7486 } _OrthancPluginChunkedRestCallback;
7520 const char* pathRegularExpression,
7529 _OrthancPluginChunkedRestCallback params;
7530 params.pathRegularExpression = pathRegularExpression;
7531 params.getHandler = getHandler;
7532 params.postHandler = postHandler;
7533 params.deleteHandler = deleteHandler;
7534 params.putHandler = putHandler;
7535 params.addChunk = addChunk;
7536 params.execute = execute;
7537 params.finalize = finalize;
7539 context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, ¶ms);
7551 const char* privateCreator;
7552 } _OrthancPluginGetTagName;
7573 const char* privateCreator)
7577 _OrthancPluginGetTagName params;
7578 params.result = &result;
7579 params.group = group;
7580 params.element = element;
7581 params.privateCreator = privateCreator;
7627 const char* transactionUid,
7628 const char*
const* sopClassUids,
7629 const char*
const* sopInstanceUids,
7630 uint32_t countInstances,
7631 const char* remoteAet,
7632 const char* calledAet);
7670 const char* sopClassUid,
7671 const char* sopInstanceUid);
7679 } _OrthancPluginRegisterStorageCommitmentScpCallback;
7700 _OrthancPluginRegisterStorageCommitmentScpCallback params;
7701 params.factory = factory;
7702 params.destructor = destructor;
7703 params.lookup = lookup;
7704 return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, ¶ms);
7731 } _OrthancPluginIncomingDicomInstanceFilter;
7759 _OrthancPluginIncomingDicomInstanceFilter params;
7760 params.callback = callback;
7762 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, ¶ms);
7785 _OrthancPluginAccessDicomInstance params;
7786 memset(¶ms, 0,
sizeof(params));
7787 params.resultStringToFree = &result;
7788 params.instance = instance;
7818 int64_t hasPixelData;
7820 _OrthancPluginAccessDicomInstance params;
7821 memset(¶ms, 0,
sizeof(params));
7822 params.resultInt64 = &hasPixelData;
7823 params.instance = instance;
7834 return (hasPixelData != 0);
7848 const char* transferSyntax;
7849 } _OrthancPluginCreateDicomInstance;
7871 _OrthancPluginCreateDicomInstance params;
7872 params.target = ⌖
7873 params.buffer = buffer;
7890 } _OrthancPluginFreeDicomInstance;
7906 _OrthancPluginFreeDicomInstance params;
7907 params.dicom = dicom;
7909 context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, ¶ms);
7915 uint32_t* targetUint32;
7918 char** targetStringToFree;
7920 uint32_t frameIndex;
7923 uint32_t maxStringLength;
7925 void* dicomWebPayload;
7926 } _OrthancPluginAccessDicomInstance2;
7945 _OrthancPluginAccessDicomInstance2 params;
7946 memset(¶ms, 0,
sizeof(params));
7947 params.targetUint32 = &count;
7948 params.instance = instance;
7983 uint32_t frameIndex)
7985 _OrthancPluginAccessDicomInstance2 params;
7986 memset(¶ms, 0,
sizeof(params));
7987 params.targetBuffer = target;
7988 params.instance = instance;
7989 params.frameIndex = frameIndex;
7991 return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, ¶ms);
8010 uint32_t frameIndex)
8014 _OrthancPluginAccessDicomInstance2 params;
8015 memset(¶ms, 0,
sizeof(params));
8016 params.targetImage = ⌖
8017 params.instance = instance;
8018 params.frameIndex = frameIndex;
8050 const char* transferSyntax)
8054 _OrthancPluginCreateDicomInstance params;
8055 params.target = ⌖
8056 params.buffer = buffer;
8058 params.transferSyntax = transferSyntax;
8089 _OrthancPluginAccessDicomInstance2 params;
8090 memset(¶ms, 0,
sizeof(params));
8091 params.targetBuffer = target;
8092 params.instance = instance;
8094 return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, ¶ms);
8121 uint32_t maxStringLength)
8123 char* result = NULL;
8125 _OrthancPluginAccessDicomInstance2 params;
8126 memset(¶ms, 0,
sizeof(params));
8127 params.targetStringToFree = &result;
8128 params.instance = instance;
8129 params.format = format;
8130 params.flags = flags;
8131 params.maxStringLength = maxStringLength;
8165 char* target = NULL;
8167 _OrthancPluginAccessDicomInstance2 params;
8168 params.targetStringToFree = ⌖
8169 params.instance = instance;
8170 params.dicomWebCallback = callback;
8171 params.dicomWebPayload = payload;
8205 char* target = NULL;
8207 _OrthancPluginAccessDicomInstance2 params;
8208 params.targetStringToFree = ⌖
8209 params.instance = instance;
8210 params.dicomWebCallback = callback;
8211 params.dicomWebPayload = payload;
8248 const char*
const* allowedSyntaxes,
8249 uint32_t countSyntaxes,
8250 uint8_t allowNewSopInstanceUid);
8256 } _OrthancPluginTranscoderCallback;
8275 _OrthancPluginTranscoderCallback params;
8276 params.callback = callback;
8278 return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, ¶ms);
8287 } _OrthancPluginCreateMemoryBuffer;
8311 _OrthancPluginCreateMemoryBuffer params;
8312 params.target = target;
8315 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, ¶ms);
8349 _OrthancPluginRetrieveDynamicString params;
8350 params.result = &result;
8351 params.argument = NULL;
8353 if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
8371 } _OrthancPluginCreateMemoryBuffer64;
8395 _OrthancPluginCreateMemoryBuffer64 params;
8396 params.target = target;
8399 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer64, ¶ms);
8409 } _OrthancPluginRegisterStorageArea2;
8434 _OrthancPluginRegisterStorageArea2 params;
8435 params.create = create;
8436 params.readWhole = readWhole;
8437 params.readRange = readRange;
8438 params.remove = remove;
8439 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea2, ¶ms);
8446 _OrthancPluginCreateDicom createDicom;
8447 const char* privateCreator;
8448 } _OrthancPluginCreateDicom2;
8480 const char* privateCreator)
8482 _OrthancPluginCreateDicom2 params;
8483 params.createDicom.target = target;
8484 params.createDicom.json = json;
8485 params.createDicom.pixelData = pixelData;
8486 params.createDicom.flags = flags;
8487 params.privateCreator = privateCreator;
8489 return context->InvokeService(context, _OrthancPluginService_CreateDicom2, ¶ms);
8501 uint16_t* httpStatus;
8504 uint32_t headersCount;
8505 const char*
const* headersKeys;
8506 const char*
const* headersValues;
8509 uint8_t afterPlugins;
8510 } _OrthancPluginCallRestApi;
8546 uint16_t* httpStatus,
8549 uint32_t headersCount,
8550 const char*
const* headersKeys,
8551 const char*
const* headersValues,
8554 uint8_t afterPlugins)
8556 _OrthancPluginCallRestApi params;
8557 memset(¶ms, 0,
sizeof(params));
8559 params.answerBody = answerBody;
8560 params.answerHeaders = answerHeaders;
8561 params.httpStatus = httpStatus;
8562 params.method = method;
8564 params.headersCount = headersCount;
8565 params.headersKeys = headersKeys;
8566 params.headersValues = headersValues;
8568 params.bodySize = bodySize;
8569 params.afterPlugins = afterPlugins;
8571 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:1816
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:3153
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:2118
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:1204
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5379
OrthancPluginChangeType
Definition: OrthancCPlugin.h:722
OrthancPluginErrorCode(* OrthancPluginStorageReadWhole)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type)
Callback for reading a whole file from the storage area.
Definition: OrthancCPlugin.h:1270
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1921
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:1182
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:6949
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:1697
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4737
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:8244
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6282
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1250
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:2040
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3541
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3296
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:8427
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1150
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1669
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition: OrthancCPlugin.h:8271
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:1161
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4929
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1311
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1223
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:1735
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:1171
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1651
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6807
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1194
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:2080
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4698
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:1293
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:7518
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition: OrthancCPlugin.h:7755
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5715
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:4654
@ OrthancPluginChangeType_OrthancStopped
Definition: OrthancCPlugin.h:734
@ OrthancPluginChangeType_OrthancStarted
Definition: OrthancCPlugin.h:733
@ OrthancPluginChangeType_Deleted
Definition: OrthancCPlugin.h:724
@ OrthancPluginChangeType_JobFailure
Definition: OrthancCPlugin.h:741
@ OrthancPluginChangeType_NewInstance
Definition: OrthancCPlugin.h:726
@ OrthancPluginChangeType_NewPatient
Definition: OrthancCPlugin.h:727
@ OrthancPluginChangeType_JobSubmitted
Definition: OrthancCPlugin.h:739
@ OrthancPluginChangeType_NewSeries
Definition: OrthancCPlugin.h:728
@ OrthancPluginChangeType_StablePatient
Definition: OrthancCPlugin.h:730
@ OrthancPluginChangeType_UpdatedPeers
Definition: OrthancCPlugin.h:737
@ OrthancPluginChangeType_StableStudy
Definition: OrthancCPlugin.h:732
@ OrthancPluginChangeType_CompletedSeries
Definition: OrthancCPlugin.h:723
@ OrthancPluginChangeType_NewChildInstance
Definition: OrthancCPlugin.h:725
@ OrthancPluginChangeType_UpdatedAttachment
Definition: OrthancCPlugin.h:735
@ OrthancPluginChangeType_UpdatedMetadata
Definition: OrthancCPlugin.h:736
@ OrthancPluginChangeType_StableSeries
Definition: OrthancCPlugin.h:731
@ OrthancPluginChangeType_UpdatedModalities
Definition: OrthancCPlugin.h:738
@ OrthancPluginChangeType_JobSuccess
Definition: OrthancCPlugin.h:740
@ OrthancPluginChangeType_NewStudy
Definition: OrthancCPlugin.h:729
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5976
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1101
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1506
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:5952
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:6044
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7646
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:1330
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:6130
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:7624
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5884
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5261
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:7667
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:5222
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5923
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:1466
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:7694
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1109
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1093
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1423
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1491
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:5118
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5184
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:6082
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:6013
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1520
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1085
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:5154
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:7814
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:8199
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition: OrthancCPlugin.h:1061
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition: OrthancCPlugin.h:7779
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:7979
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:8116
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2950
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition: OrthancCPlugin.h:7864
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition: OrthancCPlugin.h:7939
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:8007
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5287
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2917
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:8159
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:3024
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2986
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:3063
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:3104
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition: OrthancCPlugin.h:7902
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition: OrthancCPlugin.h:8084
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition: OrthancCPlugin.h:8046
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2884
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:598
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:4600
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:4184
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3975
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4440
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3874
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4475
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:3940
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:4094
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:4139
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5417
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:4052
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4515
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:4009
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:5460
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:767
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:1077
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:752
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3907
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:3686
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5506
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4547
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1069
@ OrthancPluginPixelFormat_RGBA32
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:637
@ OrthancPluginPixelFormat_RGB48
Color image in RGB48 format.
Definition: OrthancCPlugin.h:647
@ OrthancPluginPixelFormat_Grayscale8
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:605
@ OrthancPluginPixelFormat_SignedGrayscale16
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:621
@ OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:663
@ OrthancPluginPixelFormat_RGB24
Color image in RGB24 format.
Definition: OrthancCPlugin.h:629
@ OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:671
@ OrthancPluginPixelFormat_Unknown
Definition: OrthancCPlugin.h:639
@ OrthancPluginPixelFormat_Grayscale64
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:679
@ OrthancPluginPixelFormat_Grayscale32
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:655
@ OrthancPluginPixelFormat_Grayscale16
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:613
@ OrthancPluginImageFormat_Png
Definition: OrthancCPlugin.h:768
@ OrthancPluginImageFormat_Jpeg
Definition: OrthancCPlugin.h:769
@ OrthancPluginImageFormat_Dicom
Definition: OrthancCPlugin.h:770
@ OrthancPluginCompressionType_Gzip
Definition: OrthancCPlugin.h:755
@ OrthancPluginCompressionType_ZlibWithSize
Definition: OrthancCPlugin.h:754
@ OrthancPluginCompressionType_Zlib
Definition: OrthancCPlugin.h:753
@ OrthancPluginCompressionType_GzipWithSize
Definition: OrthancCPlugin.h:756
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:2348
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:2383
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:2496
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2597
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3444
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3405
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:2460
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2667
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2632
char * OrthancPluginGenerateRestApiAuthorizationToken(OrthancPluginContext *context)
Generate a token to grant full access to the REST API of Orthanc.
Definition: OrthancCPlugin.h:8344
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2281
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2702
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:2311
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2562
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2412
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2435
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:8542
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:5080
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2248
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:2207
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2770
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:6843
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2793
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:2150
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2747
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2848
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2823
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2530
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:4231
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:3644
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:5677
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3615
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:3838
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1768
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1772
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1773
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1771
uint16_t element
Definition: OrthancCPlugin.h:1770
uint16_t group
Definition: OrthancCPlugin.h:1769
The parameters of a REST request.
Definition: OrthancCPlugin.h:337
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:366
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:351
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:376
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:346
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:391
const void * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:371
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:361
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:386
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:341
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:356
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:396
A 64-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1034
uint64_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1043
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1038
A 32-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1012
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1021
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1016