Orthanc Plugin SDK  1.9.0
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1 
104 #pragma once
105 
106 
107 #include <stdio.h>
108 #include <string.h>
109 
110 #ifdef WIN32
111 # define ORTHANC_PLUGINS_API __declspec(dllexport)
112 #elif __GNUC__ >= 4
113 # define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default")))
114 #else
115 # define ORTHANC_PLUGINS_API
116 #endif
117 
118 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
119 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 9
120 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 0
121 
122 
123 #if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
124 #define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
125  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
126  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
127  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
128  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
129  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
130 #endif
131 
132 
133 
134 /********************************************************************
135  ** Check that function inlining is properly supported. The use of
136  ** inlining is required, to avoid the duplication of object code
137  ** between two compilation modules that would use the Orthanc Plugin
138  ** API.
139  ********************************************************************/
140 
141 /* If the auto-detection of the "inline" keyword below does not work
142  automatically and that your compiler is known to properly support
143  inlining, uncomment the following #define and adapt the definition
144  of "static inline". */
145 
146 /* #define ORTHANC_PLUGIN_INLINE static inline */
147 
148 #ifndef ORTHANC_PLUGIN_INLINE
149 # if __STDC_VERSION__ >= 199901L
150 /* This is C99 or above: http://predef.sourceforge.net/prestd.html */
151 # define ORTHANC_PLUGIN_INLINE static inline
152 # elif defined(__cplusplus)
153 /* This is C++ */
154 # define ORTHANC_PLUGIN_INLINE static inline
155 # elif defined(__GNUC__)
156 /* This is GCC running in C89 mode */
157 # define ORTHANC_PLUGIN_INLINE static __inline
158 # elif defined(_MSC_VER)
159 /* This is Visual Studio running in C89 mode */
160 # define ORTHANC_PLUGIN_INLINE static __inline
161 # else
162 # error Your compiler is not known to support the "inline" keyword
163 # endif
164 #endif
165 
166 
167 
168 /********************************************************************
169  ** Inclusion of standard libraries.
170  ********************************************************************/
171 
177 #include <stdint.h>
178 
179 #include <stdlib.h>
180 
181 
182 
183 /********************************************************************
184  ** Definition of the Orthanc Plugin API.
185  ********************************************************************/
186 
189 #ifdef __cplusplus
190 extern "C"
191 {
192 #endif
193 
197  typedef enum
198  {
304 
305  _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
307 
308 
313  ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
314 
315 
319  typedef enum
320  {
326  _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
328 
329 
334  typedef struct
335  {
340 
344  uint32_t groupsCount;
345 
349  const char* const* groups;
350 
354  uint32_t getCount;
355 
359  const char* const* getKeys;
360 
364  const char* const* getValues;
365 
369  const void* body;
370 
374  uint32_t bodySize;
375 
376 
377  /* --------------------------------------------------
378  New in version 0.8.1
379  -------------------------------------------------- */
380 
384  uint32_t headersCount;
385 
389  const char* const* headersKeys;
390 
394  const char* const* headersValues;
395 
397 
398 
399  typedef enum
400  {
401  /* Generic services */
402  _OrthancPluginService_LogInfo = 1,
403  _OrthancPluginService_LogWarning = 2,
404  _OrthancPluginService_LogError = 3,
405  _OrthancPluginService_GetOrthancPath = 4,
406  _OrthancPluginService_GetOrthancDirectory = 5,
407  _OrthancPluginService_GetConfigurationPath = 6,
408  _OrthancPluginService_SetPluginProperty = 7,
409  _OrthancPluginService_GetGlobalProperty = 8,
410  _OrthancPluginService_SetGlobalProperty = 9,
411  _OrthancPluginService_GetCommandLineArgumentsCount = 10,
412  _OrthancPluginService_GetCommandLineArgument = 11,
413  _OrthancPluginService_GetExpectedDatabaseVersion = 12,
414  _OrthancPluginService_GetConfiguration = 13,
415  _OrthancPluginService_BufferCompression = 14,
416  _OrthancPluginService_ReadFile = 15,
417  _OrthancPluginService_WriteFile = 16,
418  _OrthancPluginService_GetErrorDescription = 17,
419  _OrthancPluginService_CallHttpClient = 18,
420  _OrthancPluginService_RegisterErrorCode = 19,
421  _OrthancPluginService_RegisterDictionaryTag = 20,
422  _OrthancPluginService_DicomBufferToJson = 21,
423  _OrthancPluginService_DicomInstanceToJson = 22,
424  _OrthancPluginService_CreateDicom = 23,
425  _OrthancPluginService_ComputeMd5 = 24,
426  _OrthancPluginService_ComputeSha1 = 25,
427  _OrthancPluginService_LookupDictionary = 26,
428  _OrthancPluginService_CallHttpClient2 = 27,
429  _OrthancPluginService_GenerateUuid = 28,
430  _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
431  _OrthancPluginService_AutodetectMimeType = 30,
432  _OrthancPluginService_SetMetricsValue = 31,
433  _OrthancPluginService_EncodeDicomWebJson = 32,
434  _OrthancPluginService_EncodeDicomWebXml = 33,
435  _OrthancPluginService_ChunkedHttpClient = 34, /* New in Orthanc 1.5.7 */
436  _OrthancPluginService_GetTagName = 35, /* New in Orthanc 1.5.7 */
437  _OrthancPluginService_EncodeDicomWebJson2 = 36, /* New in Orthanc 1.7.0 */
438  _OrthancPluginService_EncodeDicomWebXml2 = 37, /* New in Orthanc 1.7.0 */
439  _OrthancPluginService_CreateMemoryBuffer = 38, /* New in Orthanc 1.7.0 */
440  _OrthancPluginService_GenerateRestApiAuthorizationToken = 39, /* New in Orthanc 1.8.1 */
441  _OrthancPluginService_CreateMemoryBuffer64 = 40, /* New in Orthanc 1.9.0 */
442  _OrthancPluginService_CreateDicom2 = 41, /* New in Orthanc 1.9.0 */
443 
444  /* Registration of callbacks */
445  _OrthancPluginService_RegisterRestCallback = 1000,
446  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
447  _OrthancPluginService_RegisterStorageArea = 1002,
448  _OrthancPluginService_RegisterOnChangeCallback = 1003,
449  _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
450  _OrthancPluginService_RegisterWorklistCallback = 1005,
451  _OrthancPluginService_RegisterDecodeImageCallback = 1006,
452  _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
453  _OrthancPluginService_RegisterFindCallback = 1008,
454  _OrthancPluginService_RegisterMoveCallback = 1009,
455  _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
456  _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
457  _OrthancPluginService_RegisterChunkedRestCallback = 1012, /* New in Orthanc 1.5.7 */
458  _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
459  _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
460  _OrthancPluginService_RegisterTranscoderCallback = 1015, /* New in Orthanc 1.7.0 */
461  _OrthancPluginService_RegisterStorageArea2 = 1016, /* New in Orthanc 1.9.0 */
462 
463  /* Sending answers to REST calls */
464  _OrthancPluginService_AnswerBuffer = 2000,
465  _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
466  _OrthancPluginService_Redirect = 2002,
467  _OrthancPluginService_SendHttpStatusCode = 2003,
468  _OrthancPluginService_SendUnauthorized = 2004,
469  _OrthancPluginService_SendMethodNotAllowed = 2005,
470  _OrthancPluginService_SetCookie = 2006,
471  _OrthancPluginService_SetHttpHeader = 2007,
472  _OrthancPluginService_StartMultipartAnswer = 2008,
473  _OrthancPluginService_SendMultipartItem = 2009,
474  _OrthancPluginService_SendHttpStatus = 2010,
475  _OrthancPluginService_CompressAndAnswerImage = 2011,
476  _OrthancPluginService_SendMultipartItem2 = 2012,
477  _OrthancPluginService_SetHttpErrorDetails = 2013,
478 
479  /* Access to the Orthanc database and API */
480  _OrthancPluginService_GetDicomForInstance = 3000,
481  _OrthancPluginService_RestApiGet = 3001,
482  _OrthancPluginService_RestApiPost = 3002,
483  _OrthancPluginService_RestApiDelete = 3003,
484  _OrthancPluginService_RestApiPut = 3004,
485  _OrthancPluginService_LookupPatient = 3005,
486  _OrthancPluginService_LookupStudy = 3006,
487  _OrthancPluginService_LookupSeries = 3007,
488  _OrthancPluginService_LookupInstance = 3008,
489  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
490  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
491  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
492  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
493  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
494  _OrthancPluginService_ReconstructMainDicomTags = 3014,
495  _OrthancPluginService_RestApiGet2 = 3015,
496 
497  /* Access to DICOM instances */
498  _OrthancPluginService_GetInstanceRemoteAet = 4000,
499  _OrthancPluginService_GetInstanceSize = 4001,
500  _OrthancPluginService_GetInstanceData = 4002,
501  _OrthancPluginService_GetInstanceJson = 4003,
502  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
503  _OrthancPluginService_HasInstanceMetadata = 4005,
504  _OrthancPluginService_GetInstanceMetadata = 4006,
505  _OrthancPluginService_GetInstanceOrigin = 4007,
506  _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
507  _OrthancPluginService_HasInstancePixelData = 4009,
508  _OrthancPluginService_CreateDicomInstance = 4010, /* New in Orthanc 1.7.0 */
509  _OrthancPluginService_FreeDicomInstance = 4011, /* New in Orthanc 1.7.0 */
510  _OrthancPluginService_GetInstanceFramesCount = 4012, /* New in Orthanc 1.7.0 */
511  _OrthancPluginService_GetInstanceRawFrame = 4013, /* New in Orthanc 1.7.0 */
512  _OrthancPluginService_GetInstanceDecodedFrame = 4014, /* New in Orthanc 1.7.0 */
513  _OrthancPluginService_TranscodeDicomInstance = 4015, /* New in Orthanc 1.7.0 */
514  _OrthancPluginService_SerializeDicomInstance = 4016, /* New in Orthanc 1.7.0 */
515  _OrthancPluginService_GetInstanceAdvancedJson = 4017, /* New in Orthanc 1.7.0 */
516  _OrthancPluginService_GetInstanceDicomWebJson = 4018, /* New in Orthanc 1.7.0 */
517  _OrthancPluginService_GetInstanceDicomWebXml = 4019, /* New in Orthanc 1.7.0 */
518 
519  /* Services for plugins implementing a database back-end */
520  _OrthancPluginService_RegisterDatabaseBackend = 5000,
521  _OrthancPluginService_DatabaseAnswer = 5001,
522  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
523  _OrthancPluginService_StorageAreaCreate = 5003,
524  _OrthancPluginService_StorageAreaRead = 5004,
525  _OrthancPluginService_StorageAreaRemove = 5005,
526 
527  /* Primitives for handling images */
528  _OrthancPluginService_GetImagePixelFormat = 6000,
529  _OrthancPluginService_GetImageWidth = 6001,
530  _OrthancPluginService_GetImageHeight = 6002,
531  _OrthancPluginService_GetImagePitch = 6003,
532  _OrthancPluginService_GetImageBuffer = 6004,
533  _OrthancPluginService_UncompressImage = 6005,
534  _OrthancPluginService_FreeImage = 6006,
535  _OrthancPluginService_CompressImage = 6007,
536  _OrthancPluginService_ConvertPixelFormat = 6008,
537  _OrthancPluginService_GetFontsCount = 6009,
538  _OrthancPluginService_GetFontInfo = 6010,
539  _OrthancPluginService_DrawText = 6011,
540  _OrthancPluginService_CreateImage = 6012,
541  _OrthancPluginService_CreateImageAccessor = 6013,
542  _OrthancPluginService_DecodeDicomImage = 6014,
543 
544  /* Primitives for handling C-Find, C-Move and worklists */
545  _OrthancPluginService_WorklistAddAnswer = 7000,
546  _OrthancPluginService_WorklistMarkIncomplete = 7001,
547  _OrthancPluginService_WorklistIsMatch = 7002,
548  _OrthancPluginService_WorklistGetDicomQuery = 7003,
549  _OrthancPluginService_FindAddAnswer = 7004,
550  _OrthancPluginService_FindMarkIncomplete = 7005,
551  _OrthancPluginService_GetFindQuerySize = 7006,
552  _OrthancPluginService_GetFindQueryTag = 7007,
553  _OrthancPluginService_GetFindQueryTagName = 7008,
554  _OrthancPluginService_GetFindQueryValue = 7009,
555  _OrthancPluginService_CreateFindMatcher = 7010,
556  _OrthancPluginService_FreeFindMatcher = 7011,
557  _OrthancPluginService_FindMatcherIsMatch = 7012,
558 
559  /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
560  _OrthancPluginService_GetPeers = 8000,
561  _OrthancPluginService_FreePeers = 8001,
562  _OrthancPluginService_GetPeersCount = 8003,
563  _OrthancPluginService_GetPeerName = 8004,
564  _OrthancPluginService_GetPeerUrl = 8005,
565  _OrthancPluginService_CallPeerApi = 8006,
566  _OrthancPluginService_GetPeerUserProperty = 8007,
567 
568  /* Primitives for handling jobs (new in 1.4.2) */
569  _OrthancPluginService_CreateJob = 9000,
570  _OrthancPluginService_FreeJob = 9001,
571  _OrthancPluginService_SubmitJob = 9002,
572  _OrthancPluginService_RegisterJobsUnserializer = 9003,
573 
574  _OrthancPluginService_INTERNAL = 0x7fffffff
575  } _OrthancPluginService;
576 
577 
578  typedef enum
579  {
580  _OrthancPluginProperty_Description = 1,
581  _OrthancPluginProperty_RootUri = 2,
582  _OrthancPluginProperty_OrthancExplorer = 3,
583 
584  _OrthancPluginProperty_INTERNAL = 0x7fffffff
585  } _OrthancPluginProperty;
586 
587 
588 
593  typedef enum
594  {
602 
610 
618 
626 
634 
644 
652 
660 
668 
676 
677  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
679 
680 
681 
685  typedef enum
686  {
691  _OrthancPluginContentType_INTERNAL = 0x7fffffff
693 
694 
695 
699  typedef enum
700  {
707  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
709 
710 
711 
716  typedef enum
717  {
738  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
740 
741 
746  typedef enum
747  {
753  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
755 
756 
761  typedef enum
762  {
767  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
769 
770 
775  typedef enum
776  {
805  _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
807 
808 
814  typedef enum
815  {
820  _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
822 
823 
829  typedef enum
830  {
831  OrthancPluginDicomToJsonFlags_None = 0,
839  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
841 
842 
848  typedef enum
849  {
850  OrthancPluginCreateDicomFlags_None = 0,
854  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
856 
857 
863  typedef enum
864  {
870  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
872 
873 
878  typedef enum
879  {
886  _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
888 
889 
893  typedef enum
894  {
902  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
904 
905 
909  typedef enum
910  {
915 
916 
923  typedef enum
924  {
930 
931 
935  typedef enum
936  {
946 
947 
952  typedef enum
953  {
958 
959 
965  typedef enum
966  {
994 
995 
996 
1004  typedef struct
1005  {
1009  void* data;
1010 
1014  uint32_t size;
1016 
1017 
1018 
1026  typedef struct
1027  {
1031  void* data;
1032 
1036  uint64_t size;
1038 
1039 
1040 
1041 
1046  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
1047 
1048 
1049 
1054  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
1055 
1056 
1057 
1062  typedef struct _OrthancPluginImage_t OrthancPluginImage;
1063 
1064 
1065 
1070  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
1071 
1072 
1073 
1078  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
1079 
1080 
1081 
1086  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
1087 
1088 
1089 
1094  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1095 
1096 
1097 
1102  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1103 
1104 
1105 
1110  typedef struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher;
1111 
1112 
1113 
1118  typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1119 
1120 
1121 
1126  typedef struct _OrthancPluginJob_t OrthancPluginJob;
1127 
1128 
1129 
1135  typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1136 
1137 
1138 
1144  OrthancPluginRestOutput* output,
1145  const char* url,
1146  const OrthancPluginHttpRequest* request);
1147 
1148 
1149 
1155  const OrthancPluginDicomInstance* instance,
1156  const char* instanceId);
1157 
1158 
1159 
1165  OrthancPluginChangeType changeType,
1166  OrthancPluginResourceType resourceType,
1167  const char* resourceId);
1168 
1169 
1170 
1176  OrthancPluginImage** target,
1177  const void* dicom,
1178  const uint32_t size,
1179  uint32_t frameIndex);
1180 
1181 
1182 
1187  typedef void (*OrthancPluginFree) (void* buffer);
1188 
1189 
1190 
1200  const char* bulkDataUri);
1201 
1202 
1203 
1217  const char* uuid,
1218  const void* content,
1219  int64_t size,
1221 
1222 
1223 
1244  void** content,
1245  int64_t* size,
1246  const char* uuid,
1248 
1249 
1250 
1265  const char* uuid,
1267 
1268 
1269 
1288  const char* uuid,
1290  uint64_t rangeStart);
1291 
1292 
1293 
1305  const char* uuid,
1307 
1308 
1309 
1325  const OrthancPluginWorklistQuery* query,
1326  const char* issuerAet,
1327  const char* calledAet);
1328 
1329 
1330 
1355  OrthancPluginHttpMethod method,
1356  const char* uri,
1357  const char* ip,
1358  uint32_t headersCount,
1359  const char* const* headersKeys,
1360  const char* const* headersValues);
1361 
1362 
1363 
1390  OrthancPluginHttpMethod method,
1391  const char* uri,
1392  const char* ip,
1393  uint32_t headersCount,
1394  const char* const* headersKeys,
1395  const char* const* headersValues,
1396  uint32_t getArgumentsCount,
1397  const char* const* getArgumentsKeys,
1398  const char* const* getArgumentsValues);
1399 
1400 
1401 
1417  OrthancPluginFindAnswers* answers,
1418  const OrthancPluginFindQuery* query,
1419  const char* issuerAet,
1420  const char* calledAet);
1421 
1422 
1423 
1459  typedef void* (*OrthancPluginMoveCallback) (
1460  OrthancPluginResourceType resourceType,
1461  const char* patientId,
1462  const char* accessionNumber,
1463  const char* studyInstanceUid,
1464  const char* seriesInstanceUid,
1465  const char* sopInstanceUid,
1466  const char* originatorAet,
1467  const char* sourceAet,
1468  const char* targetAet,
1469  uint16_t originatorId);
1470 
1471 
1484  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1485 
1486 
1499  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1500 
1501 
1513  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1514 
1515 
1526  typedef void (*OrthancPluginJobFinalize) (void* job);
1527 
1528 
1539  typedef float (*OrthancPluginJobGetProgress) (void* job);
1540 
1541 
1554  typedef const char* (*OrthancPluginJobGetContent) (void* job);
1555 
1556 
1572  typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1573 
1574 
1588 
1589 
1613 
1614 
1629 
1630 
1644  typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1645  const char* serialized);
1646 
1647 
1648 
1663 
1664 
1665 
1693  uint32_t levelDepth,
1694  const uint16_t* levelTagGroup,
1695  const uint16_t* levelTagElement,
1696  const uint32_t* levelIndex,
1697  uint16_t tagGroup,
1698  uint16_t tagElement,
1700 
1701 
1702 
1731  uint32_t levelDepth,
1732  const uint16_t* levelTagGroup,
1733  const uint16_t* levelTagElement,
1734  const uint32_t* levelIndex,
1735  uint16_t tagGroup,
1736  uint16_t tagElement,
1738  void* payload);
1739 
1740 
1741 
1745  typedef struct _OrthancPluginContext_t
1746  {
1747  void* pluginsManager;
1748  const char* orthancVersion;
1749  OrthancPluginFree Free;
1750  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1751  _OrthancPluginService service,
1752  const void* params);
1754 
1755 
1756 
1760  typedef struct
1761  {
1762  uint16_t group;
1763  uint16_t element;
1765  uint32_t minMultiplicity;
1766  uint32_t maxMultiplicity;
1768 
1769 
1770 
1779  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1780  OrthancPluginContext* context,
1781  char* str)
1782  {
1783  if (str != NULL)
1784  {
1785  context->Free(str);
1786  }
1787  }
1788 
1789 
1809  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1810  OrthancPluginContext* context,
1811  int expectedMajor,
1812  int expectedMinor,
1813  int expectedRevision)
1814  {
1815  int major, minor, revision;
1816 
1817  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1818  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1819  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1820  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1821  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1822  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1823  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1824  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1825  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1826  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1827  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1828  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1829  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1830  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1831  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1832  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1833  sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1834  sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
1835  sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
1836  sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
1837  sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason))
1838  {
1839  /* Mismatch in the size of the enumerations */
1840  return 0;
1841  }
1842 
1843  /* Assume compatibility with the mainline */
1844  if (!strcmp(context->orthancVersion, "mainline"))
1845  {
1846  return 1;
1847  }
1848 
1849  /* Parse the version of the Orthanc core */
1850  if (
1851 #ifdef _MSC_VER
1852  sscanf_s
1853 #else
1854  sscanf
1855 #endif
1856  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1857  {
1858  return 0;
1859  }
1860 
1861  /* Check the major number of the version */
1862 
1863  if (major > expectedMajor)
1864  {
1865  return 1;
1866  }
1867 
1868  if (major < expectedMajor)
1869  {
1870  return 0;
1871  }
1872 
1873  /* Check the minor number of the version */
1874 
1875  if (minor > expectedMinor)
1876  {
1877  return 1;
1878  }
1879 
1880  if (minor < expectedMinor)
1881  {
1882  return 0;
1883  }
1884 
1885  /* Check the revision number of the version */
1886 
1887  if (revision >= expectedRevision)
1888  {
1889  return 1;
1890  }
1891  else
1892  {
1893  return 0;
1894  }
1895  }
1896 
1897 
1914  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1915  OrthancPluginContext* context)
1916  {
1918  context,
1919  ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1920  ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1921  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1922  }
1923 
1924 
1933  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1934  OrthancPluginContext* context,
1935  OrthancPluginMemoryBuffer* buffer)
1936  {
1937  context->Free(buffer->data);
1938  }
1939 
1940 
1949  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer64(
1950  OrthancPluginContext* context,
1952  {
1953  context->Free(buffer->data);
1954  }
1955 
1956 
1965  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1966  OrthancPluginContext* context,
1967  const char* message)
1968  {
1969  context->InvokeService(context, _OrthancPluginService_LogError, message);
1970  }
1971 
1972 
1981  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
1982  OrthancPluginContext* context,
1983  const char* message)
1984  {
1985  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1986  }
1987 
1988 
1997  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
1998  OrthancPluginContext* context,
1999  const char* message)
2000  {
2001  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
2002  }
2003 
2004 
2005 
2006  typedef struct
2007  {
2008  const char* pathRegularExpression;
2009  OrthancPluginRestCallback callback;
2010  } _OrthancPluginRestCallback;
2011 
2033  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
2034  OrthancPluginContext* context,
2035  const char* pathRegularExpression,
2036  OrthancPluginRestCallback callback)
2037  {
2038  _OrthancPluginRestCallback params;
2039  params.pathRegularExpression = pathRegularExpression;
2040  params.callback = callback;
2041  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
2042  }
2043 
2044 
2045 
2073  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
2074  OrthancPluginContext* context,
2075  const char* pathRegularExpression,
2076  OrthancPluginRestCallback callback)
2077  {
2078  _OrthancPluginRestCallback params;
2079  params.pathRegularExpression = pathRegularExpression;
2080  params.callback = callback;
2081  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
2082  }
2083 
2084 
2085 
2086  typedef struct
2087  {
2089  } _OrthancPluginOnStoredInstanceCallback;
2090 
2112  OrthancPluginContext* context,
2114  {
2115  _OrthancPluginOnStoredInstanceCallback params;
2116  params.callback = callback;
2117 
2118  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
2119  }
2120 
2121 
2122 
2123  typedef struct
2124  {
2125  OrthancPluginRestOutput* output;
2126  const void* answer;
2127  uint32_t answerSize;
2128  const char* mimeType;
2129  } _OrthancPluginAnswerBuffer;
2130 
2143  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
2144  OrthancPluginContext* context,
2145  OrthancPluginRestOutput* output,
2146  const void* answer,
2147  uint32_t answerSize,
2148  const char* mimeType)
2149  {
2150  _OrthancPluginAnswerBuffer params;
2151  params.output = output;
2152  params.answer = answer;
2153  params.answerSize = answerSize;
2154  params.mimeType = mimeType;
2155  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
2156  }
2157 
2158 
2159  typedef struct
2160  {
2161  OrthancPluginRestOutput* output;
2162  OrthancPluginPixelFormat format;
2163  uint32_t width;
2164  uint32_t height;
2165  uint32_t pitch;
2166  const void* buffer;
2167  } _OrthancPluginCompressAndAnswerPngImage;
2168 
2169  typedef struct
2170  {
2171  OrthancPluginRestOutput* output;
2172  OrthancPluginImageFormat imageFormat;
2173  OrthancPluginPixelFormat pixelFormat;
2174  uint32_t width;
2175  uint32_t height;
2176  uint32_t pitch;
2177  const void* buffer;
2178  uint8_t quality;
2179  } _OrthancPluginCompressAndAnswerImage;
2180 
2181 
2200  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2201  OrthancPluginContext* context,
2202  OrthancPluginRestOutput* output,
2203  OrthancPluginPixelFormat format,
2204  uint32_t width,
2205  uint32_t height,
2206  uint32_t pitch,
2207  const void* buffer)
2208  {
2209  _OrthancPluginCompressAndAnswerImage params;
2210  params.output = output;
2211  params.imageFormat = OrthancPluginImageFormat_Png;
2212  params.pixelFormat = format;
2213  params.width = width;
2214  params.height = height;
2215  params.pitch = pitch;
2216  params.buffer = buffer;
2217  params.quality = 0; /* No quality for PNG */
2218  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2219  }
2220 
2221 
2222 
2223  typedef struct
2224  {
2225  OrthancPluginMemoryBuffer* target;
2226  const char* instanceId;
2227  } _OrthancPluginGetDicomForInstance;
2228 
2242  OrthancPluginContext* context,
2243  OrthancPluginMemoryBuffer* target,
2244  const char* instanceId)
2245  {
2246  _OrthancPluginGetDicomForInstance params;
2247  params.target = target;
2248  params.instanceId = instanceId;
2249  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2250  }
2251 
2252 
2253 
2254  typedef struct
2255  {
2256  OrthancPluginMemoryBuffer* target;
2257  const char* uri;
2258  } _OrthancPluginRestApiGet;
2259 
2275  OrthancPluginContext* context,
2276  OrthancPluginMemoryBuffer* target,
2277  const char* uri)
2278  {
2279  _OrthancPluginRestApiGet params;
2280  params.target = target;
2281  params.uri = uri;
2282  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2283  }
2284 
2285 
2286 
2305  OrthancPluginContext* context,
2306  OrthancPluginMemoryBuffer* target,
2307  const char* uri)
2308  {
2309  _OrthancPluginRestApiGet params;
2310  params.target = target;
2311  params.uri = uri;
2312  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2313  }
2314 
2315 
2316 
2317  typedef struct
2318  {
2319  OrthancPluginMemoryBuffer* target;
2320  const char* uri;
2321  const void* body;
2322  uint32_t bodySize;
2323  } _OrthancPluginRestApiPostPut;
2324 
2342  OrthancPluginContext* context,
2343  OrthancPluginMemoryBuffer* target,
2344  const char* uri,
2345  const void* body,
2346  uint32_t bodySize)
2347  {
2348  _OrthancPluginRestApiPostPut params;
2349  params.target = target;
2350  params.uri = uri;
2351  params.body = body;
2352  params.bodySize = bodySize;
2353  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2354  }
2355 
2356 
2377  OrthancPluginContext* context,
2378  OrthancPluginMemoryBuffer* target,
2379  const char* uri,
2380  const void* body,
2381  uint32_t bodySize)
2382  {
2383  _OrthancPluginRestApiPostPut params;
2384  params.target = target;
2385  params.uri = uri;
2386  params.body = body;
2387  params.bodySize = bodySize;
2388  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2389  }
2390 
2391 
2392 
2406  OrthancPluginContext* context,
2407  const char* uri)
2408  {
2409  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2410  }
2411 
2412 
2429  OrthancPluginContext* context,
2430  const char* uri)
2431  {
2432  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2433  }
2434 
2435 
2436 
2454  OrthancPluginContext* context,
2455  OrthancPluginMemoryBuffer* target,
2456  const char* uri,
2457  const void* body,
2458  uint32_t bodySize)
2459  {
2460  _OrthancPluginRestApiPostPut params;
2461  params.target = target;
2462  params.uri = uri;
2463  params.body = body;
2464  params.bodySize = bodySize;
2465  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2466  }
2467 
2468 
2469 
2490  OrthancPluginContext* context,
2491  OrthancPluginMemoryBuffer* target,
2492  const char* uri,
2493  const void* body,
2494  uint32_t bodySize)
2495  {
2496  _OrthancPluginRestApiPostPut params;
2497  params.target = target;
2498  params.uri = uri;
2499  params.body = body;
2500  params.bodySize = bodySize;
2501  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2502  }
2503 
2504 
2505 
2506  typedef struct
2507  {
2508  OrthancPluginRestOutput* output;
2509  const char* argument;
2510  } _OrthancPluginOutputPlusArgument;
2511 
2523  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2524  OrthancPluginContext* context,
2525  OrthancPluginRestOutput* output,
2526  const char* redirection)
2527  {
2528  _OrthancPluginOutputPlusArgument params;
2529  params.output = output;
2530  params.argument = redirection;
2531  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2532  }
2533 
2534 
2535 
2536  typedef struct
2537  {
2538  char** result;
2539  const char* argument;
2540  } _OrthancPluginRetrieveDynamicString;
2541 
2555  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2556  OrthancPluginContext* context,
2557  const char* patientID)
2558  {
2559  char* result;
2560 
2561  _OrthancPluginRetrieveDynamicString params;
2562  params.result = &result;
2563  params.argument = patientID;
2564 
2565  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2566  {
2567  /* Error */
2568  return NULL;
2569  }
2570  else
2571  {
2572  return result;
2573  }
2574  }
2575 
2576 
2590  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2591  OrthancPluginContext* context,
2592  const char* studyUID)
2593  {
2594  char* result;
2595 
2596  _OrthancPluginRetrieveDynamicString params;
2597  params.result = &result;
2598  params.argument = studyUID;
2599 
2600  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2601  {
2602  /* Error */
2603  return NULL;
2604  }
2605  else
2606  {
2607  return result;
2608  }
2609  }
2610 
2611 
2625  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
2626  OrthancPluginContext* context,
2627  const char* accessionNumber)
2628  {
2629  char* result;
2630 
2631  _OrthancPluginRetrieveDynamicString params;
2632  params.result = &result;
2633  params.argument = accessionNumber;
2634 
2635  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2636  {
2637  /* Error */
2638  return NULL;
2639  }
2640  else
2641  {
2642  return result;
2643  }
2644  }
2645 
2646 
2660  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2661  OrthancPluginContext* context,
2662  const char* seriesUID)
2663  {
2664  char* result;
2665 
2666  _OrthancPluginRetrieveDynamicString params;
2667  params.result = &result;
2668  params.argument = seriesUID;
2669 
2670  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2671  {
2672  /* Error */
2673  return NULL;
2674  }
2675  else
2676  {
2677  return result;
2678  }
2679  }
2680 
2681 
2695  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2696  OrthancPluginContext* context,
2697  const char* sopInstanceUID)
2698  {
2699  char* result;
2700 
2701  _OrthancPluginRetrieveDynamicString params;
2702  params.result = &result;
2703  params.argument = sopInstanceUID;
2704 
2705  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2706  {
2707  /* Error */
2708  return NULL;
2709  }
2710  else
2711  {
2712  return result;
2713  }
2714  }
2715 
2716 
2717 
2718  typedef struct
2719  {
2720  OrthancPluginRestOutput* output;
2721  uint16_t status;
2722  } _OrthancPluginSendHttpStatusCode;
2723 
2740  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2741  OrthancPluginContext* context,
2742  OrthancPluginRestOutput* output,
2743  uint16_t status)
2744  {
2745  _OrthancPluginSendHttpStatusCode params;
2746  params.output = output;
2747  params.status = status;
2748  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2749  }
2750 
2751 
2763  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2764  OrthancPluginContext* context,
2765  OrthancPluginRestOutput* output,
2766  const char* realm)
2767  {
2768  _OrthancPluginOutputPlusArgument params;
2769  params.output = output;
2770  params.argument = realm;
2771  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2772  }
2773 
2774 
2786  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2787  OrthancPluginContext* context,
2788  OrthancPluginRestOutput* output,
2789  const char* allowedMethods)
2790  {
2791  _OrthancPluginOutputPlusArgument params;
2792  params.output = output;
2793  params.argument = allowedMethods;
2794  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2795  }
2796 
2797 
2798  typedef struct
2799  {
2800  OrthancPluginRestOutput* output;
2801  const char* key;
2802  const char* value;
2803  } _OrthancPluginSetHttpHeader;
2804 
2816  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2817  OrthancPluginContext* context,
2818  OrthancPluginRestOutput* output,
2819  const char* cookie,
2820  const char* value)
2821  {
2822  _OrthancPluginSetHttpHeader params;
2823  params.output = output;
2824  params.key = cookie;
2825  params.value = value;
2826  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2827  }
2828 
2829 
2841  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2842  OrthancPluginContext* context,
2843  OrthancPluginRestOutput* output,
2844  const char* key,
2845  const char* value)
2846  {
2847  _OrthancPluginSetHttpHeader params;
2848  params.output = output;
2849  params.key = key;
2850  params.value = value;
2851  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2852  }
2853 
2854 
2855  typedef struct
2856  {
2857  char** resultStringToFree;
2858  const char** resultString;
2859  int64_t* resultInt64;
2860  const char* key;
2861  const OrthancPluginDicomInstance* instance;
2862  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2863  } _OrthancPluginAccessDicomInstance;
2864 
2865 
2877  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2878  OrthancPluginContext* context,
2879  const OrthancPluginDicomInstance* instance)
2880  {
2881  const char* result;
2882 
2883  _OrthancPluginAccessDicomInstance params;
2884  memset(&params, 0, sizeof(params));
2885  params.resultString = &result;
2886  params.instance = instance;
2887 
2888  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2889  {
2890  /* Error */
2891  return NULL;
2892  }
2893  else
2894  {
2895  return result;
2896  }
2897  }
2898 
2899 
2910  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2911  OrthancPluginContext* context,
2912  const OrthancPluginDicomInstance* instance)
2913  {
2914  int64_t size;
2915 
2916  _OrthancPluginAccessDicomInstance params;
2917  memset(&params, 0, sizeof(params));
2918  params.resultInt64 = &size;
2919  params.instance = instance;
2920 
2921  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2922  {
2923  /* Error */
2924  return -1;
2925  }
2926  else
2927  {
2928  return size;
2929  }
2930  }
2931 
2932 
2943  ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData(
2944  OrthancPluginContext* context,
2945  const OrthancPluginDicomInstance* instance)
2946  {
2947  const char* result;
2948 
2949  _OrthancPluginAccessDicomInstance params;
2950  memset(&params, 0, sizeof(params));
2951  params.resultString = &result;
2952  params.instance = instance;
2953 
2954  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2955  {
2956  /* Error */
2957  return NULL;
2958  }
2959  else
2960  {
2961  return result;
2962  }
2963  }
2964 
2965 
2979  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
2980  OrthancPluginContext* context,
2981  const OrthancPluginDicomInstance* instance)
2982  {
2983  char* result;
2984 
2985  _OrthancPluginAccessDicomInstance params;
2986  memset(&params, 0, sizeof(params));
2987  params.resultStringToFree = &result;
2988  params.instance = instance;
2989 
2990  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
2991  {
2992  /* Error */
2993  return NULL;
2994  }
2995  else
2996  {
2997  return result;
2998  }
2999  }
3000 
3001 
3017  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
3018  OrthancPluginContext* context,
3019  const OrthancPluginDicomInstance* instance)
3020  {
3021  char* result;
3022 
3023  _OrthancPluginAccessDicomInstance params;
3024  memset(&params, 0, sizeof(params));
3025  params.resultStringToFree = &result;
3026  params.instance = instance;
3027 
3028  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
3029  {
3030  /* Error */
3031  return NULL;
3032  }
3033  else
3034  {
3035  return result;
3036  }
3037  }
3038 
3039 
3056  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
3057  OrthancPluginContext* context,
3058  const OrthancPluginDicomInstance* instance,
3059  const char* metadata)
3060  {
3061  int64_t result;
3062 
3063  _OrthancPluginAccessDicomInstance params;
3064  memset(&params, 0, sizeof(params));
3065  params.resultInt64 = &result;
3066  params.instance = instance;
3067  params.key = metadata;
3068 
3069  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3070  {
3071  /* Error */
3072  return -1;
3073  }
3074  else
3075  {
3076  return (result != 0);
3077  }
3078  }
3079 
3080 
3097  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
3098  OrthancPluginContext* context,
3099  const OrthancPluginDicomInstance* instance,
3100  const char* metadata)
3101  {
3102  const char* result;
3103 
3104  _OrthancPluginAccessDicomInstance params;
3105  memset(&params, 0, sizeof(params));
3106  params.resultString = &result;
3107  params.instance = instance;
3108  params.key = metadata;
3109 
3110  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3111  {
3112  /* Error */
3113  return NULL;
3114  }
3115  else
3116  {
3117  return result;
3118  }
3119  }
3120 
3121 
3122 
3123  typedef struct
3124  {
3128  OrthancPluginFree free;
3129  } _OrthancPluginRegisterStorageArea;
3130 
3146  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
3147  OrthancPluginContext* context,
3151  {
3152  _OrthancPluginRegisterStorageArea params;
3153  params.create = create;
3154  params.read = read;
3155  params.remove = remove;
3156 
3157 #ifdef __cplusplus
3158  params.free = ::free;
3159 #else
3160  params.free = free;
3161 #endif
3162 
3163  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3164  }
3165 
3166 
3167 
3178  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3179  {
3180  char* result;
3181 
3182  _OrthancPluginRetrieveDynamicString params;
3183  params.result = &result;
3184  params.argument = NULL;
3185 
3186  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3187  {
3188  /* Error */
3189  return NULL;
3190  }
3191  else
3192  {
3193  return result;
3194  }
3195  }
3196 
3197 
3208  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3209  {
3210  char* result;
3211 
3212  _OrthancPluginRetrieveDynamicString params;
3213  params.result = &result;
3214  params.argument = NULL;
3215 
3216  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3217  {
3218  /* Error */
3219  return NULL;
3220  }
3221  else
3222  {
3223  return result;
3224  }
3225  }
3226 
3227 
3243  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3244  {
3245  char* result;
3246 
3247  _OrthancPluginRetrieveDynamicString params;
3248  params.result = &result;
3249  params.argument = NULL;
3250 
3251  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3252  {
3253  /* Error */
3254  return NULL;
3255  }
3256  else
3257  {
3258  return result;
3259  }
3260  }
3261 
3262 
3263 
3264  typedef struct
3265  {
3267  } _OrthancPluginOnChangeCallback;
3268 
3289  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3290  OrthancPluginContext* context,
3292  {
3293  _OrthancPluginOnChangeCallback params;
3294  params.callback = callback;
3295 
3296  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3297  }
3298 
3299 
3300 
3301  typedef struct
3302  {
3303  const char* plugin;
3304  _OrthancPluginProperty property;
3305  const char* value;
3306  } _OrthancPluginSetPluginProperty;
3307 
3308 
3320  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3321  OrthancPluginContext* context,
3322  const char* uri)
3323  {
3324  _OrthancPluginSetPluginProperty params;
3325  params.plugin = OrthancPluginGetName();
3326  params.property = _OrthancPluginProperty_RootUri;
3327  params.value = uri;
3328 
3329  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3330  }
3331 
3332 
3342  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3343  OrthancPluginContext* context,
3344  const char* description)
3345  {
3346  _OrthancPluginSetPluginProperty params;
3347  params.plugin = OrthancPluginGetName();
3348  params.property = _OrthancPluginProperty_Description;
3349  params.value = description;
3350 
3351  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3352  }
3353 
3354 
3364  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3365  OrthancPluginContext* context,
3366  const char* javascript)
3367  {
3368  _OrthancPluginSetPluginProperty params;
3369  params.plugin = OrthancPluginGetName();
3370  params.property = _OrthancPluginProperty_OrthancExplorer;
3371  params.value = javascript;
3372 
3373  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3374  }
3375 
3376 
3377  typedef struct
3378  {
3379  char** result;
3380  int32_t property;
3381  const char* value;
3382  } _OrthancPluginGlobalProperty;
3383 
3384 
3398  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3399  OrthancPluginContext* context,
3400  int32_t property,
3401  const char* defaultValue)
3402  {
3403  char* result;
3404 
3405  _OrthancPluginGlobalProperty params;
3406  params.result = &result;
3407  params.property = property;
3408  params.value = defaultValue;
3409 
3410  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3411  {
3412  /* Error */
3413  return NULL;
3414  }
3415  else
3416  {
3417  return result;
3418  }
3419  }
3420 
3421 
3438  OrthancPluginContext* context,
3439  int32_t property,
3440  const char* value)
3441  {
3442  _OrthancPluginGlobalProperty params;
3443  params.result = NULL;
3444  params.property = property;
3445  params.value = value;
3446 
3447  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3448  }
3449 
3450 
3451 
3452  typedef struct
3453  {
3454  int32_t *resultInt32;
3455  uint32_t *resultUint32;
3456  int64_t *resultInt64;
3457  uint64_t *resultUint64;
3458  } _OrthancPluginReturnSingleValue;
3459 
3468  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3469  OrthancPluginContext* context)
3470  {
3471  uint32_t count = 0;
3472 
3473  _OrthancPluginReturnSingleValue params;
3474  memset(&params, 0, sizeof(params));
3475  params.resultUint32 = &count;
3476 
3477  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3478  {
3479  /* Error */
3480  return 0;
3481  }
3482  else
3483  {
3484  return count;
3485  }
3486  }
3487 
3488 
3489 
3502  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3503  OrthancPluginContext* context,
3504  uint32_t argument)
3505  {
3506  char* result;
3507 
3508  _OrthancPluginGlobalProperty params;
3509  params.result = &result;
3510  params.property = (int32_t) argument;
3511  params.value = NULL;
3512 
3513  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3514  {
3515  /* Error */
3516  return NULL;
3517  }
3518  else
3519  {
3520  return result;
3521  }
3522  }
3523 
3524 
3534  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3535  OrthancPluginContext* context)
3536  {
3537  uint32_t count = 0;
3538 
3539  _OrthancPluginReturnSingleValue params;
3540  memset(&params, 0, sizeof(params));
3541  params.resultUint32 = &count;
3542 
3543  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3544  {
3545  /* Error */
3546  return 0;
3547  }
3548  else
3549  {
3550  return count;
3551  }
3552  }
3553 
3554 
3555 
3567  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3568  {
3569  char* result;
3570 
3571  _OrthancPluginRetrieveDynamicString params;
3572  params.result = &result;
3573  params.argument = NULL;
3574 
3575  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3576  {
3577  /* Error */
3578  return NULL;
3579  }
3580  else
3581  {
3582  return result;
3583  }
3584  }
3585 
3586 
3587 
3588  typedef struct
3589  {
3590  OrthancPluginRestOutput* output;
3591  const char* subType;
3592  const char* contentType;
3593  } _OrthancPluginStartMultipartAnswer;
3594 
3609  OrthancPluginContext* context,
3610  OrthancPluginRestOutput* output,
3611  const char* subType,
3612  const char* contentType)
3613  {
3614  _OrthancPluginStartMultipartAnswer params;
3615  params.output = output;
3616  params.subType = subType;
3617  params.contentType = contentType;
3618  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3619  }
3620 
3621 
3638  OrthancPluginContext* context,
3639  OrthancPluginRestOutput* output,
3640  const void* answer,
3641  uint32_t answerSize)
3642  {
3643  _OrthancPluginAnswerBuffer params;
3644  params.output = output;
3645  params.answer = answer;
3646  params.answerSize = answerSize;
3647  params.mimeType = NULL;
3648  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3649  }
3650 
3651 
3652 
3653  typedef struct
3654  {
3655  OrthancPluginMemoryBuffer* target;
3656  const void* source;
3657  uint32_t size;
3658  OrthancPluginCompressionType compression;
3659  uint8_t uncompress;
3660  } _OrthancPluginBufferCompression;
3661 
3662 
3680  OrthancPluginContext* context,
3681  OrthancPluginMemoryBuffer* target,
3682  const void* source,
3683  uint32_t size,
3684  OrthancPluginCompressionType compression,
3685  uint8_t uncompress)
3686  {
3687  _OrthancPluginBufferCompression params;
3688  params.target = target;
3689  params.source = source;
3690  params.size = size;
3691  params.compression = compression;
3692  params.uncompress = uncompress;
3693 
3694  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3695  }
3696 
3697 
3698 
3699  typedef struct
3700  {
3701  OrthancPluginMemoryBuffer* target;
3702  const char* path;
3703  } _OrthancPluginReadFile;
3704 
3717  OrthancPluginContext* context,
3718  OrthancPluginMemoryBuffer* target,
3719  const char* path)
3720  {
3721  _OrthancPluginReadFile params;
3722  params.target = target;
3723  params.path = path;
3724  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3725  }
3726 
3727 
3728 
3729  typedef struct
3730  {
3731  const char* path;
3732  const void* data;
3733  uint32_t size;
3734  } _OrthancPluginWriteFile;
3735 
3748  OrthancPluginContext* context,
3749  const char* path,
3750  const void* data,
3751  uint32_t size)
3752  {
3753  _OrthancPluginWriteFile params;
3754  params.path = path;
3755  params.data = data;
3756  params.size = size;
3757  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3758  }
3759 
3760 
3761 
3762  typedef struct
3763  {
3764  const char** target;
3765  OrthancPluginErrorCode error;
3766  } _OrthancPluginGetErrorDescription;
3767 
3778  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3779  OrthancPluginContext* context,
3780  OrthancPluginErrorCode error)
3781  {
3782  const char* result = NULL;
3783 
3784  _OrthancPluginGetErrorDescription params;
3785  params.target = &result;
3786  params.error = error;
3787 
3788  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3789  result == NULL)
3790  {
3791  return "Unknown error code";
3792  }
3793  else
3794  {
3795  return result;
3796  }
3797  }
3798 
3799 
3800 
3801  typedef struct
3802  {
3803  OrthancPluginRestOutput* output;
3804  uint16_t status;
3805  const char* body;
3806  uint32_t bodySize;
3807  } _OrthancPluginSendHttpStatus;
3808 
3831  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3832  OrthancPluginContext* context,
3833  OrthancPluginRestOutput* output,
3834  uint16_t status,
3835  const char* body,
3836  uint32_t bodySize)
3837  {
3838  _OrthancPluginSendHttpStatus params;
3839  params.output = output;
3840  params.status = status;
3841  params.body = body;
3842  params.bodySize = bodySize;
3843  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3844  }
3845 
3846 
3847 
3848  typedef struct
3849  {
3850  const OrthancPluginImage* image;
3851  uint32_t* resultUint32;
3852  OrthancPluginPixelFormat* resultPixelFormat;
3853  void** resultBuffer;
3854  } _OrthancPluginGetImageInfo;
3855 
3856 
3868  OrthancPluginContext* context,
3869  const OrthancPluginImage* image)
3870  {
3871  OrthancPluginPixelFormat target;
3872 
3873  _OrthancPluginGetImageInfo params;
3874  memset(&params, 0, sizeof(params));
3875  params.image = image;
3876  params.resultPixelFormat = &target;
3877 
3878  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3879  {
3881  }
3882  else
3883  {
3884  return (OrthancPluginPixelFormat) target;
3885  }
3886  }
3887 
3888 
3889 
3900  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3901  OrthancPluginContext* context,
3902  const OrthancPluginImage* image)
3903  {
3904  uint32_t width;
3905 
3906  _OrthancPluginGetImageInfo params;
3907  memset(&params, 0, sizeof(params));
3908  params.image = image;
3909  params.resultUint32 = &width;
3910 
3911  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3912  {
3913  return 0;
3914  }
3915  else
3916  {
3917  return width;
3918  }
3919  }
3920 
3921 
3922 
3933  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3934  OrthancPluginContext* context,
3935  const OrthancPluginImage* image)
3936  {
3937  uint32_t height;
3938 
3939  _OrthancPluginGetImageInfo params;
3940  memset(&params, 0, sizeof(params));
3941  params.image = image;
3942  params.resultUint32 = &height;
3943 
3944  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3945  {
3946  return 0;
3947  }
3948  else
3949  {
3950  return height;
3951  }
3952  }
3953 
3954 
3955 
3968  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3969  OrthancPluginContext* context,
3970  const OrthancPluginImage* image)
3971  {
3972  uint32_t pitch;
3973 
3974  _OrthancPluginGetImageInfo params;
3975  memset(&params, 0, sizeof(params));
3976  params.image = image;
3977  params.resultUint32 = &pitch;
3978 
3979  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
3980  {
3981  return 0;
3982  }
3983  else
3984  {
3985  return pitch;
3986  }
3987  }
3988 
3989 
3990 
4002  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
4003  OrthancPluginContext* context,
4004  const OrthancPluginImage* image)
4005  {
4006  void* target = NULL;
4007 
4008  _OrthancPluginGetImageInfo params;
4009  memset(&params, 0, sizeof(params));
4010  params.resultBuffer = &target;
4011  params.image = image;
4012 
4013  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
4014  {
4015  return NULL;
4016  }
4017  else
4018  {
4019  return target;
4020  }
4021  }
4022 
4023 
4024  typedef struct
4025  {
4026  OrthancPluginImage** target;
4027  const void* data;
4028  uint32_t size;
4029  OrthancPluginImageFormat format;
4030  } _OrthancPluginUncompressImage;
4031 
4032 
4046  OrthancPluginContext* context,
4047  const void* data,
4048  uint32_t size,
4049  OrthancPluginImageFormat format)
4050  {
4051  OrthancPluginImage* target = NULL;
4052 
4053  _OrthancPluginUncompressImage params;
4054  memset(&params, 0, sizeof(params));
4055  params.target = &target;
4056  params.data = data;
4057  params.size = size;
4058  params.format = format;
4059 
4060  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
4061  {
4062  return NULL;
4063  }
4064  else
4065  {
4066  return target;
4067  }
4068  }
4069 
4070 
4071 
4072 
4073  typedef struct
4074  {
4075  OrthancPluginImage* image;
4076  } _OrthancPluginFreeImage;
4077 
4087  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
4088  OrthancPluginContext* context,
4089  OrthancPluginImage* image)
4090  {
4091  _OrthancPluginFreeImage params;
4092  params.image = image;
4093 
4094  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
4095  }
4096 
4097 
4098 
4099 
4100  typedef struct
4101  {
4102  OrthancPluginMemoryBuffer* target;
4103  OrthancPluginImageFormat imageFormat;
4104  OrthancPluginPixelFormat pixelFormat;
4105  uint32_t width;
4106  uint32_t height;
4107  uint32_t pitch;
4108  const void* buffer;
4109  uint8_t quality;
4110  } _OrthancPluginCompressImage;
4111 
4112 
4133  OrthancPluginContext* context,
4134  OrthancPluginMemoryBuffer* target,
4135  OrthancPluginPixelFormat format,
4136  uint32_t width,
4137  uint32_t height,
4138  uint32_t pitch,
4139  const void* buffer)
4140  {
4141  _OrthancPluginCompressImage params;
4142  memset(&params, 0, sizeof(params));
4143  params.target = target;
4144  params.imageFormat = OrthancPluginImageFormat_Png;
4145  params.pixelFormat = format;
4146  params.width = width;
4147  params.height = height;
4148  params.pitch = pitch;
4149  params.buffer = buffer;
4150  params.quality = 0; /* Unused for PNG */
4151 
4152  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4153  }
4154 
4155 
4178  OrthancPluginContext* context,
4179  OrthancPluginMemoryBuffer* target,
4180  OrthancPluginPixelFormat format,
4181  uint32_t width,
4182  uint32_t height,
4183  uint32_t pitch,
4184  const void* buffer,
4185  uint8_t quality)
4186  {
4187  _OrthancPluginCompressImage params;
4188  memset(&params, 0, sizeof(params));
4189  params.target = target;
4190  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4191  params.pixelFormat = format;
4192  params.width = width;
4193  params.height = height;
4194  params.pitch = pitch;
4195  params.buffer = buffer;
4196  params.quality = quality;
4197 
4198  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4199  }
4200 
4201 
4202 
4224  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
4225  OrthancPluginContext* context,
4226  OrthancPluginRestOutput* output,
4227  OrthancPluginPixelFormat format,
4228  uint32_t width,
4229  uint32_t height,
4230  uint32_t pitch,
4231  const void* buffer,
4232  uint8_t quality)
4233  {
4234  _OrthancPluginCompressAndAnswerImage params;
4235  params.output = output;
4236  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4237  params.pixelFormat = format;
4238  params.width = width;
4239  params.height = height;
4240  params.pitch = pitch;
4241  params.buffer = buffer;
4242  params.quality = quality;
4243  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4244  }
4245 
4246 
4247 
4248 
4249  typedef struct
4250  {
4251  OrthancPluginMemoryBuffer* target;
4252  OrthancPluginHttpMethod method;
4253  const char* url;
4254  const char* username;
4255  const char* password;
4256  const void* body;
4257  uint32_t bodySize;
4258  } _OrthancPluginCallHttpClient;
4259 
4260 
4278  OrthancPluginContext* context,
4279  OrthancPluginMemoryBuffer* target,
4280  const char* url,
4281  const char* username,
4282  const char* password)
4283  {
4284  _OrthancPluginCallHttpClient params;
4285  memset(&params, 0, sizeof(params));
4286 
4287  params.target = target;
4288  params.method = OrthancPluginHttpMethod_Get;
4289  params.url = url;
4290  params.username = username;
4291  params.password = password;
4292 
4293  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4294  }
4295 
4296 
4316  OrthancPluginContext* context,
4317  OrthancPluginMemoryBuffer* target,
4318  const char* url,
4319  const void* body,
4320  uint32_t bodySize,
4321  const char* username,
4322  const char* password)
4323  {
4324  _OrthancPluginCallHttpClient params;
4325  memset(&params, 0, sizeof(params));
4326 
4327  params.target = target;
4328  params.method = OrthancPluginHttpMethod_Post;
4329  params.url = url;
4330  params.body = body;
4331  params.bodySize = bodySize;
4332  params.username = username;
4333  params.password = password;
4334 
4335  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4336  }
4337 
4338 
4358  OrthancPluginContext* context,
4359  OrthancPluginMemoryBuffer* target,
4360  const char* url,
4361  const void* body,
4362  uint32_t bodySize,
4363  const char* username,
4364  const char* password)
4365  {
4366  _OrthancPluginCallHttpClient params;
4367  memset(&params, 0, sizeof(params));
4368 
4369  params.target = target;
4370  params.method = OrthancPluginHttpMethod_Put;
4371  params.url = url;
4372  params.body = body;
4373  params.bodySize = bodySize;
4374  params.username = username;
4375  params.password = password;
4376 
4377  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4378  }
4379 
4380 
4396  OrthancPluginContext* context,
4397  const char* url,
4398  const char* username,
4399  const char* password)
4400  {
4401  _OrthancPluginCallHttpClient params;
4402  memset(&params, 0, sizeof(params));
4403 
4404  params.method = OrthancPluginHttpMethod_Delete;
4405  params.url = url;
4406  params.username = username;
4407  params.password = password;
4408 
4409  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4410  }
4411 
4412 
4413 
4414  typedef struct
4415  {
4416  OrthancPluginImage** target;
4417  const OrthancPluginImage* source;
4418  OrthancPluginPixelFormat targetFormat;
4419  } _OrthancPluginConvertPixelFormat;
4420 
4421 
4434  OrthancPluginContext* context,
4435  const OrthancPluginImage* source,
4436  OrthancPluginPixelFormat targetFormat)
4437  {
4438  OrthancPluginImage* target = NULL;
4439 
4440  _OrthancPluginConvertPixelFormat params;
4441  params.target = &target;
4442  params.source = source;
4443  params.targetFormat = targetFormat;
4444 
4445  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4446  {
4447  return NULL;
4448  }
4449  else
4450  {
4451  return target;
4452  }
4453  }
4454 
4455 
4456 
4468  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4469  OrthancPluginContext* context)
4470  {
4471  uint32_t count = 0;
4472 
4473  _OrthancPluginReturnSingleValue params;
4474  memset(&params, 0, sizeof(params));
4475  params.resultUint32 = &count;
4476 
4477  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4478  {
4479  /* Error */
4480  return 0;
4481  }
4482  else
4483  {
4484  return count;
4485  }
4486  }
4487 
4488 
4489 
4490 
4491  typedef struct
4492  {
4493  uint32_t fontIndex; /* in */
4494  const char** name; /* out */
4495  uint32_t* size; /* out */
4496  } _OrthancPluginGetFontInfo;
4497 
4508  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4509  OrthancPluginContext* context,
4510  uint32_t fontIndex)
4511  {
4512  const char* result = NULL;
4513 
4514  _OrthancPluginGetFontInfo params;
4515  memset(&params, 0, sizeof(params));
4516  params.name = &result;
4517  params.fontIndex = fontIndex;
4518 
4519  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4520  {
4521  return NULL;
4522  }
4523  else
4524  {
4525  return result;
4526  }
4527  }
4528 
4529 
4540  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4541  OrthancPluginContext* context,
4542  uint32_t fontIndex)
4543  {
4544  uint32_t result;
4545 
4546  _OrthancPluginGetFontInfo params;
4547  memset(&params, 0, sizeof(params));
4548  params.size = &result;
4549  params.fontIndex = fontIndex;
4550 
4551  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4552  {
4553  return 0;
4554  }
4555  else
4556  {
4557  return result;
4558  }
4559  }
4560 
4561 
4562 
4563  typedef struct
4564  {
4565  OrthancPluginImage* image;
4566  uint32_t fontIndex;
4567  const char* utf8Text;
4568  int32_t x;
4569  int32_t y;
4570  uint8_t r;
4571  uint8_t g;
4572  uint8_t b;
4573  } _OrthancPluginDrawText;
4574 
4575 
4594  OrthancPluginContext* context,
4595  OrthancPluginImage* image,
4596  uint32_t fontIndex,
4597  const char* utf8Text,
4598  int32_t x,
4599  int32_t y,
4600  uint8_t r,
4601  uint8_t g,
4602  uint8_t b)
4603  {
4604  _OrthancPluginDrawText params;
4605  memset(&params, 0, sizeof(params));
4606  params.image = image;
4607  params.fontIndex = fontIndex;
4608  params.utf8Text = utf8Text;
4609  params.x = x;
4610  params.y = y;
4611  params.r = r;
4612  params.g = g;
4613  params.b = b;
4614 
4615  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4616  }
4617 
4618 
4619 
4620  typedef struct
4621  {
4622  OrthancPluginStorageArea* storageArea;
4623  const char* uuid;
4624  const void* content;
4625  uint64_t size;
4627  } _OrthancPluginStorageAreaCreate;
4628 
4629 
4648  OrthancPluginContext* context,
4649  OrthancPluginStorageArea* storageArea,
4650  const char* uuid,
4651  const void* content,
4652  uint64_t size,
4654  {
4655  _OrthancPluginStorageAreaCreate params;
4656  params.storageArea = storageArea;
4657  params.uuid = uuid;
4658  params.content = content;
4659  params.size = size;
4660  params.type = type;
4661 
4662  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4663  }
4664 
4665 
4666  typedef struct
4667  {
4668  OrthancPluginMemoryBuffer* target;
4669  OrthancPluginStorageArea* storageArea;
4670  const char* uuid;
4672  } _OrthancPluginStorageAreaRead;
4673 
4674 
4692  OrthancPluginContext* context,
4693  OrthancPluginMemoryBuffer* target,
4694  OrthancPluginStorageArea* storageArea,
4695  const char* uuid,
4697  {
4698  _OrthancPluginStorageAreaRead params;
4699  params.target = target;
4700  params.storageArea = storageArea;
4701  params.uuid = uuid;
4702  params.type = type;
4703 
4704  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4705  }
4706 
4707 
4708  typedef struct
4709  {
4710  OrthancPluginStorageArea* storageArea;
4711  const char* uuid;
4713  } _OrthancPluginStorageAreaRemove;
4714 
4731  OrthancPluginContext* context,
4732  OrthancPluginStorageArea* storageArea,
4733  const char* uuid,
4735  {
4736  _OrthancPluginStorageAreaRemove params;
4737  params.storageArea = storageArea;
4738  params.uuid = uuid;
4739  params.type = type;
4740 
4741  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4742  }
4743 
4744 
4745 
4746  typedef struct
4747  {
4748  OrthancPluginErrorCode* target;
4749  int32_t code;
4750  uint16_t httpStatus;
4751  const char* message;
4752  } _OrthancPluginRegisterErrorCode;
4753 
4770  OrthancPluginContext* context,
4771  int32_t code,
4772  uint16_t httpStatus,
4773  const char* message)
4774  {
4775  OrthancPluginErrorCode target;
4776 
4777  _OrthancPluginRegisterErrorCode params;
4778  params.target = &target;
4779  params.code = code;
4780  params.httpStatus = httpStatus;
4781  params.message = message;
4782 
4783  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4784  {
4785  return target;
4786  }
4787  else
4788  {
4789  /* There was an error while assigned the error. Use a generic code. */
4791  }
4792  }
4793 
4794 
4795 
4796  typedef struct
4797  {
4798  uint16_t group;
4799  uint16_t element;
4801  const char* name;
4802  uint32_t minMultiplicity;
4803  uint32_t maxMultiplicity;
4804  } _OrthancPluginRegisterDictionaryTag;
4805 
4826  OrthancPluginContext* context,
4827  uint16_t group,
4828  uint16_t element,
4830  const char* name,
4831  uint32_t minMultiplicity,
4832  uint32_t maxMultiplicity)
4833  {
4834  _OrthancPluginRegisterDictionaryTag params;
4835  params.group = group;
4836  params.element = element;
4837  params.vr = vr;
4838  params.name = name;
4839  params.minMultiplicity = minMultiplicity;
4840  params.maxMultiplicity = maxMultiplicity;
4841 
4842  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4843  }
4844 
4845 
4846 
4847  typedef struct
4848  {
4849  uint16_t group;
4850  uint16_t element;
4852  const char* name;
4853  uint32_t minMultiplicity;
4854  uint32_t maxMultiplicity;
4855  const char* privateCreator;
4856  } _OrthancPluginRegisterPrivateDictionaryTag;
4857 
4879  OrthancPluginContext* context,
4880  uint16_t group,
4881  uint16_t element,
4883  const char* name,
4884  uint32_t minMultiplicity,
4885  uint32_t maxMultiplicity,
4886  const char* privateCreator)
4887  {
4888  _OrthancPluginRegisterPrivateDictionaryTag params;
4889  params.group = group;
4890  params.element = element;
4891  params.vr = vr;
4892  params.name = name;
4893  params.minMultiplicity = minMultiplicity;
4894  params.maxMultiplicity = maxMultiplicity;
4895  params.privateCreator = privateCreator;
4896 
4897  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4898  }
4899 
4900 
4901 
4902  typedef struct
4903  {
4904  OrthancPluginStorageArea* storageArea;
4906  } _OrthancPluginReconstructMainDicomTags;
4907 
4923  OrthancPluginContext* context,
4924  OrthancPluginStorageArea* storageArea,
4926  {
4927  _OrthancPluginReconstructMainDicomTags params;
4928  params.level = level;
4929  params.storageArea = storageArea;
4930 
4931  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
4932  }
4933 
4934 
4935  typedef struct
4936  {
4937  char** result;
4938  const char* instanceId;
4939  const void* buffer;
4940  uint32_t size;
4943  uint32_t maxStringLength;
4944  } _OrthancPluginDicomToJson;
4945 
4946 
4966  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4967  OrthancPluginContext* context,
4968  const void* buffer,
4969  uint32_t size,
4972  uint32_t maxStringLength)
4973  {
4974  char* result;
4975 
4976  _OrthancPluginDicomToJson params;
4977  memset(&params, 0, sizeof(params));
4978  params.result = &result;
4979  params.buffer = buffer;
4980  params.size = size;
4981  params.format = format;
4982  params.flags = flags;
4983  params.maxStringLength = maxStringLength;
4984 
4985  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
4986  {
4987  /* Error */
4988  return NULL;
4989  }
4990  else
4991  {
4992  return result;
4993  }
4994  }
4995 
4996 
5015  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
5016  OrthancPluginContext* context,
5017  const char* instanceId,
5020  uint32_t maxStringLength)
5021  {
5022  char* result;
5023 
5024  _OrthancPluginDicomToJson params;
5025  memset(&params, 0, sizeof(params));
5026  params.result = &result;
5027  params.instanceId = instanceId;
5028  params.format = format;
5029  params.flags = flags;
5030  params.maxStringLength = maxStringLength;
5031 
5032  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
5033  {
5034  /* Error */
5035  return NULL;
5036  }
5037  else
5038  {
5039  return result;
5040  }
5041  }
5042 
5043 
5044  typedef struct
5045  {
5046  OrthancPluginMemoryBuffer* target;
5047  const char* uri;
5048  uint32_t headersCount;
5049  const char* const* headersKeys;
5050  const char* const* headersValues;
5051  int32_t afterPlugins;
5052  } _OrthancPluginRestApiGet2;
5053 
5074  OrthancPluginContext* context,
5075  OrthancPluginMemoryBuffer* target,
5076  const char* uri,
5077  uint32_t headersCount,
5078  const char* const* headersKeys,
5079  const char* const* headersValues,
5080  int32_t afterPlugins)
5081  {
5082  _OrthancPluginRestApiGet2 params;
5083  params.target = target;
5084  params.uri = uri;
5085  params.headersCount = headersCount;
5086  params.headersKeys = headersKeys;
5087  params.headersValues = headersValues;
5088  params.afterPlugins = afterPlugins;
5089 
5090  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
5091  }
5092 
5093 
5094 
5095  typedef struct
5096  {
5098  } _OrthancPluginWorklistCallback;
5099 
5112  OrthancPluginContext* context,
5114  {
5115  _OrthancPluginWorklistCallback params;
5116  params.callback = callback;
5117 
5118  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
5119  }
5120 
5121 
5122 
5123  typedef struct
5124  {
5126  const OrthancPluginWorklistQuery* query;
5127  const void* dicom;
5128  uint32_t size;
5129  } _OrthancPluginWorklistAnswersOperation;
5130 
5148  OrthancPluginContext* context,
5150  const OrthancPluginWorklistQuery* query,
5151  const void* dicom,
5152  uint32_t size)
5153  {
5154  _OrthancPluginWorklistAnswersOperation params;
5155  params.answers = answers;
5156  params.query = query;
5157  params.dicom = dicom;
5158  params.size = size;
5159 
5160  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
5161  }
5162 
5163 
5178  OrthancPluginContext* context,
5180  {
5181  _OrthancPluginWorklistAnswersOperation params;
5182  params.answers = answers;
5183  params.query = NULL;
5184  params.dicom = NULL;
5185  params.size = 0;
5186 
5187  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5188  }
5189 
5190 
5191  typedef struct
5192  {
5193  const OrthancPluginWorklistQuery* query;
5194  const void* dicom;
5195  uint32_t size;
5196  int32_t* isMatch;
5197  OrthancPluginMemoryBuffer* target;
5198  } _OrthancPluginWorklistQueryOperation;
5199 
5215  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5216  OrthancPluginContext* context,
5217  const OrthancPluginWorklistQuery* query,
5218  const void* dicom,
5219  uint32_t size)
5220  {
5221  int32_t isMatch = 0;
5222 
5223  _OrthancPluginWorklistQueryOperation params;
5224  params.query = query;
5225  params.dicom = dicom;
5226  params.size = size;
5227  params.isMatch = &isMatch;
5228  params.target = NULL;
5229 
5230  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5231  {
5232  return isMatch;
5233  }
5234  else
5235  {
5236  /* Error: Assume non-match */
5237  return 0;
5238  }
5239  }
5240 
5241 
5255  OrthancPluginContext* context,
5256  OrthancPluginMemoryBuffer* target,
5257  const OrthancPluginWorklistQuery* query)
5258  {
5259  _OrthancPluginWorklistQueryOperation params;
5260  params.query = query;
5261  params.dicom = NULL;
5262  params.size = 0;
5263  params.isMatch = NULL;
5264  params.target = target;
5265 
5266  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5267  }
5268 
5269 
5281  OrthancPluginContext* context,
5282  const OrthancPluginDicomInstance* instance)
5283  {
5285 
5286  _OrthancPluginAccessDicomInstance params;
5287  memset(&params, 0, sizeof(params));
5288  params.resultOrigin = &origin;
5289  params.instance = instance;
5290 
5291  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5292  {
5293  /* Error */
5295  }
5296  else
5297  {
5298  return origin;
5299  }
5300  }
5301 
5302 
5303  typedef struct
5304  {
5305  OrthancPluginMemoryBuffer* target;
5306  const char* json;
5307  const OrthancPluginImage* pixelData;
5309  } _OrthancPluginCreateDicom;
5310 
5337  OrthancPluginContext* context,
5338  OrthancPluginMemoryBuffer* target,
5339  const char* json,
5340  const OrthancPluginImage* pixelData,
5342  {
5343  _OrthancPluginCreateDicom params;
5344  params.target = target;
5345  params.json = json;
5346  params.pixelData = pixelData;
5347  params.flags = flags;
5348 
5349  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5350  }
5351 
5352 
5353  typedef struct
5354  {
5356  } _OrthancPluginDecodeImageCallback;
5357 
5373  OrthancPluginContext* context,
5375  {
5376  _OrthancPluginDecodeImageCallback params;
5377  params.callback = callback;
5378 
5379  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5380  }
5381 
5382 
5383 
5384  typedef struct
5385  {
5386  OrthancPluginImage** target;
5387  OrthancPluginPixelFormat format;
5388  uint32_t width;
5389  uint32_t height;
5390  uint32_t pitch;
5391  void* buffer;
5392  const void* constBuffer;
5393  uint32_t bufferSize;
5394  uint32_t frameIndex;
5395  } _OrthancPluginCreateImage;
5396 
5397 
5411  OrthancPluginContext* context,
5412  OrthancPluginPixelFormat format,
5413  uint32_t width,
5414  uint32_t height)
5415  {
5416  OrthancPluginImage* target = NULL;
5417 
5418  _OrthancPluginCreateImage params;
5419  memset(&params, 0, sizeof(params));
5420  params.target = &target;
5421  params.format = format;
5422  params.width = width;
5423  params.height = height;
5424 
5425  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5426  {
5427  return NULL;
5428  }
5429  else
5430  {
5431  return target;
5432  }
5433  }
5434 
5435 
5454  OrthancPluginContext* context,
5455  OrthancPluginPixelFormat format,
5456  uint32_t width,
5457  uint32_t height,
5458  uint32_t pitch,
5459  void* buffer)
5460  {
5461  OrthancPluginImage* target = NULL;
5462 
5463  _OrthancPluginCreateImage params;
5464  memset(&params, 0, sizeof(params));
5465  params.target = &target;
5466  params.format = format;
5467  params.width = width;
5468  params.height = height;
5469  params.pitch = pitch;
5470  params.buffer = buffer;
5471 
5472  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5473  {
5474  return NULL;
5475  }
5476  else
5477  {
5478  return target;
5479  }
5480  }
5481 
5482 
5483 
5500  OrthancPluginContext* context,
5501  const void* buffer,
5502  uint32_t bufferSize,
5503  uint32_t frameIndex)
5504  {
5505  OrthancPluginImage* target = NULL;
5506 
5507  _OrthancPluginCreateImage params;
5508  memset(&params, 0, sizeof(params));
5509  params.target = &target;
5510  params.constBuffer = buffer;
5511  params.bufferSize = bufferSize;
5512  params.frameIndex = frameIndex;
5513 
5514  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5515  {
5516  return NULL;
5517  }
5518  else
5519  {
5520  return target;
5521  }
5522  }
5523 
5524 
5525 
5526  typedef struct
5527  {
5528  char** result;
5529  const void* buffer;
5530  uint32_t size;
5531  } _OrthancPluginComputeHash;
5532 
5545  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5546  OrthancPluginContext* context,
5547  const void* buffer,
5548  uint32_t size)
5549  {
5550  char* result;
5551 
5552  _OrthancPluginComputeHash params;
5553  params.result = &result;
5554  params.buffer = buffer;
5555  params.size = size;
5556 
5557  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5558  {
5559  /* Error */
5560  return NULL;
5561  }
5562  else
5563  {
5564  return result;
5565  }
5566  }
5567 
5568 
5581  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5582  OrthancPluginContext* context,
5583  const void* buffer,
5584  uint32_t size)
5585  {
5586  char* result;
5587 
5588  _OrthancPluginComputeHash params;
5589  params.result = &result;
5590  params.buffer = buffer;
5591  params.size = size;
5592 
5593  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5594  {
5595  /* Error */
5596  return NULL;
5597  }
5598  else
5599  {
5600  return result;
5601  }
5602  }
5603 
5604 
5605 
5606  typedef struct
5607  {
5609  const char* name;
5610  } _OrthancPluginLookupDictionary;
5611 
5628  OrthancPluginContext* context,
5630  const char* name)
5631  {
5632  _OrthancPluginLookupDictionary params;
5633  params.target = target;
5634  params.name = name;
5635  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5636  }
5637 
5638 
5639 
5640  typedef struct
5641  {
5642  OrthancPluginRestOutput* output;
5643  const void* answer;
5644  uint32_t answerSize;
5645  uint32_t headersCount;
5646  const char* const* headersKeys;
5647  const char* const* headersValues;
5648  } _OrthancPluginSendMultipartItem2;
5649 
5671  OrthancPluginContext* context,
5672  OrthancPluginRestOutput* output,
5673  const void* answer,
5674  uint32_t answerSize,
5675  uint32_t headersCount,
5676  const char* const* headersKeys,
5677  const char* const* headersValues)
5678  {
5679  _OrthancPluginSendMultipartItem2 params;
5680  params.output = output;
5681  params.answer = answer;
5682  params.answerSize = answerSize;
5683  params.headersCount = headersCount;
5684  params.headersKeys = headersKeys;
5685  params.headersValues = headersValues;
5686 
5687  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5688  }
5689 
5690 
5691  typedef struct
5692  {
5694  } _OrthancPluginIncomingHttpRequestFilter;
5695 
5709  OrthancPluginContext* context,
5711  {
5712  _OrthancPluginIncomingHttpRequestFilter params;
5713  params.callback = callback;
5714 
5715  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5716  }
5717 
5718 
5719 
5720  typedef struct
5721  {
5722  OrthancPluginMemoryBuffer* answerBody;
5723  OrthancPluginMemoryBuffer* answerHeaders;
5724  uint16_t* httpStatus;
5725  OrthancPluginHttpMethod method;
5726  const char* url;
5727  uint32_t headersCount;
5728  const char* const* headersKeys;
5729  const char* const* headersValues;
5730  const void* body;
5731  uint32_t bodySize;
5732  const char* username;
5733  const char* password;
5734  uint32_t timeout;
5735  const char* certificateFile;
5736  const char* certificateKeyFile;
5737  const char* certificateKeyPassword;
5738  uint8_t pkcs11;
5739  } _OrthancPluginCallHttpClient2;
5740 
5741 
5742 
5783  OrthancPluginContext* context,
5784  OrthancPluginMemoryBuffer* answerBody,
5785  OrthancPluginMemoryBuffer* answerHeaders,
5786  uint16_t* httpStatus,
5787  OrthancPluginHttpMethod method,
5788  const char* url,
5789  uint32_t headersCount,
5790  const char* const* headersKeys,
5791  const char* const* headersValues,
5792  const void* body,
5793  uint32_t bodySize,
5794  const char* username,
5795  const char* password,
5796  uint32_t timeout,
5797  const char* certificateFile,
5798  const char* certificateKeyFile,
5799  const char* certificateKeyPassword,
5800  uint8_t pkcs11)
5801  {
5802  _OrthancPluginCallHttpClient2 params;
5803  memset(&params, 0, sizeof(params));
5804 
5805  params.answerBody = answerBody;
5806  params.answerHeaders = answerHeaders;
5807  params.httpStatus = httpStatus;
5808  params.method = method;
5809  params.url = url;
5810  params.headersCount = headersCount;
5811  params.headersKeys = headersKeys;
5812  params.headersValues = headersValues;
5813  params.body = body;
5814  params.bodySize = bodySize;
5815  params.username = username;
5816  params.password = password;
5817  params.timeout = timeout;
5818  params.certificateFile = certificateFile;
5819  params.certificateKeyFile = certificateKeyFile;
5820  params.certificateKeyPassword = certificateKeyPassword;
5821  params.pkcs11 = pkcs11;
5822 
5823  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5824  }
5825 
5826 
5837  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5838  OrthancPluginContext* context)
5839  {
5840  char* result;
5841 
5842  _OrthancPluginRetrieveDynamicString params;
5843  params.result = &result;
5844  params.argument = NULL;
5845 
5846  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5847  {
5848  /* Error */
5849  return NULL;
5850  }
5851  else
5852  {
5853  return result;
5854  }
5855  }
5856 
5857 
5858 
5859 
5860  typedef struct
5861  {
5862  OrthancPluginFindCallback callback;
5863  } _OrthancPluginFindCallback;
5864 
5877  OrthancPluginContext* context,
5878  OrthancPluginFindCallback callback)
5879  {
5880  _OrthancPluginFindCallback params;
5881  params.callback = callback;
5882 
5883  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5884  }
5885 
5886 
5887  typedef struct
5888  {
5889  OrthancPluginFindAnswers *answers;
5890  const OrthancPluginFindQuery *query;
5891  const void *dicom;
5892  uint32_t size;
5893  uint32_t index;
5894  uint32_t *resultUint32;
5895  uint16_t *resultGroup;
5896  uint16_t *resultElement;
5897  char **resultString;
5898  } _OrthancPluginFindOperation;
5899 
5916  OrthancPluginContext* context,
5917  OrthancPluginFindAnswers* answers,
5918  const void* dicom,
5919  uint32_t size)
5920  {
5921  _OrthancPluginFindOperation params;
5922  memset(&params, 0, sizeof(params));
5923  params.answers = answers;
5924  params.dicom = dicom;
5925  params.size = size;
5926 
5927  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
5928  }
5929 
5930 
5945  OrthancPluginContext* context,
5946  OrthancPluginFindAnswers* answers)
5947  {
5948  _OrthancPluginFindOperation params;
5949  memset(&params, 0, sizeof(params));
5950  params.answers = answers;
5951 
5952  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
5953  }
5954 
5955 
5956 
5968  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
5969  OrthancPluginContext* context,
5970  const OrthancPluginFindQuery* query)
5971  {
5972  uint32_t count = 0;
5973 
5974  _OrthancPluginFindOperation params;
5975  memset(&params, 0, sizeof(params));
5976  params.query = query;
5977  params.resultUint32 = &count;
5978 
5979  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
5980  {
5981  /* Error */
5982  return 0;
5983  }
5984  else
5985  {
5986  return count;
5987  }
5988  }
5989 
5990 
6006  OrthancPluginContext* context,
6007  uint16_t* group,
6008  uint16_t* element,
6009  const OrthancPluginFindQuery* query,
6010  uint32_t index)
6011  {
6012  _OrthancPluginFindOperation params;
6013  memset(&params, 0, sizeof(params));
6014  params.query = query;
6015  params.index = index;
6016  params.resultGroup = group;
6017  params.resultElement = element;
6018 
6019  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
6020  }
6021 
6022 
6036  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
6037  OrthancPluginContext* context,
6038  const OrthancPluginFindQuery* query,
6039  uint32_t index)
6040  {
6041  char* result;
6042 
6043  _OrthancPluginFindOperation params;
6044  memset(&params, 0, sizeof(params));
6045  params.query = query;
6046  params.index = index;
6047  params.resultString = &result;
6048 
6049  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
6050  {
6051  /* Error */
6052  return NULL;
6053  }
6054  else
6055  {
6056  return result;
6057  }
6058  }
6059 
6060 
6074  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
6075  OrthancPluginContext* context,
6076  const OrthancPluginFindQuery* query,
6077  uint32_t index)
6078  {
6079  char* result;
6080 
6081  _OrthancPluginFindOperation params;
6082  memset(&params, 0, sizeof(params));
6083  params.query = query;
6084  params.index = index;
6085  params.resultString = &result;
6086 
6087  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
6088  {
6089  /* Error */
6090  return NULL;
6091  }
6092  else
6093  {
6094  return result;
6095  }
6096  }
6097 
6098 
6099 
6100 
6101  typedef struct
6102  {
6103  OrthancPluginMoveCallback callback;
6104  OrthancPluginGetMoveSize getMoveSize;
6105  OrthancPluginApplyMove applyMove;
6106  OrthancPluginFreeMove freeMove;
6107  } _OrthancPluginMoveCallback;
6108 
6123  OrthancPluginContext* context,
6124  OrthancPluginMoveCallback callback,
6125  OrthancPluginGetMoveSize getMoveSize,
6126  OrthancPluginApplyMove applyMove,
6127  OrthancPluginFreeMove freeMove)
6128  {
6129  _OrthancPluginMoveCallback params;
6130  params.callback = callback;
6131  params.getMoveSize = getMoveSize;
6132  params.applyMove = applyMove;
6133  params.freeMove = freeMove;
6134 
6135  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
6136  }
6137 
6138 
6139 
6140  typedef struct
6141  {
6142  OrthancPluginFindMatcher** target;
6143  const void* query;
6144  uint32_t size;
6145  } _OrthancPluginCreateFindMatcher;
6146 
6147 
6162  OrthancPluginContext* context,
6163  const void* query,
6164  uint32_t size)
6165  {
6166  OrthancPluginFindMatcher* target = NULL;
6167 
6168  _OrthancPluginCreateFindMatcher params;
6169  memset(&params, 0, sizeof(params));
6170  params.target = &target;
6171  params.query = query;
6172  params.size = size;
6173 
6174  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
6175  {
6176  return NULL;
6177  }
6178  else
6179  {
6180  return target;
6181  }
6182  }
6183 
6184 
6185  typedef struct
6186  {
6187  OrthancPluginFindMatcher* matcher;
6188  } _OrthancPluginFreeFindMatcher;
6189 
6199  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6200  OrthancPluginContext* context,
6201  OrthancPluginFindMatcher* matcher)
6202  {
6203  _OrthancPluginFreeFindMatcher params;
6204  params.matcher = matcher;
6205 
6206  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6207  }
6208 
6209 
6210  typedef struct
6211  {
6212  const OrthancPluginFindMatcher* matcher;
6213  const void* dicom;
6214  uint32_t size;
6215  int32_t* isMatch;
6216  } _OrthancPluginFindMatcherIsMatch;
6217 
6232  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6233  OrthancPluginContext* context,
6234  const OrthancPluginFindMatcher* matcher,
6235  const void* dicom,
6236  uint32_t size)
6237  {
6238  int32_t isMatch = 0;
6239 
6240  _OrthancPluginFindMatcherIsMatch params;
6241  params.matcher = matcher;
6242  params.dicom = dicom;
6243  params.size = size;
6244  params.isMatch = &isMatch;
6245 
6246  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6247  {
6248  return isMatch;
6249  }
6250  else
6251  {
6252  /* Error: Assume non-match */
6253  return 0;
6254  }
6255  }
6256 
6257 
6258  typedef struct
6259  {
6261  } _OrthancPluginIncomingHttpRequestFilter2;
6262 
6275  OrthancPluginContext* context,
6277  {
6278  _OrthancPluginIncomingHttpRequestFilter2 params;
6279  params.callback = callback;
6280 
6281  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6282  }
6283 
6284 
6285 
6286  typedef struct
6287  {
6288  OrthancPluginPeers** peers;
6289  } _OrthancPluginGetPeers;
6290 
6303  OrthancPluginContext* context)
6304  {
6305  OrthancPluginPeers* peers = NULL;
6306 
6307  _OrthancPluginGetPeers params;
6308  memset(&params, 0, sizeof(params));
6309  params.peers = &peers;
6310 
6311  if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6312  {
6313  return NULL;
6314  }
6315  else
6316  {
6317  return peers;
6318  }
6319  }
6320 
6321 
6322  typedef struct
6323  {
6324  OrthancPluginPeers* peers;
6325  } _OrthancPluginFreePeers;
6326 
6336  ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6337  OrthancPluginContext* context,
6338  OrthancPluginPeers* peers)
6339  {
6340  _OrthancPluginFreePeers params;
6341  params.peers = peers;
6342 
6343  context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6344  }
6345 
6346 
6347  typedef struct
6348  {
6349  uint32_t* target;
6350  const OrthancPluginPeers* peers;
6351  } _OrthancPluginGetPeersCount;
6352 
6366  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6367  OrthancPluginContext* context,
6368  const OrthancPluginPeers* peers)
6369  {
6370  uint32_t target = 0;
6371 
6372  _OrthancPluginGetPeersCount params;
6373  memset(&params, 0, sizeof(params));
6374  params.target = &target;
6375  params.peers = peers;
6376 
6377  if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6378  {
6379  /* Error */
6380  return 0;
6381  }
6382  else
6383  {
6384  return target;
6385  }
6386  }
6387 
6388 
6389  typedef struct
6390  {
6391  const char** target;
6392  const OrthancPluginPeers* peers;
6393  uint32_t peerIndex;
6394  const char* userProperty;
6395  } _OrthancPluginGetPeerProperty;
6396 
6414  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6415  OrthancPluginContext* context,
6416  const OrthancPluginPeers* peers,
6417  uint32_t peerIndex)
6418  {
6419  const char* target = NULL;
6420 
6421  _OrthancPluginGetPeerProperty params;
6422  memset(&params, 0, sizeof(params));
6423  params.target = &target;
6424  params.peers = peers;
6425  params.peerIndex = peerIndex;
6426  params.userProperty = NULL;
6427 
6428  if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6429  {
6430  /* Error */
6431  return NULL;
6432  }
6433  else
6434  {
6435  return target;
6436  }
6437  }
6438 
6439 
6455  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6456  OrthancPluginContext* context,
6457  const OrthancPluginPeers* peers,
6458  uint32_t peerIndex)
6459  {
6460  const char* target = NULL;
6461 
6462  _OrthancPluginGetPeerProperty params;
6463  memset(&params, 0, sizeof(params));
6464  params.target = &target;
6465  params.peers = peers;
6466  params.peerIndex = peerIndex;
6467  params.userProperty = NULL;
6468 
6469  if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6470  {
6471  /* Error */
6472  return NULL;
6473  }
6474  else
6475  {
6476  return target;
6477  }
6478  }
6479 
6480 
6481 
6501  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6502  OrthancPluginContext* context,
6503  const OrthancPluginPeers* peers,
6504  uint32_t peerIndex,
6505  const char* userProperty)
6506  {
6507  const char* target = NULL;
6508 
6509  _OrthancPluginGetPeerProperty params;
6510  memset(&params, 0, sizeof(params));
6511  params.target = &target;
6512  params.peers = peers;
6513  params.peerIndex = peerIndex;
6514  params.userProperty = userProperty;
6515 
6516  if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6517  {
6518  /* No such user property */
6519  return NULL;
6520  }
6521  else
6522  {
6523  return target;
6524  }
6525  }
6526 
6527 
6528 
6529  typedef struct
6530  {
6531  OrthancPluginMemoryBuffer* answerBody;
6532  OrthancPluginMemoryBuffer* answerHeaders;
6533  uint16_t* httpStatus;
6534  const OrthancPluginPeers* peers;
6535  uint32_t peerIndex;
6536  OrthancPluginHttpMethod method;
6537  const char* uri;
6538  uint32_t additionalHeadersCount;
6539  const char* const* additionalHeadersKeys;
6540  const char* const* additionalHeadersValues;
6541  const void* body;
6542  uint32_t bodySize;
6543  uint32_t timeout;
6544  } _OrthancPluginCallPeerApi;
6545 
6582  OrthancPluginContext* context,
6583  OrthancPluginMemoryBuffer* answerBody,
6584  OrthancPluginMemoryBuffer* answerHeaders,
6585  uint16_t* httpStatus,
6586  const OrthancPluginPeers* peers,
6587  uint32_t peerIndex,
6588  OrthancPluginHttpMethod method,
6589  const char* uri,
6590  uint32_t additionalHeadersCount,
6591  const char* const* additionalHeadersKeys,
6592  const char* const* additionalHeadersValues,
6593  const void* body,
6594  uint32_t bodySize,
6595  uint32_t timeout)
6596  {
6597  _OrthancPluginCallPeerApi params;
6598  memset(&params, 0, sizeof(params));
6599 
6600  params.answerBody = answerBody;
6601  params.answerHeaders = answerHeaders;
6602  params.httpStatus = httpStatus;
6603  params.peers = peers;
6604  params.peerIndex = peerIndex;
6605  params.method = method;
6606  params.uri = uri;
6607  params.additionalHeadersCount = additionalHeadersCount;
6608  params.additionalHeadersKeys = additionalHeadersKeys;
6609  params.additionalHeadersValues = additionalHeadersValues;
6610  params.body = body;
6611  params.bodySize = bodySize;
6612  params.timeout = timeout;
6613 
6614  return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6615  }
6616 
6617 
6618 
6619 
6620 
6621  typedef struct
6622  {
6623  OrthancPluginJob** target;
6624  void *job;
6625  OrthancPluginJobFinalize finalize;
6626  const char *type;
6627  OrthancPluginJobGetProgress getProgress;
6628  OrthancPluginJobGetContent getContent;
6629  OrthancPluginJobGetSerialized getSerialized;
6630  OrthancPluginJobStep step;
6631  OrthancPluginJobStop stop;
6632  OrthancPluginJobReset reset;
6633  } _OrthancPluginCreateJob;
6634 
6667  OrthancPluginContext *context,
6668  void *job,
6669  OrthancPluginJobFinalize finalize,
6670  const char *type,
6671  OrthancPluginJobGetProgress getProgress,
6672  OrthancPluginJobGetContent getContent,
6673  OrthancPluginJobGetSerialized getSerialized,
6674  OrthancPluginJobStep step,
6675  OrthancPluginJobStop stop,
6676  OrthancPluginJobReset reset)
6677  {
6678  OrthancPluginJob* target = NULL;
6679 
6680  _OrthancPluginCreateJob params;
6681  memset(&params, 0, sizeof(params));
6682 
6683  params.target = &target;
6684  params.job = job;
6685  params.finalize = finalize;
6686  params.type = type;
6687  params.getProgress = getProgress;
6688  params.getContent = getContent;
6689  params.getSerialized = getSerialized;
6690  params.step = step;
6691  params.stop = stop;
6692  params.reset = reset;
6693 
6694  if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6695  target == NULL)
6696  {
6697  /* Error */
6698  return NULL;
6699  }
6700  else
6701  {
6702  return target;
6703  }
6704  }
6705 
6706 
6707  typedef struct
6708  {
6709  OrthancPluginJob* job;
6710  } _OrthancPluginFreeJob;
6711 
6721  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6722  OrthancPluginContext* context,
6723  OrthancPluginJob* job)
6724  {
6725  _OrthancPluginFreeJob params;
6726  params.job = job;
6727 
6728  context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6729  }
6730 
6731 
6732 
6733  typedef struct
6734  {
6735  char** resultId;
6736  OrthancPluginJob *job;
6737  int priority;
6738  } _OrthancPluginSubmitJob;
6739 
6753  ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6754  OrthancPluginContext *context,
6755  OrthancPluginJob *job,
6756  int priority)
6757  {
6758  char* resultId = NULL;
6759 
6760  _OrthancPluginSubmitJob params;
6761  memset(&params, 0, sizeof(params));
6762 
6763  params.resultId = &resultId;
6764  params.job = job;
6765  params.priority = priority;
6766 
6767  if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6768  resultId == NULL)
6769  {
6770  /* Error */
6771  return NULL;
6772  }
6773  else
6774  {
6775  return resultId;
6776  }
6777  }
6778 
6779 
6780 
6781  typedef struct
6782  {
6783  OrthancPluginJobsUnserializer unserializer;
6784  } _OrthancPluginJobsUnserializer;
6785 
6798  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6799  OrthancPluginContext* context,
6800  OrthancPluginJobsUnserializer unserializer)
6801  {
6802  _OrthancPluginJobsUnserializer params;
6803  params.unserializer = unserializer;
6804 
6805  context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6806  }
6807 
6808 
6809 
6810  typedef struct
6811  {
6812  OrthancPluginRestOutput* output;
6813  const char* details;
6814  uint8_t log;
6815  } _OrthancPluginSetHttpErrorDetails;
6816 
6834  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
6835  OrthancPluginContext* context,
6836  OrthancPluginRestOutput* output,
6837  const char* details,
6838  uint8_t log)
6839  {
6840  _OrthancPluginSetHttpErrorDetails params;
6841  params.output = output;
6842  params.details = details;
6843  params.log = log;
6844  context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
6845  }
6846 
6847 
6848 
6849  typedef struct
6850  {
6851  const char** result;
6852  const char* argument;
6853  } _OrthancPluginRetrieveStaticString;
6854 
6866  ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
6867  OrthancPluginContext* context,
6868  const char* path)
6869  {
6870  const char* result = NULL;
6871 
6872  _OrthancPluginRetrieveStaticString params;
6873  params.result = &result;
6874  params.argument = path;
6875 
6876  if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
6877  {
6878  /* Error */
6879  return NULL;
6880  }
6881  else
6882  {
6883  return result;
6884  }
6885  }
6886 
6887 
6888 
6889  typedef struct
6890  {
6891  const char* name;
6892  float value;
6894  } _OrthancPluginSetMetricsValue;
6895 
6910  ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
6911  OrthancPluginContext* context,
6912  const char* name,
6913  float value,
6915  {
6916  _OrthancPluginSetMetricsValue params;
6917  params.name = name;
6918  params.value = value;
6919  params.type = type;
6920  context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
6921  }
6922 
6923 
6924 
6925  typedef struct
6926  {
6928  } _OrthancPluginRegisterRefreshMetricsCallback;
6929 
6941  OrthancPluginContext* context,
6943  {
6944  _OrthancPluginRegisterRefreshMetricsCallback params;
6945  params.callback = callback;
6946  context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
6947  }
6948 
6949 
6950 
6951 
6952  typedef struct
6953  {
6954  char** target;
6955  const void* dicom;
6956  uint32_t dicomSize;
6958  } _OrthancPluginEncodeDicomWeb;
6959 
6976  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
6977  OrthancPluginContext* context,
6978  const void* dicom,
6979  uint32_t dicomSize,
6981  {
6982  char* target = NULL;
6983 
6984  _OrthancPluginEncodeDicomWeb params;
6985  params.target = &target;
6986  params.dicom = dicom;
6987  params.dicomSize = dicomSize;
6988  params.callback = callback;
6989 
6990  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
6991  {
6992  /* Error */
6993  return NULL;
6994  }
6995  else
6996  {
6997  return target;
6998  }
6999  }
7000 
7001 
7018  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
7019  OrthancPluginContext* context,
7020  const void* dicom,
7021  uint32_t dicomSize,
7023  {
7024  char* target = NULL;
7025 
7026  _OrthancPluginEncodeDicomWeb params;
7027  params.target = &target;
7028  params.dicom = dicom;
7029  params.dicomSize = dicomSize;
7030  params.callback = callback;
7031 
7032  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
7033  {
7034  /* Error */
7035  return NULL;
7036  }
7037  else
7038  {
7039  return target;
7040  }
7041  }
7042 
7043 
7044 
7045  typedef struct
7046  {
7047  char** target;
7048  const void* dicom;
7049  uint32_t dicomSize;
7051  void* payload;
7052  } _OrthancPluginEncodeDicomWeb2;
7053 
7070  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson2(
7071  OrthancPluginContext* context,
7072  const void* dicom,
7073  uint32_t dicomSize,
7075  void* payload)
7076  {
7077  char* target = NULL;
7078 
7079  _OrthancPluginEncodeDicomWeb2 params;
7080  params.target = &target;
7081  params.dicom = dicom;
7082  params.dicomSize = dicomSize;
7083  params.callback = callback;
7084  params.payload = payload;
7085 
7086  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson2, &params) != OrthancPluginErrorCode_Success)
7087  {
7088  /* Error */
7089  return NULL;
7090  }
7091  else
7092  {
7093  return target;
7094  }
7095  }
7096 
7097 
7114  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml2(
7115  OrthancPluginContext* context,
7116  const void* dicom,
7117  uint32_t dicomSize,
7119  void* payload)
7120  {
7121  char* target = NULL;
7122 
7123  _OrthancPluginEncodeDicomWeb2 params;
7124  params.target = &target;
7125  params.dicom = dicom;
7126  params.dicomSize = dicomSize;
7127  params.callback = callback;
7128  params.payload = payload;
7129 
7130  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml2, &params) != OrthancPluginErrorCode_Success)
7131  {
7132  /* Error */
7133  return NULL;
7134  }
7135  else
7136  {
7137  return target;
7138  }
7139  }
7140 
7141 
7142 
7159  void* answer,
7160  const char* key,
7161  const char* value);
7162 
7163 
7180  void* answer,
7181  const void* data,
7182  uint32_t size);
7183 
7184 
7199  typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
7200 
7201 
7217 
7218 
7232  typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
7233 
7234 
7248  typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
7249 
7250 
7251  typedef struct
7252  {
7253  void* answer;
7256  uint16_t* httpStatus;
7257  OrthancPluginHttpMethod method;
7258  const char* url;
7259  uint32_t headersCount;
7260  const char* const* headersKeys;
7261  const char* const* headersValues;
7262  void* request;
7267  const char* username;
7268  const char* password;
7269  uint32_t timeout;
7270  const char* certificateFile;
7271  const char* certificateKeyFile;
7272  const char* certificateKeyPassword;
7273  uint8_t pkcs11;
7274  } _OrthancPluginChunkedHttpClient;
7275 
7276 
7328  OrthancPluginContext* context,
7329  void* answer,
7332  uint16_t* httpStatus,
7333  OrthancPluginHttpMethod method,
7334  const char* url,
7335  uint32_t headersCount,
7336  const char* const* headersKeys,
7337  const char* const* headersValues,
7338  void* request,
7343  const char* username,
7344  const char* password,
7345  uint32_t timeout,
7346  const char* certificateFile,
7347  const char* certificateKeyFile,
7348  const char* certificateKeyPassword,
7349  uint8_t pkcs11)
7350  {
7351  _OrthancPluginChunkedHttpClient params;
7352  memset(&params, 0, sizeof(params));
7353 
7354  /* In common with OrthancPluginHttpClient() */
7355  params.httpStatus = httpStatus;
7356  params.method = method;
7357  params.url = url;
7358  params.headersCount = headersCount;
7359  params.headersKeys = headersKeys;
7360  params.headersValues = headersValues;
7361  params.username = username;
7362  params.password = password;
7363  params.timeout = timeout;
7364  params.certificateFile = certificateFile;
7365  params.certificateKeyFile = certificateKeyFile;
7366  params.certificateKeyPassword = certificateKeyPassword;
7367  params.pkcs11 = pkcs11;
7368 
7369  /* For chunked body/answer */
7370  params.answer = answer;
7371  params.answerAddChunk = answerAddChunk;
7372  params.answerAddHeader = answerAddHeader;
7373  params.request = request;
7374  params.requestIsDone = requestIsDone;
7375  params.requestChunkData = requestChunkData;
7376  params.requestChunkSize = requestChunkSize;
7377  params.requestNext = requestNext;
7378 
7379  return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7380  }
7381 
7382 
7383 
7388  typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7389 
7390 
7391 
7409  const char* url,
7410  const OrthancPluginHttpRequest* request);
7411 
7412 
7428  const void* data,
7429  uint32_t size);
7430 
7431 
7448  OrthancPluginRestOutput* output);
7449 
7450 
7466 
7467  typedef struct
7468  {
7469  const char* pathRegularExpression;
7470  OrthancPluginRestCallback getHandler;
7472  OrthancPluginRestCallback deleteHandler;
7477  } _OrthancPluginChunkedRestCallback;
7478 
7479 
7509  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterChunkedRestCallback(
7510  OrthancPluginContext* context,
7511  const char* pathRegularExpression,
7512  OrthancPluginRestCallback getHandler,
7514  OrthancPluginRestCallback deleteHandler,
7519  {
7520  _OrthancPluginChunkedRestCallback params;
7521  params.pathRegularExpression = pathRegularExpression;
7522  params.getHandler = getHandler;
7523  params.postHandler = postHandler;
7524  params.deleteHandler = deleteHandler;
7525  params.putHandler = putHandler;
7526  params.addChunk = addChunk;
7527  params.execute = execute;
7528  params.finalize = finalize;
7529 
7530  context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
7531  }
7532 
7533 
7534 
7535 
7536 
7537  typedef struct
7538  {
7539  char** result;
7540  uint16_t group;
7541  uint16_t element;
7542  const char* privateCreator;
7543  } _OrthancPluginGetTagName;
7544 
7560  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
7561  OrthancPluginContext* context,
7562  uint16_t group,
7563  uint16_t element,
7564  const char* privateCreator)
7565  {
7566  char* result;
7567 
7568  _OrthancPluginGetTagName params;
7569  params.result = &result;
7570  params.group = group;
7571  params.element = element;
7572  params.privateCreator = privateCreator;
7573 
7574  if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
7575  {
7576  /* Error */
7577  return NULL;
7578  }
7579  else
7580  {
7581  return result;
7582  }
7583  }
7584 
7585 
7586 
7616  void** handler /* out */,
7617  const char* jobId,
7618  const char* transactionUid,
7619  const char* const* sopClassUids,
7620  const char* const* sopInstanceUids,
7621  uint32_t countInstances,
7622  const char* remoteAet,
7623  const char* calledAet);
7624 
7625 
7637  typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
7638 
7639 
7660  void* handler,
7661  const char* sopClassUid,
7662  const char* sopInstanceUid);
7663 
7664 
7665  typedef struct
7666  {
7670  } _OrthancPluginRegisterStorageCommitmentScpCallback;
7671 
7686  OrthancPluginContext* context,
7690  {
7691  _OrthancPluginRegisterStorageCommitmentScpCallback params;
7692  params.factory = factory;
7693  params.destructor = destructor;
7694  params.lookup = lookup;
7695  return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
7696  }
7697 
7698 
7699 
7716  const OrthancPluginDicomInstance* instance);
7717 
7718 
7719  typedef struct
7720  {
7722  } _OrthancPluginIncomingDicomInstanceFilter;
7723 
7747  OrthancPluginContext* context,
7749  {
7750  _OrthancPluginIncomingDicomInstanceFilter params;
7751  params.callback = callback;
7752 
7753  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, &params);
7754  }
7755 
7756 
7770  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceTransferSyntaxUid(
7771  OrthancPluginContext* context,
7772  const OrthancPluginDicomInstance* instance)
7773  {
7774  char* result;
7775 
7776  _OrthancPluginAccessDicomInstance params;
7777  memset(&params, 0, sizeof(params));
7778  params.resultStringToFree = &result;
7779  params.instance = instance;
7780 
7781  if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, &params) != OrthancPluginErrorCode_Success)
7782  {
7783  /* Error */
7784  return NULL;
7785  }
7786  else
7787  {
7788  return result;
7789  }
7790  }
7791 
7792 
7805  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData(
7806  OrthancPluginContext* context,
7807  const OrthancPluginDicomInstance* instance)
7808  {
7809  int64_t hasPixelData;
7810 
7811  _OrthancPluginAccessDicomInstance params;
7812  memset(&params, 0, sizeof(params));
7813  params.resultInt64 = &hasPixelData;
7814  params.instance = instance;
7815 
7816  if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, &params) != OrthancPluginErrorCode_Success ||
7817  hasPixelData < 0 ||
7818  hasPixelData > 1)
7819  {
7820  /* Error */
7821  return -1;
7822  }
7823  else
7824  {
7825  return (hasPixelData != 0);
7826  }
7827  }
7828 
7829 
7830 
7831 
7832 
7833 
7834  typedef struct
7835  {
7836  OrthancPluginDicomInstance** target;
7837  const void* buffer;
7838  uint32_t size;
7839  const char* transferSyntax;
7840  } _OrthancPluginCreateDicomInstance;
7841 
7856  OrthancPluginContext* context,
7857  const void* buffer,
7858  uint32_t size)
7859  {
7860  OrthancPluginDicomInstance* target = NULL;
7861 
7862  _OrthancPluginCreateDicomInstance params;
7863  params.target = &target;
7864  params.buffer = buffer;
7865  params.size = size;
7866 
7867  if (context->InvokeService(context, _OrthancPluginService_CreateDicomInstance, &params) != OrthancPluginErrorCode_Success)
7868  {
7869  /* Error */
7870  return NULL;
7871  }
7872  else
7873  {
7874  return target;
7875  }
7876  }
7877 
7878  typedef struct
7879  {
7881  } _OrthancPluginFreeDicomInstance;
7882 
7893  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeDicomInstance(
7894  OrthancPluginContext* context,
7896  {
7897  _OrthancPluginFreeDicomInstance params;
7898  params.dicom = dicom;
7899 
7900  context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, &params);
7901  }
7902 
7903 
7904  typedef struct
7905  {
7906  uint32_t* targetUint32;
7907  OrthancPluginMemoryBuffer* targetBuffer;
7908  OrthancPluginImage** targetImage;
7909  char** targetStringToFree;
7910  const OrthancPluginDicomInstance* instance;
7911  uint32_t frameIndex;
7914  uint32_t maxStringLength;
7915  OrthancPluginDicomWebBinaryCallback2 dicomWebCallback;
7916  void* dicomWebPayload;
7917  } _OrthancPluginAccessDicomInstance2;
7918 
7930  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetInstanceFramesCount(
7931  OrthancPluginContext* context,
7932  const OrthancPluginDicomInstance* instance)
7933  {
7934  uint32_t count;
7935 
7936  _OrthancPluginAccessDicomInstance2 params;
7937  memset(&params, 0, sizeof(params));
7938  params.targetUint32 = &count;
7939  params.instance = instance;
7940 
7941  if (context->InvokeService(context, _OrthancPluginService_GetInstanceFramesCount, &params) != OrthancPluginErrorCode_Success)
7942  {
7943  /* Error */
7944  return 0;
7945  }
7946  else
7947  {
7948  return count;
7949  }
7950  }
7951 
7952 
7971  OrthancPluginContext* context,
7972  OrthancPluginMemoryBuffer* target,
7973  const OrthancPluginDicomInstance* instance,
7974  uint32_t frameIndex)
7975  {
7976  _OrthancPluginAccessDicomInstance2 params;
7977  memset(&params, 0, sizeof(params));
7978  params.targetBuffer = target;
7979  params.instance = instance;
7980  params.frameIndex = frameIndex;
7981 
7982  return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, &params);
7983  }
7984 
7985 
7999  OrthancPluginContext* context,
8000  const OrthancPluginDicomInstance* instance,
8001  uint32_t frameIndex)
8002  {
8003  OrthancPluginImage* target = NULL;
8004 
8005  _OrthancPluginAccessDicomInstance2 params;
8006  memset(&params, 0, sizeof(params));
8007  params.targetImage = &target;
8008  params.instance = instance;
8009  params.frameIndex = frameIndex;
8010 
8011  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDecodedFrame, &params) != OrthancPluginErrorCode_Success)
8012  {
8013  return NULL;
8014  }
8015  else
8016  {
8017  return target;
8018  }
8019  }
8020 
8021 
8038  OrthancPluginContext* context,
8039  const void* buffer,
8040  uint32_t size,
8041  const char* transferSyntax)
8042  {
8043  OrthancPluginDicomInstance* target = NULL;
8044 
8045  _OrthancPluginCreateDicomInstance params;
8046  params.target = &target;
8047  params.buffer = buffer;
8048  params.size = size;
8049  params.transferSyntax = transferSyntax;
8050 
8051  if (context->InvokeService(context, _OrthancPluginService_TranscodeDicomInstance, &params) != OrthancPluginErrorCode_Success)
8052  {
8053  /* Error */
8054  return NULL;
8055  }
8056  else
8057  {
8058  return target;
8059  }
8060  }
8061 
8076  OrthancPluginContext* context,
8077  OrthancPluginMemoryBuffer* target,
8078  const OrthancPluginDicomInstance* instance)
8079  {
8080  _OrthancPluginAccessDicomInstance2 params;
8081  memset(&params, 0, sizeof(params));
8082  params.targetBuffer = target;
8083  params.instance = instance;
8084 
8085  return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, &params);
8086  }
8087 
8088 
8107  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceAdvancedJson(
8108  OrthancPluginContext* context,
8109  const OrthancPluginDicomInstance* instance,
8112  uint32_t maxStringLength)
8113  {
8114  char* result = NULL;
8115 
8116  _OrthancPluginAccessDicomInstance2 params;
8117  memset(&params, 0, sizeof(params));
8118  params.targetStringToFree = &result;
8119  params.instance = instance;
8120  params.format = format;
8121  params.flags = flags;
8122  params.maxStringLength = maxStringLength;
8123 
8124  if (context->InvokeService(context, _OrthancPluginService_GetInstanceAdvancedJson, &params) != OrthancPluginErrorCode_Success)
8125  {
8126  /* Error */
8127  return NULL;
8128  }
8129  else
8130  {
8131  return result;
8132  }
8133  }
8134 
8135 
8150  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebJson(
8151  OrthancPluginContext* context,
8152  const OrthancPluginDicomInstance* instance,
8154  void* payload)
8155  {
8156  char* target = NULL;
8157 
8158  _OrthancPluginAccessDicomInstance2 params;
8159  params.targetStringToFree = &target;
8160  params.instance = instance;
8161  params.dicomWebCallback = callback;
8162  params.dicomWebPayload = payload;
8163 
8164  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebJson, &params) != OrthancPluginErrorCode_Success)
8165  {
8166  /* Error */
8167  return NULL;
8168  }
8169  else
8170  {
8171  return target;
8172  }
8173  }
8174 
8175 
8190  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebXml(
8191  OrthancPluginContext* context,
8192  const OrthancPluginDicomInstance* instance,
8194  void* payload)
8195  {
8196  char* target = NULL;
8197 
8198  _OrthancPluginAccessDicomInstance2 params;
8199  params.targetStringToFree = &target;
8200  params.instance = instance;
8201  params.dicomWebCallback = callback;
8202  params.dicomWebPayload = payload;
8203 
8204  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebXml, &params) != OrthancPluginErrorCode_Success)
8205  {
8206  /* Error */
8207  return NULL;
8208  }
8209  else
8210  {
8211  return target;
8212  }
8213  }
8214 
8215 
8216 
8236  OrthancPluginMemoryBuffer* transcoded /* out */,
8237  const void* buffer,
8238  uint64_t size,
8239  const char* const* allowedSyntaxes,
8240  uint32_t countSyntaxes,
8241  uint8_t allowNewSopInstanceUid);
8242 
8243 
8244  typedef struct
8245  {
8247  } _OrthancPluginTranscoderCallback;
8248 
8263  OrthancPluginContext* context,
8265  {
8266  _OrthancPluginTranscoderCallback params;
8267  params.callback = callback;
8268 
8269  return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, &params);
8270  }
8271 
8272 
8273 
8274  typedef struct
8275  {
8276  OrthancPluginMemoryBuffer* target;
8277  uint32_t size;
8278  } _OrthancPluginCreateMemoryBuffer;
8279 
8298  OrthancPluginContext* context,
8299  OrthancPluginMemoryBuffer* target,
8300  uint32_t size)
8301  {
8302  _OrthancPluginCreateMemoryBuffer params;
8303  params.target = target;
8304  params.size = size;
8305 
8306  return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, &params);
8307  }
8308 
8309 
8336  OrthancPluginContext* context)
8337  {
8338  char* result;
8339 
8340  _OrthancPluginRetrieveDynamicString params;
8341  params.result = &result;
8342  params.argument = NULL;
8343 
8344  if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
8345  &params) != OrthancPluginErrorCode_Success)
8346  {
8347  /* Error */
8348  return NULL;
8349  }
8350  else
8351  {
8352  return result;
8353  }
8354  }
8355 
8356 
8357 
8358  typedef struct
8359  {
8361  uint64_t size;
8362  } _OrthancPluginCreateMemoryBuffer64;
8363 
8382  OrthancPluginContext* context,
8384  uint64_t size)
8385  {
8386  _OrthancPluginCreateMemoryBuffer64 params;
8387  params.target = target;
8388  params.size = size;
8389 
8390  return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer64, &params);
8391  }
8392 
8393 
8394  typedef struct
8395  {
8400  } _OrthancPluginRegisterStorageArea2;
8401 
8418  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea2(
8419  OrthancPluginContext* context,
8424  {
8425  _OrthancPluginRegisterStorageArea2 params;
8426  params.create = create;
8427  params.readWhole = readWhole;
8428  params.readRange = readRange;
8429  params.remove = remove;
8430  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea2, &params);
8431  }
8432 
8433 
8434 
8435  typedef struct
8436  {
8437  _OrthancPluginCreateDicom createDicom;
8438  const char* privateCreator;
8439  } _OrthancPluginCreateDicom2;
8440 
8466  OrthancPluginContext* context,
8467  OrthancPluginMemoryBuffer* target,
8468  const char* json,
8469  const OrthancPluginImage* pixelData,
8471  const char* privateCreator)
8472  {
8473  _OrthancPluginCreateDicom2 params;
8474  params.createDicom.target = target;
8475  params.createDicom.json = json;
8476  params.createDicom.pixelData = pixelData;
8477  params.createDicom.flags = flags;
8478  params.privateCreator = privateCreator;
8479 
8480  return context->InvokeService(context, _OrthancPluginService_CreateDicom2, &params);
8481  }
8482 
8483 #ifdef __cplusplus
8484 }
8485 #endif
8486 
8487 
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:1809
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:3146
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:2111
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:1197
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5372
OrthancPluginChangeType
Definition: OrthancCPlugin.h:717
OrthancPluginErrorCode(* OrthancPluginStorageReadWhole)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type)
Callback for reading a whole file from the storage area.
Definition: OrthancCPlugin.h:1263
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1914
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:1175
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:6940
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:1690
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4730
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:8235
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6274
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1243
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:2033
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3534
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3289
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:8418
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1143
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1662
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition: OrthancCPlugin.h:8262
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:1154
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4922
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1304
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1216
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:1728
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:1164
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1644
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6798
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1187
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:2073
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4691
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:1286
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:7509
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition: OrthancCPlugin.h:7746
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5708
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:4647
@ OrthancPluginChangeType_OrthancStopped
Definition: OrthancCPlugin.h:729
@ OrthancPluginChangeType_OrthancStarted
Definition: OrthancCPlugin.h:728
@ OrthancPluginChangeType_Deleted
Definition: OrthancCPlugin.h:719
@ OrthancPluginChangeType_JobFailure
Definition: OrthancCPlugin.h:736
@ OrthancPluginChangeType_NewInstance
Definition: OrthancCPlugin.h:721
@ OrthancPluginChangeType_NewPatient
Definition: OrthancCPlugin.h:722
@ OrthancPluginChangeType_JobSubmitted
Definition: OrthancCPlugin.h:734
@ OrthancPluginChangeType_NewSeries
Definition: OrthancCPlugin.h:723
@ OrthancPluginChangeType_StablePatient
Definition: OrthancCPlugin.h:725
@ OrthancPluginChangeType_UpdatedPeers
Definition: OrthancCPlugin.h:732
@ OrthancPluginChangeType_StableStudy
Definition: OrthancCPlugin.h:727
@ OrthancPluginChangeType_CompletedSeries
Definition: OrthancCPlugin.h:718
@ OrthancPluginChangeType_NewChildInstance
Definition: OrthancCPlugin.h:720
@ OrthancPluginChangeType_UpdatedAttachment
Definition: OrthancCPlugin.h:730
@ OrthancPluginChangeType_UpdatedMetadata
Definition: OrthancCPlugin.h:731
@ OrthancPluginChangeType_StableSeries
Definition: OrthancCPlugin.h:726
@ OrthancPluginChangeType_UpdatedModalities
Definition: OrthancCPlugin.h:733
@ OrthancPluginChangeType_JobSuccess
Definition: OrthancCPlugin.h:735
@ OrthancPluginChangeType_NewStudy
Definition: OrthancCPlugin.h:724
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5968
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1094
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1499
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:5944
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:6036
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7637
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:1323
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:6122
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:7615
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5876
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5254
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:7658
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:5215
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5915
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:1459
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:7685
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1102
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1086
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1416
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1484
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:5111
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5177
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:6074
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:6005
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1513
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1078
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:5147
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:7805
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:8190
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition: OrthancCPlugin.h:1054
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition: OrthancCPlugin.h:7770
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:7970
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:8107
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2943
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition: OrthancCPlugin.h:7855
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition: OrthancCPlugin.h:7930
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:7998
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5280
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2910
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:8150
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:3017
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2979
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:3056
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:3097
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition: OrthancCPlugin.h:7893
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition: OrthancCPlugin.h:8075
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition: OrthancCPlugin.h:8037
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2877
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:594
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:4593
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:4177
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3968
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4433
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3867
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4468
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:3933
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:4087
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:4132
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5410
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:4045
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4508
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:4002
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:5453
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:762
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:1070
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:747
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3900
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:3679
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5499
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4540
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1062
@ OrthancPluginPixelFormat_RGBA32
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:633
@ OrthancPluginPixelFormat_RGB48
Color image in RGB48 format.
Definition: OrthancCPlugin.h:643
@ OrthancPluginPixelFormat_Grayscale8
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:601
@ OrthancPluginPixelFormat_SignedGrayscale16
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:617
@ OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:659
@ OrthancPluginPixelFormat_RGB24
Color image in RGB24 format.
Definition: OrthancCPlugin.h:625
@ OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:667
@ OrthancPluginPixelFormat_Unknown
Definition: OrthancCPlugin.h:635
@ OrthancPluginPixelFormat_Grayscale64
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:675
@ OrthancPluginPixelFormat_Grayscale32
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:651
@ OrthancPluginPixelFormat_Grayscale16
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:609
@ OrthancPluginImageFormat_Png
Definition: OrthancCPlugin.h:763
@ OrthancPluginImageFormat_Jpeg
Definition: OrthancCPlugin.h:764
@ OrthancPluginImageFormat_Dicom
Definition: OrthancCPlugin.h:765
@ OrthancPluginCompressionType_Gzip
Definition: OrthancCPlugin.h:750
@ OrthancPluginCompressionType_ZlibWithSize
Definition: OrthancCPlugin.h:749
@ OrthancPluginCompressionType_Zlib
Definition: OrthancCPlugin.h:748
@ OrthancPluginCompressionType_GzipWithSize
Definition: OrthancCPlugin.h:751
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:2341
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:2376
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:2489
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2590
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3437
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3398
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:2453
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2660
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2625
char * OrthancPluginGenerateRestApiAuthorizationToken(OrthancPluginContext *context)
Generate a token to grant full access to the REST API of Orthanc.
Definition: OrthancCPlugin.h:8335
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2274
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2695
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:2304
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2555
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2405
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2428
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:5073
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2241
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:2200
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2763
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:6834
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2786
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:2143
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2740
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2841
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2816
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2523
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:4224
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:3637
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:5670
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3608
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:3831
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1611
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderExecute)(OrthancPluginServerChunkedRequestReader *reader, OrthancPluginRestOutput *output)
Callback invoked whenever the request body is entirely received.
Definition: OrthancCPlugin.h:7446
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:5782
struct _OrthancPluginJob_t OrthancPluginJob
Opaque structure to a job to be executed by Orthanc.
Definition: OrthancCPlugin.h:1126
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:8465
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:1997
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderFactory)(OrthancPluginServerChunkedRequestReader **reader, const char *url, const OrthancPluginHttpRequest *request)
Callback to create a reader to handle incoming chunked HTTP transfers.
Definition: OrthancCPlugin.h:7407
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:6199
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6336
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int priority)
Submit a new job to the jobs engine of Orthanc.
Definition: OrthancCPlugin.h:6753
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:4878
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:864
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:4825
OrthancPluginResourceType
Definition: OrthancCPlugin.h:700
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3747
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3468
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:198
struct _OrthancPluginPeers_t OrthancPluginPeers
Opaque structure to the set of remote Orthanc Peers that are known to the local Orthanc server.
Definition: OrthancCPlugin.h:1118
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:4315
uint32_t(* OrthancPluginChunkedClientRequestGetChunkSize)(void *request)
Callback to read the size of the current request chunk during a chunked transfer.
Definition: OrthancCPlugin.h:7248
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4769
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, uint32_t size)
Create a 32-bit memory buffer.
Definition: OrthancCPlugin.h:8297
OrthancPluginDicomWebBinaryMode
Definition: OrthancCPlugin.h:953
char * OrthancPluginEncodeDicomWebJson2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7070
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition: OrthancCPlugin.h:7715
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1572
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:5015
OrthancPluginErrorCode(* OrthancPluginChunkedClientRequestNext)(void *request)
Callback to advance in the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7216
struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode
Opaque structure that represents a node in a JSON or XML document used in DICOMweb.
Definition: OrthancCPlugin.h:1135
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1539
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:830
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:910
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:849
void(* OrthancPluginServerChunkedRequestReaderFinalize)(OrthancPluginServerChunkedRequestReader *reader)
Callback invoked to release the resources associated with an incoming HTTP chunked transfer.
Definition: OrthancCPlugin.h:7464
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:6232
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:3364
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:1981
OrthancPluginConstraintType
Definition: OrthancCPlugin.h:879
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3716
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1587
void OrthancPluginSetMetricsValue(OrthancPluginContext *context, const char *name, float value, OrthancPluginMetricsType type)
Set the value of a metrics.
Definition: OrthancCPlugin.h:6910
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:7426
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:7327
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:1046
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:6866
void OrthancPluginFreeMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1949
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:4357
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6414
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3502
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3778
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:5336
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:1389
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5837
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6721
OrthancPluginStorageCommitmentFailureReason
Definition: OrthancCPlugin.h:966
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:7179
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6455
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6302
OrthancPluginMetricsType
Definition: OrthancCPlugin.h:936
char * OrthancPluginEncodeDicomWebXml2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7114
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7018
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4395
uint8_t(* OrthancPluginChunkedClientRequestIsDone)(void *request)
Callback to know whether the request body is entirely read during a chunked transfer.
Definition: OrthancCPlugin.h:7199
char * OrthancPluginGetTagName(OrthancPluginContext *context, uint16_t group, uint16_t element, const char *privateCreator)
Returns the symbolic name of a DICOM tag.
Definition: OrthancCPlugin.h:7560
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5545
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:4966
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1933
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *target, uint64_t size)
Create a 64-bit memory buffer.
Definition: OrthancCPlugin.h:8381
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:7158
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6366
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition: OrthancCPlugin.h:7388
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:776
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:3243
const void *(* OrthancPluginChunkedClientRequestGetChunkData)(void *request)
Callback to read the current chunk of the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7232
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:4277
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:924
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:3208
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:6161
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:815
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:1965
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:320
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3567
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:1354
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:3320
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:6666
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:6581
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:1110
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:6501
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5627
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5581
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:894
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1526
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1779
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1554
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:6976
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:3178
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1628
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginContentType
Definition: OrthancCPlugin.h:686
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:3342
@ OrthancPluginIdentifierConstraint_Wildcard
Definition: OrthancCPlugin.h:868
@ OrthancPluginIdentifierConstraint_Equal
Definition: OrthancCPlugin.h:865
@ OrthancPluginIdentifierConstraint_SmallerOrEqual
Definition: OrthancCPlugin.h:866
@ OrthancPluginIdentifierConstraint_GreaterOrEqual
Definition: OrthancCPlugin.h:867
@ OrthancPluginResourceType_Instance
Definition: OrthancCPlugin.h:704
@ OrthancPluginResourceType_None
Definition: OrthancCPlugin.h:705
@ OrthancPluginResourceType_Series
Definition: OrthancCPlugin.h:703
@ OrthancPluginResourceType_Study
Definition: OrthancCPlugin.h:702
@ OrthancPluginResourceType_Patient
Definition: OrthancCPlugin.h:701
@ OrthancPluginErrorCode_CreateDicomBadParent
Definition: OrthancCPlugin.h:282
@ OrthancPluginErrorCode_SQLiteFlush
Definition: OrthancCPlugin.h:250
@ OrthancPluginErrorCode_IncompatibleDatabaseVersion
Definition: OrthancCPlugin.h:218
@ OrthancPluginErrorCode_BadSequenceOfCalls
Definition: OrthancCPlugin.h:206
@ OrthancPluginErrorCode_SharedLibrary
Definition: OrthancCPlugin.h:225
@ OrthancPluginErrorCode_NullPointer
Definition: OrthancCPlugin.h:235
@ OrthancPluginErrorCode_NotLuaPredicate
Definition: OrthancCPlugin.h:292
@ OrthancPluginErrorCode_LuaAlreadyExecuted
Definition: OrthancCPlugin.h:290
@ OrthancPluginErrorCode_NotAcceptable
Definition: OrthancCPlugin.h:234
@ OrthancPluginErrorCode_FullStorage
Definition: OrthancCPlugin.h:219
@ OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered
Definition: OrthancCPlugin.h:295
@ OrthancPluginErrorCode_InexistentFile
Definition: OrthancCPlugin.h:213
@ OrthancPluginErrorCode_CreateDicomParentEncoding
Definition: OrthancCPlugin.h:284
@ OrthancPluginErrorCode_CannotOrderSlices
Definition: OrthancCPlugin.h:298
@ OrthancPluginErrorCode_InternalError
Definition: OrthancCPlugin.h:199
@ OrthancPluginErrorCode_DiscontinuedAbi
Definition: OrthancCPlugin.h:240
@ OrthancPluginErrorCode_NoCFindHandler
Definition: OrthancCPlugin.h:268
@ OrthancPluginErrorCode_SQLiteCommitWithoutTransaction
Definition: OrthancCPlugin.h:248
@ OrthancPluginErrorCode_DatabasePlugin
Definition: OrthancCPlugin.h:231
@ OrthancPluginErrorCode_SQLiteStatementAlreadyUsed
Definition: OrthancCPlugin.h:245
@ OrthancPluginErrorCode_SQLiteCannotRun
Definition: OrthancCPlugin.h:251
@ OrthancPluginErrorCode_UnknownPluginService
Definition: OrthancCPlugin.h:226
@ OrthancPluginErrorCode_JsonToLuaTable
Definition: OrthancCPlugin.h:287
@ OrthancPluginErrorCode_CreateDicomOverrideTag
Definition: OrthancCPlugin.h:278
@ OrthancPluginErrorCode_SQLiteBindOutOfRange
Definition: OrthancCPlugin.h:253
@ OrthancPluginErrorCode_ParameterOutOfRange
Definition: OrthancCPlugin.h:203
@ OrthancPluginErrorCode_SQLiteRegisterFunction
Definition: OrthancCPlugin.h:249
@ OrthancPluginErrorCode_SQLiteTransactionBegin
Definition: OrthancCPlugin.h:257
@ OrthancPluginErrorCode_CreateDicomNoPayload
Definition: OrthancCPlugin.h:280
@ OrthancPluginErrorCode_Unauthorized
Definition: OrthancCPlugin.h:229
@ OrthancPluginErrorCode_RegularFileExpected
Definition: OrthancCPlugin.h:264
@ OrthancPluginErrorCode_DicomPortInUse
Definition: OrthancCPlugin.h:262
@ OrthancPluginErrorCode_BadApplicationEntityTitle
Definition: OrthancCPlugin.h:267
@ OrthancPluginErrorCode_NoCStoreHandler
Definition: OrthancCPlugin.h:270
@ OrthancPluginErrorCode_PathToExecutable
Definition: OrthancCPlugin.h:265
@ OrthancPluginErrorCode_NoSopClassOrInstance
Definition: OrthancCPlugin.h:272
@ OrthancPluginErrorCode_BadFont
Definition: OrthancCPlugin.h:230
@ OrthancPluginErrorCode_DatabaseUnavailable
Definition: OrthancCPlugin.h:236
@ OrthancPluginErrorCode_CannotCreateLua
Definition: OrthancCPlugin.h:288
@ OrthancPluginErrorCode_SQLiteExecute
Definition: OrthancCPlugin.h:246
@ OrthancPluginErrorCode_UriSyntax
Definition: OrthancCPlugin.h:212
@ OrthancPluginErrorCode_DirectoryOverFile
Definition: OrthancCPlugin.h:258
@ OrthancPluginErrorCode_InexistentTag
Definition: OrthancCPlugin.h:221
@ OrthancPluginErrorCode_IncompatibleImageFormat
Definition: OrthancCPlugin.h:223
@ OrthancPluginErrorCode_UnsupportedMediaType
Definition: OrthancCPlugin.h:303
@ OrthancPluginErrorCode_DicomFindUnavailable
Definition: OrthancCPlugin.h:274
@ OrthancPluginErrorCode_SQLiteCannotStep
Definition: OrthancCPlugin.h:252
@ OrthancPluginErrorCode_CreateDicomParentIsInstance
Definition: OrthancCPlugin.h:283
@ OrthancPluginErrorCode_StorageAreaAlreadyRegistered
Definition: OrthancCPlugin.h:294
@ OrthancPluginErrorCode_LuaReturnsNoString
Definition: OrthancCPlugin.h:293
@ OrthancPluginErrorCode_UnknownResource
Definition: OrthancCPlugin.h:217
@ OrthancPluginErrorCode_CreateDicomNotString
Definition: OrthancCPlugin.h:277
@ OrthancPluginErrorCode_HttpPortInUse
Definition: OrthancCPlugin.h:261
@ OrthancPluginErrorCode_SslDisabled
Definition: OrthancCPlugin.h:297
@ OrthancPluginErrorCode_UnknownModality
Definition: OrthancCPlugin.h:285
@ OrthancPluginErrorCode_BadHttpStatusInRest
Definition: OrthancCPlugin.h:263
@ OrthancPluginErrorCode_BadGeometry
Definition: OrthancCPlugin.h:238
@ OrthancPluginErrorCode_AlreadyExistingTag
Definition: OrthancCPlugin.h:300
@ OrthancPluginErrorCode_FileStorageCannotWrite
Definition: OrthancCPlugin.h:259
@ OrthancPluginErrorCode_CreateDicomUseDataUriScheme
Definition: OrthancCPlugin.h:281
@ OrthancPluginErrorCode_DirectoryExpected
Definition: OrthancCPlugin.h:260
@ OrthancPluginErrorCode_NoCMoveHandler
Definition: OrthancCPlugin.h:269
@ OrthancPluginErrorCode_SQLitePrepareStatement
Definition: OrthancCPlugin.h:254
@ OrthancPluginErrorCode_CorruptedFile
Definition: OrthancCPlugin.h:220
@ OrthancPluginErrorCode_StorageAreaPlugin
Definition: OrthancCPlugin.h:232
@ OrthancPluginErrorCode_BadJobOrdering
Definition: OrthancCPlugin.h:286
@ OrthancPluginErrorCode_CanceledJob
Definition: OrthancCPlugin.h:237
@ OrthancPluginErrorCode_BadRange
Definition: OrthancCPlugin.h:241
@ OrthancPluginErrorCode_NotImplemented
Definition: OrthancCPlugin.h:202
@ OrthancPluginErrorCode_SslInitialization
Definition: OrthancCPlugin.h:239
@ OrthancPluginErrorCode_IncompatibleImageSize
Definition: OrthancCPlugin.h:224
@ OrthancPluginErrorCode_BadFileFormat
Definition: OrthancCPlugin.h:215
@ OrthancPluginErrorCode_BadRequest
Definition: OrthancCPlugin.h:208
@ OrthancPluginErrorCode_SystemCommand
Definition: OrthancCPlugin.h:210
@ OrthancPluginErrorCode_NoStorageCommitmentHandler
Definition: OrthancCPlugin.h:301
@ OrthancPluginErrorCode_SQLiteAlreadyOpened
Definition: OrthancCPlugin.h:243
@ OrthancPluginErrorCode_Plugin
Definition: OrthancCPlugin.h:201
@ OrthancPluginErrorCode_CannotExecuteLua
Definition: OrthancCPlugin.h:289
@ OrthancPluginErrorCode_SQLiteRollbackWithoutTransaction
Definition: OrthancCPlugin.h:247
@ OrthancPluginErrorCode_UnknownDicomTag
Definition: OrthancCPlugin.h:227
@ OrthancPluginErrorCode_NoPresentationContext
Definition: OrthancCPlugin.h:273
@ OrthancPluginErrorCode_EmptyRequest
Definition: OrthancCPlugin.h:233
@ OrthancPluginErrorCode_DatabaseNotInitialized
Definition: OrthancCPlugin.h:296
@ OrthancPluginErrorCode_DicomMoveUnavailable
Definition: OrthancCPlugin.h:275
@ OrthancPluginErrorCode_SQLiteTransactionCommit
Definition: OrthancCPlugin.h:256
@ OrthancPluginErrorCode_BadJson
Definition: OrthancCPlugin.h:228
@ OrthancPluginErrorCode_Success
Definition: OrthancCPlugin.h:200
@ OrthancPluginErrorCode_NetworkProtocol
Definition: OrthancCPlugin.h:209
@ OrthancPluginErrorCode_NoApplicationEntityFilter
Definition: OrthancCPlugin.h:271
@ OrthancPluginErrorCode_InexistentItem
Definition: OrthancCPlugin.h:207
@ OrthancPluginErrorCode_Timeout
Definition: OrthancCPlugin.h:216
@ OrthancPluginErrorCode_LuaBadOutput
Definition: OrthancCPlugin.h:291
@ OrthancPluginErrorCode_SQLiteTransactionAlreadyStarted
Definition: OrthancCPlugin.h:255
@ OrthancPluginErrorCode_NoCGetHandler
Definition: OrthancCPlugin.h:302
@ OrthancPluginErrorCode_SQLiteNotOpened
Definition: OrthancCPlugin.h:242
@ OrthancPluginErrorCode_ReadOnly
Definition: OrthancCPlugin.h:222
@ OrthancPluginErrorCode_CannotStoreInstance
Definition: OrthancCPlugin.h:276
@ OrthancPluginErrorCode_CannotWriteFile
Definition: OrthancCPlugin.h:214
@ OrthancPluginErrorCode_BadParameterType
Definition: OrthancCPlugin.h:205
@ OrthancPluginErrorCode_NotEnoughMemory
Definition: OrthancCPlugin.h:204
@ OrthancPluginErrorCode_CreateDicomUseContent
Definition: OrthancCPlugin.h:279
@ OrthancPluginErrorCode_Database
Definition: OrthancCPlugin.h:211
@ OrthancPluginErrorCode_SQLiteCannotOpen
Definition: OrthancCPlugin.h:244
@ OrthancPluginErrorCode_MakeDirectory
Definition: OrthancCPlugin.h:266
@ OrthancPluginErrorCode_NoWorklistHandler
Definition: OrthancCPlugin.h:299
@ OrthancPluginDicomWebBinaryMode_InlineBinary
Definition: OrthancCPlugin.h:955
@ OrthancPluginDicomWebBinaryMode_BulkDataUri
Definition: OrthancCPlugin.h:956
@ OrthancPluginDicomWebBinaryMode_Ignore
Definition: OrthancCPlugin.h:954
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii
Definition: OrthancCPlugin.h:836
@ OrthancPluginDicomToJsonFlags_IncludeBinary
Definition: OrthancCPlugin.h:832
@ OrthancPluginDicomToJsonFlags_IncludePixelData
Definition: OrthancCPlugin.h:835
@ OrthancPluginDicomToJsonFlags_IncludeUnknownTags
Definition: OrthancCPlugin.h:834
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
Definition: OrthancCPlugin.h:837
@ OrthancPluginDicomToJsonFlags_IncludePrivateTags
Definition: OrthancCPlugin.h:833
@ OrthancPluginJobStepStatus_Continue
Definition: OrthancCPlugin.h:913
@ OrthancPluginJobStepStatus_Success
Definition: OrthancCPlugin.h:911
@ OrthancPluginJobStepStatus_Failure
Definition: OrthancCPlugin.h:912
@ OrthancPluginCreateDicomFlags_DecodeDataUriScheme
Definition: OrthancCPlugin.h:851
@ OrthancPluginCreateDicomFlags_GenerateIdentifiers
Definition: OrthancCPlugin.h:852
@ OrthancPluginConstraintType_SmallerOrEqual
Definition: OrthancCPlugin.h:881
@ OrthancPluginConstraintType_List
Definition: OrthancCPlugin.h:884
@ OrthancPluginConstraintType_GreaterOrEqual
Definition: OrthancCPlugin.h:882
@ OrthancPluginConstraintType_Equal
Definition: OrthancCPlugin.h:880
@ OrthancPluginConstraintType_Wildcard
Definition: OrthancCPlugin.h:883
@ OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
Definition: OrthancCPlugin.h:981
@ OrthancPluginStorageCommitmentFailureReason_Success
Definition: OrthancCPlugin.h:967
@ OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
Definition: OrthancCPlugin.h:990
@ OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
Definition: OrthancCPlugin.h:985
@ OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
Definition: OrthancCPlugin.h:977
@ OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
Definition: OrthancCPlugin.h:973
@ OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
Definition: OrthancCPlugin.h:970
@ OrthancPluginMetricsType_Default
Definition: OrthancCPlugin.h:937
@ OrthancPluginMetricsType_Timer
Definition: OrthancCPlugin.h:944
@ OrthancPluginValueRepresentation_PN
Definition: OrthancCPlugin.h:792
@ OrthancPluginValueRepresentation_UL
Definition: OrthancCPlugin.h:800
@ OrthancPluginValueRepresentation_UN
Definition: OrthancCPlugin.h:801
@ OrthancPluginValueRepresentation_DA
Definition: OrthancCPlugin.h:781
@ OrthancPluginValueRepresentation_OF
Definition: OrthancCPlugin.h:790
@ OrthancPluginValueRepresentation_OW
Definition: OrthancCPlugin.h:791
@ OrthancPluginValueRepresentation_CS
Definition: OrthancCPlugin.h:780
@ OrthancPluginValueRepresentation_US
Definition: OrthancCPlugin.h:802
@ OrthancPluginValueRepresentation_SH
Definition: OrthancCPlugin.h:793
@ OrthancPluginValueRepresentation_FL
Definition: OrthancCPlugin.h:785
@ OrthancPluginValueRepresentation_DT
Definition: OrthancCPlugin.h:783
@ OrthancPluginValueRepresentation_TM
Definition: OrthancCPlugin.h:798
@ OrthancPluginValueRepresentation_SQ
Definition: OrthancCPlugin.h:795
@ OrthancPluginValueRepresentation_DS
Definition: OrthancCPlugin.h:782
@ OrthancPluginValueRepresentation_OB
Definition: OrthancCPlugin.h:789
@ OrthancPluginValueRepresentation_SL
Definition: OrthancCPlugin.h:794
@ OrthancPluginValueRepresentation_ST
Definition: OrthancCPlugin.h:797
@ OrthancPluginValueRepresentation_IS
Definition: OrthancCPlugin.h:786
@ OrthancPluginValueRepresentation_LT
Definition: OrthancCPlugin.h:788
@ OrthancPluginValueRepresentation_SS
Definition: OrthancCPlugin.h:796
@ OrthancPluginValueRepresentation_UT
Definition: OrthancCPlugin.h:803
@ OrthancPluginValueRepresentation_LO
Definition: OrthancCPlugin.h:787
@ OrthancPluginValueRepresentation_AE
Definition: OrthancCPlugin.h:777
@ OrthancPluginValueRepresentation_FD
Definition: OrthancCPlugin.h:784
@ OrthancPluginValueRepresentation_UI
Definition: OrthancCPlugin.h:799
@ OrthancPluginValueRepresentation_AS
Definition: OrthancCPlugin.h:778
@ OrthancPluginValueRepresentation_AT
Definition: OrthancCPlugin.h:779
@ OrthancPluginJobStopReason_Failure
Definition: OrthancCPlugin.h:927
@ OrthancPluginJobStopReason_Success
Definition: OrthancCPlugin.h:925
@ OrthancPluginJobStopReason_Canceled
Definition: OrthancCPlugin.h:928
@ OrthancPluginJobStopReason_Paused
Definition: OrthancCPlugin.h:926
@ OrthancPluginDicomToJsonFormat_Full
Definition: OrthancCPlugin.h:816
@ OrthancPluginDicomToJsonFormat_Human
Definition: OrthancCPlugin.h:818
@ OrthancPluginDicomToJsonFormat_Short
Definition: OrthancCPlugin.h:817
@ OrthancPluginHttpMethod_Delete
Definition: OrthancCPlugin.h:324
@ OrthancPluginHttpMethod_Post
Definition: OrthancCPlugin.h:322
@ OrthancPluginHttpMethod_Put
Definition: OrthancCPlugin.h:323
@ OrthancPluginHttpMethod_Get
Definition: OrthancCPlugin.h:321
@ OrthancPluginInstanceOrigin_Unknown
Definition: OrthancCPlugin.h:895
@ OrthancPluginInstanceOrigin_RestApi
Definition: OrthancCPlugin.h:897
@ OrthancPluginInstanceOrigin_Lua
Definition: OrthancCPlugin.h:899
@ OrthancPluginInstanceOrigin_WebDav
Definition: OrthancCPlugin.h:900
@ OrthancPluginInstanceOrigin_DicomProtocol
Definition: OrthancCPlugin.h:896
@ OrthancPluginInstanceOrigin_Plugin
Definition: OrthancCPlugin.h:898
@ OrthancPluginContentType_Dicom
Definition: OrthancCPlugin.h:688
@ OrthancPluginContentType_DicomAsJson
Definition: OrthancCPlugin.h:689
@ OrthancPluginContentType_Unknown
Definition: OrthancCPlugin.h:687
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1761
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1765
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1766
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1764
uint16_t element
Definition: OrthancCPlugin.h:1763
uint16_t group
Definition: OrthancCPlugin.h:1762
The parameters of a REST request.
Definition: OrthancCPlugin.h:335
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:364
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:349
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:374
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:344
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:389
const void * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:369
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:359
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:384
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:339
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:354
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:394
A 64-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1027
uint64_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1036
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1031
A 32-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1005
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1014
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1009