114# define ORTHANC_PLUGINS_API __declspec(dllexport)
116# define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default")))
118# define ORTHANC_PLUGINS_API
121#define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
122#define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 12
123#define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 1
126#if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
127#define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
128 (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
129 (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
130 (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
131 (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
132 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
151#ifndef ORTHANC_PLUGIN_INLINE
152# if __STDC_VERSION__ >= 199901L
154# define ORTHANC_PLUGIN_INLINE static inline
155# elif defined(__cplusplus)
157# define ORTHANC_PLUGIN_INLINE static inline
158# elif defined(__GNUC__)
160# define ORTHANC_PLUGIN_INLINE static __inline
161# elif defined(_MSC_VER)
163# define ORTHANC_PLUGIN_INLINE static __inline
165# error Your compiler is not known to support the "inline" keyword
311 _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
319 ORTHANC_PLUGINS_API
const char* OrthancPluginGetName();
332 _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
408 _OrthancPluginService_LogInfo = 1,
409 _OrthancPluginService_LogWarning = 2,
410 _OrthancPluginService_LogError = 3,
411 _OrthancPluginService_GetOrthancPath = 4,
412 _OrthancPluginService_GetOrthancDirectory = 5,
413 _OrthancPluginService_GetConfigurationPath = 6,
414 _OrthancPluginService_SetPluginProperty = 7,
415 _OrthancPluginService_GetGlobalProperty = 8,
416 _OrthancPluginService_SetGlobalProperty = 9,
417 _OrthancPluginService_GetCommandLineArgumentsCount = 10,
418 _OrthancPluginService_GetCommandLineArgument = 11,
419 _OrthancPluginService_GetExpectedDatabaseVersion = 12,
420 _OrthancPluginService_GetConfiguration = 13,
421 _OrthancPluginService_BufferCompression = 14,
422 _OrthancPluginService_ReadFile = 15,
423 _OrthancPluginService_WriteFile = 16,
424 _OrthancPluginService_GetErrorDescription = 17,
425 _OrthancPluginService_CallHttpClient = 18,
426 _OrthancPluginService_RegisterErrorCode = 19,
427 _OrthancPluginService_RegisterDictionaryTag = 20,
428 _OrthancPluginService_DicomBufferToJson = 21,
429 _OrthancPluginService_DicomInstanceToJson = 22,
430 _OrthancPluginService_CreateDicom = 23,
431 _OrthancPluginService_ComputeMd5 = 24,
432 _OrthancPluginService_ComputeSha1 = 25,
433 _OrthancPluginService_LookupDictionary = 26,
434 _OrthancPluginService_CallHttpClient2 = 27,
435 _OrthancPluginService_GenerateUuid = 28,
436 _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
437 _OrthancPluginService_AutodetectMimeType = 30,
438 _OrthancPluginService_SetMetricsValue = 31,
439 _OrthancPluginService_EncodeDicomWebJson = 32,
440 _OrthancPluginService_EncodeDicomWebXml = 33,
441 _OrthancPluginService_ChunkedHttpClient = 34,
442 _OrthancPluginService_GetTagName = 35,
443 _OrthancPluginService_EncodeDicomWebJson2 = 36,
444 _OrthancPluginService_EncodeDicomWebXml2 = 37,
445 _OrthancPluginService_CreateMemoryBuffer = 38,
446 _OrthancPluginService_GenerateRestApiAuthorizationToken = 39,
447 _OrthancPluginService_CreateMemoryBuffer64 = 40,
448 _OrthancPluginService_CreateDicom2 = 41,
449 _OrthancPluginService_GetDatabaseServerIdentifier = 42,
450 _OrthancPluginService_SetMetricsIntegerValue = 43,
453 _OrthancPluginService_RegisterRestCallback = 1000,
454 _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
455 _OrthancPluginService_RegisterStorageArea = 1002,
456 _OrthancPluginService_RegisterOnChangeCallback = 1003,
457 _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
458 _OrthancPluginService_RegisterWorklistCallback = 1005,
459 _OrthancPluginService_RegisterDecodeImageCallback = 1006,
460 _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
461 _OrthancPluginService_RegisterFindCallback = 1008,
462 _OrthancPluginService_RegisterMoveCallback = 1009,
463 _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
464 _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
465 _OrthancPluginService_RegisterChunkedRestCallback = 1012,
466 _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
467 _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
468 _OrthancPluginService_RegisterTranscoderCallback = 1015,
469 _OrthancPluginService_RegisterStorageArea2 = 1016,
470 _OrthancPluginService_RegisterIncomingCStoreInstanceFilter = 1017,
471 _OrthancPluginService_RegisterReceivedInstanceCallback = 1018,
472 _OrthancPluginService_RegisterWebDavCollection = 1019,
475 _OrthancPluginService_AnswerBuffer = 2000,
476 _OrthancPluginService_CompressAndAnswerPngImage = 2001,
477 _OrthancPluginService_Redirect = 2002,
478 _OrthancPluginService_SendHttpStatusCode = 2003,
479 _OrthancPluginService_SendUnauthorized = 2004,
480 _OrthancPluginService_SendMethodNotAllowed = 2005,
481 _OrthancPluginService_SetCookie = 2006,
482 _OrthancPluginService_SetHttpHeader = 2007,
483 _OrthancPluginService_StartMultipartAnswer = 2008,
484 _OrthancPluginService_SendMultipartItem = 2009,
485 _OrthancPluginService_SendHttpStatus = 2010,
486 _OrthancPluginService_CompressAndAnswerImage = 2011,
487 _OrthancPluginService_SendMultipartItem2 = 2012,
488 _OrthancPluginService_SetHttpErrorDetails = 2013,
491 _OrthancPluginService_GetDicomForInstance = 3000,
492 _OrthancPluginService_RestApiGet = 3001,
493 _OrthancPluginService_RestApiPost = 3002,
494 _OrthancPluginService_RestApiDelete = 3003,
495 _OrthancPluginService_RestApiPut = 3004,
496 _OrthancPluginService_LookupPatient = 3005,
497 _OrthancPluginService_LookupStudy = 3006,
498 _OrthancPluginService_LookupSeries = 3007,
499 _OrthancPluginService_LookupInstance = 3008,
500 _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
501 _OrthancPluginService_RestApiGetAfterPlugins = 3010,
502 _OrthancPluginService_RestApiPostAfterPlugins = 3011,
503 _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
504 _OrthancPluginService_RestApiPutAfterPlugins = 3013,
505 _OrthancPluginService_ReconstructMainDicomTags = 3014,
506 _OrthancPluginService_RestApiGet2 = 3015,
507 _OrthancPluginService_CallRestApi = 3016,
510 _OrthancPluginService_GetInstanceRemoteAet = 4000,
511 _OrthancPluginService_GetInstanceSize = 4001,
512 _OrthancPluginService_GetInstanceData = 4002,
513 _OrthancPluginService_GetInstanceJson = 4003,
514 _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
515 _OrthancPluginService_HasInstanceMetadata = 4005,
516 _OrthancPluginService_GetInstanceMetadata = 4006,
517 _OrthancPluginService_GetInstanceOrigin = 4007,
518 _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
519 _OrthancPluginService_HasInstancePixelData = 4009,
520 _OrthancPluginService_CreateDicomInstance = 4010,
521 _OrthancPluginService_FreeDicomInstance = 4011,
522 _OrthancPluginService_GetInstanceFramesCount = 4012,
523 _OrthancPluginService_GetInstanceRawFrame = 4013,
524 _OrthancPluginService_GetInstanceDecodedFrame = 4014,
525 _OrthancPluginService_TranscodeDicomInstance = 4015,
526 _OrthancPluginService_SerializeDicomInstance = 4016,
527 _OrthancPluginService_GetInstanceAdvancedJson = 4017,
528 _OrthancPluginService_GetInstanceDicomWebJson = 4018,
529 _OrthancPluginService_GetInstanceDicomWebXml = 4019,
530 _OrthancPluginService_LoadDicomInstance = 4020,
533 _OrthancPluginService_RegisterDatabaseBackend = 5000,
534 _OrthancPluginService_DatabaseAnswer = 5001,
535 _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
536 _OrthancPluginService_StorageAreaCreate = 5003,
537 _OrthancPluginService_StorageAreaRead = 5004,
538 _OrthancPluginService_StorageAreaRemove = 5005,
539 _OrthancPluginService_RegisterDatabaseBackendV3 = 5006,
540 _OrthancPluginService_RegisterDatabaseBackendV4 = 5007,
543 _OrthancPluginService_GetImagePixelFormat = 6000,
544 _OrthancPluginService_GetImageWidth = 6001,
545 _OrthancPluginService_GetImageHeight = 6002,
546 _OrthancPluginService_GetImagePitch = 6003,
547 _OrthancPluginService_GetImageBuffer = 6004,
548 _OrthancPluginService_UncompressImage = 6005,
549 _OrthancPluginService_FreeImage = 6006,
550 _OrthancPluginService_CompressImage = 6007,
551 _OrthancPluginService_ConvertPixelFormat = 6008,
552 _OrthancPluginService_GetFontsCount = 6009,
553 _OrthancPluginService_GetFontInfo = 6010,
554 _OrthancPluginService_DrawText = 6011,
555 _OrthancPluginService_CreateImage = 6012,
556 _OrthancPluginService_CreateImageAccessor = 6013,
557 _OrthancPluginService_DecodeDicomImage = 6014,
560 _OrthancPluginService_WorklistAddAnswer = 7000,
561 _OrthancPluginService_WorklistMarkIncomplete = 7001,
562 _OrthancPluginService_WorklistIsMatch = 7002,
563 _OrthancPluginService_WorklistGetDicomQuery = 7003,
564 _OrthancPluginService_FindAddAnswer = 7004,
565 _OrthancPluginService_FindMarkIncomplete = 7005,
566 _OrthancPluginService_GetFindQuerySize = 7006,
567 _OrthancPluginService_GetFindQueryTag = 7007,
568 _OrthancPluginService_GetFindQueryTagName = 7008,
569 _OrthancPluginService_GetFindQueryValue = 7009,
570 _OrthancPluginService_CreateFindMatcher = 7010,
571 _OrthancPluginService_FreeFindMatcher = 7011,
572 _OrthancPluginService_FindMatcherIsMatch = 7012,
575 _OrthancPluginService_GetPeers = 8000,
576 _OrthancPluginService_FreePeers = 8001,
577 _OrthancPluginService_GetPeersCount = 8003,
578 _OrthancPluginService_GetPeerName = 8004,
579 _OrthancPluginService_GetPeerUrl = 8005,
580 _OrthancPluginService_CallPeerApi = 8006,
581 _OrthancPluginService_GetPeerUserProperty = 8007,
584 _OrthancPluginService_CreateJob = 9000,
585 _OrthancPluginService_FreeJob = 9001,
586 _OrthancPluginService_SubmitJob = 9002,
587 _OrthancPluginService_RegisterJobsUnserializer = 9003,
588 _OrthancPluginService_CreateJob2 = 9004,
590 _OrthancPluginService_INTERNAL = 0x7fffffff
591 } _OrthancPluginService;
596 _OrthancPluginProperty_Description = 1,
597 _OrthancPluginProperty_RootUri = 2,
598 _OrthancPluginProperty_OrthancExplorer = 3,
600 _OrthancPluginProperty_INTERNAL = 0x7fffffff
601 } _OrthancPluginProperty;
693 _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
708 _OrthancPluginContentType_INTERNAL = 0x7fffffff
724 _OrthancPluginResourceType_INTERNAL = 0x7fffffff
755 _OrthancPluginChangeType_INTERNAL = 0x7fffffff
770 _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
784 _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
822 _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
837 _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
848 OrthancPluginDicomToJsonFlags_None = 0,
858 _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
869 OrthancPluginCreateDicomFlags_None = 0,
873 _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
889 _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
905 _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
921 _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
1024 _OrthancPluginReceivedInstanceAction_INTERNAL = 0x7fffffff
1046 _OrthancPluginLoadDicomInstanceMode_INTERNAL = 0x7fffffff
1209 const char* instanceId);
1220 const char* resourceId);
1231 const uint32_t size,
1232 uint32_t frameIndex);
1253 const char* bulkDataUri);
1271 const void* content,
1343 uint64_t rangeStart);
1379 const char* issuerAet,
1380 const char* calledAet);
1411 uint32_t headersCount,
1412 const char*
const* headersKeys,
1413 const char*
const* headersValues);
1446 uint32_t headersCount,
1447 const char*
const* headersKeys,
1448 const char*
const* headersValues,
1449 uint32_t getArgumentsCount,
1450 const char*
const* getArgumentsKeys,
1451 const char*
const* getArgumentsValues);
1472 const char* issuerAet,
1473 const char* calledAet);
1512 typedef void* (*OrthancPluginMoveCallback) (
1514 const char* patientId,
1515 const char* accessionNumber,
1516 const char* studyInstanceUid,
1517 const char* seriesInstanceUid,
1518 const char* sopInstanceUid,
1519 const char* originatorAet,
1520 const char* sourceAet,
1521 const char* targetAet,
1522 uint16_t originatorId);
1608 typedef const char* (*OrthancPluginJobGetContent) (
void* job);
1646 typedef const char* (*OrthancPluginJobGetSerialized) (
void* job);
1740 const char* serialized);
1789 uint32_t levelDepth,
1790 const uint16_t* levelTagGroup,
1791 const uint16_t* levelTagElement,
1792 const uint32_t* levelIndex,
1794 uint16_t tagElement,
1827 uint32_t levelDepth,
1828 const uint16_t* levelTagGroup,
1829 const uint16_t* levelTagElement,
1830 const uint32_t* levelIndex,
1832 uint16_t tagElement,
1841 typedef struct _OrthancPluginContext_t
1843 void* pluginsManager;
1844 const char* orthancVersion;
1847 _OrthancPluginService service,
1848 const void* params);
1909 int expectedRevision)
1911 int major, minor, revision;
1915 sizeof(int32_t) !=
sizeof(_OrthancPluginService) ||
1916 sizeof(int32_t) !=
sizeof(_OrthancPluginProperty) ||
1941 if (!strcmp(context->orthancVersion,
"mainline"))
1953 (context->orthancVersion,
"%4d.%4d.%4d", &major, &minor, &revision) != 3)
1960 if (major > expectedMajor)
1965 if (major < expectedMajor)
1972 if (minor > expectedMinor)
1977 if (minor < expectedMinor)
1984 if (revision >= expectedRevision)
2016 ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
2017 ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
2018 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
2034 context->Free(buffer->
data);
2050 context->Free(buffer->
data);
2064 const char* message)
2066 context->InvokeService(context, _OrthancPluginService_LogError, message);
2080 const char* message)
2082 context->InvokeService(context, _OrthancPluginService_LogWarning, message);
2096 const char* message)
2098 context->InvokeService(context, _OrthancPluginService_LogInfo, message);
2105 const char* pathRegularExpression;
2107 } _OrthancPluginRestCallback;
2132 const char* pathRegularExpression,
2135 _OrthancPluginRestCallback params;
2136 params.pathRegularExpression = pathRegularExpression;
2137 params.callback = callback;
2138 context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, ¶ms);
2172 const char* pathRegularExpression,
2175 _OrthancPluginRestCallback params;
2176 params.pathRegularExpression = pathRegularExpression;
2177 params.callback = callback;
2178 context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, ¶ms);
2186 } _OrthancPluginOnStoredInstanceCallback;
2212 _OrthancPluginOnStoredInstanceCallback params;
2213 params.callback = callback;
2215 context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, ¶ms);
2224 uint32_t answerSize;
2225 const char* mimeType;
2226 } _OrthancPluginAnswerBuffer;
2244 uint32_t answerSize,
2245 const char* mimeType)
2247 _OrthancPluginAnswerBuffer params;
2248 params.output = output;
2249 params.answer = answer;
2250 params.answerSize = answerSize;
2251 params.mimeType = mimeType;
2252 context->InvokeService(context, _OrthancPluginService_AnswerBuffer, ¶ms);
2264 } _OrthancPluginCompressAndAnswerPngImage;
2276 } _OrthancPluginCompressAndAnswerImage;
2306 _OrthancPluginCompressAndAnswerImage params;
2307 params.output = output;
2309 params.pixelFormat = format;
2310 params.width = width;
2311 params.height = height;
2312 params.pitch = pitch;
2313 params.buffer = buffer;
2315 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, ¶ms);
2323 const char* instanceId;
2324 } _OrthancPluginGetDicomForInstance;
2341 const char* instanceId)
2343 _OrthancPluginGetDicomForInstance params;
2344 params.target = target;
2345 params.instanceId = instanceId;
2346 return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, ¶ms);
2355 } _OrthancPluginRestApiGet;
2376 _OrthancPluginRestApiGet params;
2377 params.target = target;
2379 return context->InvokeService(context, _OrthancPluginService_RestApiGet, ¶ms);
2406 _OrthancPluginRestApiGet params;
2407 params.target = target;
2409 return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, ¶ms);
2420 } _OrthancPluginRestApiPostPut;
2445 _OrthancPluginRestApiPostPut params;
2446 params.target = target;
2449 params.bodySize = bodySize;
2450 return context->InvokeService(context, _OrthancPluginService_RestApiPost, ¶ms);
2480 _OrthancPluginRestApiPostPut params;
2481 params.target = target;
2484 params.bodySize = bodySize;
2485 return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, ¶ms);
2506 return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2529 return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2557 _OrthancPluginRestApiPostPut params;
2558 params.target = target;
2561 params.bodySize = bodySize;
2562 return context->InvokeService(context, _OrthancPluginService_RestApiPut, ¶ms);
2593 _OrthancPluginRestApiPostPut params;
2594 params.target = target;
2597 params.bodySize = bodySize;
2598 return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, ¶ms);
2606 const char* argument;
2607 } _OrthancPluginOutputPlusArgument;
2623 const char* redirection)
2625 _OrthancPluginOutputPlusArgument params;
2626 params.output = output;
2627 params.argument = redirection;
2628 context->InvokeService(context, _OrthancPluginService_Redirect, ¶ms);
2636 const char* argument;
2637 } _OrthancPluginRetrieveDynamicString;
2654 const char* patientID)
2658 _OrthancPluginRetrieveDynamicString params;
2659 params.result = &result;
2660 params.argument = patientID;
2689 const char* studyUID)
2693 _OrthancPluginRetrieveDynamicString params;
2694 params.result = &result;
2695 params.argument = studyUID;
2724 const char* accessionNumber)
2728 _OrthancPluginRetrieveDynamicString params;
2729 params.result = &result;
2730 params.argument = accessionNumber;
2759 const char* seriesUID)
2763 _OrthancPluginRetrieveDynamicString params;
2764 params.result = &result;
2765 params.argument = seriesUID;
2794 const char* sopInstanceUID)
2798 _OrthancPluginRetrieveDynamicString params;
2799 params.result = &result;
2800 params.argument = sopInstanceUID;
2819 } _OrthancPluginSendHttpStatusCode;
2842 _OrthancPluginSendHttpStatusCode params;
2843 params.output = output;
2844 params.status = status;
2845 context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, ¶ms);
2865 _OrthancPluginOutputPlusArgument params;
2866 params.output = output;
2867 params.argument = realm;
2868 context->InvokeService(context, _OrthancPluginService_SendUnauthorized, ¶ms);
2886 const char* allowedMethods)
2888 _OrthancPluginOutputPlusArgument params;
2889 params.output = output;
2890 params.argument = allowedMethods;
2891 context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, ¶ms);
2900 } _OrthancPluginSetHttpHeader;
2919 _OrthancPluginSetHttpHeader params;
2920 params.output = output;
2921 params.key = cookie;
2922 params.value = value;
2923 context->InvokeService(context, _OrthancPluginService_SetCookie, ¶ms);
2944 _OrthancPluginSetHttpHeader params;
2945 params.output = output;
2947 params.value = value;
2948 context->InvokeService(context, _OrthancPluginService_SetHttpHeader, ¶ms);
2954 char** resultStringToFree;
2955 const char** resultString;
2956 int64_t* resultInt64;
2960 } _OrthancPluginAccessDicomInstance;
2980 _OrthancPluginAccessDicomInstance params;
2981 memset(¶ms, 0,
sizeof(params));
2982 params.resultString = &result;
2983 params.instance = instance;
3013 _OrthancPluginAccessDicomInstance params;
3014 memset(¶ms, 0,
sizeof(params));
3015 params.resultInt64 = &size;
3016 params.instance = instance;
3046 _OrthancPluginAccessDicomInstance params;
3047 memset(¶ms, 0,
sizeof(params));
3048 params.resultString = &result;
3049 params.instance = instance;
3082 _OrthancPluginAccessDicomInstance params;
3083 memset(¶ms, 0,
sizeof(params));
3084 params.resultStringToFree = &result;
3085 params.instance = instance;
3120 _OrthancPluginAccessDicomInstance params;
3121 memset(¶ms, 0,
sizeof(params));
3122 params.resultStringToFree = &result;
3123 params.instance = instance;
3156 const char* metadata)
3160 _OrthancPluginAccessDicomInstance params;
3161 memset(¶ms, 0,
sizeof(params));
3162 params.resultInt64 = &result;
3163 params.instance = instance;
3164 params.key = metadata;
3173 return (result != 0);
3197 const char* metadata)
3201 _OrthancPluginAccessDicomInstance params;
3202 memset(¶ms, 0,
sizeof(params));
3203 params.resultString = &result;
3204 params.instance = instance;
3205 params.key = metadata;
3226 } _OrthancPluginRegisterStorageArea;
3249 _OrthancPluginRegisterStorageArea params;
3250 params.create = create;
3252 params.remove = remove;
3255 params.free = ::free;
3260 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, ¶ms);
3279 _OrthancPluginRetrieveDynamicString params;
3280 params.result = &result;
3281 params.argument = NULL;
3309 _OrthancPluginRetrieveDynamicString params;
3310 params.result = &result;
3311 params.argument = NULL;
3344 _OrthancPluginRetrieveDynamicString params;
3345 params.result = &result;
3346 params.argument = NULL;
3364 } _OrthancPluginOnChangeCallback;
3390 _OrthancPluginOnChangeCallback params;
3391 params.callback = callback;
3393 context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, ¶ms);
3401 _OrthancPluginProperty property;
3403 } _OrthancPluginSetPluginProperty;
3421 _OrthancPluginSetPluginProperty params;
3422 params.plugin = OrthancPluginGetName();
3423 params.property = _OrthancPluginProperty_RootUri;
3426 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms);
3441 const char* description)
3443 _OrthancPluginSetPluginProperty params;
3444 params.plugin = OrthancPluginGetName();
3445 params.property = _OrthancPluginProperty_Description;
3446 params.value = description;
3448 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms);
3463 const char* javascript)
3465 _OrthancPluginSetPluginProperty params;
3466 params.plugin = OrthancPluginGetName();
3467 params.property = _OrthancPluginProperty_OrthancExplorer;
3468 params.value = javascript;
3470 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, ¶ms);
3479 } _OrthancPluginGlobalProperty;
3498 const char* defaultValue)
3502 _OrthancPluginGlobalProperty params;
3503 params.result = &result;
3504 params.property = property;
3505 params.value = defaultValue;
3539 _OrthancPluginGlobalProperty params;
3540 params.result = NULL;
3541 params.property = property;
3542 params.value = value;
3544 return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, ¶ms);
3551 int32_t *resultInt32;
3552 uint32_t *resultUint32;
3553 int64_t *resultInt64;
3554 uint64_t *resultUint64;
3555 } _OrthancPluginReturnSingleValue;
3570 _OrthancPluginReturnSingleValue params;
3571 memset(¶ms, 0,
sizeof(params));
3572 params.resultUint32 = &count;
3605 _OrthancPluginGlobalProperty params;
3606 params.result = &result;
3607 params.property = (int32_t) argument;
3608 params.value = NULL;
3636 _OrthancPluginReturnSingleValue params;
3637 memset(¶ms, 0,
sizeof(params));
3638 params.resultUint32 = &count;
3668 _OrthancPluginRetrieveDynamicString params;
3669 params.result = &result;
3670 params.argument = NULL;
3688 const char* subType;
3689 const char* contentType;
3690 } _OrthancPluginStartMultipartAnswer;
3708 const char* subType,
3709 const char* contentType)
3711 _OrthancPluginStartMultipartAnswer params;
3712 params.output = output;
3713 params.subType = subType;
3714 params.contentType = contentType;
3715 return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, ¶ms);
3738 uint32_t answerSize)
3740 _OrthancPluginAnswerBuffer params;
3741 params.output = output;
3742 params.answer = answer;
3743 params.answerSize = answerSize;
3744 params.mimeType = NULL;
3745 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, ¶ms);
3757 } _OrthancPluginBufferCompression;
3784 _OrthancPluginBufferCompression params;
3785 params.target = target;
3786 params.source = source;
3788 params.compression = compression;
3789 params.uncompress = uncompress;
3791 return context->InvokeService(context, _OrthancPluginService_BufferCompression, ¶ms);
3800 } _OrthancPluginReadFile;
3818 _OrthancPluginReadFile params;
3819 params.target = target;
3821 return context->InvokeService(context, _OrthancPluginService_ReadFile, ¶ms);
3831 } _OrthancPluginWriteFile;
3850 _OrthancPluginWriteFile params;
3854 return context->InvokeService(context, _OrthancPluginService_WriteFile, ¶ms);
3861 const char** target;
3863 } _OrthancPluginGetErrorDescription;
3879 const char* result = NULL;
3881 _OrthancPluginGetErrorDescription params;
3882 params.target = &result;
3883 params.error = error;
3888 return "Unknown error code";
3904 } _OrthancPluginSendHttpStatus;
3935 _OrthancPluginSendHttpStatus params;
3936 params.output = output;
3937 params.status = status;
3939 params.bodySize = bodySize;
3940 context->InvokeService(context, _OrthancPluginService_SendHttpStatus, ¶ms);
3948 uint32_t* resultUint32;
3950 void** resultBuffer;
3951 } _OrthancPluginGetImageInfo;
3970 _OrthancPluginGetImageInfo params;
3971 memset(¶ms, 0,
sizeof(params));
3972 params.image = image;
3973 params.resultPixelFormat = ⌖
4003 _OrthancPluginGetImageInfo params;
4004 memset(¶ms, 0,
sizeof(params));
4005 params.image = image;
4006 params.resultUint32 = &width;
4036 _OrthancPluginGetImageInfo params;
4037 memset(¶ms, 0,
sizeof(params));
4038 params.image = image;
4039 params.resultUint32 = &height;
4071 _OrthancPluginGetImageInfo params;
4072 memset(¶ms, 0,
sizeof(params));
4073 params.image = image;
4074 params.resultUint32 = &pitch;
4103 void* target = NULL;
4105 _OrthancPluginGetImageInfo params;
4106 memset(¶ms, 0,
sizeof(params));
4107 params.resultBuffer = ⌖
4108 params.image = image;
4127 } _OrthancPluginUncompressImage;
4150 _OrthancPluginUncompressImage params;
4151 memset(¶ms, 0,
sizeof(params));
4152 params.target = ⌖
4155 params.format = format;
4173 } _OrthancPluginFreeImage;
4188 _OrthancPluginFreeImage params;
4189 params.image = image;
4191 context->InvokeService(context, _OrthancPluginService_FreeImage, ¶ms);
4207 } _OrthancPluginCompressImage;
4238 _OrthancPluginCompressImage params;
4239 memset(¶ms, 0,
sizeof(params));
4240 params.target = target;
4242 params.pixelFormat = format;
4243 params.width = width;
4244 params.height = height;
4245 params.pitch = pitch;
4246 params.buffer = buffer;
4249 return context->InvokeService(context, _OrthancPluginService_CompressImage, ¶ms);
4284 _OrthancPluginCompressImage params;
4285 memset(¶ms, 0,
sizeof(params));
4286 params.target = target;
4288 params.pixelFormat = format;
4289 params.width = width;
4290 params.height = height;
4291 params.pitch = pitch;
4292 params.buffer = buffer;
4293 params.quality = quality;
4295 return context->InvokeService(context, _OrthancPluginService_CompressImage, ¶ms);
4331 _OrthancPluginCompressAndAnswerImage params;
4332 params.output = output;
4334 params.pixelFormat = format;
4335 params.width = width;
4336 params.height = height;
4337 params.pitch = pitch;
4338 params.buffer = buffer;
4339 params.quality = quality;
4340 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, ¶ms);
4351 const char* username;
4352 const char* password;
4355 } _OrthancPluginCallHttpClient;
4378 const char* username,
4379 const char* password)
4381 _OrthancPluginCallHttpClient params;
4382 memset(¶ms, 0,
sizeof(params));
4384 params.target = target;
4387 params.username = username;
4388 params.password = password;
4390 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
4418 const char* username,
4419 const char* password)
4421 _OrthancPluginCallHttpClient params;
4422 memset(¶ms, 0,
sizeof(params));
4424 params.target = target;
4428 params.bodySize = bodySize;
4429 params.username = username;
4430 params.password = password;
4432 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
4460 const char* username,
4461 const char* password)
4463 _OrthancPluginCallHttpClient params;
4464 memset(¶ms, 0,
sizeof(params));
4466 params.target = target;
4470 params.bodySize = bodySize;
4471 params.username = username;
4472 params.password = password;
4474 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
4495 const char* username,
4496 const char* password)
4498 _OrthancPluginCallHttpClient params;
4499 memset(¶ms, 0,
sizeof(params));
4503 params.username = username;
4504 params.password = password;
4506 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, ¶ms);
4516 } _OrthancPluginConvertPixelFormat;
4537 _OrthancPluginConvertPixelFormat params;
4538 params.target = ⌖
4539 params.source = source;
4540 params.targetFormat = targetFormat;
4570 _OrthancPluginReturnSingleValue params;
4571 memset(¶ms, 0,
sizeof(params));
4572 params.resultUint32 = &count;
4593 } _OrthancPluginGetFontInfo;
4609 const char* result = NULL;
4611 _OrthancPluginGetFontInfo params;
4612 memset(¶ms, 0,
sizeof(params));
4613 params.name = &result;
4614 params.fontIndex = fontIndex;
4643 _OrthancPluginGetFontInfo params;
4644 memset(¶ms, 0,
sizeof(params));
4645 params.size = &result;
4646 params.fontIndex = fontIndex;
4664 const char* utf8Text;
4670 } _OrthancPluginDrawText;
4694 const char* utf8Text,
4701 _OrthancPluginDrawText params;
4702 memset(¶ms, 0,
sizeof(params));
4703 params.image = image;
4704 params.fontIndex = fontIndex;
4705 params.utf8Text = utf8Text;
4712 return context->InvokeService(context, _OrthancPluginService_DrawText, ¶ms);
4721 const void* content;
4724 } _OrthancPluginStorageAreaCreate;
4748 const void* content,
4752 _OrthancPluginStorageAreaCreate params;
4753 params.storageArea = storageArea;
4755 params.content = content;
4759 return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, ¶ms);
4769 } _OrthancPluginStorageAreaRead;
4795 _OrthancPluginStorageAreaRead params;
4796 params.target = target;
4797 params.storageArea = storageArea;
4801 return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, ¶ms);
4810 } _OrthancPluginStorageAreaRemove;
4833 _OrthancPluginStorageAreaRemove params;
4834 params.storageArea = storageArea;
4838 return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, ¶ms);
4847 uint16_t httpStatus;
4848 const char* message;
4849 } _OrthancPluginRegisterErrorCode;
4869 uint16_t httpStatus,
4870 const char* message)
4874 _OrthancPluginRegisterErrorCode params;
4875 params.target = ⌖
4877 params.httpStatus = httpStatus;
4878 params.message = message;
4899 uint32_t minMultiplicity;
4900 uint32_t maxMultiplicity;
4901 } _OrthancPluginRegisterDictionaryTag;
4928 uint32_t minMultiplicity,
4929 uint32_t maxMultiplicity)
4931 _OrthancPluginRegisterDictionaryTag params;
4932 params.group = group;
4933 params.element = element;
4936 params.minMultiplicity = minMultiplicity;
4937 params.maxMultiplicity = maxMultiplicity;
4939 return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, ¶ms);
4950 uint32_t minMultiplicity;
4951 uint32_t maxMultiplicity;
4952 const char* privateCreator;
4953 } _OrthancPluginRegisterPrivateDictionaryTag;
4981 uint32_t minMultiplicity,
4982 uint32_t maxMultiplicity,
4983 const char* privateCreator)
4985 _OrthancPluginRegisterPrivateDictionaryTag params;
4986 params.group = group;
4987 params.element = element;
4990 params.minMultiplicity = minMultiplicity;
4991 params.maxMultiplicity = maxMultiplicity;
4992 params.privateCreator = privateCreator;
4994 return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, ¶ms);
5003 } _OrthancPluginReconstructMainDicomTags;
5024 _OrthancPluginReconstructMainDicomTags params;
5025 params.level = level;
5026 params.storageArea = storageArea;
5028 return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, ¶ms);
5035 const char* instanceId;
5040 uint32_t maxStringLength;
5041 } _OrthancPluginDicomToJson;
5069 uint32_t maxStringLength)
5073 _OrthancPluginDicomToJson params;
5074 memset(¶ms, 0,
sizeof(params));
5075 params.result = &result;
5076 params.buffer = buffer;
5078 params.format = format;
5079 params.flags = flags;
5080 params.maxStringLength = maxStringLength;
5114 const char* instanceId,
5117 uint32_t maxStringLength)
5121 _OrthancPluginDicomToJson params;
5122 memset(¶ms, 0,
sizeof(params));
5123 params.result = &result;
5124 params.instanceId = instanceId;
5125 params.format = format;
5126 params.flags = flags;
5127 params.maxStringLength = maxStringLength;
5145 uint32_t headersCount;
5146 const char*
const* headersKeys;
5147 const char*
const* headersValues;
5148 int32_t afterPlugins;
5149 } _OrthancPluginRestApiGet2;
5174 uint32_t headersCount,
5175 const char*
const* headersKeys,
5176 const char*
const* headersValues,
5177 int32_t afterPlugins)
5179 _OrthancPluginRestApiGet2 params;
5180 params.target = target;
5182 params.headersCount = headersCount;
5183 params.headersKeys = headersKeys;
5184 params.headersValues = headersValues;
5185 params.afterPlugins = afterPlugins;
5187 return context->InvokeService(context, _OrthancPluginService_RestApiGet2, ¶ms);
5195 } _OrthancPluginWorklistCallback;
5212 _OrthancPluginWorklistCallback params;
5213 params.callback = callback;
5215 return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, ¶ms);
5226 } _OrthancPluginWorklistAnswersOperation;
5251 _OrthancPluginWorklistAnswersOperation params;
5252 params.answers = answers;
5253 params.query = query;
5254 params.dicom = dicom;
5257 return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, ¶ms);
5278 _OrthancPluginWorklistAnswersOperation params;
5279 params.answers = answers;
5280 params.query = NULL;
5281 params.dicom = NULL;
5284 return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, ¶ms);
5295 } _OrthancPluginWorklistQueryOperation;
5318 int32_t isMatch = 0;
5320 _OrthancPluginWorklistQueryOperation params;
5321 params.query = query;
5322 params.dicom = dicom;
5324 params.isMatch = &isMatch;
5325 params.target = NULL;
5356 _OrthancPluginWorklistQueryOperation params;
5357 params.query = query;
5358 params.dicom = NULL;
5360 params.isMatch = NULL;
5361 params.target = target;
5363 return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, ¶ms);
5383 _OrthancPluginAccessDicomInstance params;
5384 memset(¶ms, 0,
sizeof(params));
5385 params.resultOrigin = &origin;
5386 params.instance = instance;
5406 } _OrthancPluginCreateDicom;
5440 _OrthancPluginCreateDicom params;
5441 params.target = target;
5443 params.pixelData = pixelData;
5444 params.flags = flags;
5446 return context->InvokeService(context, _OrthancPluginService_CreateDicom, ¶ms);
5453 } _OrthancPluginDecodeImageCallback;
5473 _OrthancPluginDecodeImageCallback params;
5474 params.callback = callback;
5476 return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, ¶ms);
5489 const void* constBuffer;
5490 uint32_t bufferSize;
5491 uint32_t frameIndex;
5492 } _OrthancPluginCreateImage;
5515 _OrthancPluginCreateImage params;
5516 memset(¶ms, 0,
sizeof(params));
5517 params.target = ⌖
5518 params.format = format;
5519 params.width = width;
5520 params.height = height;
5560 _OrthancPluginCreateImage params;
5561 memset(¶ms, 0,
sizeof(params));
5562 params.target = ⌖
5563 params.format = format;
5564 params.width = width;
5565 params.height = height;
5566 params.pitch = pitch;
5567 params.buffer = buffer;
5599 uint32_t bufferSize,
5600 uint32_t frameIndex)
5604 _OrthancPluginCreateImage params;
5605 memset(¶ms, 0,
sizeof(params));
5606 params.target = ⌖
5607 params.constBuffer = buffer;
5608 params.bufferSize = bufferSize;
5609 params.frameIndex = frameIndex;
5628 } _OrthancPluginComputeHash;
5649 _OrthancPluginComputeHash params;
5650 params.result = &result;
5651 params.buffer = buffer;
5685 _OrthancPluginComputeHash params;
5686 params.result = &result;
5687 params.buffer = buffer;
5707 } _OrthancPluginLookupDictionary;
5729 _OrthancPluginLookupDictionary params;
5730 params.target = target;
5732 return context->InvokeService(context, _OrthancPluginService_LookupDictionary, ¶ms);
5741 uint32_t answerSize;
5742 uint32_t headersCount;
5743 const char*
const* headersKeys;
5744 const char*
const* headersValues;
5745 } _OrthancPluginSendMultipartItem2;
5771 uint32_t answerSize,
5772 uint32_t headersCount,
5773 const char*
const* headersKeys,
5774 const char*
const* headersValues)
5776 _OrthancPluginSendMultipartItem2 params;
5777 params.output = output;
5778 params.answer = answer;
5779 params.answerSize = answerSize;
5780 params.headersCount = headersCount;
5781 params.headersKeys = headersKeys;
5782 params.headersValues = headersValues;
5784 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, ¶ms);
5791 } _OrthancPluginIncomingHttpRequestFilter;
5809 _OrthancPluginIncomingHttpRequestFilter params;
5810 params.callback = callback;
5812 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, ¶ms);
5821 uint16_t* httpStatus;
5824 uint32_t headersCount;
5825 const char*
const* headersKeys;
5826 const char*
const* headersValues;
5829 const char* username;
5830 const char* password;
5832 const char* certificateFile;
5833 const char* certificateKeyFile;
5834 const char* certificateKeyPassword;
5836 } _OrthancPluginCallHttpClient2;
5884 uint16_t* httpStatus,
5887 uint32_t headersCount,
5888 const char*
const* headersKeys,
5889 const char*
const* headersValues,
5892 const char* username,
5893 const char* password,
5895 const char* certificateFile,
5896 const char* certificateKeyFile,
5897 const char* certificateKeyPassword,
5900 _OrthancPluginCallHttpClient2 params;
5901 memset(¶ms, 0,
sizeof(params));
5903 params.answerBody = answerBody;
5904 params.answerHeaders = answerHeaders;
5905 params.httpStatus = httpStatus;
5906 params.method = method;
5908 params.headersCount = headersCount;
5909 params.headersKeys = headersKeys;
5910 params.headersValues = headersValues;
5912 params.bodySize = bodySize;
5913 params.username = username;
5914 params.password = password;
5915 params.timeout = timeout;
5916 params.certificateFile = certificateFile;
5917 params.certificateKeyFile = certificateKeyFile;
5918 params.certificateKeyPassword = certificateKeyPassword;
5919 params.pkcs11 = pkcs11;
5921 return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, ¶ms);
5940 _OrthancPluginRetrieveDynamicString params;
5941 params.result = &result;
5942 params.argument = NULL;
5961 } _OrthancPluginFindCallback;
5978 _OrthancPluginFindCallback params;
5979 params.callback = callback;
5981 return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, ¶ms);
5992 uint32_t *resultUint32;
5993 uint16_t *resultGroup;
5994 uint16_t *resultElement;
5995 char **resultString;
5996 } _OrthancPluginFindOperation;
6019 _OrthancPluginFindOperation params;
6020 memset(¶ms, 0,
sizeof(params));
6021 params.answers = answers;
6022 params.dicom = dicom;
6025 return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, ¶ms);
6046 _OrthancPluginFindOperation params;
6047 memset(¶ms, 0,
sizeof(params));
6048 params.answers = answers;
6050 return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, ¶ms);
6072 _OrthancPluginFindOperation params;
6073 memset(¶ms, 0,
sizeof(params));
6074 params.query = query;
6075 params.resultUint32 = &count;
6110 _OrthancPluginFindOperation params;
6111 memset(¶ms, 0,
sizeof(params));
6112 params.query = query;
6113 params.index = index;
6114 params.resultGroup = group;
6115 params.resultElement = element;
6117 return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, ¶ms);
6141 _OrthancPluginFindOperation params;
6142 memset(¶ms, 0,
sizeof(params));
6143 params.query = query;
6144 params.index = index;
6145 params.resultString = &result;
6179 _OrthancPluginFindOperation params;
6180 memset(¶ms, 0,
sizeof(params));
6181 params.query = query;
6182 params.index = index;
6183 params.resultString = &result;
6205 } _OrthancPluginMoveCallback;
6227 _OrthancPluginMoveCallback params;
6228 params.callback = callback;
6229 params.getMoveSize = getMoveSize;
6230 params.applyMove = applyMove;
6231 params.freeMove = freeMove;
6233 return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, ¶ms);
6243 } _OrthancPluginCreateFindMatcher;
6266 _OrthancPluginCreateFindMatcher params;
6267 memset(¶ms, 0,
sizeof(params));
6268 params.target = ⌖
6269 params.query = query;
6286 } _OrthancPluginFreeFindMatcher;
6301 _OrthancPluginFreeFindMatcher params;
6302 params.matcher = matcher;
6304 context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, ¶ms);
6314 } _OrthancPluginFindMatcherIsMatch;
6336 int32_t isMatch = 0;
6338 _OrthancPluginFindMatcherIsMatch params;
6339 params.matcher = matcher;
6340 params.dicom = dicom;
6342 params.isMatch = &isMatch;
6359 } _OrthancPluginIncomingHttpRequestFilter2;
6376 _OrthancPluginIncomingHttpRequestFilter2 params;
6377 params.callback = callback;
6379 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, ¶ms);
6387 } _OrthancPluginGetPeers;
6405 _OrthancPluginGetPeers params;
6406 memset(¶ms, 0,
sizeof(params));
6407 params.peers = &peers;
6423 } _OrthancPluginFreePeers;
6438 _OrthancPluginFreePeers params;
6439 params.peers = peers;
6441 context->InvokeService(context, _OrthancPluginService_FreePeers, ¶ms);
6449 } _OrthancPluginGetPeersCount;
6468 uint32_t target = 0;
6470 _OrthancPluginGetPeersCount params;
6471 memset(¶ms, 0,
sizeof(params));
6472 params.target = ⌖
6473 params.peers = peers;
6489 const char** target;
6492 const char* userProperty;
6493 } _OrthancPluginGetPeerProperty;
6517 const char* target = NULL;
6519 _OrthancPluginGetPeerProperty params;
6520 memset(¶ms, 0,
sizeof(params));
6521 params.target = ⌖
6522 params.peers = peers;
6523 params.peerIndex = peerIndex;
6524 params.userProperty = NULL;
6558 const char* target = NULL;
6560 _OrthancPluginGetPeerProperty params;
6561 memset(¶ms, 0,
sizeof(params));
6562 params.target = ⌖
6563 params.peers = peers;
6564 params.peerIndex = peerIndex;
6565 params.userProperty = NULL;
6603 const char* userProperty)
6605 const char* target = NULL;
6607 _OrthancPluginGetPeerProperty params;
6608 memset(¶ms, 0,
sizeof(params));
6609 params.target = ⌖
6610 params.peers = peers;
6611 params.peerIndex = peerIndex;
6612 params.userProperty = userProperty;
6631 uint16_t* httpStatus;
6636 uint32_t additionalHeadersCount;
6637 const char*
const* additionalHeadersKeys;
6638 const char*
const* additionalHeadersValues;
6642 } _OrthancPluginCallPeerApi;
6684 uint16_t* httpStatus,
6689 uint32_t additionalHeadersCount,
6690 const char*
const* additionalHeadersKeys,
6691 const char*
const* additionalHeadersValues,
6696 _OrthancPluginCallPeerApi params;
6697 memset(¶ms, 0,
sizeof(params));
6699 params.answerBody = answerBody;
6700 params.answerHeaders = answerHeaders;
6701 params.httpStatus = httpStatus;
6702 params.peers = peers;
6703 params.peerIndex = peerIndex;
6704 params.method = method;
6706 params.additionalHeadersCount = additionalHeadersCount;
6707 params.additionalHeadersKeys = additionalHeadersKeys;
6708 params.additionalHeadersValues = additionalHeadersValues;
6710 params.bodySize = bodySize;
6711 params.timeout = timeout;
6713 return context->InvokeService(context, _OrthancPluginService_CallPeerApi, ¶ms);
6732 } _OrthancPluginCreateJob;
6780 _OrthancPluginCreateJob params;
6781 memset(¶ms, 0,
sizeof(params));
6783 params.target = ⌖
6785 params.finalize = finalize;
6787 params.getProgress = getProgress;
6788 params.getContent = getContent;
6789 params.getSerialized = getSerialized;
6792 params.reset = reset;
6819 } _OrthancPluginCreateJob2;
6866 _OrthancPluginCreateJob2 params;
6867 memset(¶ms, 0,
sizeof(params));
6869 params.target = ⌖
6871 params.finalize = finalize;
6873 params.getProgress = getProgress;
6874 params.getContent = getContent;
6875 params.getSerialized = getSerialized;
6878 params.reset = reset;
6896 } _OrthancPluginFreeJob;
6911 _OrthancPluginFreeJob params;
6914 context->InvokeService(context, _OrthancPluginService_FreeJob, ¶ms);
6924 } _OrthancPluginSubmitJob;
6944 char* resultId = NULL;
6946 _OrthancPluginSubmitJob params;
6947 memset(¶ms, 0,
sizeof(params));
6949 params.resultId = &resultId;
6951 params.priority = priority;
6970 } _OrthancPluginJobsUnserializer;
6988 _OrthancPluginJobsUnserializer params;
6989 params.unserializer = unserializer;
6991 context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, ¶ms);
6999 const char* details;
7001 } _OrthancPluginSetHttpErrorDetails;
7023 const char* details,
7026 _OrthancPluginSetHttpErrorDetails params;
7027 params.output = output;
7028 params.details = details;
7030 context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, ¶ms);
7037 const char** result;
7038 const char* argument;
7039 } _OrthancPluginRetrieveStaticString;
7056 const char* result = NULL;
7058 _OrthancPluginRetrieveStaticString params;
7059 params.result = &result;
7060 params.argument = path;
7080 } _OrthancPluginSetMetricsValue;
7104 _OrthancPluginSetMetricsValue params;
7106 params.value = value;
7108 context->InvokeService(context, _OrthancPluginService_SetMetricsValue, ¶ms);
7116 } _OrthancPluginRegisterRefreshMetricsCallback;
7133 _OrthancPluginRegisterRefreshMetricsCallback params;
7134 params.callback = callback;
7135 context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, ¶ms);
7147 } _OrthancPluginEncodeDicomWeb;
7171 char* target = NULL;
7173 _OrthancPluginEncodeDicomWeb params;
7174 params.target = ⌖
7175 params.dicom = dicom;
7176 params.dicomSize = dicomSize;
7177 params.callback = callback;
7213 char* target = NULL;
7215 _OrthancPluginEncodeDicomWeb params;
7216 params.target = ⌖
7217 params.dicom = dicom;
7218 params.dicomSize = dicomSize;
7219 params.callback = callback;
7241 } _OrthancPluginEncodeDicomWeb2;
7266 char* target = NULL;
7268 _OrthancPluginEncodeDicomWeb2 params;
7269 params.target = ⌖
7270 params.dicom = dicom;
7271 params.dicomSize = dicomSize;
7272 params.callback = callback;
7273 params.payload = payload;
7310 char* target = NULL;
7312 _OrthancPluginEncodeDicomWeb2 params;
7313 params.target = ⌖
7314 params.dicom = dicom;
7315 params.dicomSize = dicomSize;
7316 params.callback = callback;
7317 params.payload = payload;
7421 typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (
void* request);
7445 uint16_t* httpStatus;
7448 uint32_t headersCount;
7449 const char*
const* headersKeys;
7450 const char*
const* headersValues;
7456 const char* username;
7457 const char* password;
7459 const char* certificateFile;
7460 const char* certificateKeyFile;
7461 const char* certificateKeyPassword;
7463 } _OrthancPluginChunkedHttpClient;
7521 uint16_t* httpStatus,
7524 uint32_t headersCount,
7525 const char*
const* headersKeys,
7526 const char*
const* headersValues,
7532 const char* username,
7533 const char* password,
7535 const char* certificateFile,
7536 const char* certificateKeyFile,
7537 const char* certificateKeyPassword,
7540 _OrthancPluginChunkedHttpClient params;
7541 memset(¶ms, 0,
sizeof(params));
7544 params.httpStatus = httpStatus;
7545 params.method = method;
7547 params.headersCount = headersCount;
7548 params.headersKeys = headersKeys;
7549 params.headersValues = headersValues;
7550 params.username = username;
7551 params.password = password;
7552 params.timeout = timeout;
7553 params.certificateFile = certificateFile;
7554 params.certificateKeyFile = certificateKeyFile;
7555 params.certificateKeyPassword = certificateKeyPassword;
7556 params.pkcs11 = pkcs11;
7559 params.answer = answer;
7560 params.answerAddChunk = answerAddChunk;
7561 params.answerAddHeader = answerAddHeader;
7562 params.request = request;
7563 params.requestIsDone = requestIsDone;
7564 params.requestChunkData = requestChunkData;
7565 params.requestChunkSize = requestChunkSize;
7566 params.requestNext = requestNext;
7568 return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, ¶ms);
7658 const char* pathRegularExpression;
7666 } _OrthancPluginChunkedRestCallback;
7700 const char* pathRegularExpression,
7709 _OrthancPluginChunkedRestCallback params;
7710 params.pathRegularExpression = pathRegularExpression;
7711 params.getHandler = getHandler;
7712 params.postHandler = postHandler;
7713 params.deleteHandler = deleteHandler;
7714 params.putHandler = putHandler;
7715 params.addChunk = addChunk;
7716 params.execute = execute;
7717 params.finalize = finalize;
7719 context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, ¶ms);
7731 const char* privateCreator;
7732 } _OrthancPluginGetTagName;
7753 const char* privateCreator)
7757 _OrthancPluginGetTagName params;
7758 params.result = &result;
7759 params.group = group;
7760 params.element = element;
7761 params.privateCreator = privateCreator;
7807 const char* transactionUid,
7808 const char*
const* sopClassUids,
7809 const char*
const* sopInstanceUids,
7810 uint32_t countInstances,
7811 const char* remoteAet,
7812 const char* calledAet);
7850 const char* sopClassUid,
7851 const char* sopInstanceUid);
7859 } _OrthancPluginRegisterStorageCommitmentScpCallback;
7880 _OrthancPluginRegisterStorageCommitmentScpCallback params;
7881 params.factory = factory;
7882 params.destructor = destructor;
7883 params.lookup = lookup;
7884 return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, ¶ms);
7921 } _OrthancPluginIncomingDicomInstanceFilter;
7939 _OrthancPluginIncomingDicomInstanceFilter params;
7940 params.callback = callback;
7942 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, ¶ms);
7977 uint16_t* dimseStatus ,
7984 } _OrthancPluginIncomingCStoreInstanceFilter;
8002 _OrthancPluginIncomingCStoreInstanceFilter params;
8003 params.callback = callback;
8005 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingCStoreInstanceFilter, ¶ms);
8045 const void* receivedDicomBuffer,
8046 uint64_t receivedDicomBufferSize,
8053 } _OrthancPluginReceivedInstanceCallback;
8079 _OrthancPluginReceivedInstanceCallback params;
8080 params.callback = callback;
8082 return context->InvokeService(context, _OrthancPluginService_RegisterReceivedInstanceCallback, ¶ms);
8104 _OrthancPluginAccessDicomInstance params;
8105 memset(¶ms, 0,
sizeof(params));
8106 params.resultStringToFree = &result;
8107 params.instance = instance;
8137 int64_t hasPixelData;
8139 _OrthancPluginAccessDicomInstance params;
8140 memset(¶ms, 0,
sizeof(params));
8141 params.resultInt64 = &hasPixelData;
8142 params.instance = instance;
8153 return (hasPixelData != 0);
8167 const char* transferSyntax;
8168 } _OrthancPluginCreateDicomInstance;
8190 _OrthancPluginCreateDicomInstance params;
8191 params.target = ⌖
8192 params.buffer = buffer;
8209 } _OrthancPluginFreeDicomInstance;
8225 _OrthancPluginFreeDicomInstance params;
8226 params.dicom = dicom;
8228 context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, ¶ms);
8234 uint32_t* targetUint32;
8237 char** targetStringToFree;
8239 uint32_t frameIndex;
8242 uint32_t maxStringLength;
8244 void* dicomWebPayload;
8245 } _OrthancPluginAccessDicomInstance2;
8264 _OrthancPluginAccessDicomInstance2 params;
8265 memset(¶ms, 0,
sizeof(params));
8266 params.targetUint32 = &count;
8267 params.instance = instance;
8302 uint32_t frameIndex)
8304 _OrthancPluginAccessDicomInstance2 params;
8305 memset(¶ms, 0,
sizeof(params));
8306 params.targetBuffer = target;
8307 params.instance = instance;
8308 params.frameIndex = frameIndex;
8310 return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, ¶ms);
8329 uint32_t frameIndex)
8333 _OrthancPluginAccessDicomInstance2 params;
8334 memset(¶ms, 0,
sizeof(params));
8335 params.targetImage = ⌖
8336 params.instance = instance;
8337 params.frameIndex = frameIndex;
8369 const char* transferSyntax)
8373 _OrthancPluginCreateDicomInstance params;
8374 params.target = ⌖
8375 params.buffer = buffer;
8377 params.transferSyntax = transferSyntax;
8408 _OrthancPluginAccessDicomInstance2 params;
8409 memset(¶ms, 0,
sizeof(params));
8410 params.targetBuffer = target;
8411 params.instance = instance;
8413 return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, ¶ms);
8440 uint32_t maxStringLength)
8442 char* result = NULL;
8444 _OrthancPluginAccessDicomInstance2 params;
8445 memset(¶ms, 0,
sizeof(params));
8446 params.targetStringToFree = &result;
8447 params.instance = instance;
8448 params.format = format;
8449 params.flags = flags;
8450 params.maxStringLength = maxStringLength;
8484 char* target = NULL;
8486 _OrthancPluginAccessDicomInstance2 params;
8487 params.targetStringToFree = ⌖
8488 params.instance = instance;
8489 params.dicomWebCallback = callback;
8490 params.dicomWebPayload = payload;
8524 char* target = NULL;
8526 _OrthancPluginAccessDicomInstance2 params;
8527 params.targetStringToFree = ⌖
8528 params.instance = instance;
8529 params.dicomWebCallback = callback;
8530 params.dicomWebPayload = payload;
8567 const char*
const* allowedSyntaxes,
8568 uint32_t countSyntaxes,
8569 uint8_t allowNewSopInstanceUid);
8575 } _OrthancPluginTranscoderCallback;
8594 _OrthancPluginTranscoderCallback params;
8595 params.callback = callback;
8597 return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, ¶ms);
8606 } _OrthancPluginCreateMemoryBuffer;
8630 _OrthancPluginCreateMemoryBuffer params;
8631 params.target = target;
8634 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, ¶ms);
8668 _OrthancPluginRetrieveDynamicString params;
8669 params.result = &result;
8670 params.argument = NULL;
8672 if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
8690 } _OrthancPluginCreateMemoryBuffer64;
8714 _OrthancPluginCreateMemoryBuffer64 params;
8715 params.target = target;
8718 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer64, ¶ms);
8728 } _OrthancPluginRegisterStorageArea2;
8753 _OrthancPluginRegisterStorageArea2 params;
8754 params.create = create;
8755 params.readWhole = readWhole;
8756 params.readRange = readRange;
8757 params.remove = remove;
8758 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea2, ¶ms);
8765 _OrthancPluginCreateDicom createDicom;
8766 const char* privateCreator;
8767 } _OrthancPluginCreateDicom2;
8799 const char* privateCreator)
8801 _OrthancPluginCreateDicom2 params;
8802 params.createDicom.target = target;
8803 params.createDicom.json = json;
8804 params.createDicom.pixelData = pixelData;
8805 params.createDicom.flags = flags;
8806 params.privateCreator = privateCreator;
8808 return context->InvokeService(context, _OrthancPluginService_CreateDicom2, ¶ms);
8820 uint16_t* httpStatus;
8823 uint32_t headersCount;
8824 const char*
const* headersKeys;
8825 const char*
const* headersValues;
8828 uint8_t afterPlugins;
8829 } _OrthancPluginCallRestApi;
8865 uint16_t* httpStatus,
8868 uint32_t headersCount,
8869 const char*
const* headersKeys,
8870 const char*
const* headersValues,
8873 uint8_t afterPlugins)
8875 _OrthancPluginCallRestApi params;
8876 memset(¶ms, 0,
sizeof(params));
8878 params.answerBody = answerBody;
8879 params.answerHeaders = answerHeaders;
8880 params.httpStatus = httpStatus;
8881 params.method = method;
8883 params.headersCount = headersCount;
8884 params.headersKeys = headersKeys;
8885 params.headersValues = headersValues;
8887 params.bodySize = bodySize;
8888 params.afterPlugins = afterPlugins;
8890 return context->InvokeService(context, _OrthancPluginService_CallRestApi, ¶ms);
8922 const char* mimeType,
8923 const char* dateTime);
8942 const char* dateTime);
8970 const char* mimeType,
8971 const char* dateTime);
8988 uint8_t* isExisting,
8990 const char*
const* pathItems,
9013 uint8_t* isExisting,
9018 const char*
const* pathItems,
9042 const char*
const* pathItems,
9062 uint8_t* isReadOnly,
9064 const char*
const* pathItems,
9084 uint8_t* isReadOnly,
9086 const char*
const* pathItems,
9104 uint8_t* isReadOnly,
9106 const char*
const* pathItems,
9120 } _OrthancPluginRegisterWebDavCollection;
9153 _OrthancPluginRegisterWebDavCollection params;
9155 params.isExistingFolder = isExistingFolder;
9156 params.listFolder = listFolder;
9157 params.retrieveFile = retrieveFile;
9158 params.storeFile = storeFile;
9159 params.createFolder = createFolder;
9160 params.deleteItem = deleteItem;
9161 params.payload = payload;
9163 return context->InvokeService(context, _OrthancPluginService_RegisterWebDavCollection, ¶ms);
9180 _OrthancPluginRetrieveStaticString params;
9181 params.result = &result;
9182 params.argument = NULL;
9205 const void* request,
9206 uint64_t requestSize);
9218 uint32_t maxDatabaseRetries;
9221 } _OrthancPluginRegisterDatabaseBackendV4;
9243 uint32_t maxDatabaseRetries,
9247 _OrthancPluginRegisterDatabaseBackendV4 params;
9248 params.backend = backend;
9249 params.maxDatabaseRetries = maxDatabaseRetries;
9250 params.operations = operations;
9251 params.finalize = finalize;
9253 return context->InvokeService(context, _OrthancPluginService_RegisterDatabaseBackendV4, ¶ms);
9260 const char* instanceId;
9262 } _OrthancPluginLoadDicomInstance;
9279 const char* instanceId,
9284 _OrthancPluginLoadDicomInstance params;
9285 params.target = ⌖
9286 params.instanceId = instanceId;
9306 } _OrthancPluginSetMetricsIntegerValue;
9329 _OrthancPluginSetMetricsIntegerValue params;
9331 params.value = value;
9333 context->InvokeService(context, _OrthancPluginService_SetMetricsIntegerValue, ¶ms);
OrthancPluginErrorCode OrthancPluginRegisterDatabaseBackendV4(OrthancPluginContext *context, void *backend, uint32_t maxDatabaseRetries, OrthancPluginCallDatabaseBackendV4 operations, OrthancPluginFinalizeDatabaseBackendV4 finalize)
Definition: OrthancCPlugin.h:9240
OrthancPluginErrorCode(* OrthancPluginCallDatabaseBackendV4)(OrthancPluginMemoryBuffer64 *response, void *backend, const void *request, uint64_t requestSize)
Signature of a callback function that is triggered when the Orthanc core requests an operation from t...
Definition: OrthancCPlugin.h:9202
OrthancPluginReceivedInstanceAction(* OrthancPluginReceivedInstanceCallback)(OrthancPluginMemoryBuffer64 *modifiedDicomBuffer, const void *receivedDicomBuffer, uint64_t receivedDicomBufferSize, OrthancPluginInstanceOrigin origin)
Callback to keep/discard/modify a DICOM instance received by Orthanc from any source (C-STORE or REST...
Definition: OrthancCPlugin.h:8043
OrthancPluginErrorCode(* OrthancPluginWebDavAddFile)(OrthancPluginWebDavCollection *collection, const char *name, uint64_t size, const char *mimeType, const char *dateTime)
Declare a file while returning the content of a folder.
Definition: OrthancCPlugin.h:8918
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:1905
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:3243
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:2208
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:1250
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5469
OrthancPluginChangeType
Definition: OrthancCPlugin.h:734
OrthancPluginErrorCode(* OrthancPluginStorageReadWhole)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type)
Callback for reading a whole file from the storage area.
Definition: OrthancCPlugin.h:1316
OrthancPluginErrorCode OrthancPluginRegisterIncomingCStoreInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingCStoreInstanceFilter callback)
Register a callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition: OrthancCPlugin.h:7998
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:2011
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:1228
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:7129
OrthancPluginErrorCode(* OrthancPluginWebDavCreateFolderCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback to create a folder.
Definition: OrthancCPlugin.h:9083
struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection
Opaque structure that represents a WebDAV collection.
Definition: OrthancCPlugin.h:8899
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:1786
OrthancPluginErrorCode(* OrthancPluginWebDavRetrieveFileCallback)(OrthancPluginWebDavCollection *collection, OrthancPluginWebDavRetrieveFile retrieveFile, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback for retrieving the content of a file.
Definition: OrthancCPlugin.h:9038
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition: OrthancCPlugin.h:7914
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4827
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:8563
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6372
OrthancPluginErrorCode(* OrthancPluginWebDavRetrieveFile)(OrthancPluginWebDavCollection *collection, const void *data, uint64_t size, const char *mimeType, const char *dateTime)
Retrieve the content of a file.
Definition: OrthancCPlugin.h:8966
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1296
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:2130
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3631
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:8075
OrthancPluginErrorCode(* OrthancPluginWebDavListFolderCallback)(uint8_t *isExisting, OrthancPluginWebDavCollection *collection, OrthancPluginWebDavAddFile addFile, OrthancPluginWebDavAddFolder addFolder, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback for listing the content of a folder.
Definition: OrthancCPlugin.h:9012
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1739
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:1099
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3386
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:8746
OrthancPluginErrorCode(* OrthancPluginWebDavAddFolder)(OrthancPluginWebDavCollection *collection, const char *name, const char *dateTime)
Declare a subfolder while returning the content of a folder.
Definition: OrthancCPlugin.h:8939
OrthancPluginErrorCode OrthancPluginRegisterWebDavCollection(OrthancPluginContext *context, const char *uri, OrthancPluginWebDavIsExistingFolderCallback isExistingFolder, OrthancPluginWebDavListFolderCallback listFolder, OrthancPluginWebDavRetrieveFileCallback retrieveFile, OrthancPluginWebDavStoreFileCallback storeFile, OrthancPluginWebDavCreateFolderCallback createFolder, OrthancPluginWebDavDeleteItemCallback deleteItem, void *payload)
Register a WebDAV virtual filesystem.
Definition: OrthancCPlugin.h:9142
int32_t(* OrthancPluginIncomingHttpRequestFilter2)(OrthancPluginHttpMethod method, const char *uri, const char *ip, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, uint32_t getArgumentsCount, const char *const *getArgumentsKeys, const char *const *getArgumentsValues)
Callback to filter incoming HTTP requests received by Orthanc.
Definition: OrthancCPlugin.h:1442
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1196
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1758
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition: OrthancCPlugin.h:8590
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:1207
OrthancPluginErrorCode(* OrthancPluginWebDavStoreFileCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, const void *data, uint64_t size, void *payload)
Callback to store a file.
Definition: OrthancCPlugin.h:9061
OrthancPluginErrorCode(* OrthancPluginWebDavDeleteItemCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback to remove a file or a folder.
Definition: OrthancCPlugin.h:9103
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:5019
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1357
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1269
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:1824
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:1217
void(* OrthancPluginFinalizeDatabaseBackendV4)(void *backend)
Signature of a callback function that is triggered when the database plugin must be finalized.
Definition: OrthancCPlugin.h:9213
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition: OrthancCPlugin.h:7577
OrthancPluginErrorCode(* OrthancPluginWebDavIsExistingFolderCallback)(uint8_t *isExisting, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback for testing the existence of a folder.
Definition: OrthancCPlugin.h:8987
int32_t(* OrthancPluginIncomingHttpRequestFilter)(OrthancPluginHttpMethod method, const char *uri, const char *ip, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues)
Callback to filter incoming HTTP requests received by Orthanc.
Definition: OrthancCPlugin.h:1407
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6984
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1240
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:2170
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4788
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:1339
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:7698
int32_t(* OrthancPluginIncomingCStoreInstanceFilter)(uint16_t *dimseStatus, const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition: OrthancCPlugin.h:7976
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition: OrthancCPlugin.h:7935
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5805
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:4744
@ OrthancPluginChangeType_OrthancStopped
Definition: OrthancCPlugin.h:746
@ OrthancPluginChangeType_OrthancStarted
Definition: OrthancCPlugin.h:745
@ OrthancPluginChangeType_Deleted
Definition: OrthancCPlugin.h:736
@ OrthancPluginChangeType_JobFailure
Definition: OrthancCPlugin.h:753
@ OrthancPluginChangeType_NewInstance
Definition: OrthancCPlugin.h:738
@ OrthancPluginChangeType_NewPatient
Definition: OrthancCPlugin.h:739
@ OrthancPluginChangeType_JobSubmitted
Definition: OrthancCPlugin.h:751
@ OrthancPluginChangeType_NewSeries
Definition: OrthancCPlugin.h:740
@ OrthancPluginChangeType_StablePatient
Definition: OrthancCPlugin.h:742
@ OrthancPluginChangeType_UpdatedPeers
Definition: OrthancCPlugin.h:749
@ OrthancPluginChangeType_StableStudy
Definition: OrthancCPlugin.h:744
@ OrthancPluginChangeType_CompletedSeries
Definition: OrthancCPlugin.h:735
@ OrthancPluginChangeType_NewChildInstance
Definition: OrthancCPlugin.h:737
@ OrthancPluginChangeType_UpdatedAttachment
Definition: OrthancCPlugin.h:747
@ OrthancPluginChangeType_UpdatedMetadata
Definition: OrthancCPlugin.h:748
@ OrthancPluginChangeType_StableSeries
Definition: OrthancCPlugin.h:743
@ OrthancPluginChangeType_UpdatedModalities
Definition: OrthancCPlugin.h:750
@ OrthancPluginChangeType_JobSuccess
Definition: OrthancCPlugin.h:752
@ OrthancPluginChangeType_NewStudy
Definition: OrthancCPlugin.h:741
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:6066
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1147
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1552
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:6042
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7826
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:1376
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:6220
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:6172
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:7804
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5974
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5351
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:7847
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:5312
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:6013
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:7874
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1155
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1139
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1469
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1537
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:5208
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:6134
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5274
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:6103
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1566
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1131
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:1512
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:5244
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:8133
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:8518
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition: OrthancCPlugin.h:1107
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:8298
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2974
OrthancPluginDicomInstance * OrthancPluginLoadDicomInstance(OrthancPluginContext *context, const char *instanceId, OrthancPluginLoadDicomInstanceMode mode)
Load a DICOM instance from the Orthanc server.
Definition: OrthancCPlugin.h:9277
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:3076
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition: OrthancCPlugin.h:8365
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition: OrthancCPlugin.h:8183
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition: OrthancCPlugin.h:8258
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5377
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:3007
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:8478
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition: OrthancCPlugin.h:8098
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:3153
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition: OrthancCPlugin.h:8221
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition: OrthancCPlugin.h:8403
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:3194
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:3114
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:3040
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:8326
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:8435
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4530
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:610
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:4690
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:4274
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:4065
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3964
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5507
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4565
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:4030
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:4099
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:4184
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:4229
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5596
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:4142
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4605
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:779
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:1123
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:764
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3997
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:3776
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4637
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:5550
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1115
@ OrthancPluginPixelFormat_RGBA32
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:649
@ OrthancPluginPixelFormat_RGB48
Color image in RGB48 format.
Definition: OrthancCPlugin.h:659
@ OrthancPluginPixelFormat_Grayscale8
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:617
@ OrthancPluginPixelFormat_SignedGrayscale16
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:633
@ OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:675
@ OrthancPluginPixelFormat_RGB24
Color image in RGB24 format.
Definition: OrthancCPlugin.h:641
@ OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:683
@ OrthancPluginPixelFormat_Unknown
Definition: OrthancCPlugin.h:651
@ OrthancPluginPixelFormat_Grayscale64
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:691
@ OrthancPluginPixelFormat_Grayscale32
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:667
@ OrthancPluginPixelFormat_Grayscale16
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:625
@ OrthancPluginImageFormat_Png
Definition: OrthancCPlugin.h:780
@ OrthancPluginImageFormat_Jpeg
Definition: OrthancCPlugin.h:781
@ OrthancPluginImageFormat_Dicom
Definition: OrthancCPlugin.h:782
@ OrthancPluginCompressionType_Gzip
Definition: OrthancCPlugin.h:767
@ OrthancPluginCompressionType_ZlibWithSize
Definition: OrthancCPlugin.h:766
@ OrthancPluginCompressionType_Zlib
Definition: OrthancCPlugin.h:765
@ OrthancPluginCompressionType_GzipWithSize
Definition: OrthancCPlugin.h:768
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:2438
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:2473
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:2586
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2722
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2757
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3534
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:2550
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3495
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2687
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2371
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2792
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:2401
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2652
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2502
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2525
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:8861
char * OrthancPluginGenerateRestApiAuthorizationToken(OrthancPluginContext *context)
Generate a token to grant full access to the REST API of Orthanc.
Definition: OrthancCPlugin.h:8663
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:5170
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2338
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:2297
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2860
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:7020
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2883
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:2240
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2837
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2938
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2913
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2620
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:4321
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:3734
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:5767
void OrthancPluginSendHttpStatus(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status, const void *body, uint32_t bodySize)
Send a HTTP status, with a custom body.
Definition: OrthancCPlugin.h:3928
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3705
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1857
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1861
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1862
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1860
uint16_t element
Definition: OrthancCPlugin.h:1859
uint16_t group
Definition: OrthancCPlugin.h:1858
The parameters of a REST request.
Definition: OrthancCPlugin.h:341
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:370
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:355
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:380
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:350
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:395
const void * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:375
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:365
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:390
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:345
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:360
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:400
A 64-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1080
uint64_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1089
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1084
A 32-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1058
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1067
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1062