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