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