Orthanc Plugin SDK 1.11.0
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1
107#pragma once
108
109
110#include <stdio.h>
111#include <string.h>
112
113#ifdef WIN32
114# define ORTHANC_PLUGINS_API __declspec(dllexport)
115#elif __GNUC__ >= 4
116# define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default")))
117#else
118# define ORTHANC_PLUGINS_API
119#endif
120
121#define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
122#define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 11
123#define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 0
124
125
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))))
133#endif
134
135
136
137/********************************************************************
138 ** Check that function inlining is properly supported. The use of
139 ** inlining is required, to avoid the duplication of object code
140 ** between two compilation modules that would use the Orthanc Plugin
141 ** API.
142 ********************************************************************/
143
144/* If the auto-detection of the "inline" keyword below does not work
145 automatically and that your compiler is known to properly support
146 inlining, uncomment the following #define and adapt the definition
147 of "static inline". */
148
149/* #define ORTHANC_PLUGIN_INLINE static inline */
150
151#ifndef ORTHANC_PLUGIN_INLINE
152# if __STDC_VERSION__ >= 199901L
153/* This is C99 or above: http://predef.sourceforge.net/prestd.html */
154# define ORTHANC_PLUGIN_INLINE static inline
155# elif defined(__cplusplus)
156/* This is C++ */
157# define ORTHANC_PLUGIN_INLINE static inline
158# elif defined(__GNUC__)
159/* This is GCC running in C89 mode */
160# define ORTHANC_PLUGIN_INLINE static __inline
161# elif defined(_MSC_VER)
162/* This is Visual Studio running in C89 mode */
163# define ORTHANC_PLUGIN_INLINE static __inline
164# else
165# error Your compiler is not known to support the "inline" keyword
166# endif
167#endif
168
169
170
171/********************************************************************
172 ** Inclusion of standard libraries.
173 ********************************************************************/
174
180#include <stdint.h>
181
182#include <stdlib.h>
183
184
185
186/********************************************************************
187 ** Definition of the Orthanc Plugin API.
188 ********************************************************************/
189
192#ifdef __cplusplus
193extern "C"
194{
195#endif
196
200 typedef enum
201 {
310
311 _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
313
314
319 ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
320
321
325 typedef enum
326 {
332 _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
334
335
340 typedef struct
341 {
346
350 uint32_t groupsCount;
351
355 const char* const* groups;
356
360 uint32_t getCount;
361
365 const char* const* getKeys;
366
370 const char* const* getValues;
371
375 const void* body;
376
380 uint32_t bodySize;
381
382
383 /* --------------------------------------------------
384 New in version 0.8.1
385 -------------------------------------------------- */
386
390 uint32_t headersCount;
391
395 const char* const* headersKeys;
396
400 const char* const* headersValues;
401
403
404
405 typedef enum
406 {
407 /* Generic services */
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, /* New in Orthanc 1.5.7 */
442 _OrthancPluginService_GetTagName = 35, /* New in Orthanc 1.5.7 */
443 _OrthancPluginService_EncodeDicomWebJson2 = 36, /* New in Orthanc 1.7.0 */
444 _OrthancPluginService_EncodeDicomWebXml2 = 37, /* New in Orthanc 1.7.0 */
445 _OrthancPluginService_CreateMemoryBuffer = 38, /* New in Orthanc 1.7.0 */
446 _OrthancPluginService_GenerateRestApiAuthorizationToken = 39, /* New in Orthanc 1.8.1 */
447 _OrthancPluginService_CreateMemoryBuffer64 = 40, /* New in Orthanc 1.9.0 */
448 _OrthancPluginService_CreateDicom2 = 41, /* New in Orthanc 1.9.0 */
449
450 /* Registration of callbacks */
451 _OrthancPluginService_RegisterRestCallback = 1000,
452 _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
453 _OrthancPluginService_RegisterStorageArea = 1002,
454 _OrthancPluginService_RegisterOnChangeCallback = 1003,
455 _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
456 _OrthancPluginService_RegisterWorklistCallback = 1005,
457 _OrthancPluginService_RegisterDecodeImageCallback = 1006,
458 _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
459 _OrthancPluginService_RegisterFindCallback = 1008,
460 _OrthancPluginService_RegisterMoveCallback = 1009,
461 _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
462 _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
463 _OrthancPluginService_RegisterChunkedRestCallback = 1012, /* New in Orthanc 1.5.7 */
464 _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
465 _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
466 _OrthancPluginService_RegisterTranscoderCallback = 1015, /* New in Orthanc 1.7.0 */
467 _OrthancPluginService_RegisterStorageArea2 = 1016, /* New in Orthanc 1.9.0 */
468 _OrthancPluginService_RegisterIncomingCStoreInstanceFilter = 1017, /* New in Orthanc 1.10.0 */
469 _OrthancPluginService_RegisterReceivedInstanceCallback = 1018, /* New in Orthanc 1.10.0 */
470 _OrthancPluginService_RegisterWebDavCollection = 1019, /* New in Orthanc 1.10.1 */
471
472 /* Sending answers to REST calls */
473 _OrthancPluginService_AnswerBuffer = 2000,
474 _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
475 _OrthancPluginService_Redirect = 2002,
476 _OrthancPluginService_SendHttpStatusCode = 2003,
477 _OrthancPluginService_SendUnauthorized = 2004,
478 _OrthancPluginService_SendMethodNotAllowed = 2005,
479 _OrthancPluginService_SetCookie = 2006,
480 _OrthancPluginService_SetHttpHeader = 2007,
481 _OrthancPluginService_StartMultipartAnswer = 2008,
482 _OrthancPluginService_SendMultipartItem = 2009,
483 _OrthancPluginService_SendHttpStatus = 2010,
484 _OrthancPluginService_CompressAndAnswerImage = 2011,
485 _OrthancPluginService_SendMultipartItem2 = 2012,
486 _OrthancPluginService_SetHttpErrorDetails = 2013,
487
488 /* Access to the Orthanc database and API */
489 _OrthancPluginService_GetDicomForInstance = 3000,
490 _OrthancPluginService_RestApiGet = 3001,
491 _OrthancPluginService_RestApiPost = 3002,
492 _OrthancPluginService_RestApiDelete = 3003,
493 _OrthancPluginService_RestApiPut = 3004,
494 _OrthancPluginService_LookupPatient = 3005,
495 _OrthancPluginService_LookupStudy = 3006,
496 _OrthancPluginService_LookupSeries = 3007,
497 _OrthancPluginService_LookupInstance = 3008,
498 _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
499 _OrthancPluginService_RestApiGetAfterPlugins = 3010,
500 _OrthancPluginService_RestApiPostAfterPlugins = 3011,
501 _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
502 _OrthancPluginService_RestApiPutAfterPlugins = 3013,
503 _OrthancPluginService_ReconstructMainDicomTags = 3014,
504 _OrthancPluginService_RestApiGet2 = 3015,
505 _OrthancPluginService_CallRestApi = 3016, /* New in Orthanc 1.9.2 */
506
507 /* Access to DICOM instances */
508 _OrthancPluginService_GetInstanceRemoteAet = 4000,
509 _OrthancPluginService_GetInstanceSize = 4001,
510 _OrthancPluginService_GetInstanceData = 4002,
511 _OrthancPluginService_GetInstanceJson = 4003,
512 _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
513 _OrthancPluginService_HasInstanceMetadata = 4005,
514 _OrthancPluginService_GetInstanceMetadata = 4006,
515 _OrthancPluginService_GetInstanceOrigin = 4007,
516 _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
517 _OrthancPluginService_HasInstancePixelData = 4009,
518 _OrthancPluginService_CreateDicomInstance = 4010, /* New in Orthanc 1.7.0 */
519 _OrthancPluginService_FreeDicomInstance = 4011, /* New in Orthanc 1.7.0 */
520 _OrthancPluginService_GetInstanceFramesCount = 4012, /* New in Orthanc 1.7.0 */
521 _OrthancPluginService_GetInstanceRawFrame = 4013, /* New in Orthanc 1.7.0 */
522 _OrthancPluginService_GetInstanceDecodedFrame = 4014, /* New in Orthanc 1.7.0 */
523 _OrthancPluginService_TranscodeDicomInstance = 4015, /* New in Orthanc 1.7.0 */
524 _OrthancPluginService_SerializeDicomInstance = 4016, /* New in Orthanc 1.7.0 */
525 _OrthancPluginService_GetInstanceAdvancedJson = 4017, /* New in Orthanc 1.7.0 */
526 _OrthancPluginService_GetInstanceDicomWebJson = 4018, /* New in Orthanc 1.7.0 */
527 _OrthancPluginService_GetInstanceDicomWebXml = 4019, /* New in Orthanc 1.7.0 */
528
529 /* Services for plugins implementing a database back-end */
530 _OrthancPluginService_RegisterDatabaseBackend = 5000, /* New in Orthanc 0.8.6 */
531 _OrthancPluginService_DatabaseAnswer = 5001,
532 _OrthancPluginService_RegisterDatabaseBackendV2 = 5002, /* New in Orthanc 0.9.4 */
533 _OrthancPluginService_StorageAreaCreate = 5003,
534 _OrthancPluginService_StorageAreaRead = 5004,
535 _OrthancPluginService_StorageAreaRemove = 5005,
536 _OrthancPluginService_RegisterDatabaseBackendV3 = 5006, /* New in Orthanc 1.9.2 */
537
538 /* Primitives for handling images */
539 _OrthancPluginService_GetImagePixelFormat = 6000,
540 _OrthancPluginService_GetImageWidth = 6001,
541 _OrthancPluginService_GetImageHeight = 6002,
542 _OrthancPluginService_GetImagePitch = 6003,
543 _OrthancPluginService_GetImageBuffer = 6004,
544 _OrthancPluginService_UncompressImage = 6005,
545 _OrthancPluginService_FreeImage = 6006,
546 _OrthancPluginService_CompressImage = 6007,
547 _OrthancPluginService_ConvertPixelFormat = 6008,
548 _OrthancPluginService_GetFontsCount = 6009,
549 _OrthancPluginService_GetFontInfo = 6010,
550 _OrthancPluginService_DrawText = 6011,
551 _OrthancPluginService_CreateImage = 6012,
552 _OrthancPluginService_CreateImageAccessor = 6013,
553 _OrthancPluginService_DecodeDicomImage = 6014,
554
555 /* Primitives for handling C-Find, C-Move and worklists */
556 _OrthancPluginService_WorklistAddAnswer = 7000,
557 _OrthancPluginService_WorklistMarkIncomplete = 7001,
558 _OrthancPluginService_WorklistIsMatch = 7002,
559 _OrthancPluginService_WorklistGetDicomQuery = 7003,
560 _OrthancPluginService_FindAddAnswer = 7004,
561 _OrthancPluginService_FindMarkIncomplete = 7005,
562 _OrthancPluginService_GetFindQuerySize = 7006,
563 _OrthancPluginService_GetFindQueryTag = 7007,
564 _OrthancPluginService_GetFindQueryTagName = 7008,
565 _OrthancPluginService_GetFindQueryValue = 7009,
566 _OrthancPluginService_CreateFindMatcher = 7010,
567 _OrthancPluginService_FreeFindMatcher = 7011,
568 _OrthancPluginService_FindMatcherIsMatch = 7012,
569
570 /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
571 _OrthancPluginService_GetPeers = 8000,
572 _OrthancPluginService_FreePeers = 8001,
573 _OrthancPluginService_GetPeersCount = 8003,
574 _OrthancPluginService_GetPeerName = 8004,
575 _OrthancPluginService_GetPeerUrl = 8005,
576 _OrthancPluginService_CallPeerApi = 8006,
577 _OrthancPluginService_GetPeerUserProperty = 8007,
578
579 /* Primitives for handling jobs (new in 1.4.2) */
580 _OrthancPluginService_CreateJob = 9000,
581 _OrthancPluginService_FreeJob = 9001,
582 _OrthancPluginService_SubmitJob = 9002,
583 _OrthancPluginService_RegisterJobsUnserializer = 9003,
584
585 _OrthancPluginService_INTERNAL = 0x7fffffff
586 } _OrthancPluginService;
587
588
589 typedef enum
590 {
591 _OrthancPluginProperty_Description = 1,
592 _OrthancPluginProperty_RootUri = 2,
593 _OrthancPluginProperty_OrthancExplorer = 3,
594
595 _OrthancPluginProperty_INTERNAL = 0x7fffffff
596 } _OrthancPluginProperty;
597
598
599
604 typedef enum
605 {
613
621
629
637
645
655
663
671
679
687
688 _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
690
691
692
696 typedef enum
697 {
703 _OrthancPluginContentType_INTERNAL = 0x7fffffff
705
706
707
711 typedef enum
712 {
719 _OrthancPluginResourceType_INTERNAL = 0x7fffffff
721
722
723
728 typedef enum
729 {
750 _OrthancPluginChangeType_INTERNAL = 0x7fffffff
752
753
758 typedef enum
759 {
765 _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
767
768
773 typedef enum
774 {
779 _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
781
782
787 typedef enum
788 {
817 _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
819
820
826 typedef enum
827 {
832 _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
834
835
841 typedef enum
842 {
843 OrthancPluginDicomToJsonFlags_None = 0,
853 _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
855
856
862 typedef enum
863 {
864 OrthancPluginCreateDicomFlags_None = 0,
868 _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
870
871
877 typedef enum
878 {
884 _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
886
887
892 typedef enum
893 {
900 _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
902
903
907 typedef enum
908 {
916 _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
918
919
923 typedef enum
924 {
929
930
937 typedef enum
938 {
944
945
949 typedef enum
950 {
960
961
966 typedef enum
967 {
972
973
979 typedef enum
980 {
1008
1009
1013 typedef enum
1014 {
1019 _OrthancPluginReceivedInstanceAction_INTERNAL = 0x7fffffff
1021
1022
1030 typedef struct
1031 {
1035 void* data;
1036
1040 uint32_t size;
1042
1043
1044
1052 typedef struct
1053 {
1057 void* data;
1058
1062 uint64_t size;
1064
1065
1066
1067
1072 typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
1073
1074
1075
1080 typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
1081
1082
1083
1088 typedef struct _OrthancPluginImage_t OrthancPluginImage;
1089
1090
1091
1096 typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
1097
1098
1099
1104 typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
1105
1106
1107
1112 typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
1113
1114
1115
1120 typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1121
1122
1123
1128 typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1129
1130
1131
1136 typedef struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher;
1137
1138
1139
1144 typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1145
1146
1147
1152 typedef struct _OrthancPluginJob_t OrthancPluginJob;
1153
1154
1155
1161 typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1162
1163
1164
1171 const char* url,
1172 const OrthancPluginHttpRequest* request);
1173
1174
1175
1181 const OrthancPluginDicomInstance* instance,
1182 const char* instanceId);
1183
1184
1185
1191 OrthancPluginChangeType changeType,
1192 OrthancPluginResourceType resourceType,
1193 const char* resourceId);
1194
1195
1196
1202 OrthancPluginImage** target,
1203 const void* dicom,
1204 const uint32_t size,
1205 uint32_t frameIndex);
1206
1207
1208
1213 typedef void (*OrthancPluginFree) (void* buffer);
1214
1215
1216
1226 const char* bulkDataUri);
1227
1228
1229
1243 const char* uuid,
1244 const void* content,
1245 int64_t size,
1247
1248
1249
1270 void** content,
1271 int64_t* size,
1272 const char* uuid,
1274
1275
1276
1291 const char* uuid,
1293
1294
1295
1314 const char* uuid,
1316 uint64_t rangeStart);
1317
1318
1319
1331 const char* uuid,
1333
1334
1335
1351 const OrthancPluginWorklistQuery* query,
1352 const char* issuerAet,
1353 const char* calledAet);
1354
1355
1356
1382 const char* uri,
1383 const char* ip,
1384 uint32_t headersCount,
1385 const char* const* headersKeys,
1386 const char* const* headersValues);
1387
1388
1389
1417 const char* uri,
1418 const char* ip,
1419 uint32_t headersCount,
1420 const char* const* headersKeys,
1421 const char* const* headersValues,
1422 uint32_t getArgumentsCount,
1423 const char* const* getArgumentsKeys,
1424 const char* const* getArgumentsValues);
1425
1426
1427
1443 OrthancPluginFindAnswers* answers,
1444 const OrthancPluginFindQuery* query,
1445 const char* issuerAet,
1446 const char* calledAet);
1447
1448
1449
1485 typedef void* (*OrthancPluginMoveCallback) (
1486 OrthancPluginResourceType resourceType,
1487 const char* patientId,
1488 const char* accessionNumber,
1489 const char* studyInstanceUid,
1490 const char* seriesInstanceUid,
1491 const char* sopInstanceUid,
1492 const char* originatorAet,
1493 const char* sourceAet,
1494 const char* targetAet,
1495 uint16_t originatorId);
1496
1497
1510 typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1511
1512
1525 typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1526
1527
1539 typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1540
1541
1552 typedef void (*OrthancPluginJobFinalize) (void* job);
1553
1554
1565 typedef float (*OrthancPluginJobGetProgress) (void* job);
1566
1567
1580 typedef const char* (*OrthancPluginJobGetContent) (void* job);
1581
1582
1598 typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1599
1600
1614
1615
1639
1640
1655
1656
1670 typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1671 const char* serialized);
1672
1673
1674
1689
1690
1691
1719 uint32_t levelDepth,
1720 const uint16_t* levelTagGroup,
1721 const uint16_t* levelTagElement,
1722 const uint32_t* levelIndex,
1723 uint16_t tagGroup,
1724 uint16_t tagElement,
1726
1727
1728
1757 uint32_t levelDepth,
1758 const uint16_t* levelTagGroup,
1759 const uint16_t* levelTagElement,
1760 const uint32_t* levelIndex,
1761 uint16_t tagGroup,
1762 uint16_t tagElement,
1764 void* payload);
1765
1766
1767
1771 typedef struct _OrthancPluginContext_t
1772 {
1773 void* pluginsManager;
1774 const char* orthancVersion;
1775 OrthancPluginFree Free;
1776 OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1777 _OrthancPluginService service,
1778 const void* params);
1780
1781
1782
1786 typedef struct
1787 {
1788 uint16_t group;
1789 uint16_t element;
1794
1795
1796
1805 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1806 OrthancPluginContext* context,
1807 char* str)
1808 {
1809 if (str != NULL)
1810 {
1811 context->Free(str);
1812 }
1813 }
1814
1815
1835 ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1836 OrthancPluginContext* context,
1837 int expectedMajor,
1838 int expectedMinor,
1839 int expectedRevision)
1840 {
1841 int major, minor, revision;
1842
1843 if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1844 sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1845 sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1846 sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1847 sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1848 sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1849 sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1850 sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1851 sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1852 sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1853 sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1854 sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1855 sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1856 sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1857 sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1858 sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1859 sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1860 sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
1861 sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
1862 sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
1863 sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason) ||
1864 sizeof(int32_t) != sizeof(OrthancPluginReceivedInstanceAction))
1865 {
1866 /* Mismatch in the size of the enumerations */
1867 return 0;
1868 }
1869
1870 /* Assume compatibility with the mainline */
1871 if (!strcmp(context->orthancVersion, "mainline"))
1872 {
1873 return 1;
1874 }
1875
1876 /* Parse the version of the Orthanc core */
1877 if (
1878#ifdef _MSC_VER
1879 sscanf_s
1880#else
1881 sscanf
1882#endif
1883 (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1884 {
1885 return 0;
1886 }
1887
1888 /* Check the major number of the version */
1889
1890 if (major > expectedMajor)
1891 {
1892 return 1;
1893 }
1894
1895 if (major < expectedMajor)
1896 {
1897 return 0;
1898 }
1899
1900 /* Check the minor number of the version */
1901
1902 if (minor > expectedMinor)
1903 {
1904 return 1;
1905 }
1906
1907 if (minor < expectedMinor)
1908 {
1909 return 0;
1910 }
1911
1912 /* Check the revision number of the version */
1913
1914 if (revision >= expectedRevision)
1915 {
1916 return 1;
1917 }
1918 else
1919 {
1920 return 0;
1921 }
1922 }
1923
1924
1941 ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1942 OrthancPluginContext* context)
1943 {
1945 context,
1946 ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1947 ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1948 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1949 }
1950
1951
1960 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1961 OrthancPluginContext* context,
1963 {
1964 context->Free(buffer->data);
1965 }
1966
1967
1976 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer64(
1977 OrthancPluginContext* context,
1979 {
1980 context->Free(buffer->data);
1981 }
1982
1983
1992 ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1993 OrthancPluginContext* context,
1994 const char* message)
1995 {
1996 context->InvokeService(context, _OrthancPluginService_LogError, message);
1997 }
1998
1999
2008 ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
2009 OrthancPluginContext* context,
2010 const char* message)
2011 {
2012 context->InvokeService(context, _OrthancPluginService_LogWarning, message);
2013 }
2014
2015
2024 ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
2025 OrthancPluginContext* context,
2026 const char* message)
2027 {
2028 context->InvokeService(context, _OrthancPluginService_LogInfo, message);
2029 }
2030
2031
2032
2033 typedef struct
2034 {
2035 const char* pathRegularExpression;
2037 } _OrthancPluginRestCallback;
2038
2060 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
2061 OrthancPluginContext* context,
2062 const char* pathRegularExpression,
2064 {
2065 _OrthancPluginRestCallback params;
2066 params.pathRegularExpression = pathRegularExpression;
2067 params.callback = callback;
2068 context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
2069 }
2070
2071
2072
2101 OrthancPluginContext* context,
2102 const char* pathRegularExpression,
2104 {
2105 _OrthancPluginRestCallback params;
2106 params.pathRegularExpression = pathRegularExpression;
2107 params.callback = callback;
2108 context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
2109 }
2110
2111
2112
2113 typedef struct
2114 {
2116 } _OrthancPluginOnStoredInstanceCallback;
2117
2139 OrthancPluginContext* context,
2141 {
2142 _OrthancPluginOnStoredInstanceCallback params;
2143 params.callback = callback;
2144
2145 context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
2146 }
2147
2148
2149
2150 typedef struct
2151 {
2153 const void* answer;
2154 uint32_t answerSize;
2155 const char* mimeType;
2156 } _OrthancPluginAnswerBuffer;
2157
2170 ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
2171 OrthancPluginContext* context,
2173 const void* answer,
2174 uint32_t answerSize,
2175 const char* mimeType)
2176 {
2177 _OrthancPluginAnswerBuffer params;
2178 params.output = output;
2179 params.answer = answer;
2180 params.answerSize = answerSize;
2181 params.mimeType = mimeType;
2182 context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
2183 }
2184
2185
2186 typedef struct
2187 {
2190 uint32_t width;
2191 uint32_t height;
2192 uint32_t pitch;
2193 const void* buffer;
2194 } _OrthancPluginCompressAndAnswerPngImage;
2195
2196 typedef struct
2197 {
2199 OrthancPluginImageFormat imageFormat;
2200 OrthancPluginPixelFormat pixelFormat;
2201 uint32_t width;
2202 uint32_t height;
2203 uint32_t pitch;
2204 const void* buffer;
2205 uint8_t quality;
2206 } _OrthancPluginCompressAndAnswerImage;
2207
2208
2227 ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2228 OrthancPluginContext* context,
2231 uint32_t width,
2232 uint32_t height,
2233 uint32_t pitch,
2234 const void* buffer)
2235 {
2236 _OrthancPluginCompressAndAnswerImage params;
2237 params.output = output;
2238 params.imageFormat = OrthancPluginImageFormat_Png;
2239 params.pixelFormat = format;
2240 params.width = width;
2241 params.height = height;
2242 params.pitch = pitch;
2243 params.buffer = buffer;
2244 params.quality = 0; /* No quality for PNG */
2245 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2246 }
2247
2248
2249
2250 typedef struct
2251 {
2253 const char* instanceId;
2254 } _OrthancPluginGetDicomForInstance;
2255
2269 OrthancPluginContext* context,
2271 const char* instanceId)
2272 {
2273 _OrthancPluginGetDicomForInstance params;
2274 params.target = target;
2275 params.instanceId = instanceId;
2276 return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2277 }
2278
2279
2280
2281 typedef struct
2282 {
2284 const char* uri;
2285 } _OrthancPluginRestApiGet;
2286
2302 OrthancPluginContext* context,
2304 const char* uri)
2305 {
2306 _OrthancPluginRestApiGet params;
2307 params.target = target;
2308 params.uri = uri;
2309 return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2310 }
2311
2312
2313
2332 OrthancPluginContext* context,
2334 const char* uri)
2335 {
2336 _OrthancPluginRestApiGet params;
2337 params.target = target;
2338 params.uri = uri;
2339 return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2340 }
2341
2342
2343
2344 typedef struct
2345 {
2347 const char* uri;
2348 const void* body;
2349 uint32_t bodySize;
2350 } _OrthancPluginRestApiPostPut;
2351
2369 OrthancPluginContext* context,
2371 const char* uri,
2372 const void* body,
2373 uint32_t bodySize)
2374 {
2375 _OrthancPluginRestApiPostPut params;
2376 params.target = target;
2377 params.uri = uri;
2378 params.body = body;
2379 params.bodySize = bodySize;
2380 return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2381 }
2382
2383
2404 OrthancPluginContext* context,
2406 const char* uri,
2407 const void* body,
2408 uint32_t bodySize)
2409 {
2410 _OrthancPluginRestApiPostPut params;
2411 params.target = target;
2412 params.uri = uri;
2413 params.body = body;
2414 params.bodySize = bodySize;
2415 return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2416 }
2417
2418
2419
2433 OrthancPluginContext* context,
2434 const char* uri)
2435 {
2436 return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2437 }
2438
2439
2456 OrthancPluginContext* context,
2457 const char* uri)
2458 {
2459 return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2460 }
2461
2462
2463
2481 OrthancPluginContext* context,
2483 const char* uri,
2484 const void* body,
2485 uint32_t bodySize)
2486 {
2487 _OrthancPluginRestApiPostPut params;
2488 params.target = target;
2489 params.uri = uri;
2490 params.body = body;
2491 params.bodySize = bodySize;
2492 return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2493 }
2494
2495
2496
2517 OrthancPluginContext* context,
2519 const char* uri,
2520 const void* body,
2521 uint32_t bodySize)
2522 {
2523 _OrthancPluginRestApiPostPut params;
2524 params.target = target;
2525 params.uri = uri;
2526 params.body = body;
2527 params.bodySize = bodySize;
2528 return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2529 }
2530
2531
2532
2533 typedef struct
2534 {
2536 const char* argument;
2537 } _OrthancPluginOutputPlusArgument;
2538
2550 ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2551 OrthancPluginContext* context,
2553 const char* redirection)
2554 {
2555 _OrthancPluginOutputPlusArgument params;
2556 params.output = output;
2557 params.argument = redirection;
2558 context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2559 }
2560
2561
2562
2563 typedef struct
2564 {
2565 char** result;
2566 const char* argument;
2567 } _OrthancPluginRetrieveDynamicString;
2568
2582 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2583 OrthancPluginContext* context,
2584 const char* patientID)
2585 {
2586 char* result;
2587
2588 _OrthancPluginRetrieveDynamicString params;
2589 params.result = &result;
2590 params.argument = patientID;
2591
2592 if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2593 {
2594 /* Error */
2595 return NULL;
2596 }
2597 else
2598 {
2599 return result;
2600 }
2601 }
2602
2603
2617 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2618 OrthancPluginContext* context,
2619 const char* studyUID)
2620 {
2621 char* result;
2622
2623 _OrthancPluginRetrieveDynamicString params;
2624 params.result = &result;
2625 params.argument = studyUID;
2626
2627 if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2628 {
2629 /* Error */
2630 return NULL;
2631 }
2632 else
2633 {
2634 return result;
2635 }
2636 }
2637
2638
2653 OrthancPluginContext* context,
2654 const char* accessionNumber)
2655 {
2656 char* result;
2657
2658 _OrthancPluginRetrieveDynamicString params;
2659 params.result = &result;
2660 params.argument = accessionNumber;
2661
2662 if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2663 {
2664 /* Error */
2665 return NULL;
2666 }
2667 else
2668 {
2669 return result;
2670 }
2671 }
2672
2673
2687 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2688 OrthancPluginContext* context,
2689 const char* seriesUID)
2690 {
2691 char* result;
2692
2693 _OrthancPluginRetrieveDynamicString params;
2694 params.result = &result;
2695 params.argument = seriesUID;
2696
2697 if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2698 {
2699 /* Error */
2700 return NULL;
2701 }
2702 else
2703 {
2704 return result;
2705 }
2706 }
2707
2708
2722 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2723 OrthancPluginContext* context,
2724 const char* sopInstanceUID)
2725 {
2726 char* result;
2727
2728 _OrthancPluginRetrieveDynamicString params;
2729 params.result = &result;
2730 params.argument = sopInstanceUID;
2731
2732 if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2733 {
2734 /* Error */
2735 return NULL;
2736 }
2737 else
2738 {
2739 return result;
2740 }
2741 }
2742
2743
2744
2745 typedef struct
2746 {
2748 uint16_t status;
2749 } _OrthancPluginSendHttpStatusCode;
2750
2767 ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2768 OrthancPluginContext* context,
2770 uint16_t status)
2771 {
2772 _OrthancPluginSendHttpStatusCode params;
2773 params.output = output;
2774 params.status = status;
2775 context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2776 }
2777
2778
2790 ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2791 OrthancPluginContext* context,
2793 const char* realm)
2794 {
2795 _OrthancPluginOutputPlusArgument params;
2796 params.output = output;
2797 params.argument = realm;
2798 context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2799 }
2800
2801
2813 ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2814 OrthancPluginContext* context,
2816 const char* allowedMethods)
2817 {
2818 _OrthancPluginOutputPlusArgument params;
2819 params.output = output;
2820 params.argument = allowedMethods;
2821 context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2822 }
2823
2824
2825 typedef struct
2826 {
2828 const char* key;
2829 const char* value;
2830 } _OrthancPluginSetHttpHeader;
2831
2843 ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2844 OrthancPluginContext* context,
2846 const char* cookie,
2847 const char* value)
2848 {
2849 _OrthancPluginSetHttpHeader params;
2850 params.output = output;
2851 params.key = cookie;
2852 params.value = value;
2853 context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2854 }
2855
2856
2868 ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2869 OrthancPluginContext* context,
2871 const char* key,
2872 const char* value)
2873 {
2874 _OrthancPluginSetHttpHeader params;
2875 params.output = output;
2876 params.key = key;
2877 params.value = value;
2878 context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2879 }
2880
2881
2882 typedef struct
2883 {
2884 char** resultStringToFree;
2885 const char** resultString;
2886 int64_t* resultInt64;
2887 const char* key;
2888 const OrthancPluginDicomInstance* instance;
2889 OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2890 } _OrthancPluginAccessDicomInstance;
2891
2892
2904 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2905 OrthancPluginContext* context,
2906 const OrthancPluginDicomInstance* instance)
2907 {
2908 const char* result;
2909
2910 _OrthancPluginAccessDicomInstance params;
2911 memset(&params, 0, sizeof(params));
2912 params.resultString = &result;
2913 params.instance = instance;
2914
2915 if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2916 {
2917 /* Error */
2918 return NULL;
2919 }
2920 else
2921 {
2922 return result;
2923 }
2924 }
2925
2926
2937 ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2938 OrthancPluginContext* context,
2939 const OrthancPluginDicomInstance* instance)
2940 {
2941 int64_t size;
2942
2943 _OrthancPluginAccessDicomInstance params;
2944 memset(&params, 0, sizeof(params));
2945 params.resultInt64 = &size;
2946 params.instance = instance;
2947
2948 if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2949 {
2950 /* Error */
2951 return -1;
2952 }
2953 else
2954 {
2955 return size;
2956 }
2957 }
2958
2959
2970 ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData(
2971 OrthancPluginContext* context,
2972 const OrthancPluginDicomInstance* instance)
2973 {
2974 const char* result;
2975
2976 _OrthancPluginAccessDicomInstance params;
2977 memset(&params, 0, sizeof(params));
2978 params.resultString = &result;
2979 params.instance = instance;
2980
2981 if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2982 {
2983 /* Error */
2984 return NULL;
2985 }
2986 else
2987 {
2988 return result;
2989 }
2990 }
2991
2992
3006 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
3007 OrthancPluginContext* context,
3008 const OrthancPluginDicomInstance* instance)
3009 {
3010 char* result;
3011
3012 _OrthancPluginAccessDicomInstance params;
3013 memset(&params, 0, sizeof(params));
3014 params.resultStringToFree = &result;
3015 params.instance = instance;
3016
3017 if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
3018 {
3019 /* Error */
3020 return NULL;
3021 }
3022 else
3023 {
3024 return result;
3025 }
3026 }
3027
3028
3044 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
3045 OrthancPluginContext* context,
3046 const OrthancPluginDicomInstance* instance)
3047 {
3048 char* result;
3049
3050 _OrthancPluginAccessDicomInstance params;
3051 memset(&params, 0, sizeof(params));
3052 params.resultStringToFree = &result;
3053 params.instance = instance;
3054
3055 if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
3056 {
3057 /* Error */
3058 return NULL;
3059 }
3060 else
3061 {
3062 return result;
3063 }
3064 }
3065
3066
3083 ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
3084 OrthancPluginContext* context,
3085 const OrthancPluginDicomInstance* instance,
3086 const char* metadata)
3087 {
3088 int64_t result;
3089
3090 _OrthancPluginAccessDicomInstance params;
3091 memset(&params, 0, sizeof(params));
3092 params.resultInt64 = &result;
3093 params.instance = instance;
3094 params.key = metadata;
3095
3096 if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3097 {
3098 /* Error */
3099 return -1;
3100 }
3101 else
3102 {
3103 return (result != 0);
3104 }
3105 }
3106
3107
3124 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
3125 OrthancPluginContext* context,
3126 const OrthancPluginDicomInstance* instance,
3127 const char* metadata)
3128 {
3129 const char* result;
3130
3131 _OrthancPluginAccessDicomInstance params;
3132 memset(&params, 0, sizeof(params));
3133 params.resultString = &result;
3134 params.instance = instance;
3135 params.key = metadata;
3136
3137 if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3138 {
3139 /* Error */
3140 return NULL;
3141 }
3142 else
3143 {
3144 return result;
3145 }
3146 }
3147
3148
3149
3150 typedef struct
3151 {
3155 OrthancPluginFree free;
3156 } _OrthancPluginRegisterStorageArea;
3157
3173 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
3174 OrthancPluginContext* context,
3178 {
3179 _OrthancPluginRegisterStorageArea params;
3180 params.create = create;
3181 params.read = read;
3182 params.remove = remove;
3183
3184#ifdef __cplusplus
3185 params.free = ::free;
3186#else
3187 params.free = free;
3188#endif
3189
3190 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3191 }
3192
3193
3194
3205 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3206 {
3207 char* result;
3208
3209 _OrthancPluginRetrieveDynamicString params;
3210 params.result = &result;
3211 params.argument = NULL;
3212
3213 if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3214 {
3215 /* Error */
3216 return NULL;
3217 }
3218 else
3219 {
3220 return result;
3221 }
3222 }
3223
3224
3235 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3236 {
3237 char* result;
3238
3239 _OrthancPluginRetrieveDynamicString params;
3240 params.result = &result;
3241 params.argument = NULL;
3242
3243 if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3244 {
3245 /* Error */
3246 return NULL;
3247 }
3248 else
3249 {
3250 return result;
3251 }
3252 }
3253
3254
3270 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3271 {
3272 char* result;
3273
3274 _OrthancPluginRetrieveDynamicString params;
3275 params.result = &result;
3276 params.argument = NULL;
3277
3278 if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3279 {
3280 /* Error */
3281 return NULL;
3282 }
3283 else
3284 {
3285 return result;
3286 }
3287 }
3288
3289
3290
3291 typedef struct
3292 {
3294 } _OrthancPluginOnChangeCallback;
3295
3316 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3317 OrthancPluginContext* context,
3319 {
3320 _OrthancPluginOnChangeCallback params;
3321 params.callback = callback;
3322
3323 context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3324 }
3325
3326
3327
3328 typedef struct
3329 {
3330 const char* plugin;
3331 _OrthancPluginProperty property;
3332 const char* value;
3333 } _OrthancPluginSetPluginProperty;
3334
3335
3347 ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3348 OrthancPluginContext* context,
3349 const char* uri)
3350 {
3351 _OrthancPluginSetPluginProperty params;
3352 params.plugin = OrthancPluginGetName();
3353 params.property = _OrthancPluginProperty_RootUri;
3354 params.value = uri;
3355
3356 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3357 }
3358
3359
3369 ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3370 OrthancPluginContext* context,
3371 const char* description)
3372 {
3373 _OrthancPluginSetPluginProperty params;
3374 params.plugin = OrthancPluginGetName();
3375 params.property = _OrthancPluginProperty_Description;
3376 params.value = description;
3377
3378 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3379 }
3380
3381
3391 ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3392 OrthancPluginContext* context,
3393 const char* javascript)
3394 {
3395 _OrthancPluginSetPluginProperty params;
3396 params.plugin = OrthancPluginGetName();
3397 params.property = _OrthancPluginProperty_OrthancExplorer;
3398 params.value = javascript;
3399
3400 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3401 }
3402
3403
3404 typedef struct
3405 {
3406 char** result;
3407 int32_t property;
3408 const char* value;
3409 } _OrthancPluginGlobalProperty;
3410
3411
3425 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3426 OrthancPluginContext* context,
3427 int32_t property,
3428 const char* defaultValue)
3429 {
3430 char* result;
3431
3432 _OrthancPluginGlobalProperty params;
3433 params.result = &result;
3434 params.property = property;
3435 params.value = defaultValue;
3436
3437 if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3438 {
3439 /* Error */
3440 return NULL;
3441 }
3442 else
3443 {
3444 return result;
3445 }
3446 }
3447
3448
3465 OrthancPluginContext* context,
3466 int32_t property,
3467 const char* value)
3468 {
3469 _OrthancPluginGlobalProperty params;
3470 params.result = NULL;
3471 params.property = property;
3472 params.value = value;
3473
3474 return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3475 }
3476
3477
3478
3479 typedef struct
3480 {
3481 int32_t *resultInt32;
3482 uint32_t *resultUint32;
3483 int64_t *resultInt64;
3484 uint64_t *resultUint64;
3485 } _OrthancPluginReturnSingleValue;
3486
3495 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3496 OrthancPluginContext* context)
3497 {
3498 uint32_t count = 0;
3499
3500 _OrthancPluginReturnSingleValue params;
3501 memset(&params, 0, sizeof(params));
3502 params.resultUint32 = &count;
3503
3504 if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3505 {
3506 /* Error */
3507 return 0;
3508 }
3509 else
3510 {
3511 return count;
3512 }
3513 }
3514
3515
3516
3529 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3530 OrthancPluginContext* context,
3531 uint32_t argument)
3532 {
3533 char* result;
3534
3535 _OrthancPluginGlobalProperty params;
3536 params.result = &result;
3537 params.property = (int32_t) argument;
3538 params.value = NULL;
3539
3540 if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3541 {
3542 /* Error */
3543 return NULL;
3544 }
3545 else
3546 {
3547 return result;
3548 }
3549 }
3550
3551
3561 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3562 OrthancPluginContext* context)
3563 {
3564 uint32_t count = 0;
3565
3566 _OrthancPluginReturnSingleValue params;
3567 memset(&params, 0, sizeof(params));
3568 params.resultUint32 = &count;
3569
3570 if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3571 {
3572 /* Error */
3573 return 0;
3574 }
3575 else
3576 {
3577 return count;
3578 }
3579 }
3580
3581
3582
3594 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3595 {
3596 char* result;
3597
3598 _OrthancPluginRetrieveDynamicString params;
3599 params.result = &result;
3600 params.argument = NULL;
3601
3602 if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3603 {
3604 /* Error */
3605 return NULL;
3606 }
3607 else
3608 {
3609 return result;
3610 }
3611 }
3612
3613
3614
3615 typedef struct
3616 {
3618 const char* subType;
3619 const char* contentType;
3620 } _OrthancPluginStartMultipartAnswer;
3621
3636 OrthancPluginContext* context,
3638 const char* subType,
3639 const char* contentType)
3640 {
3641 _OrthancPluginStartMultipartAnswer params;
3642 params.output = output;
3643 params.subType = subType;
3644 params.contentType = contentType;
3645 return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3646 }
3647
3648
3665 OrthancPluginContext* context,
3667 const void* answer,
3668 uint32_t answerSize)
3669 {
3670 _OrthancPluginAnswerBuffer params;
3671 params.output = output;
3672 params.answer = answer;
3673 params.answerSize = answerSize;
3674 params.mimeType = NULL;
3675 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3676 }
3677
3678
3679
3680 typedef struct
3681 {
3683 const void* source;
3684 uint32_t size;
3685 OrthancPluginCompressionType compression;
3686 uint8_t uncompress;
3687 } _OrthancPluginBufferCompression;
3688
3689
3707 OrthancPluginContext* context,
3709 const void* source,
3710 uint32_t size,
3711 OrthancPluginCompressionType compression,
3712 uint8_t uncompress)
3713 {
3714 _OrthancPluginBufferCompression params;
3715 params.target = target;
3716 params.source = source;
3717 params.size = size;
3718 params.compression = compression;
3719 params.uncompress = uncompress;
3720
3721 return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3722 }
3723
3724
3725
3726 typedef struct
3727 {
3729 const char* path;
3730 } _OrthancPluginReadFile;
3731
3744 OrthancPluginContext* context,
3746 const char* path)
3747 {
3748 _OrthancPluginReadFile params;
3749 params.target = target;
3750 params.path = path;
3751 return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3752 }
3753
3754
3755
3756 typedef struct
3757 {
3758 const char* path;
3759 const void* data;
3760 uint32_t size;
3761 } _OrthancPluginWriteFile;
3762
3775 OrthancPluginContext* context,
3776 const char* path,
3777 const void* data,
3778 uint32_t size)
3779 {
3780 _OrthancPluginWriteFile params;
3781 params.path = path;
3782 params.data = data;
3783 params.size = size;
3784 return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3785 }
3786
3787
3788
3789 typedef struct
3790 {
3791 const char** target;
3793 } _OrthancPluginGetErrorDescription;
3794
3805 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3806 OrthancPluginContext* context,
3808 {
3809 const char* result = NULL;
3810
3811 _OrthancPluginGetErrorDescription params;
3812 params.target = &result;
3813 params.error = error;
3814
3815 if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3816 result == NULL)
3817 {
3818 return "Unknown error code";
3819 }
3820 else
3821 {
3822 return result;
3823 }
3824 }
3825
3826
3827
3828 typedef struct
3829 {
3831 uint16_t status;
3832 const char* body;
3833 uint32_t bodySize;
3834 } _OrthancPluginSendHttpStatus;
3835
3858 ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3859 OrthancPluginContext* context,
3861 uint16_t status,
3862 const char* body,
3863 uint32_t bodySize)
3864 {
3865 _OrthancPluginSendHttpStatus params;
3866 params.output = output;
3867 params.status = status;
3868 params.body = body;
3869 params.bodySize = bodySize;
3870 context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3871 }
3872
3873
3874
3875 typedef struct
3876 {
3877 const OrthancPluginImage* image;
3878 uint32_t* resultUint32;
3879 OrthancPluginPixelFormat* resultPixelFormat;
3880 void** resultBuffer;
3881 } _OrthancPluginGetImageInfo;
3882
3883
3895 OrthancPluginContext* context,
3896 const OrthancPluginImage* image)
3897 {
3899
3900 _OrthancPluginGetImageInfo params;
3901 memset(&params, 0, sizeof(params));
3902 params.image = image;
3903 params.resultPixelFormat = &target;
3904
3905 if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3906 {
3908 }
3909 else
3910 {
3911 return (OrthancPluginPixelFormat) target;
3912 }
3913 }
3914
3915
3916
3927 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3928 OrthancPluginContext* context,
3929 const OrthancPluginImage* image)
3930 {
3931 uint32_t width;
3932
3933 _OrthancPluginGetImageInfo params;
3934 memset(&params, 0, sizeof(params));
3935 params.image = image;
3936 params.resultUint32 = &width;
3937
3938 if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3939 {
3940 return 0;
3941 }
3942 else
3943 {
3944 return width;
3945 }
3946 }
3947
3948
3949
3960 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3961 OrthancPluginContext* context,
3962 const OrthancPluginImage* image)
3963 {
3964 uint32_t height;
3965
3966 _OrthancPluginGetImageInfo params;
3967 memset(&params, 0, sizeof(params));
3968 params.image = image;
3969 params.resultUint32 = &height;
3970
3971 if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3972 {
3973 return 0;
3974 }
3975 else
3976 {
3977 return height;
3978 }
3979 }
3980
3981
3982
3995 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3996 OrthancPluginContext* context,
3997 const OrthancPluginImage* image)
3998 {
3999 uint32_t pitch;
4000
4001 _OrthancPluginGetImageInfo params;
4002 memset(&params, 0, sizeof(params));
4003 params.image = image;
4004 params.resultUint32 = &pitch;
4005
4006 if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
4007 {
4008 return 0;
4009 }
4010 else
4011 {
4012 return pitch;
4013 }
4014 }
4015
4016
4017
4029 ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
4030 OrthancPluginContext* context,
4031 const OrthancPluginImage* image)
4032 {
4033 void* target = NULL;
4034
4035 _OrthancPluginGetImageInfo params;
4036 memset(&params, 0, sizeof(params));
4037 params.resultBuffer = &target;
4038 params.image = image;
4039
4040 if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
4041 {
4042 return NULL;
4043 }
4044 else
4045 {
4046 return target;
4047 }
4048 }
4049
4050
4051 typedef struct
4052 {
4053 OrthancPluginImage** target;
4054 const void* data;
4055 uint32_t size;
4057 } _OrthancPluginUncompressImage;
4058
4059
4073 OrthancPluginContext* context,
4074 const void* data,
4075 uint32_t size,
4077 {
4078 OrthancPluginImage* target = NULL;
4079
4080 _OrthancPluginUncompressImage params;
4081 memset(&params, 0, sizeof(params));
4082 params.target = &target;
4083 params.data = data;
4084 params.size = size;
4085 params.format = format;
4086
4087 if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
4088 {
4089 return NULL;
4090 }
4091 else
4092 {
4093 return target;
4094 }
4095 }
4096
4097
4098
4099
4100 typedef struct
4101 {
4102 OrthancPluginImage* image;
4103 } _OrthancPluginFreeImage;
4104
4114 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
4115 OrthancPluginContext* context,
4116 OrthancPluginImage* image)
4117 {
4118 _OrthancPluginFreeImage params;
4119 params.image = image;
4120
4121 context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
4122 }
4123
4124
4125
4126
4127 typedef struct
4128 {
4130 OrthancPluginImageFormat imageFormat;
4131 OrthancPluginPixelFormat pixelFormat;
4132 uint32_t width;
4133 uint32_t height;
4134 uint32_t pitch;
4135 const void* buffer;
4136 uint8_t quality;
4137 } _OrthancPluginCompressImage;
4138
4139
4160 OrthancPluginContext* context,
4163 uint32_t width,
4164 uint32_t height,
4165 uint32_t pitch,
4166 const void* buffer)
4167 {
4168 _OrthancPluginCompressImage params;
4169 memset(&params, 0, sizeof(params));
4170 params.target = target;
4171 params.imageFormat = OrthancPluginImageFormat_Png;
4172 params.pixelFormat = format;
4173 params.width = width;
4174 params.height = height;
4175 params.pitch = pitch;
4176 params.buffer = buffer;
4177 params.quality = 0; /* Unused for PNG */
4178
4179 return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4180 }
4181
4182
4205 OrthancPluginContext* context,
4208 uint32_t width,
4209 uint32_t height,
4210 uint32_t pitch,
4211 const void* buffer,
4212 uint8_t quality)
4213 {
4214 _OrthancPluginCompressImage params;
4215 memset(&params, 0, sizeof(params));
4216 params.target = target;
4217 params.imageFormat = OrthancPluginImageFormat_Jpeg;
4218 params.pixelFormat = format;
4219 params.width = width;
4220 params.height = height;
4221 params.pitch = pitch;
4222 params.buffer = buffer;
4223 params.quality = quality;
4224
4225 return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4226 }
4227
4228
4229
4252 OrthancPluginContext* context,
4255 uint32_t width,
4256 uint32_t height,
4257 uint32_t pitch,
4258 const void* buffer,
4259 uint8_t quality)
4260 {
4261 _OrthancPluginCompressAndAnswerImage params;
4262 params.output = output;
4263 params.imageFormat = OrthancPluginImageFormat_Jpeg;
4264 params.pixelFormat = format;
4265 params.width = width;
4266 params.height = height;
4267 params.pitch = pitch;
4268 params.buffer = buffer;
4269 params.quality = quality;
4270 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4271 }
4272
4273
4274
4275
4276 typedef struct
4277 {
4280 const char* url;
4281 const char* username;
4282 const char* password;
4283 const void* body;
4284 uint32_t bodySize;
4285 } _OrthancPluginCallHttpClient;
4286
4287
4305 OrthancPluginContext* context,
4307 const char* url,
4308 const char* username,
4309 const char* password)
4310 {
4311 _OrthancPluginCallHttpClient params;
4312 memset(&params, 0, sizeof(params));
4313
4314 params.target = target;
4315 params.method = OrthancPluginHttpMethod_Get;
4316 params.url = url;
4317 params.username = username;
4318 params.password = password;
4319
4320 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4321 }
4322
4323
4343 OrthancPluginContext* context,
4345 const char* url,
4346 const void* body,
4347 uint32_t bodySize,
4348 const char* username,
4349 const char* password)
4350 {
4351 _OrthancPluginCallHttpClient params;
4352 memset(&params, 0, sizeof(params));
4353
4354 params.target = target;
4355 params.method = OrthancPluginHttpMethod_Post;
4356 params.url = url;
4357 params.body = body;
4358 params.bodySize = bodySize;
4359 params.username = username;
4360 params.password = password;
4361
4362 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4363 }
4364
4365
4385 OrthancPluginContext* context,
4387 const char* url,
4388 const void* body,
4389 uint32_t bodySize,
4390 const char* username,
4391 const char* password)
4392 {
4393 _OrthancPluginCallHttpClient params;
4394 memset(&params, 0, sizeof(params));
4395
4396 params.target = target;
4397 params.method = OrthancPluginHttpMethod_Put;
4398 params.url = url;
4399 params.body = body;
4400 params.bodySize = bodySize;
4401 params.username = username;
4402 params.password = password;
4403
4404 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4405 }
4406
4407
4423 OrthancPluginContext* context,
4424 const char* url,
4425 const char* username,
4426 const char* password)
4427 {
4428 _OrthancPluginCallHttpClient params;
4429 memset(&params, 0, sizeof(params));
4430
4431 params.method = OrthancPluginHttpMethod_Delete;
4432 params.url = url;
4433 params.username = username;
4434 params.password = password;
4435
4436 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4437 }
4438
4439
4440
4441 typedef struct
4442 {
4443 OrthancPluginImage** target;
4444 const OrthancPluginImage* source;
4445 OrthancPluginPixelFormat targetFormat;
4446 } _OrthancPluginConvertPixelFormat;
4447
4448
4461 OrthancPluginContext* context,
4462 const OrthancPluginImage* source,
4463 OrthancPluginPixelFormat targetFormat)
4464 {
4465 OrthancPluginImage* target = NULL;
4466
4467 _OrthancPluginConvertPixelFormat params;
4468 params.target = &target;
4469 params.source = source;
4470 params.targetFormat = targetFormat;
4471
4472 if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4473 {
4474 return NULL;
4475 }
4476 else
4477 {
4478 return target;
4479 }
4480 }
4481
4482
4483
4495 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4496 OrthancPluginContext* context)
4497 {
4498 uint32_t count = 0;
4499
4500 _OrthancPluginReturnSingleValue params;
4501 memset(&params, 0, sizeof(params));
4502 params.resultUint32 = &count;
4503
4504 if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4505 {
4506 /* Error */
4507 return 0;
4508 }
4509 else
4510 {
4511 return count;
4512 }
4513 }
4514
4515
4516
4517
4518 typedef struct
4519 {
4520 uint32_t fontIndex; /* in */
4521 const char** name; /* out */
4522 uint32_t* size; /* out */
4523 } _OrthancPluginGetFontInfo;
4524
4535 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4536 OrthancPluginContext* context,
4537 uint32_t fontIndex)
4538 {
4539 const char* result = NULL;
4540
4541 _OrthancPluginGetFontInfo params;
4542 memset(&params, 0, sizeof(params));
4543 params.name = &result;
4544 params.fontIndex = fontIndex;
4545
4546 if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4547 {
4548 return NULL;
4549 }
4550 else
4551 {
4552 return result;
4553 }
4554 }
4555
4556
4567 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4568 OrthancPluginContext* context,
4569 uint32_t fontIndex)
4570 {
4571 uint32_t result;
4572
4573 _OrthancPluginGetFontInfo params;
4574 memset(&params, 0, sizeof(params));
4575 params.size = &result;
4576 params.fontIndex = fontIndex;
4577
4578 if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4579 {
4580 return 0;
4581 }
4582 else
4583 {
4584 return result;
4585 }
4586 }
4587
4588
4589
4590 typedef struct
4591 {
4592 OrthancPluginImage* image;
4593 uint32_t fontIndex;
4594 const char* utf8Text;
4595 int32_t x;
4596 int32_t y;
4597 uint8_t r;
4598 uint8_t g;
4599 uint8_t b;
4600 } _OrthancPluginDrawText;
4601
4602
4621 OrthancPluginContext* context,
4622 OrthancPluginImage* image,
4623 uint32_t fontIndex,
4624 const char* utf8Text,
4625 int32_t x,
4626 int32_t y,
4627 uint8_t r,
4628 uint8_t g,
4629 uint8_t b)
4630 {
4631 _OrthancPluginDrawText params;
4632 memset(&params, 0, sizeof(params));
4633 params.image = image;
4634 params.fontIndex = fontIndex;
4635 params.utf8Text = utf8Text;
4636 params.x = x;
4637 params.y = y;
4638 params.r = r;
4639 params.g = g;
4640 params.b = b;
4641
4642 return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4643 }
4644
4645
4646
4647 typedef struct
4648 {
4649 OrthancPluginStorageArea* storageArea;
4650 const char* uuid;
4651 const void* content;
4652 uint64_t size;
4654 } _OrthancPluginStorageAreaCreate;
4655
4656
4675 OrthancPluginContext* context,
4676 OrthancPluginStorageArea* storageArea,
4677 const char* uuid,
4678 const void* content,
4679 uint64_t size,
4681 {
4682 _OrthancPluginStorageAreaCreate params;
4683 params.storageArea = storageArea;
4684 params.uuid = uuid;
4685 params.content = content;
4686 params.size = size;
4687 params.type = type;
4688
4689 return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4690 }
4691
4692
4693 typedef struct
4694 {
4696 OrthancPluginStorageArea* storageArea;
4697 const char* uuid;
4699 } _OrthancPluginStorageAreaRead;
4700
4701
4719 OrthancPluginContext* context,
4721 OrthancPluginStorageArea* storageArea,
4722 const char* uuid,
4724 {
4725 _OrthancPluginStorageAreaRead params;
4726 params.target = target;
4727 params.storageArea = storageArea;
4728 params.uuid = uuid;
4729 params.type = type;
4730
4731 return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4732 }
4733
4734
4735 typedef struct
4736 {
4737 OrthancPluginStorageArea* storageArea;
4738 const char* uuid;
4740 } _OrthancPluginStorageAreaRemove;
4741
4758 OrthancPluginContext* context,
4759 OrthancPluginStorageArea* storageArea,
4760 const char* uuid,
4762 {
4763 _OrthancPluginStorageAreaRemove params;
4764 params.storageArea = storageArea;
4765 params.uuid = uuid;
4766 params.type = type;
4767
4768 return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4769 }
4770
4771
4772
4773 typedef struct
4774 {
4775 OrthancPluginErrorCode* target;
4776 int32_t code;
4777 uint16_t httpStatus;
4778 const char* message;
4779 } _OrthancPluginRegisterErrorCode;
4780
4797 OrthancPluginContext* context,
4798 int32_t code,
4799 uint16_t httpStatus,
4800 const char* message)
4801 {
4803
4804 _OrthancPluginRegisterErrorCode params;
4805 params.target = &target;
4806 params.code = code;
4807 params.httpStatus = httpStatus;
4808 params.message = message;
4809
4810 if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4811 {
4812 return target;
4813 }
4814 else
4815 {
4816 /* There was an error while assigned the error. Use a generic code. */
4818 }
4819 }
4820
4821
4822
4823 typedef struct
4824 {
4825 uint16_t group;
4826 uint16_t element;
4828 const char* name;
4829 uint32_t minMultiplicity;
4830 uint32_t maxMultiplicity;
4831 } _OrthancPluginRegisterDictionaryTag;
4832
4853 OrthancPluginContext* context,
4854 uint16_t group,
4855 uint16_t element,
4857 const char* name,
4858 uint32_t minMultiplicity,
4859 uint32_t maxMultiplicity)
4860 {
4861 _OrthancPluginRegisterDictionaryTag params;
4862 params.group = group;
4863 params.element = element;
4864 params.vr = vr;
4865 params.name = name;
4866 params.minMultiplicity = minMultiplicity;
4867 params.maxMultiplicity = maxMultiplicity;
4868
4869 return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4870 }
4871
4872
4873
4874 typedef struct
4875 {
4876 uint16_t group;
4877 uint16_t element;
4879 const char* name;
4880 uint32_t minMultiplicity;
4881 uint32_t maxMultiplicity;
4882 const char* privateCreator;
4883 } _OrthancPluginRegisterPrivateDictionaryTag;
4884
4906 OrthancPluginContext* context,
4907 uint16_t group,
4908 uint16_t element,
4910 const char* name,
4911 uint32_t minMultiplicity,
4912 uint32_t maxMultiplicity,
4913 const char* privateCreator)
4914 {
4915 _OrthancPluginRegisterPrivateDictionaryTag params;
4916 params.group = group;
4917 params.element = element;
4918 params.vr = vr;
4919 params.name = name;
4920 params.minMultiplicity = minMultiplicity;
4921 params.maxMultiplicity = maxMultiplicity;
4922 params.privateCreator = privateCreator;
4923
4924 return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4925 }
4926
4927
4928
4929 typedef struct
4930 {
4931 OrthancPluginStorageArea* storageArea;
4933 } _OrthancPluginReconstructMainDicomTags;
4934
4950 OrthancPluginContext* context,
4951 OrthancPluginStorageArea* storageArea,
4953 {
4954 _OrthancPluginReconstructMainDicomTags params;
4955 params.level = level;
4956 params.storageArea = storageArea;
4957
4958 return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
4959 }
4960
4961
4962 typedef struct
4963 {
4964 char** result;
4965 const char* instanceId;
4966 const void* buffer;
4967 uint32_t size;
4970 uint32_t maxStringLength;
4971 } _OrthancPluginDicomToJson;
4972
4973
4993 ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4994 OrthancPluginContext* context,
4995 const void* buffer,
4996 uint32_t size,
4999 uint32_t maxStringLength)
5000 {
5001 char* result;
5002
5003 _OrthancPluginDicomToJson params;
5004 memset(&params, 0, sizeof(params));
5005 params.result = &result;
5006 params.buffer = buffer;
5007 params.size = size;
5008 params.format = format;
5009 params.flags = flags;
5010 params.maxStringLength = maxStringLength;
5011
5012 if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
5013 {
5014 /* Error */
5015 return NULL;
5016 }
5017 else
5018 {
5019 return result;
5020 }
5021 }
5022
5023
5042 ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
5043 OrthancPluginContext* context,
5044 const char* instanceId,
5047 uint32_t maxStringLength)
5048 {
5049 char* result;
5050
5051 _OrthancPluginDicomToJson params;
5052 memset(&params, 0, sizeof(params));
5053 params.result = &result;
5054 params.instanceId = instanceId;
5055 params.format = format;
5056 params.flags = flags;
5057 params.maxStringLength = maxStringLength;
5058
5059 if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
5060 {
5061 /* Error */
5062 return NULL;
5063 }
5064 else
5065 {
5066 return result;
5067 }
5068 }
5069
5070
5071 typedef struct
5072 {
5074 const char* uri;
5075 uint32_t headersCount;
5076 const char* const* headersKeys;
5077 const char* const* headersValues;
5078 int32_t afterPlugins;
5079 } _OrthancPluginRestApiGet2;
5080
5101 OrthancPluginContext* context,
5103 const char* uri,
5104 uint32_t headersCount,
5105 const char* const* headersKeys,
5106 const char* const* headersValues,
5107 int32_t afterPlugins)
5108 {
5109 _OrthancPluginRestApiGet2 params;
5110 params.target = target;
5111 params.uri = uri;
5112 params.headersCount = headersCount;
5113 params.headersKeys = headersKeys;
5114 params.headersValues = headersValues;
5115 params.afterPlugins = afterPlugins;
5116
5117 return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
5118 }
5119
5120
5121
5122 typedef struct
5123 {
5125 } _OrthancPluginWorklistCallback;
5126
5139 OrthancPluginContext* context,
5141 {
5142 _OrthancPluginWorklistCallback params;
5143 params.callback = callback;
5144
5145 return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
5146 }
5147
5148
5149
5150 typedef struct
5151 {
5153 const OrthancPluginWorklistQuery* query;
5154 const void* dicom;
5155 uint32_t size;
5156 } _OrthancPluginWorklistAnswersOperation;
5157
5175 OrthancPluginContext* context,
5177 const OrthancPluginWorklistQuery* query,
5178 const void* dicom,
5179 uint32_t size)
5180 {
5181 _OrthancPluginWorklistAnswersOperation params;
5182 params.answers = answers;
5183 params.query = query;
5184 params.dicom = dicom;
5185 params.size = size;
5186
5187 return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
5188 }
5189
5190
5205 OrthancPluginContext* context,
5207 {
5208 _OrthancPluginWorklistAnswersOperation params;
5209 params.answers = answers;
5210 params.query = NULL;
5211 params.dicom = NULL;
5212 params.size = 0;
5213
5214 return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5215 }
5216
5217
5218 typedef struct
5219 {
5220 const OrthancPluginWorklistQuery* query;
5221 const void* dicom;
5222 uint32_t size;
5223 int32_t* isMatch;
5225 } _OrthancPluginWorklistQueryOperation;
5226
5242 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5243 OrthancPluginContext* context,
5244 const OrthancPluginWorklistQuery* query,
5245 const void* dicom,
5246 uint32_t size)
5247 {
5248 int32_t isMatch = 0;
5249
5250 _OrthancPluginWorklistQueryOperation params;
5251 params.query = query;
5252 params.dicom = dicom;
5253 params.size = size;
5254 params.isMatch = &isMatch;
5255 params.target = NULL;
5256
5257 if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5258 {
5259 return isMatch;
5260 }
5261 else
5262 {
5263 /* Error: Assume non-match */
5264 return 0;
5265 }
5266 }
5267
5268
5282 OrthancPluginContext* context,
5284 const OrthancPluginWorklistQuery* query)
5285 {
5286 _OrthancPluginWorklistQueryOperation params;
5287 params.query = query;
5288 params.dicom = NULL;
5289 params.size = 0;
5290 params.isMatch = NULL;
5291 params.target = target;
5292
5293 return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5294 }
5295
5296
5308 OrthancPluginContext* context,
5309 const OrthancPluginDicomInstance* instance)
5310 {
5312
5313 _OrthancPluginAccessDicomInstance params;
5314 memset(&params, 0, sizeof(params));
5315 params.resultOrigin = &origin;
5316 params.instance = instance;
5317
5318 if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5319 {
5320 /* Error */
5322 }
5323 else
5324 {
5325 return origin;
5326 }
5327 }
5328
5329
5330 typedef struct
5331 {
5333 const char* json;
5334 const OrthancPluginImage* pixelData;
5336 } _OrthancPluginCreateDicom;
5337
5364 OrthancPluginContext* context,
5366 const char* json,
5367 const OrthancPluginImage* pixelData,
5369 {
5370 _OrthancPluginCreateDicom params;
5371 params.target = target;
5372 params.json = json;
5373 params.pixelData = pixelData;
5374 params.flags = flags;
5375
5376 return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5377 }
5378
5379
5380 typedef struct
5381 {
5383 } _OrthancPluginDecodeImageCallback;
5384
5400 OrthancPluginContext* context,
5402 {
5403 _OrthancPluginDecodeImageCallback params;
5404 params.callback = callback;
5405
5406 return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5407 }
5408
5409
5410
5411 typedef struct
5412 {
5413 OrthancPluginImage** target;
5415 uint32_t width;
5416 uint32_t height;
5417 uint32_t pitch;
5418 void* buffer;
5419 const void* constBuffer;
5420 uint32_t bufferSize;
5421 uint32_t frameIndex;
5422 } _OrthancPluginCreateImage;
5423
5424
5438 OrthancPluginContext* context,
5440 uint32_t width,
5441 uint32_t height)
5442 {
5443 OrthancPluginImage* target = NULL;
5444
5445 _OrthancPluginCreateImage params;
5446 memset(&params, 0, sizeof(params));
5447 params.target = &target;
5448 params.format = format;
5449 params.width = width;
5450 params.height = height;
5451
5452 if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5453 {
5454 return NULL;
5455 }
5456 else
5457 {
5458 return target;
5459 }
5460 }
5461
5462
5481 OrthancPluginContext* context,
5483 uint32_t width,
5484 uint32_t height,
5485 uint32_t pitch,
5486 void* buffer)
5487 {
5488 OrthancPluginImage* target = NULL;
5489
5490 _OrthancPluginCreateImage params;
5491 memset(&params, 0, sizeof(params));
5492 params.target = &target;
5493 params.format = format;
5494 params.width = width;
5495 params.height = height;
5496 params.pitch = pitch;
5497 params.buffer = buffer;
5498
5499 if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5500 {
5501 return NULL;
5502 }
5503 else
5504 {
5505 return target;
5506 }
5507 }
5508
5509
5510
5527 OrthancPluginContext* context,
5528 const void* buffer,
5529 uint32_t bufferSize,
5530 uint32_t frameIndex)
5531 {
5532 OrthancPluginImage* target = NULL;
5533
5534 _OrthancPluginCreateImage params;
5535 memset(&params, 0, sizeof(params));
5536 params.target = &target;
5537 params.constBuffer = buffer;
5538 params.bufferSize = bufferSize;
5539 params.frameIndex = frameIndex;
5540
5541 if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5542 {
5543 return NULL;
5544 }
5545 else
5546 {
5547 return target;
5548 }
5549 }
5550
5551
5552
5553 typedef struct
5554 {
5555 char** result;
5556 const void* buffer;
5557 uint32_t size;
5558 } _OrthancPluginComputeHash;
5559
5572 ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5573 OrthancPluginContext* context,
5574 const void* buffer,
5575 uint32_t size)
5576 {
5577 char* result;
5578
5579 _OrthancPluginComputeHash params;
5580 params.result = &result;
5581 params.buffer = buffer;
5582 params.size = size;
5583
5584 if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5585 {
5586 /* Error */
5587 return NULL;
5588 }
5589 else
5590 {
5591 return result;
5592 }
5593 }
5594
5595
5608 ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5609 OrthancPluginContext* context,
5610 const void* buffer,
5611 uint32_t size)
5612 {
5613 char* result;
5614
5615 _OrthancPluginComputeHash params;
5616 params.result = &result;
5617 params.buffer = buffer;
5618 params.size = size;
5619
5620 if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5621 {
5622 /* Error */
5623 return NULL;
5624 }
5625 else
5626 {
5627 return result;
5628 }
5629 }
5630
5631
5632
5633 typedef struct
5634 {
5636 const char* name;
5637 } _OrthancPluginLookupDictionary;
5638
5655 OrthancPluginContext* context,
5657 const char* name)
5658 {
5659 _OrthancPluginLookupDictionary params;
5660 params.target = target;
5661 params.name = name;
5662 return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5663 }
5664
5665
5666
5667 typedef struct
5668 {
5670 const void* answer;
5671 uint32_t answerSize;
5672 uint32_t headersCount;
5673 const char* const* headersKeys;
5674 const char* const* headersValues;
5675 } _OrthancPluginSendMultipartItem2;
5676
5698 OrthancPluginContext* context,
5700 const void* answer,
5701 uint32_t answerSize,
5702 uint32_t headersCount,
5703 const char* const* headersKeys,
5704 const char* const* headersValues)
5705 {
5706 _OrthancPluginSendMultipartItem2 params;
5707 params.output = output;
5708 params.answer = answer;
5709 params.answerSize = answerSize;
5710 params.headersCount = headersCount;
5711 params.headersKeys = headersKeys;
5712 params.headersValues = headersValues;
5713
5714 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5715 }
5716
5717
5718 typedef struct
5719 {
5721 } _OrthancPluginIncomingHttpRequestFilter;
5722
5736 OrthancPluginContext* context,
5738 {
5739 _OrthancPluginIncomingHttpRequestFilter params;
5740 params.callback = callback;
5741
5742 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5743 }
5744
5745
5746
5747 typedef struct
5748 {
5749 OrthancPluginMemoryBuffer* answerBody;
5750 OrthancPluginMemoryBuffer* answerHeaders;
5751 uint16_t* httpStatus;
5753 const char* url;
5754 uint32_t headersCount;
5755 const char* const* headersKeys;
5756 const char* const* headersValues;
5757 const void* body;
5758 uint32_t bodySize;
5759 const char* username;
5760 const char* password;
5761 uint32_t timeout;
5762 const char* certificateFile;
5763 const char* certificateKeyFile;
5764 const char* certificateKeyPassword;
5765 uint8_t pkcs11;
5766 } _OrthancPluginCallHttpClient2;
5767
5768
5769
5811 OrthancPluginContext* context,
5812 OrthancPluginMemoryBuffer* answerBody,
5813 OrthancPluginMemoryBuffer* answerHeaders,
5814 uint16_t* httpStatus,
5816 const char* url,
5817 uint32_t headersCount,
5818 const char* const* headersKeys,
5819 const char* const* headersValues,
5820 const void* body,
5821 uint32_t bodySize,
5822 const char* username,
5823 const char* password,
5824 uint32_t timeout,
5825 const char* certificateFile,
5826 const char* certificateKeyFile,
5827 const char* certificateKeyPassword,
5828 uint8_t pkcs11)
5829 {
5830 _OrthancPluginCallHttpClient2 params;
5831 memset(&params, 0, sizeof(params));
5832
5833 params.answerBody = answerBody;
5834 params.answerHeaders = answerHeaders;
5835 params.httpStatus = httpStatus;
5836 params.method = method;
5837 params.url = url;
5838 params.headersCount = headersCount;
5839 params.headersKeys = headersKeys;
5840 params.headersValues = headersValues;
5841 params.body = body;
5842 params.bodySize = bodySize;
5843 params.username = username;
5844 params.password = password;
5845 params.timeout = timeout;
5846 params.certificateFile = certificateFile;
5847 params.certificateKeyFile = certificateKeyFile;
5848 params.certificateKeyPassword = certificateKeyPassword;
5849 params.pkcs11 = pkcs11;
5850
5851 return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5852 }
5853
5854
5865 ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5866 OrthancPluginContext* context)
5867 {
5868 char* result;
5869
5870 _OrthancPluginRetrieveDynamicString params;
5871 params.result = &result;
5872 params.argument = NULL;
5873
5874 if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5875 {
5876 /* Error */
5877 return NULL;
5878 }
5879 else
5880 {
5881 return result;
5882 }
5883 }
5884
5885
5886
5887
5888 typedef struct
5889 {
5891 } _OrthancPluginFindCallback;
5892
5905 OrthancPluginContext* context,
5907 {
5908 _OrthancPluginFindCallback params;
5909 params.callback = callback;
5910
5911 return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5912 }
5913
5914
5915 typedef struct
5916 {
5917 OrthancPluginFindAnswers *answers;
5918 const OrthancPluginFindQuery *query;
5919 const void *dicom;
5920 uint32_t size;
5921 uint32_t index;
5922 uint32_t *resultUint32;
5923 uint16_t *resultGroup;
5924 uint16_t *resultElement;
5925 char **resultString;
5926 } _OrthancPluginFindOperation;
5927
5944 OrthancPluginContext* context,
5945 OrthancPluginFindAnswers* answers,
5946 const void* dicom,
5947 uint32_t size)
5948 {
5949 _OrthancPluginFindOperation params;
5950 memset(&params, 0, sizeof(params));
5951 params.answers = answers;
5952 params.dicom = dicom;
5953 params.size = size;
5954
5955 return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
5956 }
5957
5958
5973 OrthancPluginContext* context,
5974 OrthancPluginFindAnswers* answers)
5975 {
5976 _OrthancPluginFindOperation params;
5977 memset(&params, 0, sizeof(params));
5978 params.answers = answers;
5979
5980 return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
5981 }
5982
5983
5984
5996 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
5997 OrthancPluginContext* context,
5998 const OrthancPluginFindQuery* query)
5999 {
6000 uint32_t count = 0;
6001
6002 _OrthancPluginFindOperation params;
6003 memset(&params, 0, sizeof(params));
6004 params.query = query;
6005 params.resultUint32 = &count;
6006
6007 if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
6008 {
6009 /* Error */
6010 return 0;
6011 }
6012 else
6013 {
6014 return count;
6015 }
6016 }
6017
6018
6034 OrthancPluginContext* context,
6035 uint16_t* group,
6036 uint16_t* element,
6037 const OrthancPluginFindQuery* query,
6038 uint32_t index)
6039 {
6040 _OrthancPluginFindOperation params;
6041 memset(&params, 0, sizeof(params));
6042 params.query = query;
6043 params.index = index;
6044 params.resultGroup = group;
6045 params.resultElement = element;
6046
6047 return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
6048 }
6049
6050
6064 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
6065 OrthancPluginContext* context,
6066 const OrthancPluginFindQuery* query,
6067 uint32_t index)
6068 {
6069 char* result;
6070
6071 _OrthancPluginFindOperation params;
6072 memset(&params, 0, sizeof(params));
6073 params.query = query;
6074 params.index = index;
6075 params.resultString = &result;
6076
6077 if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
6078 {
6079 /* Error */
6080 return NULL;
6081 }
6082 else
6083 {
6084 return result;
6085 }
6086 }
6087
6088
6102 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
6103 OrthancPluginContext* context,
6104 const OrthancPluginFindQuery* query,
6105 uint32_t index)
6106 {
6107 char* result;
6108
6109 _OrthancPluginFindOperation params;
6110 memset(&params, 0, sizeof(params));
6111 params.query = query;
6112 params.index = index;
6113 params.resultString = &result;
6114
6115 if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
6116 {
6117 /* Error */
6118 return NULL;
6119 }
6120 else
6121 {
6122 return result;
6123 }
6124 }
6125
6126
6127
6128
6129 typedef struct
6130 {
6132 OrthancPluginGetMoveSize getMoveSize;
6133 OrthancPluginApplyMove applyMove;
6134 OrthancPluginFreeMove freeMove;
6135 } _OrthancPluginMoveCallback;
6136
6151 OrthancPluginContext* context,
6153 OrthancPluginGetMoveSize getMoveSize,
6154 OrthancPluginApplyMove applyMove,
6155 OrthancPluginFreeMove freeMove)
6156 {
6157 _OrthancPluginMoveCallback params;
6158 params.callback = callback;
6159 params.getMoveSize = getMoveSize;
6160 params.applyMove = applyMove;
6161 params.freeMove = freeMove;
6162
6163 return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
6164 }
6165
6166
6167
6168 typedef struct
6169 {
6170 OrthancPluginFindMatcher** target;
6171 const void* query;
6172 uint32_t size;
6173 } _OrthancPluginCreateFindMatcher;
6174
6175
6190 OrthancPluginContext* context,
6191 const void* query,
6192 uint32_t size)
6193 {
6194 OrthancPluginFindMatcher* target = NULL;
6195
6196 _OrthancPluginCreateFindMatcher params;
6197 memset(&params, 0, sizeof(params));
6198 params.target = &target;
6199 params.query = query;
6200 params.size = size;
6201
6202 if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
6203 {
6204 return NULL;
6205 }
6206 else
6207 {
6208 return target;
6209 }
6210 }
6211
6212
6213 typedef struct
6214 {
6215 OrthancPluginFindMatcher* matcher;
6216 } _OrthancPluginFreeFindMatcher;
6217
6227 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6228 OrthancPluginContext* context,
6229 OrthancPluginFindMatcher* matcher)
6230 {
6231 _OrthancPluginFreeFindMatcher params;
6232 params.matcher = matcher;
6233
6234 context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6235 }
6236
6237
6238 typedef struct
6239 {
6240 const OrthancPluginFindMatcher* matcher;
6241 const void* dicom;
6242 uint32_t size;
6243 int32_t* isMatch;
6244 } _OrthancPluginFindMatcherIsMatch;
6245
6260 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6261 OrthancPluginContext* context,
6262 const OrthancPluginFindMatcher* matcher,
6263 const void* dicom,
6264 uint32_t size)
6265 {
6266 int32_t isMatch = 0;
6267
6268 _OrthancPluginFindMatcherIsMatch params;
6269 params.matcher = matcher;
6270 params.dicom = dicom;
6271 params.size = size;
6272 params.isMatch = &isMatch;
6273
6274 if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6275 {
6276 return isMatch;
6277 }
6278 else
6279 {
6280 /* Error: Assume non-match */
6281 return 0;
6282 }
6283 }
6284
6285
6286 typedef struct
6287 {
6289 } _OrthancPluginIncomingHttpRequestFilter2;
6290
6303 OrthancPluginContext* context,
6305 {
6306 _OrthancPluginIncomingHttpRequestFilter2 params;
6307 params.callback = callback;
6308
6309 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6310 }
6311
6312
6313
6314 typedef struct
6315 {
6316 OrthancPluginPeers** peers;
6317 } _OrthancPluginGetPeers;
6318
6331 OrthancPluginContext* context)
6332 {
6333 OrthancPluginPeers* peers = NULL;
6334
6335 _OrthancPluginGetPeers params;
6336 memset(&params, 0, sizeof(params));
6337 params.peers = &peers;
6338
6339 if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6340 {
6341 return NULL;
6342 }
6343 else
6344 {
6345 return peers;
6346 }
6347 }
6348
6349
6350 typedef struct
6351 {
6352 OrthancPluginPeers* peers;
6353 } _OrthancPluginFreePeers;
6354
6364 ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6365 OrthancPluginContext* context,
6366 OrthancPluginPeers* peers)
6367 {
6368 _OrthancPluginFreePeers params;
6369 params.peers = peers;
6370
6371 context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6372 }
6373
6374
6375 typedef struct
6376 {
6377 uint32_t* target;
6378 const OrthancPluginPeers* peers;
6379 } _OrthancPluginGetPeersCount;
6380
6394 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6395 OrthancPluginContext* context,
6396 const OrthancPluginPeers* peers)
6397 {
6398 uint32_t target = 0;
6399
6400 _OrthancPluginGetPeersCount params;
6401 memset(&params, 0, sizeof(params));
6402 params.target = &target;
6403 params.peers = peers;
6404
6405 if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6406 {
6407 /* Error */
6408 return 0;
6409 }
6410 else
6411 {
6412 return target;
6413 }
6414 }
6415
6416
6417 typedef struct
6418 {
6419 const char** target;
6420 const OrthancPluginPeers* peers;
6421 uint32_t peerIndex;
6422 const char* userProperty;
6423 } _OrthancPluginGetPeerProperty;
6424
6442 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6443 OrthancPluginContext* context,
6444 const OrthancPluginPeers* peers,
6445 uint32_t peerIndex)
6446 {
6447 const char* target = NULL;
6448
6449 _OrthancPluginGetPeerProperty params;
6450 memset(&params, 0, sizeof(params));
6451 params.target = &target;
6452 params.peers = peers;
6453 params.peerIndex = peerIndex;
6454 params.userProperty = NULL;
6455
6456 if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6457 {
6458 /* Error */
6459 return NULL;
6460 }
6461 else
6462 {
6463 return target;
6464 }
6465 }
6466
6467
6483 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6484 OrthancPluginContext* context,
6485 const OrthancPluginPeers* peers,
6486 uint32_t peerIndex)
6487 {
6488 const char* target = NULL;
6489
6490 _OrthancPluginGetPeerProperty params;
6491 memset(&params, 0, sizeof(params));
6492 params.target = &target;
6493 params.peers = peers;
6494 params.peerIndex = peerIndex;
6495 params.userProperty = NULL;
6496
6497 if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6498 {
6499 /* Error */
6500 return NULL;
6501 }
6502 else
6503 {
6504 return target;
6505 }
6506 }
6507
6508
6509
6529 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6530 OrthancPluginContext* context,
6531 const OrthancPluginPeers* peers,
6532 uint32_t peerIndex,
6533 const char* userProperty)
6534 {
6535 const char* target = NULL;
6536
6537 _OrthancPluginGetPeerProperty params;
6538 memset(&params, 0, sizeof(params));
6539 params.target = &target;
6540 params.peers = peers;
6541 params.peerIndex = peerIndex;
6542 params.userProperty = userProperty;
6543
6544 if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6545 {
6546 /* No such user property */
6547 return NULL;
6548 }
6549 else
6550 {
6551 return target;
6552 }
6553 }
6554
6555
6556
6557 typedef struct
6558 {
6559 OrthancPluginMemoryBuffer* answerBody;
6560 OrthancPluginMemoryBuffer* answerHeaders;
6561 uint16_t* httpStatus;
6562 const OrthancPluginPeers* peers;
6563 uint32_t peerIndex;
6565 const char* uri;
6566 uint32_t additionalHeadersCount;
6567 const char* const* additionalHeadersKeys;
6568 const char* const* additionalHeadersValues;
6569 const void* body;
6570 uint32_t bodySize;
6571 uint32_t timeout;
6572 } _OrthancPluginCallPeerApi;
6573
6611 OrthancPluginContext* context,
6612 OrthancPluginMemoryBuffer* answerBody,
6613 OrthancPluginMemoryBuffer* answerHeaders,
6614 uint16_t* httpStatus,
6615 const OrthancPluginPeers* peers,
6616 uint32_t peerIndex,
6618 const char* uri,
6619 uint32_t additionalHeadersCount,
6620 const char* const* additionalHeadersKeys,
6621 const char* const* additionalHeadersValues,
6622 const void* body,
6623 uint32_t bodySize,
6624 uint32_t timeout)
6625 {
6626 _OrthancPluginCallPeerApi params;
6627 memset(&params, 0, sizeof(params));
6628
6629 params.answerBody = answerBody;
6630 params.answerHeaders = answerHeaders;
6631 params.httpStatus = httpStatus;
6632 params.peers = peers;
6633 params.peerIndex = peerIndex;
6634 params.method = method;
6635 params.uri = uri;
6636 params.additionalHeadersCount = additionalHeadersCount;
6637 params.additionalHeadersKeys = additionalHeadersKeys;
6638 params.additionalHeadersValues = additionalHeadersValues;
6639 params.body = body;
6640 params.bodySize = bodySize;
6641 params.timeout = timeout;
6642
6643 return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6644 }
6645
6646
6647
6648
6649
6650 typedef struct
6651 {
6652 OrthancPluginJob** target;
6653 void *job;
6654 OrthancPluginJobFinalize finalize;
6655 const char *type;
6656 OrthancPluginJobGetProgress getProgress;
6657 OrthancPluginJobGetContent getContent;
6658 OrthancPluginJobGetSerialized getSerialized;
6662 } _OrthancPluginCreateJob;
6663
6696 OrthancPluginContext *context,
6697 void *job,
6698 OrthancPluginJobFinalize finalize,
6699 const char *type,
6700 OrthancPluginJobGetProgress getProgress,
6701 OrthancPluginJobGetContent getContent,
6702 OrthancPluginJobGetSerialized getSerialized,
6706 {
6707 OrthancPluginJob* target = NULL;
6708
6709 _OrthancPluginCreateJob params;
6710 memset(&params, 0, sizeof(params));
6711
6712 params.target = &target;
6713 params.job = job;
6714 params.finalize = finalize;
6715 params.type = type;
6716 params.getProgress = getProgress;
6717 params.getContent = getContent;
6718 params.getSerialized = getSerialized;
6719 params.step = step;
6720 params.stop = stop;
6721 params.reset = reset;
6722
6723 if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6724 target == NULL)
6725 {
6726 /* Error */
6727 return NULL;
6728 }
6729 else
6730 {
6731 return target;
6732 }
6733 }
6734
6735
6736 typedef struct
6737 {
6738 OrthancPluginJob* job;
6739 } _OrthancPluginFreeJob;
6740
6750 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6751 OrthancPluginContext* context,
6752 OrthancPluginJob* job)
6753 {
6754 _OrthancPluginFreeJob params;
6755 params.job = job;
6756
6757 context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6758 }
6759
6760
6761
6762 typedef struct
6763 {
6764 char** resultId;
6765 OrthancPluginJob *job;
6766 int priority;
6767 } _OrthancPluginSubmitJob;
6768
6782 ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6783 OrthancPluginContext *context,
6784 OrthancPluginJob *job,
6785 int priority)
6786 {
6787 char* resultId = NULL;
6788
6789 _OrthancPluginSubmitJob params;
6790 memset(&params, 0, sizeof(params));
6791
6792 params.resultId = &resultId;
6793 params.job = job;
6794 params.priority = priority;
6795
6796 if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6797 resultId == NULL)
6798 {
6799 /* Error */
6800 return NULL;
6801 }
6802 else
6803 {
6804 return resultId;
6805 }
6806 }
6807
6808
6809
6810 typedef struct
6811 {
6812 OrthancPluginJobsUnserializer unserializer;
6813 } _OrthancPluginJobsUnserializer;
6814
6827 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6828 OrthancPluginContext* context,
6829 OrthancPluginJobsUnserializer unserializer)
6830 {
6831 _OrthancPluginJobsUnserializer params;
6832 params.unserializer = unserializer;
6833
6834 context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6835 }
6836
6837
6838
6839 typedef struct
6840 {
6842 const char* details;
6843 uint8_t log;
6844 } _OrthancPluginSetHttpErrorDetails;
6845
6863 ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
6864 OrthancPluginContext* context,
6866 const char* details,
6867 uint8_t log)
6868 {
6869 _OrthancPluginSetHttpErrorDetails params;
6870 params.output = output;
6871 params.details = details;
6872 params.log = log;
6873 context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
6874 }
6875
6876
6877
6878 typedef struct
6879 {
6880 const char** result;
6881 const char* argument;
6882 } _OrthancPluginRetrieveStaticString;
6883
6895 ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
6896 OrthancPluginContext* context,
6897 const char* path)
6898 {
6899 const char* result = NULL;
6900
6901 _OrthancPluginRetrieveStaticString params;
6902 params.result = &result;
6903 params.argument = path;
6904
6905 if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
6906 {
6907 /* Error */
6908 return NULL;
6909 }
6910 else
6911 {
6912 return result;
6913 }
6914 }
6915
6916
6917
6918 typedef struct
6919 {
6920 const char* name;
6921 float value;
6923 } _OrthancPluginSetMetricsValue;
6924
6939 ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
6940 OrthancPluginContext* context,
6941 const char* name,
6942 float value,
6944 {
6945 _OrthancPluginSetMetricsValue params;
6946 params.name = name;
6947 params.value = value;
6948 params.type = type;
6949 context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
6950 }
6951
6952
6953
6954 typedef struct
6955 {
6957 } _OrthancPluginRegisterRefreshMetricsCallback;
6958
6970 OrthancPluginContext* context,
6972 {
6973 _OrthancPluginRegisterRefreshMetricsCallback params;
6974 params.callback = callback;
6975 context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
6976 }
6977
6978
6979
6980
6981 typedef struct
6982 {
6983 char** target;
6984 const void* dicom;
6985 uint32_t dicomSize;
6987 } _OrthancPluginEncodeDicomWeb;
6988
7005 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
7006 OrthancPluginContext* context,
7007 const void* dicom,
7008 uint32_t dicomSize,
7010 {
7011 char* target = NULL;
7012
7013 _OrthancPluginEncodeDicomWeb params;
7014 params.target = &target;
7015 params.dicom = dicom;
7016 params.dicomSize = dicomSize;
7017 params.callback = callback;
7018
7019 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
7020 {
7021 /* Error */
7022 return NULL;
7023 }
7024 else
7025 {
7026 return target;
7027 }
7028 }
7029
7030
7047 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
7048 OrthancPluginContext* context,
7049 const void* dicom,
7050 uint32_t dicomSize,
7052 {
7053 char* target = NULL;
7054
7055 _OrthancPluginEncodeDicomWeb params;
7056 params.target = &target;
7057 params.dicom = dicom;
7058 params.dicomSize = dicomSize;
7059 params.callback = callback;
7060
7061 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
7062 {
7063 /* Error */
7064 return NULL;
7065 }
7066 else
7067 {
7068 return target;
7069 }
7070 }
7071
7072
7073
7074 typedef struct
7075 {
7076 char** target;
7077 const void* dicom;
7078 uint32_t dicomSize;
7080 void* payload;
7081 } _OrthancPluginEncodeDicomWeb2;
7082
7099 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson2(
7100 OrthancPluginContext* context,
7101 const void* dicom,
7102 uint32_t dicomSize,
7104 void* payload)
7105 {
7106 char* target = NULL;
7107
7108 _OrthancPluginEncodeDicomWeb2 params;
7109 params.target = &target;
7110 params.dicom = dicom;
7111 params.dicomSize = dicomSize;
7112 params.callback = callback;
7113 params.payload = payload;
7114
7115 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson2, &params) != OrthancPluginErrorCode_Success)
7116 {
7117 /* Error */
7118 return NULL;
7119 }
7120 else
7121 {
7122 return target;
7123 }
7124 }
7125
7126
7143 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml2(
7144 OrthancPluginContext* context,
7145 const void* dicom,
7146 uint32_t dicomSize,
7148 void* payload)
7149 {
7150 char* target = NULL;
7151
7152 _OrthancPluginEncodeDicomWeb2 params;
7153 params.target = &target;
7154 params.dicom = dicom;
7155 params.dicomSize = dicomSize;
7156 params.callback = callback;
7157 params.payload = payload;
7158
7159 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml2, &params) != OrthancPluginErrorCode_Success)
7160 {
7161 /* Error */
7162 return NULL;
7163 }
7164 else
7165 {
7166 return target;
7167 }
7168 }
7169
7170
7171
7188 void* answer,
7189 const char* key,
7190 const char* value);
7191
7192
7209 void* answer,
7210 const void* data,
7211 uint32_t size);
7212
7213
7228 typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
7229
7230
7246
7247
7261 typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
7262
7263
7277 typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
7278
7279
7280 typedef struct
7281 {
7282 void* answer;
7285 uint16_t* httpStatus;
7287 const char* url;
7288 uint32_t headersCount;
7289 const char* const* headersKeys;
7290 const char* const* headersValues;
7291 void* request;
7296 const char* username;
7297 const char* password;
7298 uint32_t timeout;
7299 const char* certificateFile;
7300 const char* certificateKeyFile;
7301 const char* certificateKeyPassword;
7302 uint8_t pkcs11;
7303 } _OrthancPluginChunkedHttpClient;
7304
7305
7357 OrthancPluginContext* context,
7358 void* answer,
7361 uint16_t* httpStatus,
7363 const char* url,
7364 uint32_t headersCount,
7365 const char* const* headersKeys,
7366 const char* const* headersValues,
7367 void* request,
7372 const char* username,
7373 const char* password,
7374 uint32_t timeout,
7375 const char* certificateFile,
7376 const char* certificateKeyFile,
7377 const char* certificateKeyPassword,
7378 uint8_t pkcs11)
7379 {
7380 _OrthancPluginChunkedHttpClient params;
7381 memset(&params, 0, sizeof(params));
7382
7383 /* In common with OrthancPluginHttpClient() */
7384 params.httpStatus = httpStatus;
7385 params.method = method;
7386 params.url = url;
7387 params.headersCount = headersCount;
7388 params.headersKeys = headersKeys;
7389 params.headersValues = headersValues;
7390 params.username = username;
7391 params.password = password;
7392 params.timeout = timeout;
7393 params.certificateFile = certificateFile;
7394 params.certificateKeyFile = certificateKeyFile;
7395 params.certificateKeyPassword = certificateKeyPassword;
7396 params.pkcs11 = pkcs11;
7397
7398 /* For chunked body/answer */
7399 params.answer = answer;
7400 params.answerAddChunk = answerAddChunk;
7401 params.answerAddHeader = answerAddHeader;
7402 params.request = request;
7403 params.requestIsDone = requestIsDone;
7404 params.requestChunkData = requestChunkData;
7405 params.requestChunkSize = requestChunkSize;
7406 params.requestNext = requestNext;
7407
7408 return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7409 }
7410
7411
7412
7417 typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7418
7419
7420
7438 const char* url,
7439 const OrthancPluginHttpRequest* request);
7440
7441
7457 const void* data,
7458 uint32_t size);
7459
7460
7477 OrthancPluginRestOutput* output);
7478
7479
7495
7496 typedef struct
7497 {
7498 const char* pathRegularExpression;
7499 OrthancPluginRestCallback getHandler;
7501 OrthancPluginRestCallback deleteHandler;
7506 } _OrthancPluginChunkedRestCallback;
7507
7508
7539 OrthancPluginContext* context,
7540 const char* pathRegularExpression,
7541 OrthancPluginRestCallback getHandler,
7543 OrthancPluginRestCallback deleteHandler,
7548 {
7549 _OrthancPluginChunkedRestCallback params;
7550 params.pathRegularExpression = pathRegularExpression;
7551 params.getHandler = getHandler;
7552 params.postHandler = postHandler;
7553 params.deleteHandler = deleteHandler;
7554 params.putHandler = putHandler;
7555 params.addChunk = addChunk;
7556 params.execute = execute;
7557 params.finalize = finalize;
7558
7559 context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
7560 }
7561
7562
7563
7564
7565
7566 typedef struct
7567 {
7568 char** result;
7569 uint16_t group;
7570 uint16_t element;
7571 const char* privateCreator;
7572 } _OrthancPluginGetTagName;
7573
7589 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
7590 OrthancPluginContext* context,
7591 uint16_t group,
7592 uint16_t element,
7593 const char* privateCreator)
7594 {
7595 char* result;
7596
7597 _OrthancPluginGetTagName params;
7598 params.result = &result;
7599 params.group = group;
7600 params.element = element;
7601 params.privateCreator = privateCreator;
7602
7603 if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
7604 {
7605 /* Error */
7606 return NULL;
7607 }
7608 else
7609 {
7610 return result;
7611 }
7612 }
7613
7614
7615
7645 void** handler /* out */,
7646 const char* jobId,
7647 const char* transactionUid,
7648 const char* const* sopClassUids,
7649 const char* const* sopInstanceUids,
7650 uint32_t countInstances,
7651 const char* remoteAet,
7652 const char* calledAet);
7653
7654
7666 typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
7667
7668
7689 void* handler,
7690 const char* sopClassUid,
7691 const char* sopInstanceUid);
7692
7693
7694 typedef struct
7695 {
7699 } _OrthancPluginRegisterStorageCommitmentScpCallback;
7700
7715 OrthancPluginContext* context,
7719 {
7720 _OrthancPluginRegisterStorageCommitmentScpCallback params;
7721 params.factory = factory;
7722 params.destructor = destructor;
7723 params.lookup = lookup;
7724 return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
7725 }
7726
7727
7728
7755 const OrthancPluginDicomInstance* instance);
7756
7757
7758 typedef struct
7759 {
7761 } _OrthancPluginIncomingDicomInstanceFilter;
7762
7776 OrthancPluginContext* context,
7778 {
7779 _OrthancPluginIncomingDicomInstanceFilter params;
7780 params.callback = callback;
7781
7782 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, &params);
7783 }
7784
7785
7817 uint16_t* dimseStatus /* out */,
7818 const OrthancPluginDicomInstance* instance);
7819
7820
7821 typedef struct
7822 {
7824 } _OrthancPluginIncomingCStoreInstanceFilter;
7825
7839 OrthancPluginContext* context,
7841 {
7842 _OrthancPluginIncomingCStoreInstanceFilter params;
7843 params.callback = callback;
7844
7845 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingCStoreInstanceFilter, &params);
7846 }
7847
7884 OrthancPluginMemoryBuffer64* modifiedDicomBuffer,
7885 const void* receivedDicomBuffer,
7886 uint64_t receivedDicomBufferSize,
7888
7889
7890 typedef struct
7891 {
7893 } _OrthancPluginReceivedInstanceCallback;
7894
7916 OrthancPluginContext* context,
7918 {
7919 _OrthancPluginReceivedInstanceCallback params;
7920 params.callback = callback;
7921
7922 return context->InvokeService(context, _OrthancPluginService_RegisterReceivedInstanceCallback, &params);
7923 }
7924
7939 OrthancPluginContext* context,
7940 const OrthancPluginDicomInstance* instance)
7941 {
7942 char* result;
7943
7944 _OrthancPluginAccessDicomInstance params;
7945 memset(&params, 0, sizeof(params));
7946 params.resultStringToFree = &result;
7947 params.instance = instance;
7948
7949 if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, &params) != OrthancPluginErrorCode_Success)
7950 {
7951 /* Error */
7952 return NULL;
7953 }
7954 else
7955 {
7956 return result;
7957 }
7958 }
7959
7960
7973 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData(
7974 OrthancPluginContext* context,
7975 const OrthancPluginDicomInstance* instance)
7976 {
7977 int64_t hasPixelData;
7978
7979 _OrthancPluginAccessDicomInstance params;
7980 memset(&params, 0, sizeof(params));
7981 params.resultInt64 = &hasPixelData;
7982 params.instance = instance;
7983
7984 if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, &params) != OrthancPluginErrorCode_Success ||
7985 hasPixelData < 0 ||
7986 hasPixelData > 1)
7987 {
7988 /* Error */
7989 return -1;
7990 }
7991 else
7992 {
7993 return (hasPixelData != 0);
7994 }
7995 }
7996
7997
7998
7999
8000
8001
8002 typedef struct
8003 {
8005 const void* buffer;
8006 uint32_t size;
8007 const char* transferSyntax;
8008 } _OrthancPluginCreateDicomInstance;
8009
8024 OrthancPluginContext* context,
8025 const void* buffer,
8026 uint32_t size)
8027 {
8028 OrthancPluginDicomInstance* target = NULL;
8029
8030 _OrthancPluginCreateDicomInstance params;
8031 params.target = &target;
8032 params.buffer = buffer;
8033 params.size = size;
8034
8035 if (context->InvokeService(context, _OrthancPluginService_CreateDicomInstance, &params) != OrthancPluginErrorCode_Success)
8036 {
8037 /* Error */
8038 return NULL;
8039 }
8040 else
8041 {
8042 return target;
8043 }
8044 }
8045
8046 typedef struct
8047 {
8049 } _OrthancPluginFreeDicomInstance;
8050
8061 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeDicomInstance(
8062 OrthancPluginContext* context,
8064 {
8065 _OrthancPluginFreeDicomInstance params;
8066 params.dicom = dicom;
8067
8068 context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, &params);
8069 }
8070
8071
8072 typedef struct
8073 {
8074 uint32_t* targetUint32;
8075 OrthancPluginMemoryBuffer* targetBuffer;
8076 OrthancPluginImage** targetImage;
8077 char** targetStringToFree;
8078 const OrthancPluginDicomInstance* instance;
8079 uint32_t frameIndex;
8082 uint32_t maxStringLength;
8083 OrthancPluginDicomWebBinaryCallback2 dicomWebCallback;
8084 void* dicomWebPayload;
8085 } _OrthancPluginAccessDicomInstance2;
8086
8098 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetInstanceFramesCount(
8099 OrthancPluginContext* context,
8100 const OrthancPluginDicomInstance* instance)
8101 {
8102 uint32_t count;
8103
8104 _OrthancPluginAccessDicomInstance2 params;
8105 memset(&params, 0, sizeof(params));
8106 params.targetUint32 = &count;
8107 params.instance = instance;
8108
8109 if (context->InvokeService(context, _OrthancPluginService_GetInstanceFramesCount, &params) != OrthancPluginErrorCode_Success)
8110 {
8111 /* Error */
8112 return 0;
8113 }
8114 else
8115 {
8116 return count;
8117 }
8118 }
8119
8120
8139 OrthancPluginContext* context,
8141 const OrthancPluginDicomInstance* instance,
8142 uint32_t frameIndex)
8143 {
8144 _OrthancPluginAccessDicomInstance2 params;
8145 memset(&params, 0, sizeof(params));
8146 params.targetBuffer = target;
8147 params.instance = instance;
8148 params.frameIndex = frameIndex;
8149
8150 return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, &params);
8151 }
8152
8153
8167 OrthancPluginContext* context,
8168 const OrthancPluginDicomInstance* instance,
8169 uint32_t frameIndex)
8170 {
8171 OrthancPluginImage* target = NULL;
8172
8173 _OrthancPluginAccessDicomInstance2 params;
8174 memset(&params, 0, sizeof(params));
8175 params.targetImage = &target;
8176 params.instance = instance;
8177 params.frameIndex = frameIndex;
8178
8179 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDecodedFrame, &params) != OrthancPluginErrorCode_Success)
8180 {
8181 return NULL;
8182 }
8183 else
8184 {
8185 return target;
8186 }
8187 }
8188
8189
8206 OrthancPluginContext* context,
8207 const void* buffer,
8208 uint32_t size,
8209 const char* transferSyntax)
8210 {
8211 OrthancPluginDicomInstance* target = NULL;
8212
8213 _OrthancPluginCreateDicomInstance params;
8214 params.target = &target;
8215 params.buffer = buffer;
8216 params.size = size;
8217 params.transferSyntax = transferSyntax;
8218
8219 if (context->InvokeService(context, _OrthancPluginService_TranscodeDicomInstance, &params) != OrthancPluginErrorCode_Success)
8220 {
8221 /* Error */
8222 return NULL;
8223 }
8224 else
8225 {
8226 return target;
8227 }
8228 }
8229
8244 OrthancPluginContext* context,
8246 const OrthancPluginDicomInstance* instance)
8247 {
8248 _OrthancPluginAccessDicomInstance2 params;
8249 memset(&params, 0, sizeof(params));
8250 params.targetBuffer = target;
8251 params.instance = instance;
8252
8253 return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, &params);
8254 }
8255
8256
8275 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceAdvancedJson(
8276 OrthancPluginContext* context,
8277 const OrthancPluginDicomInstance* instance,
8280 uint32_t maxStringLength)
8281 {
8282 char* result = NULL;
8283
8284 _OrthancPluginAccessDicomInstance2 params;
8285 memset(&params, 0, sizeof(params));
8286 params.targetStringToFree = &result;
8287 params.instance = instance;
8288 params.format = format;
8289 params.flags = flags;
8290 params.maxStringLength = maxStringLength;
8291
8292 if (context->InvokeService(context, _OrthancPluginService_GetInstanceAdvancedJson, &params) != OrthancPluginErrorCode_Success)
8293 {
8294 /* Error */
8295 return NULL;
8296 }
8297 else
8298 {
8299 return result;
8300 }
8301 }
8302
8303
8318 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebJson(
8319 OrthancPluginContext* context,
8320 const OrthancPluginDicomInstance* instance,
8322 void* payload)
8323 {
8324 char* target = NULL;
8325
8326 _OrthancPluginAccessDicomInstance2 params;
8327 params.targetStringToFree = &target;
8328 params.instance = instance;
8329 params.dicomWebCallback = callback;
8330 params.dicomWebPayload = payload;
8331
8332 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebJson, &params) != OrthancPluginErrorCode_Success)
8333 {
8334 /* Error */
8335 return NULL;
8336 }
8337 else
8338 {
8339 return target;
8340 }
8341 }
8342
8343
8358 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebXml(
8359 OrthancPluginContext* context,
8360 const OrthancPluginDicomInstance* instance,
8362 void* payload)
8363 {
8364 char* target = NULL;
8365
8366 _OrthancPluginAccessDicomInstance2 params;
8367 params.targetStringToFree = &target;
8368 params.instance = instance;
8369 params.dicomWebCallback = callback;
8370 params.dicomWebPayload = payload;
8371
8372 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebXml, &params) != OrthancPluginErrorCode_Success)
8373 {
8374 /* Error */
8375 return NULL;
8376 }
8377 else
8378 {
8379 return target;
8380 }
8381 }
8382
8383
8384
8404 OrthancPluginMemoryBuffer* transcoded /* out */,
8405 const void* buffer,
8406 uint64_t size,
8407 const char* const* allowedSyntaxes,
8408 uint32_t countSyntaxes,
8409 uint8_t allowNewSopInstanceUid);
8410
8411
8412 typedef struct
8413 {
8415 } _OrthancPluginTranscoderCallback;
8416
8431 OrthancPluginContext* context,
8433 {
8434 _OrthancPluginTranscoderCallback params;
8435 params.callback = callback;
8436
8437 return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, &params);
8438 }
8439
8440
8441
8442 typedef struct
8443 {
8445 uint32_t size;
8446 } _OrthancPluginCreateMemoryBuffer;
8447
8466 OrthancPluginContext* context,
8468 uint32_t size)
8469 {
8470 _OrthancPluginCreateMemoryBuffer params;
8471 params.target = target;
8472 params.size = size;
8473
8474 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, &params);
8475 }
8476
8477
8504 OrthancPluginContext* context)
8505 {
8506 char* result;
8507
8508 _OrthancPluginRetrieveDynamicString params;
8509 params.result = &result;
8510 params.argument = NULL;
8511
8512 if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
8514 {
8515 /* Error */
8516 return NULL;
8517 }
8518 else
8519 {
8520 return result;
8521 }
8522 }
8523
8524
8525
8526 typedef struct
8527 {
8529 uint64_t size;
8530 } _OrthancPluginCreateMemoryBuffer64;
8531
8550 OrthancPluginContext* context,
8552 uint64_t size)
8553 {
8554 _OrthancPluginCreateMemoryBuffer64 params;
8555 params.target = target;
8556 params.size = size;
8557
8558 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer64, &params);
8559 }
8560
8561
8562 typedef struct
8563 {
8568 } _OrthancPluginRegisterStorageArea2;
8569
8586 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea2(
8587 OrthancPluginContext* context,
8592 {
8593 _OrthancPluginRegisterStorageArea2 params;
8594 params.create = create;
8595 params.readWhole = readWhole;
8596 params.readRange = readRange;
8597 params.remove = remove;
8598 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea2, &params);
8599 }
8600
8601
8602
8603 typedef struct
8604 {
8605 _OrthancPluginCreateDicom createDicom;
8606 const char* privateCreator;
8607 } _OrthancPluginCreateDicom2;
8608
8634 OrthancPluginContext* context,
8636 const char* json,
8637 const OrthancPluginImage* pixelData,
8639 const char* privateCreator)
8640 {
8641 _OrthancPluginCreateDicom2 params;
8642 params.createDicom.target = target;
8643 params.createDicom.json = json;
8644 params.createDicom.pixelData = pixelData;
8645 params.createDicom.flags = flags;
8646 params.privateCreator = privateCreator;
8647
8648 return context->InvokeService(context, _OrthancPluginService_CreateDicom2, &params);
8649 }
8650
8651
8652
8653
8654
8655
8656 typedef struct
8657 {
8658 OrthancPluginMemoryBuffer* answerBody;
8659 OrthancPluginMemoryBuffer* answerHeaders;
8660 uint16_t* httpStatus;
8662 const char* uri;
8663 uint32_t headersCount;
8664 const char* const* headersKeys;
8665 const char* const* headersValues;
8666 const void* body;
8667 uint32_t bodySize;
8668 uint8_t afterPlugins;
8669 } _OrthancPluginCallRestApi;
8670
8702 OrthancPluginContext* context,
8703 OrthancPluginMemoryBuffer* answerBody,
8704 OrthancPluginMemoryBuffer* answerHeaders,
8705 uint16_t* httpStatus,
8707 const char* uri,
8708 uint32_t headersCount,
8709 const char* const* headersKeys,
8710 const char* const* headersValues,
8711 const void* body,
8712 uint32_t bodySize,
8713 uint8_t afterPlugins)
8714 {
8715 _OrthancPluginCallRestApi params;
8716 memset(&params, 0, sizeof(params));
8717
8718 params.answerBody = answerBody;
8719 params.answerHeaders = answerHeaders;
8720 params.httpStatus = httpStatus;
8721 params.method = method;
8722 params.uri = uri;
8723 params.headersCount = headersCount;
8724 params.headersKeys = headersKeys;
8725 params.headersValues = headersValues;
8726 params.body = body;
8727 params.bodySize = bodySize;
8728 params.afterPlugins = afterPlugins;
8729
8730 return context->InvokeService(context, _OrthancPluginService_CallRestApi, &params);
8731 }
8732
8733
8734
8739 typedef struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection;
8740
8741
8760 const char* name,
8761 uint64_t size,
8762 const char* mimeType,
8763 const char* dateTime);
8764
8765
8781 const char* name,
8782 const char* dateTime);
8783
8784
8808 const void* data,
8809 uint64_t size,
8810 const char* mimeType,
8811 const char* dateTime);
8812
8813
8828 uint8_t* isExisting, /* out */
8829 uint32_t pathSize,
8830 const char* const* pathItems,
8831 void* payload);
8832
8833
8853 uint8_t* isExisting, /* out */
8857 uint32_t pathSize,
8858 const char* const* pathItems,
8859 void* payload);
8860
8861
8881 uint32_t pathSize,
8882 const char* const* pathItems,
8883 void* payload);
8884
8885
8902 uint8_t* isReadOnly, /* out */
8903 uint32_t pathSize,
8904 const char* const* pathItems,
8905 const void* data,
8906 uint64_t size,
8907 void* payload);
8908
8909
8924 uint8_t* isReadOnly, /* out */
8925 uint32_t pathSize,
8926 const char* const* pathItems,
8927 void* payload);
8928
8929
8944 uint8_t* isReadOnly, /* out */
8945 uint32_t pathSize,
8946 const char* const* pathItems,
8947 void* payload);
8948
8949
8950 typedef struct
8951 {
8952 const char* uri;
8959 void* payload;
8960 } _OrthancPluginRegisterWebDavCollection;
8961
8983 OrthancPluginContext* context,
8984 const char* uri,
8991 void* payload)
8992 {
8993 _OrthancPluginRegisterWebDavCollection params;
8994 params.uri = uri;
8995 params.isExistingFolder = isExistingFolder;
8996 params.listFolder = listFolder;
8997 params.retrieveFile = retrieveFile;
8998 params.storeFile = storeFile;
8999 params.createFolder = createFolder;
9000 params.deleteItem = deleteItem;
9001 params.payload = payload;
9002
9003 return context->InvokeService(context, _OrthancPluginService_RegisterWebDavCollection, &params);
9004 }
9005
9006
9007#ifdef __cplusplus
9008}
9009#endif
9010
9011
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:7883
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:8758
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:1835
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:3173
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:2138
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:1223
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5399
OrthancPluginChangeType
Definition: OrthancCPlugin.h:729
OrthancPluginErrorCode(* OrthancPluginStorageReadWhole)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type)
Callback for reading a whole file from the storage area.
Definition: OrthancCPlugin.h:1289
OrthancPluginErrorCode OrthancPluginRegisterIncomingCStoreInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingCStoreInstanceFilter callback)
Register a callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition: OrthancCPlugin.h:7838
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1941
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:1201
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:6969
OrthancPluginErrorCode(* OrthancPluginWebDavCreateFolderCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback to create a folder.
Definition: OrthancCPlugin.h:8923
struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection
Opaque structure that represents a WebDAV collection.
Definition: OrthancCPlugin.h:8739
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:1716
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:8878
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition: OrthancCPlugin.h:7754
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4757
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:8403
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6302
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:8806
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1269
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:2060
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3561
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:7915
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:8852
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1670
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:1072
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3316
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:8586
OrthancPluginErrorCode(* OrthancPluginWebDavAddFolder)(OrthancPluginWebDavCollection *collection, const char *name, const char *dateTime)
Declare a subfolder while returning the content of a folder.
Definition: OrthancCPlugin.h:8779
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:8982
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:1415
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1169
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1688
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition: OrthancCPlugin.h:8430
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:1180
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:8901
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:8943
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4949
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1330
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1242
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:1754
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:1190
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition: OrthancCPlugin.h:7417
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:8827
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:1380
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6827
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1213
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:2100
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4718
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:1312
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:7538
int32_t(* OrthancPluginIncomingCStoreInstanceFilter)(uint16_t *dimseStatus, const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition: OrthancCPlugin.h:7816
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition: OrthancCPlugin.h:7775
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5735
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:4674
@ OrthancPluginChangeType_OrthancStopped
Definition: OrthancCPlugin.h:741
@ OrthancPluginChangeType_OrthancStarted
Definition: OrthancCPlugin.h:740
@ OrthancPluginChangeType_Deleted
Definition: OrthancCPlugin.h:731
@ OrthancPluginChangeType_JobFailure
Definition: OrthancCPlugin.h:748
@ OrthancPluginChangeType_NewInstance
Definition: OrthancCPlugin.h:733
@ OrthancPluginChangeType_NewPatient
Definition: OrthancCPlugin.h:734
@ OrthancPluginChangeType_JobSubmitted
Definition: OrthancCPlugin.h:746
@ OrthancPluginChangeType_NewSeries
Definition: OrthancCPlugin.h:735
@ OrthancPluginChangeType_StablePatient
Definition: OrthancCPlugin.h:737
@ OrthancPluginChangeType_UpdatedPeers
Definition: OrthancCPlugin.h:744
@ OrthancPluginChangeType_StableStudy
Definition: OrthancCPlugin.h:739
@ OrthancPluginChangeType_CompletedSeries
Definition: OrthancCPlugin.h:730
@ OrthancPluginChangeType_NewChildInstance
Definition: OrthancCPlugin.h:732
@ OrthancPluginChangeType_UpdatedAttachment
Definition: OrthancCPlugin.h:742
@ OrthancPluginChangeType_UpdatedMetadata
Definition: OrthancCPlugin.h:743
@ OrthancPluginChangeType_StableSeries
Definition: OrthancCPlugin.h:738
@ OrthancPluginChangeType_UpdatedModalities
Definition: OrthancCPlugin.h:745
@ OrthancPluginChangeType_JobSuccess
Definition: OrthancCPlugin.h:747
@ OrthancPluginChangeType_NewStudy
Definition: OrthancCPlugin.h:736
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5996
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1120
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1525
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:5972
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7666
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:1349
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:6150
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:6102
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:7644
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5904
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5281
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:7687
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:5242
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5943
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:7714
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1128
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1112
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1442
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1510
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:5138
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:6064
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5204
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:6033
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1539
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1104
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:1485
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:5174
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:7973
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:8358
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition: OrthancCPlugin.h:1080
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:8138
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2904
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:3006
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition: OrthancCPlugin.h:8205
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition: OrthancCPlugin.h:8023
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition: OrthancCPlugin.h:8098
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5307
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2937
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:8318
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition: OrthancCPlugin.h:7938
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:3083
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition: OrthancCPlugin.h:8061
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition: OrthancCPlugin.h:8243
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:3124
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:3044
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2970
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:8166
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:8275
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4460
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:605
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:4620
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:4204
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3995
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3894
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5437
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4495
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:3960
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:4029
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:4114
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:4159
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5526
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:4072
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4535
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:774
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:1096
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:759
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3927
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:3706
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4567
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:5480
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1088
@ OrthancPluginPixelFormat_RGBA32
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:644
@ OrthancPluginPixelFormat_RGB48
Color image in RGB48 format.
Definition: OrthancCPlugin.h:654
@ OrthancPluginPixelFormat_Grayscale8
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:612
@ OrthancPluginPixelFormat_SignedGrayscale16
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:628
@ OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:670
@ OrthancPluginPixelFormat_RGB24
Color image in RGB24 format.
Definition: OrthancCPlugin.h:636
@ OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:678
@ OrthancPluginPixelFormat_Unknown
Definition: OrthancCPlugin.h:646
@ OrthancPluginPixelFormat_Grayscale64
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:686
@ OrthancPluginPixelFormat_Grayscale32
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:662
@ OrthancPluginPixelFormat_Grayscale16
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:620
@ OrthancPluginImageFormat_Png
Definition: OrthancCPlugin.h:775
@ OrthancPluginImageFormat_Jpeg
Definition: OrthancCPlugin.h:776
@ OrthancPluginImageFormat_Dicom
Definition: OrthancCPlugin.h:777
@ OrthancPluginCompressionType_Gzip
Definition: OrthancCPlugin.h:762
@ OrthancPluginCompressionType_ZlibWithSize
Definition: OrthancCPlugin.h:761
@ OrthancPluginCompressionType_Zlib
Definition: OrthancCPlugin.h:760
@ OrthancPluginCompressionType_GzipWithSize
Definition: OrthancCPlugin.h:763
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:2368
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:2403
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:2516
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2652
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2687
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3464
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:2480
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3425
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2617
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2301
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2722
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:2331
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2582
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2432
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2455
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:8701
char * OrthancPluginGenerateRestApiAuthorizationToken(OrthancPluginContext *context)
Generate a token to grant full access to the REST API of Orthanc.
Definition: OrthancCPlugin.h:8503
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:5100
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2268
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:2227
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2790
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:6863
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2813
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:2170
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2767
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2868
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2843
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2550
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:4251
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:3664
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:5697
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3635
void OrthancPluginSendHttpStatus(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status, const char *body, uint32_t bodySize)
Send a HTTP status, with a custom body.
Definition: OrthancCPlugin.h:3858
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1637
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderExecute)(OrthancPluginServerChunkedRequestReader *reader, OrthancPluginRestOutput *output)
Callback invoked whenever the request body is entirely received.
Definition: OrthancCPlugin.h:7475
OrthancPluginErrorCode OrthancPluginHttpClient(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, OrthancPluginHttpMethod method, const char *url, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, const void *body, uint32_t bodySize, const char *username, const char *password, uint32_t timeout, const char *certificateFile, const char *certificateKeyFile, const char *certificateKeyPassword, uint8_t pkcs11)
Issue a HTTP call with full flexibility.
Definition: OrthancCPlugin.h:5810
struct _OrthancPluginJob_t OrthancPluginJob
Opaque structure to a job to be executed by Orthanc.
Definition: OrthancCPlugin.h:1152
OrthancPluginErrorCode OrthancPluginCreateDicom2(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *json, const OrthancPluginImage *pixelData, OrthancPluginCreateDicomFlags flags, const char *privateCreator)
Create a DICOM instance from a JSON string and an image, with a private creator.
Definition: OrthancCPlugin.h:8633
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:2024
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderFactory)(OrthancPluginServerChunkedRequestReader **reader, const char *url, const OrthancPluginHttpRequest *request)
Callback to create a reader to handle incoming chunked HTTP transfers.
Definition: OrthancCPlugin.h:7436
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:6227
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6364
OrthancPluginErrorCode OrthancPluginRegisterPrivateDictionaryTag(OrthancPluginContext *context, uint16_t group, uint16_t element, OrthancPluginValueRepresentation vr, const char *name, uint32_t minMultiplicity, uint32_t maxMultiplicity, const char *privateCreator)
Register a new private tag into the DICOM dictionary.
Definition: OrthancCPlugin.h:4905
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:878
OrthancPluginErrorCode OrthancPluginRegisterDictionaryTag(OrthancPluginContext *context, uint16_t group, uint16_t element, OrthancPluginValueRepresentation vr, const char *name, uint32_t minMultiplicity, uint32_t maxMultiplicity)
Register a new tag into the DICOM dictionary.
Definition: OrthancCPlugin.h:4852
OrthancPluginResourceType
Definition: OrthancCPlugin.h:712
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3774
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3495
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5572
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:201
struct _OrthancPluginPeers_t OrthancPluginPeers
Opaque structure to the set of remote Orthanc Peers that are known to the local Orthanc server.
Definition: OrthancCPlugin.h:1144
OrthancPluginErrorCode OrthancPluginHttpPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const void *body, uint32_t bodySize, const char *username, const char *password)
Issue a HTTP POST call.
Definition: OrthancCPlugin.h:4342
uint32_t(* OrthancPluginChunkedClientRequestGetChunkSize)(void *request)
Callback to read the size of the current request chunk during a chunked transfer.
Definition: OrthancCPlugin.h:7277
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4796
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, uint32_t size)
Create a 32-bit memory buffer.
Definition: OrthancCPlugin.h:8465
OrthancPluginDicomWebBinaryMode
Definition: OrthancCPlugin.h:967
OrthancPluginErrorCode(* OrthancPluginChunkedClientRequestNext)(void *request)
Callback to advance in the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7245
struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode
Opaque structure that represents a node in a JSON or XML document used in DICOMweb.
Definition: OrthancCPlugin.h:1161
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1565
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7005
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:6189
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:842
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:924
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:863
void(* OrthancPluginServerChunkedRequestReaderFinalize)(OrthancPluginServerChunkedRequestReader *reader)
Callback invoked to release the resources associated with an incoming HTTP chunked transfer.
Definition: OrthancCPlugin.h:7493
int32_t OrthancPluginFindMatcherIsMatch(OrthancPluginContext *context, const OrthancPluginFindMatcher *matcher, const void *dicom, uint32_t size)
Test whether a DICOM instance matches a C-Find query.
Definition: OrthancCPlugin.h:6260
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:3391
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:2008
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6442
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6330
OrthancPluginConstraintType
Definition: OrthancCPlugin.h:893
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:3235
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3743
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1613
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5608
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3529
void OrthancPluginSetMetricsValue(OrthancPluginContext *context, const char *name, float value, OrthancPluginMetricsType type)
Set the value of a metrics.
Definition: OrthancCPlugin.h:6939
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderAddChunk)(OrthancPluginServerChunkedRequestReader *reader, const void *data, uint32_t size)
Callback invoked whenever a new data chunk is available during a chunked transfer.
Definition: OrthancCPlugin.h:7455
OrthancPluginReceivedInstanceAction
Definition: OrthancCPlugin.h:1014
OrthancPluginErrorCode OrthancPluginChunkedHttpClient(OrthancPluginContext *context, void *answer, OrthancPluginChunkedClientAnswerAddChunk answerAddChunk, OrthancPluginChunkedClientAnswerAddHeader answerAddHeader, uint16_t *httpStatus, OrthancPluginHttpMethod method, const char *url, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, void *request, OrthancPluginChunkedClientRequestIsDone requestIsDone, OrthancPluginChunkedClientRequestGetChunkData requestChunkData, OrthancPluginChunkedClientRequestGetChunkSize requestChunkSize, OrthancPluginChunkedClientRequestNext requestNext, const char *username, const char *password, uint32_t timeout, const char *certificateFile, const char *certificateKeyFile, const char *certificateKeyPassword, uint8_t pkcs11)
Issue a HTTP call, using chunked HTTP transfers.
Definition: OrthancCPlugin.h:7356
void OrthancPluginFreeMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1976
OrthancPluginErrorCode OrthancPluginHttpPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const void *body, uint32_t bodySize, const char *username, const char *password)
Issue a HTTP PUT call.
Definition: OrthancCPlugin.h:4384
char * OrthancPluginDicomBufferToJson(OrthancPluginContext *context, const void *buffer, uint32_t size, OrthancPluginDicomToJsonFormat format, OrthancPluginDicomToJsonFlags flags, uint32_t maxStringLength)
Format a DICOM memory buffer as a JSON string.
Definition: OrthancCPlugin.h:4993
OrthancPluginErrorCode OrthancPluginCreateDicom(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *json, const OrthancPluginImage *pixelData, OrthancPluginCreateDicomFlags flags)
Create a DICOM instance from a JSON string and an image.
Definition: OrthancCPlugin.h:5363
char * OrthancPluginDicomInstanceToJson(OrthancPluginContext *context, const char *instanceId, OrthancPluginDicomToJsonFormat format, OrthancPluginDicomToJsonFlags flags, uint32_t maxStringLength)
Format a DICOM instance as a JSON string.
Definition: OrthancCPlugin.h:5042
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6750
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int priority)
Submit a new job to the jobs engine of Orthanc.
Definition: OrthancCPlugin.h:6782
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5865
OrthancPluginStorageCommitmentFailureReason
Definition: OrthancCPlugin.h:980
OrthancPluginErrorCode(* OrthancPluginChunkedClientAnswerAddChunk)(void *answer, const void *data, uint32_t size)
Callback executed when an answer chunk is received during a chunked transfer.
Definition: OrthancCPlugin.h:7208
const char * OrthancPluginGetPeerUserProperty(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex, const char *userProperty)
Get some user-defined property of an Orthanc peer.
Definition: OrthancCPlugin.h:6529
OrthancPluginMetricsType
Definition: OrthancCPlugin.h:950
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:6895
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4422
uint8_t(* OrthancPluginChunkedClientRequestIsDone)(void *request)
Callback to know whether the request body is entirely read during a chunked transfer.
Definition: OrthancCPlugin.h:7228
const void *(* OrthancPluginChunkedClientRequestGetChunkData)(void *request)
Callback to read the current chunk of the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7261
OrthancPluginJob * OrthancPluginCreateJob(OrthancPluginContext *context, void *job, OrthancPluginJobFinalize finalize, const char *type, OrthancPluginJobGetProgress getProgress, OrthancPluginJobGetContent getContent, OrthancPluginJobGetSerialized getSerialized, OrthancPluginJobStep step, OrthancPluginJobStop stop, OrthancPluginJobReset reset)
Create a custom job.
Definition: OrthancCPlugin.h:6695
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1960
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7047
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1598
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3594
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *target, uint64_t size)
Create a 64-bit memory buffer.
Definition: OrthancCPlugin.h:8549
OrthancPluginErrorCode(* OrthancPluginChunkedClientAnswerAddHeader)(void *answer, const char *key, const char *value)
Callback executed when a HTTP header is received during a chunked transfer.
Definition: OrthancCPlugin.h:7187
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6394
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1580
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:788
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:4304
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:938
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:3205
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:827
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:1992
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:3270
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:326
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:3347
char * OrthancPluginEncodeDicomWebXml2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7143
OrthancPluginErrorCode OrthancPluginCallPeerApi(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, const OrthancPluginPeers *peers, uint32_t peerIndex, OrthancPluginHttpMethod method, const char *uri, uint32_t additionalHeadersCount, const char *const *additionalHeadersKeys, const char *const *additionalHeadersValues, const void *body, uint32_t bodySize, uint32_t timeout)
Call the REST API of an Orthanc peer.
Definition: OrthancCPlugin.h:6610
struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher
Opaque structure to an object that can be used to check whether a DICOM instance matches a C-Find que...
Definition: OrthancCPlugin.h:1136
char * OrthancPluginEncodeDicomWebJson2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7099
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5654
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:908
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1552
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1805
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1654
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3805
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginContentType
Definition: OrthancCPlugin.h:697
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6483
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:3369
char * OrthancPluginGetTagName(OrthancPluginContext *context, uint16_t group, uint16_t element, const char *privateCreator)
Returns the symbolic name of a DICOM tag.
Definition: OrthancCPlugin.h:7589
@ OrthancPluginIdentifierConstraint_Wildcard
Definition: OrthancCPlugin.h:882
@ OrthancPluginIdentifierConstraint_Equal
Definition: OrthancCPlugin.h:879
@ OrthancPluginIdentifierConstraint_SmallerOrEqual
Definition: OrthancCPlugin.h:880
@ OrthancPluginIdentifierConstraint_GreaterOrEqual
Definition: OrthancCPlugin.h:881
@ OrthancPluginResourceType_Instance
Definition: OrthancCPlugin.h:716
@ OrthancPluginResourceType_None
Definition: OrthancCPlugin.h:717
@ OrthancPluginResourceType_Series
Definition: OrthancCPlugin.h:715
@ OrthancPluginResourceType_Study
Definition: OrthancCPlugin.h:714
@ OrthancPluginResourceType_Patient
Definition: OrthancCPlugin.h:713
@ OrthancPluginErrorCode_CreateDicomBadParent
Definition: OrthancCPlugin.h:288
@ OrthancPluginErrorCode_MainDicomTagsMultiplyDefined
Definition: OrthancCPlugin.h:247
@ OrthancPluginErrorCode_SQLiteFlush
Definition: OrthancCPlugin.h:256
@ OrthancPluginErrorCode_IncompatibleDatabaseVersion
Definition: OrthancCPlugin.h:221
@ OrthancPluginErrorCode_BadSequenceOfCalls
Definition: OrthancCPlugin.h:209
@ OrthancPluginErrorCode_SharedLibrary
Definition: OrthancCPlugin.h:228
@ OrthancPluginErrorCode_NullPointer
Definition: OrthancCPlugin.h:238
@ OrthancPluginErrorCode_NotLuaPredicate
Definition: OrthancCPlugin.h:298
@ OrthancPluginErrorCode_LuaAlreadyExecuted
Definition: OrthancCPlugin.h:296
@ OrthancPluginErrorCode_NotAcceptable
Definition: OrthancCPlugin.h:237
@ OrthancPluginErrorCode_FullStorage
Definition: OrthancCPlugin.h:222
@ OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered
Definition: OrthancCPlugin.h:301
@ OrthancPluginErrorCode_InexistentFile
Definition: OrthancCPlugin.h:216
@ OrthancPluginErrorCode_CreateDicomParentEncoding
Definition: OrthancCPlugin.h:290
@ OrthancPluginErrorCode_CannotOrderSlices
Definition: OrthancCPlugin.h:304
@ OrthancPluginErrorCode_InternalError
Definition: OrthancCPlugin.h:202
@ OrthancPluginErrorCode_DiscontinuedAbi
Definition: OrthancCPlugin.h:243
@ OrthancPluginErrorCode_NoCFindHandler
Definition: OrthancCPlugin.h:274
@ OrthancPluginErrorCode_SQLiteCommitWithoutTransaction
Definition: OrthancCPlugin.h:254
@ OrthancPluginErrorCode_DatabasePlugin
Definition: OrthancCPlugin.h:234
@ OrthancPluginErrorCode_SQLiteStatementAlreadyUsed
Definition: OrthancCPlugin.h:251
@ OrthancPluginErrorCode_SQLiteCannotRun
Definition: OrthancCPlugin.h:257
@ OrthancPluginErrorCode_UnknownPluginService
Definition: OrthancCPlugin.h:229
@ OrthancPluginErrorCode_JsonToLuaTable
Definition: OrthancCPlugin.h:293
@ OrthancPluginErrorCode_CreateDicomOverrideTag
Definition: OrthancCPlugin.h:284
@ OrthancPluginErrorCode_SQLiteBindOutOfRange
Definition: OrthancCPlugin.h:259
@ OrthancPluginErrorCode_ParameterOutOfRange
Definition: OrthancCPlugin.h:206
@ OrthancPluginErrorCode_SQLiteRegisterFunction
Definition: OrthancCPlugin.h:255
@ OrthancPluginErrorCode_SQLiteTransactionBegin
Definition: OrthancCPlugin.h:263
@ OrthancPluginErrorCode_CreateDicomNoPayload
Definition: OrthancCPlugin.h:286
@ OrthancPluginErrorCode_Unauthorized
Definition: OrthancCPlugin.h:232
@ OrthancPluginErrorCode_RegularFileExpected
Definition: OrthancCPlugin.h:270
@ OrthancPluginErrorCode_DicomPortInUse
Definition: OrthancCPlugin.h:268
@ OrthancPluginErrorCode_BadApplicationEntityTitle
Definition: OrthancCPlugin.h:273
@ OrthancPluginErrorCode_NoCStoreHandler
Definition: OrthancCPlugin.h:276
@ OrthancPluginErrorCode_PathToExecutable
Definition: OrthancCPlugin.h:271
@ OrthancPluginErrorCode_NoSopClassOrInstance
Definition: OrthancCPlugin.h:278
@ OrthancPluginErrorCode_BadFont
Definition: OrthancCPlugin.h:233
@ OrthancPluginErrorCode_DatabaseUnavailable
Definition: OrthancCPlugin.h:239
@ OrthancPluginErrorCode_CannotCreateLua
Definition: OrthancCPlugin.h:294
@ OrthancPluginErrorCode_SQLiteExecute
Definition: OrthancCPlugin.h:252
@ OrthancPluginErrorCode_UriSyntax
Definition: OrthancCPlugin.h:215
@ OrthancPluginErrorCode_DirectoryOverFile
Definition: OrthancCPlugin.h:264
@ OrthancPluginErrorCode_Revision
Definition: OrthancCPlugin.h:246
@ OrthancPluginErrorCode_InexistentTag
Definition: OrthancCPlugin.h:224
@ OrthancPluginErrorCode_IncompatibleImageFormat
Definition: OrthancCPlugin.h:226
@ OrthancPluginErrorCode_UnsupportedMediaType
Definition: OrthancCPlugin.h:309
@ OrthancPluginErrorCode_DicomFindUnavailable
Definition: OrthancCPlugin.h:280
@ OrthancPluginErrorCode_SQLiteCannotStep
Definition: OrthancCPlugin.h:258
@ OrthancPluginErrorCode_CreateDicomParentIsInstance
Definition: OrthancCPlugin.h:289
@ OrthancPluginErrorCode_StorageAreaAlreadyRegistered
Definition: OrthancCPlugin.h:300
@ OrthancPluginErrorCode_LuaReturnsNoString
Definition: OrthancCPlugin.h:299
@ OrthancPluginErrorCode_UnknownResource
Definition: OrthancCPlugin.h:220
@ OrthancPluginErrorCode_CreateDicomNotString
Definition: OrthancCPlugin.h:283
@ OrthancPluginErrorCode_HttpPortInUse
Definition: OrthancCPlugin.h:267
@ OrthancPluginErrorCode_SslDisabled
Definition: OrthancCPlugin.h:303
@ OrthancPluginErrorCode_UnknownModality
Definition: OrthancCPlugin.h:291
@ OrthancPluginErrorCode_BadHttpStatusInRest
Definition: OrthancCPlugin.h:269
@ OrthancPluginErrorCode_BadGeometry
Definition: OrthancCPlugin.h:241
@ OrthancPluginErrorCode_AlreadyExistingTag
Definition: OrthancCPlugin.h:306
@ OrthancPluginErrorCode_FileStorageCannotWrite
Definition: OrthancCPlugin.h:265
@ OrthancPluginErrorCode_CreateDicomUseDataUriScheme
Definition: OrthancCPlugin.h:287
@ OrthancPluginErrorCode_DirectoryExpected
Definition: OrthancCPlugin.h:266
@ OrthancPluginErrorCode_NoCMoveHandler
Definition: OrthancCPlugin.h:275
@ OrthancPluginErrorCode_SQLitePrepareStatement
Definition: OrthancCPlugin.h:260
@ OrthancPluginErrorCode_CorruptedFile
Definition: OrthancCPlugin.h:223
@ OrthancPluginErrorCode_StorageAreaPlugin
Definition: OrthancCPlugin.h:235
@ OrthancPluginErrorCode_BadJobOrdering
Definition: OrthancCPlugin.h:292
@ OrthancPluginErrorCode_DatabaseCannotSerialize
Definition: OrthancCPlugin.h:245
@ OrthancPluginErrorCode_CanceledJob
Definition: OrthancCPlugin.h:240
@ OrthancPluginErrorCode_BadRange
Definition: OrthancCPlugin.h:244
@ OrthancPluginErrorCode_NotImplemented
Definition: OrthancCPlugin.h:205
@ OrthancPluginErrorCode_SslInitialization
Definition: OrthancCPlugin.h:242
@ OrthancPluginErrorCode_IncompatibleImageSize
Definition: OrthancCPlugin.h:227
@ OrthancPluginErrorCode_BadFileFormat
Definition: OrthancCPlugin.h:218
@ OrthancPluginErrorCode_BadRequest
Definition: OrthancCPlugin.h:211
@ OrthancPluginErrorCode_SystemCommand
Definition: OrthancCPlugin.h:213
@ OrthancPluginErrorCode_NoStorageCommitmentHandler
Definition: OrthancCPlugin.h:307
@ OrthancPluginErrorCode_SQLiteAlreadyOpened
Definition: OrthancCPlugin.h:249
@ OrthancPluginErrorCode_Plugin
Definition: OrthancCPlugin.h:204
@ OrthancPluginErrorCode_CannotExecuteLua
Definition: OrthancCPlugin.h:295
@ OrthancPluginErrorCode_SQLiteRollbackWithoutTransaction
Definition: OrthancCPlugin.h:253
@ OrthancPluginErrorCode_UnknownDicomTag
Definition: OrthancCPlugin.h:230
@ OrthancPluginErrorCode_NoPresentationContext
Definition: OrthancCPlugin.h:279
@ OrthancPluginErrorCode_EmptyRequest
Definition: OrthancCPlugin.h:236
@ OrthancPluginErrorCode_DatabaseNotInitialized
Definition: OrthancCPlugin.h:302
@ OrthancPluginErrorCode_DicomMoveUnavailable
Definition: OrthancCPlugin.h:281
@ OrthancPluginErrorCode_SQLiteTransactionCommit
Definition: OrthancCPlugin.h:262
@ OrthancPluginErrorCode_BadJson
Definition: OrthancCPlugin.h:231
@ OrthancPluginErrorCode_Success
Definition: OrthancCPlugin.h:203
@ OrthancPluginErrorCode_NetworkProtocol
Definition: OrthancCPlugin.h:212
@ OrthancPluginErrorCode_NoApplicationEntityFilter
Definition: OrthancCPlugin.h:277
@ OrthancPluginErrorCode_InexistentItem
Definition: OrthancCPlugin.h:210
@ OrthancPluginErrorCode_Timeout
Definition: OrthancCPlugin.h:219
@ OrthancPluginErrorCode_LuaBadOutput
Definition: OrthancCPlugin.h:297
@ OrthancPluginErrorCode_SQLiteTransactionAlreadyStarted
Definition: OrthancCPlugin.h:261
@ OrthancPluginErrorCode_NoCGetHandler
Definition: OrthancCPlugin.h:308
@ OrthancPluginErrorCode_SQLiteNotOpened
Definition: OrthancCPlugin.h:248
@ OrthancPluginErrorCode_ReadOnly
Definition: OrthancCPlugin.h:225
@ OrthancPluginErrorCode_CannotStoreInstance
Definition: OrthancCPlugin.h:282
@ OrthancPluginErrorCode_CannotWriteFile
Definition: OrthancCPlugin.h:217
@ OrthancPluginErrorCode_BadParameterType
Definition: OrthancCPlugin.h:208
@ OrthancPluginErrorCode_NotEnoughMemory
Definition: OrthancCPlugin.h:207
@ OrthancPluginErrorCode_CreateDicomUseContent
Definition: OrthancCPlugin.h:285
@ OrthancPluginErrorCode_Database
Definition: OrthancCPlugin.h:214
@ OrthancPluginErrorCode_SQLiteCannotOpen
Definition: OrthancCPlugin.h:250
@ OrthancPluginErrorCode_MakeDirectory
Definition: OrthancCPlugin.h:272
@ OrthancPluginErrorCode_NoWorklistHandler
Definition: OrthancCPlugin.h:305
@ OrthancPluginDicomWebBinaryMode_InlineBinary
Definition: OrthancCPlugin.h:969
@ OrthancPluginDicomWebBinaryMode_BulkDataUri
Definition: OrthancCPlugin.h:970
@ OrthancPluginDicomWebBinaryMode_Ignore
Definition: OrthancCPlugin.h:968
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii
Definition: OrthancCPlugin.h:848
@ OrthancPluginDicomToJsonFlags_IncludeBinary
Definition: OrthancCPlugin.h:844
@ OrthancPluginDicomToJsonFlags_IncludePixelData
Definition: OrthancCPlugin.h:847
@ OrthancPluginDicomToJsonFlags_IncludeUnknownTags
Definition: OrthancCPlugin.h:846
@ OrthancPluginDicomToJsonFlags_SkipGroupLengths
Definition: OrthancCPlugin.h:851
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
Definition: OrthancCPlugin.h:849
@ OrthancPluginDicomToJsonFlags_StopAfterPixelData
Definition: OrthancCPlugin.h:850
@ OrthancPluginDicomToJsonFlags_IncludePrivateTags
Definition: OrthancCPlugin.h:845
@ OrthancPluginJobStepStatus_Continue
Definition: OrthancCPlugin.h:927
@ OrthancPluginJobStepStatus_Success
Definition: OrthancCPlugin.h:925
@ OrthancPluginJobStepStatus_Failure
Definition: OrthancCPlugin.h:926
@ OrthancPluginCreateDicomFlags_DecodeDataUriScheme
Definition: OrthancCPlugin.h:865
@ OrthancPluginCreateDicomFlags_GenerateIdentifiers
Definition: OrthancCPlugin.h:866
@ OrthancPluginConstraintType_SmallerOrEqual
Definition: OrthancCPlugin.h:895
@ OrthancPluginConstraintType_List
Definition: OrthancCPlugin.h:898
@ OrthancPluginConstraintType_GreaterOrEqual
Definition: OrthancCPlugin.h:896
@ OrthancPluginConstraintType_Equal
Definition: OrthancCPlugin.h:894
@ OrthancPluginConstraintType_Wildcard
Definition: OrthancCPlugin.h:897
@ OrthancPluginReceivedInstanceAction_KeepAsIs
Definition: OrthancCPlugin.h:1015
@ OrthancPluginReceivedInstanceAction_Discard
Definition: OrthancCPlugin.h:1017
@ OrthancPluginReceivedInstanceAction_Modify
Definition: OrthancCPlugin.h:1016
@ OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
Definition: OrthancCPlugin.h:995
@ OrthancPluginStorageCommitmentFailureReason_Success
Definition: OrthancCPlugin.h:981
@ OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
Definition: OrthancCPlugin.h:1004
@ OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
Definition: OrthancCPlugin.h:999
@ OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
Definition: OrthancCPlugin.h:991
@ OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
Definition: OrthancCPlugin.h:987
@ OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
Definition: OrthancCPlugin.h:984
@ OrthancPluginMetricsType_Default
Definition: OrthancCPlugin.h:951
@ OrthancPluginMetricsType_Timer
Definition: OrthancCPlugin.h:958
@ OrthancPluginValueRepresentation_PN
Definition: OrthancCPlugin.h:804
@ OrthancPluginValueRepresentation_UL
Definition: OrthancCPlugin.h:812
@ OrthancPluginValueRepresentation_UN
Definition: OrthancCPlugin.h:813
@ OrthancPluginValueRepresentation_DA
Definition: OrthancCPlugin.h:793
@ OrthancPluginValueRepresentation_OF
Definition: OrthancCPlugin.h:802
@ OrthancPluginValueRepresentation_OW
Definition: OrthancCPlugin.h:803
@ OrthancPluginValueRepresentation_CS
Definition: OrthancCPlugin.h:792
@ OrthancPluginValueRepresentation_US
Definition: OrthancCPlugin.h:814
@ OrthancPluginValueRepresentation_SH
Definition: OrthancCPlugin.h:805
@ OrthancPluginValueRepresentation_FL
Definition: OrthancCPlugin.h:797
@ OrthancPluginValueRepresentation_DT
Definition: OrthancCPlugin.h:795
@ OrthancPluginValueRepresentation_TM
Definition: OrthancCPlugin.h:810
@ OrthancPluginValueRepresentation_SQ
Definition: OrthancCPlugin.h:807
@ OrthancPluginValueRepresentation_DS
Definition: OrthancCPlugin.h:794
@ OrthancPluginValueRepresentation_OB
Definition: OrthancCPlugin.h:801
@ OrthancPluginValueRepresentation_SL
Definition: OrthancCPlugin.h:806
@ OrthancPluginValueRepresentation_ST
Definition: OrthancCPlugin.h:809
@ OrthancPluginValueRepresentation_IS
Definition: OrthancCPlugin.h:798
@ OrthancPluginValueRepresentation_LT
Definition: OrthancCPlugin.h:800
@ OrthancPluginValueRepresentation_SS
Definition: OrthancCPlugin.h:808
@ OrthancPluginValueRepresentation_UT
Definition: OrthancCPlugin.h:815
@ OrthancPluginValueRepresentation_LO
Definition: OrthancCPlugin.h:799
@ OrthancPluginValueRepresentation_AE
Definition: OrthancCPlugin.h:789
@ OrthancPluginValueRepresentation_FD
Definition: OrthancCPlugin.h:796
@ OrthancPluginValueRepresentation_UI
Definition: OrthancCPlugin.h:811
@ OrthancPluginValueRepresentation_AS
Definition: OrthancCPlugin.h:790
@ OrthancPluginValueRepresentation_AT
Definition: OrthancCPlugin.h:791
@ OrthancPluginJobStopReason_Failure
Definition: OrthancCPlugin.h:941
@ OrthancPluginJobStopReason_Success
Definition: OrthancCPlugin.h:939
@ OrthancPluginJobStopReason_Canceled
Definition: OrthancCPlugin.h:942
@ OrthancPluginJobStopReason_Paused
Definition: OrthancCPlugin.h:940
@ OrthancPluginDicomToJsonFormat_Full
Definition: OrthancCPlugin.h:828
@ OrthancPluginDicomToJsonFormat_Human
Definition: OrthancCPlugin.h:830
@ OrthancPluginDicomToJsonFormat_Short
Definition: OrthancCPlugin.h:829
@ OrthancPluginHttpMethod_Delete
Definition: OrthancCPlugin.h:330
@ OrthancPluginHttpMethod_Post
Definition: OrthancCPlugin.h:328
@ OrthancPluginHttpMethod_Put
Definition: OrthancCPlugin.h:329
@ OrthancPluginHttpMethod_Get
Definition: OrthancCPlugin.h:327
@ OrthancPluginInstanceOrigin_Unknown
Definition: OrthancCPlugin.h:909
@ OrthancPluginInstanceOrigin_RestApi
Definition: OrthancCPlugin.h:911
@ OrthancPluginInstanceOrigin_Lua
Definition: OrthancCPlugin.h:913
@ OrthancPluginInstanceOrigin_WebDav
Definition: OrthancCPlugin.h:914
@ OrthancPluginInstanceOrigin_DicomProtocol
Definition: OrthancCPlugin.h:910
@ OrthancPluginInstanceOrigin_Plugin
Definition: OrthancCPlugin.h:912
@ OrthancPluginContentType_Dicom
Definition: OrthancCPlugin.h:699
@ OrthancPluginContentType_DicomAsJson
Definition: OrthancCPlugin.h:700
@ OrthancPluginContentType_Unknown
Definition: OrthancCPlugin.h:698
@ OrthancPluginContentType_DicomUntilPixelData
Definition: OrthancCPlugin.h:701
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1787
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1791
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1792
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1790
uint16_t element
Definition: OrthancCPlugin.h:1789
uint16_t group
Definition: OrthancCPlugin.h:1788
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:1053
uint64_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1062
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1057
A 32-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1031
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1040
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1035