Orthanc Plugin SDK  1.9.1
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,
841  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
843 
844 
850  typedef enum
851  {
852  OrthancPluginCreateDicomFlags_None = 0,
856  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
858 
859 
865  typedef enum
866  {
872  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
874 
875 
880  typedef enum
881  {
888  _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
890 
891 
895  typedef enum
896  {
904  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
906 
907 
911  typedef enum
912  {
917 
918 
925  typedef enum
926  {
932 
933 
937  typedef enum
938  {
948 
949 
954  typedef enum
955  {
960 
961 
967  typedef enum
968  {
996 
997 
998 
1006  typedef struct
1007  {
1011  void* data;
1012 
1016  uint32_t size;
1018 
1019 
1020 
1028  typedef struct
1029  {
1033  void* data;
1034 
1038  uint64_t size;
1040 
1041 
1042 
1043 
1048  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
1049 
1050 
1051 
1056  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
1057 
1058 
1059 
1064  typedef struct _OrthancPluginImage_t OrthancPluginImage;
1065 
1066 
1067 
1072  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
1073 
1074 
1075 
1080  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
1081 
1082 
1083 
1088  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
1089 
1090 
1091 
1096  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1097 
1098 
1099 
1104  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1105 
1106 
1107 
1112  typedef struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher;
1113 
1114 
1115 
1120  typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1121 
1122 
1123 
1128  typedef struct _OrthancPluginJob_t OrthancPluginJob;
1129 
1130 
1131 
1137  typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1138 
1139 
1140 
1146  OrthancPluginRestOutput* output,
1147  const char* url,
1148  const OrthancPluginHttpRequest* request);
1149 
1150 
1151 
1157  const OrthancPluginDicomInstance* instance,
1158  const char* instanceId);
1159 
1160 
1161 
1167  OrthancPluginChangeType changeType,
1168  OrthancPluginResourceType resourceType,
1169  const char* resourceId);
1170 
1171 
1172 
1178  OrthancPluginImage** target,
1179  const void* dicom,
1180  const uint32_t size,
1181  uint32_t frameIndex);
1182 
1183 
1184 
1189  typedef void (*OrthancPluginFree) (void* buffer);
1190 
1191 
1192 
1202  const char* bulkDataUri);
1203 
1204 
1205 
1219  const char* uuid,
1220  const void* content,
1221  int64_t size,
1223 
1224 
1225 
1246  void** content,
1247  int64_t* size,
1248  const char* uuid,
1250 
1251 
1252 
1267  const char* uuid,
1269 
1270 
1271 
1290  const char* uuid,
1292  uint64_t rangeStart);
1293 
1294 
1295 
1307  const char* uuid,
1309 
1310 
1311 
1327  const OrthancPluginWorklistQuery* query,
1328  const char* issuerAet,
1329  const char* calledAet);
1330 
1331 
1332 
1357  OrthancPluginHttpMethod method,
1358  const char* uri,
1359  const char* ip,
1360  uint32_t headersCount,
1361  const char* const* headersKeys,
1362  const char* const* headersValues);
1363 
1364 
1365 
1392  OrthancPluginHttpMethod method,
1393  const char* uri,
1394  const char* ip,
1395  uint32_t headersCount,
1396  const char* const* headersKeys,
1397  const char* const* headersValues,
1398  uint32_t getArgumentsCount,
1399  const char* const* getArgumentsKeys,
1400  const char* const* getArgumentsValues);
1401 
1402 
1403 
1419  OrthancPluginFindAnswers* answers,
1420  const OrthancPluginFindQuery* query,
1421  const char* issuerAet,
1422  const char* calledAet);
1423 
1424 
1425 
1461  typedef void* (*OrthancPluginMoveCallback) (
1462  OrthancPluginResourceType resourceType,
1463  const char* patientId,
1464  const char* accessionNumber,
1465  const char* studyInstanceUid,
1466  const char* seriesInstanceUid,
1467  const char* sopInstanceUid,
1468  const char* originatorAet,
1469  const char* sourceAet,
1470  const char* targetAet,
1471  uint16_t originatorId);
1472 
1473 
1486  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1487 
1488 
1501  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1502 
1503 
1515  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1516 
1517 
1528  typedef void (*OrthancPluginJobFinalize) (void* job);
1529 
1530 
1541  typedef float (*OrthancPluginJobGetProgress) (void* job);
1542 
1543 
1556  typedef const char* (*OrthancPluginJobGetContent) (void* job);
1557 
1558 
1574  typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1575 
1576 
1590 
1591 
1615 
1616 
1631 
1632 
1646  typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1647  const char* serialized);
1648 
1649 
1650 
1665 
1666 
1667 
1695  uint32_t levelDepth,
1696  const uint16_t* levelTagGroup,
1697  const uint16_t* levelTagElement,
1698  const uint32_t* levelIndex,
1699  uint16_t tagGroup,
1700  uint16_t tagElement,
1702 
1703 
1704 
1733  uint32_t levelDepth,
1734  const uint16_t* levelTagGroup,
1735  const uint16_t* levelTagElement,
1736  const uint32_t* levelIndex,
1737  uint16_t tagGroup,
1738  uint16_t tagElement,
1740  void* payload);
1741 
1742 
1743 
1747  typedef struct _OrthancPluginContext_t
1748  {
1749  void* pluginsManager;
1750  const char* orthancVersion;
1751  OrthancPluginFree Free;
1752  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1753  _OrthancPluginService service,
1754  const void* params);
1756 
1757 
1758 
1762  typedef struct
1763  {
1764  uint16_t group;
1765  uint16_t element;
1767  uint32_t minMultiplicity;
1768  uint32_t maxMultiplicity;
1770 
1771 
1772 
1781  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1782  OrthancPluginContext* context,
1783  char* str)
1784  {
1785  if (str != NULL)
1786  {
1787  context->Free(str);
1788  }
1789  }
1790 
1791 
1811  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1812  OrthancPluginContext* context,
1813  int expectedMajor,
1814  int expectedMinor,
1815  int expectedRevision)
1816  {
1817  int major, minor, revision;
1818 
1819  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1820  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1821  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1822  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1823  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1824  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1825  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1826  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1827  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1828  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1829  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1830  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1831  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1832  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1833  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1834  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1835  sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1836  sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
1837  sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
1838  sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
1839  sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason))
1840  {
1841  /* Mismatch in the size of the enumerations */
1842  return 0;
1843  }
1844 
1845  /* Assume compatibility with the mainline */
1846  if (!strcmp(context->orthancVersion, "mainline"))
1847  {
1848  return 1;
1849  }
1850 
1851  /* Parse the version of the Orthanc core */
1852  if (
1853 #ifdef _MSC_VER
1854  sscanf_s
1855 #else
1856  sscanf
1857 #endif
1858  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1859  {
1860  return 0;
1861  }
1862 
1863  /* Check the major number of the version */
1864 
1865  if (major > expectedMajor)
1866  {
1867  return 1;
1868  }
1869 
1870  if (major < expectedMajor)
1871  {
1872  return 0;
1873  }
1874 
1875  /* Check the minor number of the version */
1876 
1877  if (minor > expectedMinor)
1878  {
1879  return 1;
1880  }
1881 
1882  if (minor < expectedMinor)
1883  {
1884  return 0;
1885  }
1886 
1887  /* Check the revision number of the version */
1888 
1889  if (revision >= expectedRevision)
1890  {
1891  return 1;
1892  }
1893  else
1894  {
1895  return 0;
1896  }
1897  }
1898 
1899 
1916  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1917  OrthancPluginContext* context)
1918  {
1920  context,
1921  ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1922  ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1923  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1924  }
1925 
1926 
1935  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1936  OrthancPluginContext* context,
1937  OrthancPluginMemoryBuffer* buffer)
1938  {
1939  context->Free(buffer->data);
1940  }
1941 
1942 
1951  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer64(
1952  OrthancPluginContext* context,
1954  {
1955  context->Free(buffer->data);
1956  }
1957 
1958 
1967  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1968  OrthancPluginContext* context,
1969  const char* message)
1970  {
1971  context->InvokeService(context, _OrthancPluginService_LogError, message);
1972  }
1973 
1974 
1983  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
1984  OrthancPluginContext* context,
1985  const char* message)
1986  {
1987  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1988  }
1989 
1990 
1999  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
2000  OrthancPluginContext* context,
2001  const char* message)
2002  {
2003  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
2004  }
2005 
2006 
2007 
2008  typedef struct
2009  {
2010  const char* pathRegularExpression;
2011  OrthancPluginRestCallback callback;
2012  } _OrthancPluginRestCallback;
2013 
2035  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
2036  OrthancPluginContext* context,
2037  const char* pathRegularExpression,
2038  OrthancPluginRestCallback callback)
2039  {
2040  _OrthancPluginRestCallback params;
2041  params.pathRegularExpression = pathRegularExpression;
2042  params.callback = callback;
2043  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
2044  }
2045 
2046 
2047 
2075  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
2076  OrthancPluginContext* context,
2077  const char* pathRegularExpression,
2078  OrthancPluginRestCallback callback)
2079  {
2080  _OrthancPluginRestCallback params;
2081  params.pathRegularExpression = pathRegularExpression;
2082  params.callback = callback;
2083  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
2084  }
2085 
2086 
2087 
2088  typedef struct
2089  {
2091  } _OrthancPluginOnStoredInstanceCallback;
2092 
2114  OrthancPluginContext* context,
2116  {
2117  _OrthancPluginOnStoredInstanceCallback params;
2118  params.callback = callback;
2119 
2120  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
2121  }
2122 
2123 
2124 
2125  typedef struct
2126  {
2127  OrthancPluginRestOutput* output;
2128  const void* answer;
2129  uint32_t answerSize;
2130  const char* mimeType;
2131  } _OrthancPluginAnswerBuffer;
2132 
2145  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
2146  OrthancPluginContext* context,
2147  OrthancPluginRestOutput* output,
2148  const void* answer,
2149  uint32_t answerSize,
2150  const char* mimeType)
2151  {
2152  _OrthancPluginAnswerBuffer params;
2153  params.output = output;
2154  params.answer = answer;
2155  params.answerSize = answerSize;
2156  params.mimeType = mimeType;
2157  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
2158  }
2159 
2160 
2161  typedef struct
2162  {
2163  OrthancPluginRestOutput* output;
2164  OrthancPluginPixelFormat format;
2165  uint32_t width;
2166  uint32_t height;
2167  uint32_t pitch;
2168  const void* buffer;
2169  } _OrthancPluginCompressAndAnswerPngImage;
2170 
2171  typedef struct
2172  {
2173  OrthancPluginRestOutput* output;
2174  OrthancPluginImageFormat imageFormat;
2175  OrthancPluginPixelFormat pixelFormat;
2176  uint32_t width;
2177  uint32_t height;
2178  uint32_t pitch;
2179  const void* buffer;
2180  uint8_t quality;
2181  } _OrthancPluginCompressAndAnswerImage;
2182 
2183 
2202  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2203  OrthancPluginContext* context,
2204  OrthancPluginRestOutput* output,
2205  OrthancPluginPixelFormat format,
2206  uint32_t width,
2207  uint32_t height,
2208  uint32_t pitch,
2209  const void* buffer)
2210  {
2211  _OrthancPluginCompressAndAnswerImage params;
2212  params.output = output;
2213  params.imageFormat = OrthancPluginImageFormat_Png;
2214  params.pixelFormat = format;
2215  params.width = width;
2216  params.height = height;
2217  params.pitch = pitch;
2218  params.buffer = buffer;
2219  params.quality = 0; /* No quality for PNG */
2220  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2221  }
2222 
2223 
2224 
2225  typedef struct
2226  {
2227  OrthancPluginMemoryBuffer* target;
2228  const char* instanceId;
2229  } _OrthancPluginGetDicomForInstance;
2230 
2244  OrthancPluginContext* context,
2245  OrthancPluginMemoryBuffer* target,
2246  const char* instanceId)
2247  {
2248  _OrthancPluginGetDicomForInstance params;
2249  params.target = target;
2250  params.instanceId = instanceId;
2251  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2252  }
2253 
2254 
2255 
2256  typedef struct
2257  {
2258  OrthancPluginMemoryBuffer* target;
2259  const char* uri;
2260  } _OrthancPluginRestApiGet;
2261 
2277  OrthancPluginContext* context,
2278  OrthancPluginMemoryBuffer* target,
2279  const char* uri)
2280  {
2281  _OrthancPluginRestApiGet params;
2282  params.target = target;
2283  params.uri = uri;
2284  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2285  }
2286 
2287 
2288 
2307  OrthancPluginContext* context,
2308  OrthancPluginMemoryBuffer* target,
2309  const char* uri)
2310  {
2311  _OrthancPluginRestApiGet params;
2312  params.target = target;
2313  params.uri = uri;
2314  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2315  }
2316 
2317 
2318 
2319  typedef struct
2320  {
2321  OrthancPluginMemoryBuffer* target;
2322  const char* uri;
2323  const void* body;
2324  uint32_t bodySize;
2325  } _OrthancPluginRestApiPostPut;
2326 
2344  OrthancPluginContext* context,
2345  OrthancPluginMemoryBuffer* target,
2346  const char* uri,
2347  const void* body,
2348  uint32_t bodySize)
2349  {
2350  _OrthancPluginRestApiPostPut params;
2351  params.target = target;
2352  params.uri = uri;
2353  params.body = body;
2354  params.bodySize = bodySize;
2355  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2356  }
2357 
2358 
2379  OrthancPluginContext* context,
2380  OrthancPluginMemoryBuffer* target,
2381  const char* uri,
2382  const void* body,
2383  uint32_t bodySize)
2384  {
2385  _OrthancPluginRestApiPostPut params;
2386  params.target = target;
2387  params.uri = uri;
2388  params.body = body;
2389  params.bodySize = bodySize;
2390  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2391  }
2392 
2393 
2394 
2408  OrthancPluginContext* context,
2409  const char* uri)
2410  {
2411  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2412  }
2413 
2414 
2431  OrthancPluginContext* context,
2432  const char* uri)
2433  {
2434  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2435  }
2436 
2437 
2438 
2456  OrthancPluginContext* context,
2457  OrthancPluginMemoryBuffer* target,
2458  const char* uri,
2459  const void* body,
2460  uint32_t bodySize)
2461  {
2462  _OrthancPluginRestApiPostPut params;
2463  params.target = target;
2464  params.uri = uri;
2465  params.body = body;
2466  params.bodySize = bodySize;
2467  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2468  }
2469 
2470 
2471 
2492  OrthancPluginContext* context,
2493  OrthancPluginMemoryBuffer* target,
2494  const char* uri,
2495  const void* body,
2496  uint32_t bodySize)
2497  {
2498  _OrthancPluginRestApiPostPut params;
2499  params.target = target;
2500  params.uri = uri;
2501  params.body = body;
2502  params.bodySize = bodySize;
2503  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2504  }
2505 
2506 
2507 
2508  typedef struct
2509  {
2510  OrthancPluginRestOutput* output;
2511  const char* argument;
2512  } _OrthancPluginOutputPlusArgument;
2513 
2525  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2526  OrthancPluginContext* context,
2527  OrthancPluginRestOutput* output,
2528  const char* redirection)
2529  {
2530  _OrthancPluginOutputPlusArgument params;
2531  params.output = output;
2532  params.argument = redirection;
2533  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2534  }
2535 
2536 
2537 
2538  typedef struct
2539  {
2540  char** result;
2541  const char* argument;
2542  } _OrthancPluginRetrieveDynamicString;
2543 
2557  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2558  OrthancPluginContext* context,
2559  const char* patientID)
2560  {
2561  char* result;
2562 
2563  _OrthancPluginRetrieveDynamicString params;
2564  params.result = &result;
2565  params.argument = patientID;
2566 
2567  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2568  {
2569  /* Error */
2570  return NULL;
2571  }
2572  else
2573  {
2574  return result;
2575  }
2576  }
2577 
2578 
2592  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2593  OrthancPluginContext* context,
2594  const char* studyUID)
2595  {
2596  char* result;
2597 
2598  _OrthancPluginRetrieveDynamicString params;
2599  params.result = &result;
2600  params.argument = studyUID;
2601 
2602  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2603  {
2604  /* Error */
2605  return NULL;
2606  }
2607  else
2608  {
2609  return result;
2610  }
2611  }
2612 
2613 
2627  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
2628  OrthancPluginContext* context,
2629  const char* accessionNumber)
2630  {
2631  char* result;
2632 
2633  _OrthancPluginRetrieveDynamicString params;
2634  params.result = &result;
2635  params.argument = accessionNumber;
2636 
2637  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2638  {
2639  /* Error */
2640  return NULL;
2641  }
2642  else
2643  {
2644  return result;
2645  }
2646  }
2647 
2648 
2662  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2663  OrthancPluginContext* context,
2664  const char* seriesUID)
2665  {
2666  char* result;
2667 
2668  _OrthancPluginRetrieveDynamicString params;
2669  params.result = &result;
2670  params.argument = seriesUID;
2671 
2672  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2673  {
2674  /* Error */
2675  return NULL;
2676  }
2677  else
2678  {
2679  return result;
2680  }
2681  }
2682 
2683 
2697  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2698  OrthancPluginContext* context,
2699  const char* sopInstanceUID)
2700  {
2701  char* result;
2702 
2703  _OrthancPluginRetrieveDynamicString params;
2704  params.result = &result;
2705  params.argument = sopInstanceUID;
2706 
2707  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2708  {
2709  /* Error */
2710  return NULL;
2711  }
2712  else
2713  {
2714  return result;
2715  }
2716  }
2717 
2718 
2719 
2720  typedef struct
2721  {
2722  OrthancPluginRestOutput* output;
2723  uint16_t status;
2724  } _OrthancPluginSendHttpStatusCode;
2725 
2742  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2743  OrthancPluginContext* context,
2744  OrthancPluginRestOutput* output,
2745  uint16_t status)
2746  {
2747  _OrthancPluginSendHttpStatusCode params;
2748  params.output = output;
2749  params.status = status;
2750  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2751  }
2752 
2753 
2765  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2766  OrthancPluginContext* context,
2767  OrthancPluginRestOutput* output,
2768  const char* realm)
2769  {
2770  _OrthancPluginOutputPlusArgument params;
2771  params.output = output;
2772  params.argument = realm;
2773  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2774  }
2775 
2776 
2788  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2789  OrthancPluginContext* context,
2790  OrthancPluginRestOutput* output,
2791  const char* allowedMethods)
2792  {
2793  _OrthancPluginOutputPlusArgument params;
2794  params.output = output;
2795  params.argument = allowedMethods;
2796  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2797  }
2798 
2799 
2800  typedef struct
2801  {
2802  OrthancPluginRestOutput* output;
2803  const char* key;
2804  const char* value;
2805  } _OrthancPluginSetHttpHeader;
2806 
2818  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2819  OrthancPluginContext* context,
2820  OrthancPluginRestOutput* output,
2821  const char* cookie,
2822  const char* value)
2823  {
2824  _OrthancPluginSetHttpHeader params;
2825  params.output = output;
2826  params.key = cookie;
2827  params.value = value;
2828  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2829  }
2830 
2831 
2843  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2844  OrthancPluginContext* context,
2845  OrthancPluginRestOutput* output,
2846  const char* key,
2847  const char* value)
2848  {
2849  _OrthancPluginSetHttpHeader params;
2850  params.output = output;
2851  params.key = key;
2852  params.value = value;
2853  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2854  }
2855 
2856 
2857  typedef struct
2858  {
2859  char** resultStringToFree;
2860  const char** resultString;
2861  int64_t* resultInt64;
2862  const char* key;
2863  const OrthancPluginDicomInstance* instance;
2864  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2865  } _OrthancPluginAccessDicomInstance;
2866 
2867 
2879  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2880  OrthancPluginContext* context,
2881  const OrthancPluginDicomInstance* instance)
2882  {
2883  const char* result;
2884 
2885  _OrthancPluginAccessDicomInstance params;
2886  memset(&params, 0, sizeof(params));
2887  params.resultString = &result;
2888  params.instance = instance;
2889 
2890  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2891  {
2892  /* Error */
2893  return NULL;
2894  }
2895  else
2896  {
2897  return result;
2898  }
2899  }
2900 
2901 
2912  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2913  OrthancPluginContext* context,
2914  const OrthancPluginDicomInstance* instance)
2915  {
2916  int64_t size;
2917 
2918  _OrthancPluginAccessDicomInstance params;
2919  memset(&params, 0, sizeof(params));
2920  params.resultInt64 = &size;
2921  params.instance = instance;
2922 
2923  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2924  {
2925  /* Error */
2926  return -1;
2927  }
2928  else
2929  {
2930  return size;
2931  }
2932  }
2933 
2934 
2945  ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData(
2946  OrthancPluginContext* context,
2947  const OrthancPluginDicomInstance* instance)
2948  {
2949  const char* result;
2950 
2951  _OrthancPluginAccessDicomInstance params;
2952  memset(&params, 0, sizeof(params));
2953  params.resultString = &result;
2954  params.instance = instance;
2955 
2956  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2957  {
2958  /* Error */
2959  return NULL;
2960  }
2961  else
2962  {
2963  return result;
2964  }
2965  }
2966 
2967 
2981  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
2982  OrthancPluginContext* context,
2983  const OrthancPluginDicomInstance* instance)
2984  {
2985  char* result;
2986 
2987  _OrthancPluginAccessDicomInstance params;
2988  memset(&params, 0, sizeof(params));
2989  params.resultStringToFree = &result;
2990  params.instance = instance;
2991 
2992  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
2993  {
2994  /* Error */
2995  return NULL;
2996  }
2997  else
2998  {
2999  return result;
3000  }
3001  }
3002 
3003 
3019  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
3020  OrthancPluginContext* context,
3021  const OrthancPluginDicomInstance* instance)
3022  {
3023  char* result;
3024 
3025  _OrthancPluginAccessDicomInstance params;
3026  memset(&params, 0, sizeof(params));
3027  params.resultStringToFree = &result;
3028  params.instance = instance;
3029 
3030  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
3031  {
3032  /* Error */
3033  return NULL;
3034  }
3035  else
3036  {
3037  return result;
3038  }
3039  }
3040 
3041 
3058  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
3059  OrthancPluginContext* context,
3060  const OrthancPluginDicomInstance* instance,
3061  const char* metadata)
3062  {
3063  int64_t result;
3064 
3065  _OrthancPluginAccessDicomInstance params;
3066  memset(&params, 0, sizeof(params));
3067  params.resultInt64 = &result;
3068  params.instance = instance;
3069  params.key = metadata;
3070 
3071  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3072  {
3073  /* Error */
3074  return -1;
3075  }
3076  else
3077  {
3078  return (result != 0);
3079  }
3080  }
3081 
3082 
3099  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
3100  OrthancPluginContext* context,
3101  const OrthancPluginDicomInstance* instance,
3102  const char* metadata)
3103  {
3104  const char* result;
3105 
3106  _OrthancPluginAccessDicomInstance params;
3107  memset(&params, 0, sizeof(params));
3108  params.resultString = &result;
3109  params.instance = instance;
3110  params.key = metadata;
3111 
3112  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3113  {
3114  /* Error */
3115  return NULL;
3116  }
3117  else
3118  {
3119  return result;
3120  }
3121  }
3122 
3123 
3124 
3125  typedef struct
3126  {
3130  OrthancPluginFree free;
3131  } _OrthancPluginRegisterStorageArea;
3132 
3148  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
3149  OrthancPluginContext* context,
3153  {
3154  _OrthancPluginRegisterStorageArea params;
3155  params.create = create;
3156  params.read = read;
3157  params.remove = remove;
3158 
3159 #ifdef __cplusplus
3160  params.free = ::free;
3161 #else
3162  params.free = free;
3163 #endif
3164 
3165  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3166  }
3167 
3168 
3169 
3180  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3181  {
3182  char* result;
3183 
3184  _OrthancPluginRetrieveDynamicString params;
3185  params.result = &result;
3186  params.argument = NULL;
3187 
3188  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3189  {
3190  /* Error */
3191  return NULL;
3192  }
3193  else
3194  {
3195  return result;
3196  }
3197  }
3198 
3199 
3210  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3211  {
3212  char* result;
3213 
3214  _OrthancPluginRetrieveDynamicString params;
3215  params.result = &result;
3216  params.argument = NULL;
3217 
3218  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3219  {
3220  /* Error */
3221  return NULL;
3222  }
3223  else
3224  {
3225  return result;
3226  }
3227  }
3228 
3229 
3245  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3246  {
3247  char* result;
3248 
3249  _OrthancPluginRetrieveDynamicString params;
3250  params.result = &result;
3251  params.argument = NULL;
3252 
3253  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3254  {
3255  /* Error */
3256  return NULL;
3257  }
3258  else
3259  {
3260  return result;
3261  }
3262  }
3263 
3264 
3265 
3266  typedef struct
3267  {
3269  } _OrthancPluginOnChangeCallback;
3270 
3291  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3292  OrthancPluginContext* context,
3294  {
3295  _OrthancPluginOnChangeCallback params;
3296  params.callback = callback;
3297 
3298  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3299  }
3300 
3301 
3302 
3303  typedef struct
3304  {
3305  const char* plugin;
3306  _OrthancPluginProperty property;
3307  const char* value;
3308  } _OrthancPluginSetPluginProperty;
3309 
3310 
3322  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3323  OrthancPluginContext* context,
3324  const char* uri)
3325  {
3326  _OrthancPluginSetPluginProperty params;
3327  params.plugin = OrthancPluginGetName();
3328  params.property = _OrthancPluginProperty_RootUri;
3329  params.value = uri;
3330 
3331  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3332  }
3333 
3334 
3344  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3345  OrthancPluginContext* context,
3346  const char* description)
3347  {
3348  _OrthancPluginSetPluginProperty params;
3349  params.plugin = OrthancPluginGetName();
3350  params.property = _OrthancPluginProperty_Description;
3351  params.value = description;
3352 
3353  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3354  }
3355 
3356 
3366  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3367  OrthancPluginContext* context,
3368  const char* javascript)
3369  {
3370  _OrthancPluginSetPluginProperty params;
3371  params.plugin = OrthancPluginGetName();
3372  params.property = _OrthancPluginProperty_OrthancExplorer;
3373  params.value = javascript;
3374 
3375  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3376  }
3377 
3378 
3379  typedef struct
3380  {
3381  char** result;
3382  int32_t property;
3383  const char* value;
3384  } _OrthancPluginGlobalProperty;
3385 
3386 
3400  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3401  OrthancPluginContext* context,
3402  int32_t property,
3403  const char* defaultValue)
3404  {
3405  char* result;
3406 
3407  _OrthancPluginGlobalProperty params;
3408  params.result = &result;
3409  params.property = property;
3410  params.value = defaultValue;
3411 
3412  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3413  {
3414  /* Error */
3415  return NULL;
3416  }
3417  else
3418  {
3419  return result;
3420  }
3421  }
3422 
3423 
3440  OrthancPluginContext* context,
3441  int32_t property,
3442  const char* value)
3443  {
3444  _OrthancPluginGlobalProperty params;
3445  params.result = NULL;
3446  params.property = property;
3447  params.value = value;
3448 
3449  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3450  }
3451 
3452 
3453 
3454  typedef struct
3455  {
3456  int32_t *resultInt32;
3457  uint32_t *resultUint32;
3458  int64_t *resultInt64;
3459  uint64_t *resultUint64;
3460  } _OrthancPluginReturnSingleValue;
3461 
3470  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3471  OrthancPluginContext* context)
3472  {
3473  uint32_t count = 0;
3474 
3475  _OrthancPluginReturnSingleValue params;
3476  memset(&params, 0, sizeof(params));
3477  params.resultUint32 = &count;
3478 
3479  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3480  {
3481  /* Error */
3482  return 0;
3483  }
3484  else
3485  {
3486  return count;
3487  }
3488  }
3489 
3490 
3491 
3504  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3505  OrthancPluginContext* context,
3506  uint32_t argument)
3507  {
3508  char* result;
3509 
3510  _OrthancPluginGlobalProperty params;
3511  params.result = &result;
3512  params.property = (int32_t) argument;
3513  params.value = NULL;
3514 
3515  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3516  {
3517  /* Error */
3518  return NULL;
3519  }
3520  else
3521  {
3522  return result;
3523  }
3524  }
3525 
3526 
3536  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3537  OrthancPluginContext* context)
3538  {
3539  uint32_t count = 0;
3540 
3541  _OrthancPluginReturnSingleValue params;
3542  memset(&params, 0, sizeof(params));
3543  params.resultUint32 = &count;
3544 
3545  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3546  {
3547  /* Error */
3548  return 0;
3549  }
3550  else
3551  {
3552  return count;
3553  }
3554  }
3555 
3556 
3557 
3569  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3570  {
3571  char* result;
3572 
3573  _OrthancPluginRetrieveDynamicString params;
3574  params.result = &result;
3575  params.argument = NULL;
3576 
3577  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3578  {
3579  /* Error */
3580  return NULL;
3581  }
3582  else
3583  {
3584  return result;
3585  }
3586  }
3587 
3588 
3589 
3590  typedef struct
3591  {
3592  OrthancPluginRestOutput* output;
3593  const char* subType;
3594  const char* contentType;
3595  } _OrthancPluginStartMultipartAnswer;
3596 
3611  OrthancPluginContext* context,
3612  OrthancPluginRestOutput* output,
3613  const char* subType,
3614  const char* contentType)
3615  {
3616  _OrthancPluginStartMultipartAnswer params;
3617  params.output = output;
3618  params.subType = subType;
3619  params.contentType = contentType;
3620  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3621  }
3622 
3623 
3640  OrthancPluginContext* context,
3641  OrthancPluginRestOutput* output,
3642  const void* answer,
3643  uint32_t answerSize)
3644  {
3645  _OrthancPluginAnswerBuffer params;
3646  params.output = output;
3647  params.answer = answer;
3648  params.answerSize = answerSize;
3649  params.mimeType = NULL;
3650  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3651  }
3652 
3653 
3654 
3655  typedef struct
3656  {
3657  OrthancPluginMemoryBuffer* target;
3658  const void* source;
3659  uint32_t size;
3660  OrthancPluginCompressionType compression;
3661  uint8_t uncompress;
3662  } _OrthancPluginBufferCompression;
3663 
3664 
3682  OrthancPluginContext* context,
3683  OrthancPluginMemoryBuffer* target,
3684  const void* source,
3685  uint32_t size,
3686  OrthancPluginCompressionType compression,
3687  uint8_t uncompress)
3688  {
3689  _OrthancPluginBufferCompression params;
3690  params.target = target;
3691  params.source = source;
3692  params.size = size;
3693  params.compression = compression;
3694  params.uncompress = uncompress;
3695 
3696  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3697  }
3698 
3699 
3700 
3701  typedef struct
3702  {
3703  OrthancPluginMemoryBuffer* target;
3704  const char* path;
3705  } _OrthancPluginReadFile;
3706 
3719  OrthancPluginContext* context,
3720  OrthancPluginMemoryBuffer* target,
3721  const char* path)
3722  {
3723  _OrthancPluginReadFile params;
3724  params.target = target;
3725  params.path = path;
3726  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3727  }
3728 
3729 
3730 
3731  typedef struct
3732  {
3733  const char* path;
3734  const void* data;
3735  uint32_t size;
3736  } _OrthancPluginWriteFile;
3737 
3750  OrthancPluginContext* context,
3751  const char* path,
3752  const void* data,
3753  uint32_t size)
3754  {
3755  _OrthancPluginWriteFile params;
3756  params.path = path;
3757  params.data = data;
3758  params.size = size;
3759  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3760  }
3761 
3762 
3763 
3764  typedef struct
3765  {
3766  const char** target;
3767  OrthancPluginErrorCode error;
3768  } _OrthancPluginGetErrorDescription;
3769 
3780  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3781  OrthancPluginContext* context,
3782  OrthancPluginErrorCode error)
3783  {
3784  const char* result = NULL;
3785 
3786  _OrthancPluginGetErrorDescription params;
3787  params.target = &result;
3788  params.error = error;
3789 
3790  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3791  result == NULL)
3792  {
3793  return "Unknown error code";
3794  }
3795  else
3796  {
3797  return result;
3798  }
3799  }
3800 
3801 
3802 
3803  typedef struct
3804  {
3805  OrthancPluginRestOutput* output;
3806  uint16_t status;
3807  const char* body;
3808  uint32_t bodySize;
3809  } _OrthancPluginSendHttpStatus;
3810 
3833  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3834  OrthancPluginContext* context,
3835  OrthancPluginRestOutput* output,
3836  uint16_t status,
3837  const char* body,
3838  uint32_t bodySize)
3839  {
3840  _OrthancPluginSendHttpStatus params;
3841  params.output = output;
3842  params.status = status;
3843  params.body = body;
3844  params.bodySize = bodySize;
3845  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3846  }
3847 
3848 
3849 
3850  typedef struct
3851  {
3852  const OrthancPluginImage* image;
3853  uint32_t* resultUint32;
3854  OrthancPluginPixelFormat* resultPixelFormat;
3855  void** resultBuffer;
3856  } _OrthancPluginGetImageInfo;
3857 
3858 
3870  OrthancPluginContext* context,
3871  const OrthancPluginImage* image)
3872  {
3873  OrthancPluginPixelFormat target;
3874 
3875  _OrthancPluginGetImageInfo params;
3876  memset(&params, 0, sizeof(params));
3877  params.image = image;
3878  params.resultPixelFormat = &target;
3879 
3880  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3881  {
3883  }
3884  else
3885  {
3886  return (OrthancPluginPixelFormat) target;
3887  }
3888  }
3889 
3890 
3891 
3902  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3903  OrthancPluginContext* context,
3904  const OrthancPluginImage* image)
3905  {
3906  uint32_t width;
3907 
3908  _OrthancPluginGetImageInfo params;
3909  memset(&params, 0, sizeof(params));
3910  params.image = image;
3911  params.resultUint32 = &width;
3912 
3913  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3914  {
3915  return 0;
3916  }
3917  else
3918  {
3919  return width;
3920  }
3921  }
3922 
3923 
3924 
3935  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3936  OrthancPluginContext* context,
3937  const OrthancPluginImage* image)
3938  {
3939  uint32_t height;
3940 
3941  _OrthancPluginGetImageInfo params;
3942  memset(&params, 0, sizeof(params));
3943  params.image = image;
3944  params.resultUint32 = &height;
3945 
3946  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3947  {
3948  return 0;
3949  }
3950  else
3951  {
3952  return height;
3953  }
3954  }
3955 
3956 
3957 
3970  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3971  OrthancPluginContext* context,
3972  const OrthancPluginImage* image)
3973  {
3974  uint32_t pitch;
3975 
3976  _OrthancPluginGetImageInfo params;
3977  memset(&params, 0, sizeof(params));
3978  params.image = image;
3979  params.resultUint32 = &pitch;
3980 
3981  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
3982  {
3983  return 0;
3984  }
3985  else
3986  {
3987  return pitch;
3988  }
3989  }
3990 
3991 
3992 
4004  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
4005  OrthancPluginContext* context,
4006  const OrthancPluginImage* image)
4007  {
4008  void* target = NULL;
4009 
4010  _OrthancPluginGetImageInfo params;
4011  memset(&params, 0, sizeof(params));
4012  params.resultBuffer = &target;
4013  params.image = image;
4014 
4015  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
4016  {
4017  return NULL;
4018  }
4019  else
4020  {
4021  return target;
4022  }
4023  }
4024 
4025 
4026  typedef struct
4027  {
4028  OrthancPluginImage** target;
4029  const void* data;
4030  uint32_t size;
4031  OrthancPluginImageFormat format;
4032  } _OrthancPluginUncompressImage;
4033 
4034 
4048  OrthancPluginContext* context,
4049  const void* data,
4050  uint32_t size,
4051  OrthancPluginImageFormat format)
4052  {
4053  OrthancPluginImage* target = NULL;
4054 
4055  _OrthancPluginUncompressImage params;
4056  memset(&params, 0, sizeof(params));
4057  params.target = &target;
4058  params.data = data;
4059  params.size = size;
4060  params.format = format;
4061 
4062  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
4063  {
4064  return NULL;
4065  }
4066  else
4067  {
4068  return target;
4069  }
4070  }
4071 
4072 
4073 
4074 
4075  typedef struct
4076  {
4077  OrthancPluginImage* image;
4078  } _OrthancPluginFreeImage;
4079 
4089  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
4090  OrthancPluginContext* context,
4091  OrthancPluginImage* image)
4092  {
4093  _OrthancPluginFreeImage params;
4094  params.image = image;
4095 
4096  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
4097  }
4098 
4099 
4100 
4101 
4102  typedef struct
4103  {
4104  OrthancPluginMemoryBuffer* target;
4105  OrthancPluginImageFormat imageFormat;
4106  OrthancPluginPixelFormat pixelFormat;
4107  uint32_t width;
4108  uint32_t height;
4109  uint32_t pitch;
4110  const void* buffer;
4111  uint8_t quality;
4112  } _OrthancPluginCompressImage;
4113 
4114 
4135  OrthancPluginContext* context,
4136  OrthancPluginMemoryBuffer* target,
4137  OrthancPluginPixelFormat format,
4138  uint32_t width,
4139  uint32_t height,
4140  uint32_t pitch,
4141  const void* buffer)
4142  {
4143  _OrthancPluginCompressImage params;
4144  memset(&params, 0, sizeof(params));
4145  params.target = target;
4146  params.imageFormat = OrthancPluginImageFormat_Png;
4147  params.pixelFormat = format;
4148  params.width = width;
4149  params.height = height;
4150  params.pitch = pitch;
4151  params.buffer = buffer;
4152  params.quality = 0; /* Unused for PNG */
4153 
4154  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4155  }
4156 
4157 
4180  OrthancPluginContext* context,
4181  OrthancPluginMemoryBuffer* target,
4182  OrthancPluginPixelFormat format,
4183  uint32_t width,
4184  uint32_t height,
4185  uint32_t pitch,
4186  const void* buffer,
4187  uint8_t quality)
4188  {
4189  _OrthancPluginCompressImage params;
4190  memset(&params, 0, sizeof(params));
4191  params.target = target;
4192  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4193  params.pixelFormat = format;
4194  params.width = width;
4195  params.height = height;
4196  params.pitch = pitch;
4197  params.buffer = buffer;
4198  params.quality = quality;
4199 
4200  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4201  }
4202 
4203 
4204 
4226  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
4227  OrthancPluginContext* context,
4228  OrthancPluginRestOutput* output,
4229  OrthancPluginPixelFormat format,
4230  uint32_t width,
4231  uint32_t height,
4232  uint32_t pitch,
4233  const void* buffer,
4234  uint8_t quality)
4235  {
4236  _OrthancPluginCompressAndAnswerImage params;
4237  params.output = output;
4238  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4239  params.pixelFormat = format;
4240  params.width = width;
4241  params.height = height;
4242  params.pitch = pitch;
4243  params.buffer = buffer;
4244  params.quality = quality;
4245  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4246  }
4247 
4248 
4249 
4250 
4251  typedef struct
4252  {
4253  OrthancPluginMemoryBuffer* target;
4254  OrthancPluginHttpMethod method;
4255  const char* url;
4256  const char* username;
4257  const char* password;
4258  const void* body;
4259  uint32_t bodySize;
4260  } _OrthancPluginCallHttpClient;
4261 
4262 
4280  OrthancPluginContext* context,
4281  OrthancPluginMemoryBuffer* target,
4282  const char* url,
4283  const char* username,
4284  const char* password)
4285  {
4286  _OrthancPluginCallHttpClient params;
4287  memset(&params, 0, sizeof(params));
4288 
4289  params.target = target;
4290  params.method = OrthancPluginHttpMethod_Get;
4291  params.url = url;
4292  params.username = username;
4293  params.password = password;
4294 
4295  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4296  }
4297 
4298 
4318  OrthancPluginContext* context,
4319  OrthancPluginMemoryBuffer* target,
4320  const char* url,
4321  const void* body,
4322  uint32_t bodySize,
4323  const char* username,
4324  const char* password)
4325  {
4326  _OrthancPluginCallHttpClient params;
4327  memset(&params, 0, sizeof(params));
4328 
4329  params.target = target;
4330  params.method = OrthancPluginHttpMethod_Post;
4331  params.url = url;
4332  params.body = body;
4333  params.bodySize = bodySize;
4334  params.username = username;
4335  params.password = password;
4336 
4337  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4338  }
4339 
4340 
4360  OrthancPluginContext* context,
4361  OrthancPluginMemoryBuffer* target,
4362  const char* url,
4363  const void* body,
4364  uint32_t bodySize,
4365  const char* username,
4366  const char* password)
4367  {
4368  _OrthancPluginCallHttpClient params;
4369  memset(&params, 0, sizeof(params));
4370 
4371  params.target = target;
4372  params.method = OrthancPluginHttpMethod_Put;
4373  params.url = url;
4374  params.body = body;
4375  params.bodySize = bodySize;
4376  params.username = username;
4377  params.password = password;
4378 
4379  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4380  }
4381 
4382 
4398  OrthancPluginContext* context,
4399  const char* url,
4400  const char* username,
4401  const char* password)
4402  {
4403  _OrthancPluginCallHttpClient params;
4404  memset(&params, 0, sizeof(params));
4405 
4406  params.method = OrthancPluginHttpMethod_Delete;
4407  params.url = url;
4408  params.username = username;
4409  params.password = password;
4410 
4411  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4412  }
4413 
4414 
4415 
4416  typedef struct
4417  {
4418  OrthancPluginImage** target;
4419  const OrthancPluginImage* source;
4420  OrthancPluginPixelFormat targetFormat;
4421  } _OrthancPluginConvertPixelFormat;
4422 
4423 
4436  OrthancPluginContext* context,
4437  const OrthancPluginImage* source,
4438  OrthancPluginPixelFormat targetFormat)
4439  {
4440  OrthancPluginImage* target = NULL;
4441 
4442  _OrthancPluginConvertPixelFormat params;
4443  params.target = &target;
4444  params.source = source;
4445  params.targetFormat = targetFormat;
4446 
4447  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4448  {
4449  return NULL;
4450  }
4451  else
4452  {
4453  return target;
4454  }
4455  }
4456 
4457 
4458 
4470  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4471  OrthancPluginContext* context)
4472  {
4473  uint32_t count = 0;
4474 
4475  _OrthancPluginReturnSingleValue params;
4476  memset(&params, 0, sizeof(params));
4477  params.resultUint32 = &count;
4478 
4479  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4480  {
4481  /* Error */
4482  return 0;
4483  }
4484  else
4485  {
4486  return count;
4487  }
4488  }
4489 
4490 
4491 
4492 
4493  typedef struct
4494  {
4495  uint32_t fontIndex; /* in */
4496  const char** name; /* out */
4497  uint32_t* size; /* out */
4498  } _OrthancPluginGetFontInfo;
4499 
4510  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4511  OrthancPluginContext* context,
4512  uint32_t fontIndex)
4513  {
4514  const char* result = NULL;
4515 
4516  _OrthancPluginGetFontInfo params;
4517  memset(&params, 0, sizeof(params));
4518  params.name = &result;
4519  params.fontIndex = fontIndex;
4520 
4521  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4522  {
4523  return NULL;
4524  }
4525  else
4526  {
4527  return result;
4528  }
4529  }
4530 
4531 
4542  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4543  OrthancPluginContext* context,
4544  uint32_t fontIndex)
4545  {
4546  uint32_t result;
4547 
4548  _OrthancPluginGetFontInfo params;
4549  memset(&params, 0, sizeof(params));
4550  params.size = &result;
4551  params.fontIndex = fontIndex;
4552 
4553  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4554  {
4555  return 0;
4556  }
4557  else
4558  {
4559  return result;
4560  }
4561  }
4562 
4563 
4564 
4565  typedef struct
4566  {
4567  OrthancPluginImage* image;
4568  uint32_t fontIndex;
4569  const char* utf8Text;
4570  int32_t x;
4571  int32_t y;
4572  uint8_t r;
4573  uint8_t g;
4574  uint8_t b;
4575  } _OrthancPluginDrawText;
4576 
4577 
4596  OrthancPluginContext* context,
4597  OrthancPluginImage* image,
4598  uint32_t fontIndex,
4599  const char* utf8Text,
4600  int32_t x,
4601  int32_t y,
4602  uint8_t r,
4603  uint8_t g,
4604  uint8_t b)
4605  {
4606  _OrthancPluginDrawText params;
4607  memset(&params, 0, sizeof(params));
4608  params.image = image;
4609  params.fontIndex = fontIndex;
4610  params.utf8Text = utf8Text;
4611  params.x = x;
4612  params.y = y;
4613  params.r = r;
4614  params.g = g;
4615  params.b = b;
4616 
4617  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4618  }
4619 
4620 
4621 
4622  typedef struct
4623  {
4624  OrthancPluginStorageArea* storageArea;
4625  const char* uuid;
4626  const void* content;
4627  uint64_t size;
4629  } _OrthancPluginStorageAreaCreate;
4630 
4631 
4650  OrthancPluginContext* context,
4651  OrthancPluginStorageArea* storageArea,
4652  const char* uuid,
4653  const void* content,
4654  uint64_t size,
4656  {
4657  _OrthancPluginStorageAreaCreate params;
4658  params.storageArea = storageArea;
4659  params.uuid = uuid;
4660  params.content = content;
4661  params.size = size;
4662  params.type = type;
4663 
4664  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4665  }
4666 
4667 
4668  typedef struct
4669  {
4670  OrthancPluginMemoryBuffer* target;
4671  OrthancPluginStorageArea* storageArea;
4672  const char* uuid;
4674  } _OrthancPluginStorageAreaRead;
4675 
4676 
4694  OrthancPluginContext* context,
4695  OrthancPluginMemoryBuffer* target,
4696  OrthancPluginStorageArea* storageArea,
4697  const char* uuid,
4699  {
4700  _OrthancPluginStorageAreaRead params;
4701  params.target = target;
4702  params.storageArea = storageArea;
4703  params.uuid = uuid;
4704  params.type = type;
4705 
4706  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4707  }
4708 
4709 
4710  typedef struct
4711  {
4712  OrthancPluginStorageArea* storageArea;
4713  const char* uuid;
4715  } _OrthancPluginStorageAreaRemove;
4716 
4733  OrthancPluginContext* context,
4734  OrthancPluginStorageArea* storageArea,
4735  const char* uuid,
4737  {
4738  _OrthancPluginStorageAreaRemove params;
4739  params.storageArea = storageArea;
4740  params.uuid = uuid;
4741  params.type = type;
4742 
4743  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4744  }
4745 
4746 
4747 
4748  typedef struct
4749  {
4750  OrthancPluginErrorCode* target;
4751  int32_t code;
4752  uint16_t httpStatus;
4753  const char* message;
4754  } _OrthancPluginRegisterErrorCode;
4755 
4772  OrthancPluginContext* context,
4773  int32_t code,
4774  uint16_t httpStatus,
4775  const char* message)
4776  {
4777  OrthancPluginErrorCode target;
4778 
4779  _OrthancPluginRegisterErrorCode params;
4780  params.target = &target;
4781  params.code = code;
4782  params.httpStatus = httpStatus;
4783  params.message = message;
4784 
4785  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4786  {
4787  return target;
4788  }
4789  else
4790  {
4791  /* There was an error while assigned the error. Use a generic code. */
4793  }
4794  }
4795 
4796 
4797 
4798  typedef struct
4799  {
4800  uint16_t group;
4801  uint16_t element;
4803  const char* name;
4804  uint32_t minMultiplicity;
4805  uint32_t maxMultiplicity;
4806  } _OrthancPluginRegisterDictionaryTag;
4807 
4828  OrthancPluginContext* context,
4829  uint16_t group,
4830  uint16_t element,
4832  const char* name,
4833  uint32_t minMultiplicity,
4834  uint32_t maxMultiplicity)
4835  {
4836  _OrthancPluginRegisterDictionaryTag params;
4837  params.group = group;
4838  params.element = element;
4839  params.vr = vr;
4840  params.name = name;
4841  params.minMultiplicity = minMultiplicity;
4842  params.maxMultiplicity = maxMultiplicity;
4843 
4844  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4845  }
4846 
4847 
4848 
4849  typedef struct
4850  {
4851  uint16_t group;
4852  uint16_t element;
4854  const char* name;
4855  uint32_t minMultiplicity;
4856  uint32_t maxMultiplicity;
4857  const char* privateCreator;
4858  } _OrthancPluginRegisterPrivateDictionaryTag;
4859 
4881  OrthancPluginContext* context,
4882  uint16_t group,
4883  uint16_t element,
4885  const char* name,
4886  uint32_t minMultiplicity,
4887  uint32_t maxMultiplicity,
4888  const char* privateCreator)
4889  {
4890  _OrthancPluginRegisterPrivateDictionaryTag params;
4891  params.group = group;
4892  params.element = element;
4893  params.vr = vr;
4894  params.name = name;
4895  params.minMultiplicity = minMultiplicity;
4896  params.maxMultiplicity = maxMultiplicity;
4897  params.privateCreator = privateCreator;
4898 
4899  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4900  }
4901 
4902 
4903 
4904  typedef struct
4905  {
4906  OrthancPluginStorageArea* storageArea;
4908  } _OrthancPluginReconstructMainDicomTags;
4909 
4925  OrthancPluginContext* context,
4926  OrthancPluginStorageArea* storageArea,
4928  {
4929  _OrthancPluginReconstructMainDicomTags params;
4930  params.level = level;
4931  params.storageArea = storageArea;
4932 
4933  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
4934  }
4935 
4936 
4937  typedef struct
4938  {
4939  char** result;
4940  const char* instanceId;
4941  const void* buffer;
4942  uint32_t size;
4945  uint32_t maxStringLength;
4946  } _OrthancPluginDicomToJson;
4947 
4948 
4968  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4969  OrthancPluginContext* context,
4970  const void* buffer,
4971  uint32_t size,
4974  uint32_t maxStringLength)
4975  {
4976  char* result;
4977 
4978  _OrthancPluginDicomToJson params;
4979  memset(&params, 0, sizeof(params));
4980  params.result = &result;
4981  params.buffer = buffer;
4982  params.size = size;
4983  params.format = format;
4984  params.flags = flags;
4985  params.maxStringLength = maxStringLength;
4986 
4987  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
4988  {
4989  /* Error */
4990  return NULL;
4991  }
4992  else
4993  {
4994  return result;
4995  }
4996  }
4997 
4998 
5017  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
5018  OrthancPluginContext* context,
5019  const char* instanceId,
5022  uint32_t maxStringLength)
5023  {
5024  char* result;
5025 
5026  _OrthancPluginDicomToJson params;
5027  memset(&params, 0, sizeof(params));
5028  params.result = &result;
5029  params.instanceId = instanceId;
5030  params.format = format;
5031  params.flags = flags;
5032  params.maxStringLength = maxStringLength;
5033 
5034  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
5035  {
5036  /* Error */
5037  return NULL;
5038  }
5039  else
5040  {
5041  return result;
5042  }
5043  }
5044 
5045 
5046  typedef struct
5047  {
5048  OrthancPluginMemoryBuffer* target;
5049  const char* uri;
5050  uint32_t headersCount;
5051  const char* const* headersKeys;
5052  const char* const* headersValues;
5053  int32_t afterPlugins;
5054  } _OrthancPluginRestApiGet2;
5055 
5076  OrthancPluginContext* context,
5077  OrthancPluginMemoryBuffer* target,
5078  const char* uri,
5079  uint32_t headersCount,
5080  const char* const* headersKeys,
5081  const char* const* headersValues,
5082  int32_t afterPlugins)
5083  {
5084  _OrthancPluginRestApiGet2 params;
5085  params.target = target;
5086  params.uri = uri;
5087  params.headersCount = headersCount;
5088  params.headersKeys = headersKeys;
5089  params.headersValues = headersValues;
5090  params.afterPlugins = afterPlugins;
5091 
5092  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
5093  }
5094 
5095 
5096 
5097  typedef struct
5098  {
5100  } _OrthancPluginWorklistCallback;
5101 
5114  OrthancPluginContext* context,
5116  {
5117  _OrthancPluginWorklistCallback params;
5118  params.callback = callback;
5119 
5120  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
5121  }
5122 
5123 
5124 
5125  typedef struct
5126  {
5128  const OrthancPluginWorklistQuery* query;
5129  const void* dicom;
5130  uint32_t size;
5131  } _OrthancPluginWorklistAnswersOperation;
5132 
5150  OrthancPluginContext* context,
5152  const OrthancPluginWorklistQuery* query,
5153  const void* dicom,
5154  uint32_t size)
5155  {
5156  _OrthancPluginWorklistAnswersOperation params;
5157  params.answers = answers;
5158  params.query = query;
5159  params.dicom = dicom;
5160  params.size = size;
5161 
5162  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
5163  }
5164 
5165 
5180  OrthancPluginContext* context,
5182  {
5183  _OrthancPluginWorklistAnswersOperation params;
5184  params.answers = answers;
5185  params.query = NULL;
5186  params.dicom = NULL;
5187  params.size = 0;
5188 
5189  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5190  }
5191 
5192 
5193  typedef struct
5194  {
5195  const OrthancPluginWorklistQuery* query;
5196  const void* dicom;
5197  uint32_t size;
5198  int32_t* isMatch;
5199  OrthancPluginMemoryBuffer* target;
5200  } _OrthancPluginWorklistQueryOperation;
5201 
5217  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5218  OrthancPluginContext* context,
5219  const OrthancPluginWorklistQuery* query,
5220  const void* dicom,
5221  uint32_t size)
5222  {
5223  int32_t isMatch = 0;
5224 
5225  _OrthancPluginWorklistQueryOperation params;
5226  params.query = query;
5227  params.dicom = dicom;
5228  params.size = size;
5229  params.isMatch = &isMatch;
5230  params.target = NULL;
5231 
5232  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5233  {
5234  return isMatch;
5235  }
5236  else
5237  {
5238  /* Error: Assume non-match */
5239  return 0;
5240  }
5241  }
5242 
5243 
5257  OrthancPluginContext* context,
5258  OrthancPluginMemoryBuffer* target,
5259  const OrthancPluginWorklistQuery* query)
5260  {
5261  _OrthancPluginWorklistQueryOperation params;
5262  params.query = query;
5263  params.dicom = NULL;
5264  params.size = 0;
5265  params.isMatch = NULL;
5266  params.target = target;
5267 
5268  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5269  }
5270 
5271 
5283  OrthancPluginContext* context,
5284  const OrthancPluginDicomInstance* instance)
5285  {
5287 
5288  _OrthancPluginAccessDicomInstance params;
5289  memset(&params, 0, sizeof(params));
5290  params.resultOrigin = &origin;
5291  params.instance = instance;
5292 
5293  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5294  {
5295  /* Error */
5297  }
5298  else
5299  {
5300  return origin;
5301  }
5302  }
5303 
5304 
5305  typedef struct
5306  {
5307  OrthancPluginMemoryBuffer* target;
5308  const char* json;
5309  const OrthancPluginImage* pixelData;
5311  } _OrthancPluginCreateDicom;
5312 
5339  OrthancPluginContext* context,
5340  OrthancPluginMemoryBuffer* target,
5341  const char* json,
5342  const OrthancPluginImage* pixelData,
5344  {
5345  _OrthancPluginCreateDicom params;
5346  params.target = target;
5347  params.json = json;
5348  params.pixelData = pixelData;
5349  params.flags = flags;
5350 
5351  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5352  }
5353 
5354 
5355  typedef struct
5356  {
5358  } _OrthancPluginDecodeImageCallback;
5359 
5375  OrthancPluginContext* context,
5377  {
5378  _OrthancPluginDecodeImageCallback params;
5379  params.callback = callback;
5380 
5381  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5382  }
5383 
5384 
5385 
5386  typedef struct
5387  {
5388  OrthancPluginImage** target;
5389  OrthancPluginPixelFormat format;
5390  uint32_t width;
5391  uint32_t height;
5392  uint32_t pitch;
5393  void* buffer;
5394  const void* constBuffer;
5395  uint32_t bufferSize;
5396  uint32_t frameIndex;
5397  } _OrthancPluginCreateImage;
5398 
5399 
5413  OrthancPluginContext* context,
5414  OrthancPluginPixelFormat format,
5415  uint32_t width,
5416  uint32_t height)
5417  {
5418  OrthancPluginImage* target = NULL;
5419 
5420  _OrthancPluginCreateImage params;
5421  memset(&params, 0, sizeof(params));
5422  params.target = &target;
5423  params.format = format;
5424  params.width = width;
5425  params.height = height;
5426 
5427  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5428  {
5429  return NULL;
5430  }
5431  else
5432  {
5433  return target;
5434  }
5435  }
5436 
5437 
5456  OrthancPluginContext* context,
5457  OrthancPluginPixelFormat format,
5458  uint32_t width,
5459  uint32_t height,
5460  uint32_t pitch,
5461  void* buffer)
5462  {
5463  OrthancPluginImage* target = NULL;
5464 
5465  _OrthancPluginCreateImage params;
5466  memset(&params, 0, sizeof(params));
5467  params.target = &target;
5468  params.format = format;
5469  params.width = width;
5470  params.height = height;
5471  params.pitch = pitch;
5472  params.buffer = buffer;
5473 
5474  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5475  {
5476  return NULL;
5477  }
5478  else
5479  {
5480  return target;
5481  }
5482  }
5483 
5484 
5485 
5502  OrthancPluginContext* context,
5503  const void* buffer,
5504  uint32_t bufferSize,
5505  uint32_t frameIndex)
5506  {
5507  OrthancPluginImage* target = NULL;
5508 
5509  _OrthancPluginCreateImage params;
5510  memset(&params, 0, sizeof(params));
5511  params.target = &target;
5512  params.constBuffer = buffer;
5513  params.bufferSize = bufferSize;
5514  params.frameIndex = frameIndex;
5515 
5516  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5517  {
5518  return NULL;
5519  }
5520  else
5521  {
5522  return target;
5523  }
5524  }
5525 
5526 
5527 
5528  typedef struct
5529  {
5530  char** result;
5531  const void* buffer;
5532  uint32_t size;
5533  } _OrthancPluginComputeHash;
5534 
5547  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5548  OrthancPluginContext* context,
5549  const void* buffer,
5550  uint32_t size)
5551  {
5552  char* result;
5553 
5554  _OrthancPluginComputeHash params;
5555  params.result = &result;
5556  params.buffer = buffer;
5557  params.size = size;
5558 
5559  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5560  {
5561  /* Error */
5562  return NULL;
5563  }
5564  else
5565  {
5566  return result;
5567  }
5568  }
5569 
5570 
5583  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5584  OrthancPluginContext* context,
5585  const void* buffer,
5586  uint32_t size)
5587  {
5588  char* result;
5589 
5590  _OrthancPluginComputeHash params;
5591  params.result = &result;
5592  params.buffer = buffer;
5593  params.size = size;
5594 
5595  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5596  {
5597  /* Error */
5598  return NULL;
5599  }
5600  else
5601  {
5602  return result;
5603  }
5604  }
5605 
5606 
5607 
5608  typedef struct
5609  {
5611  const char* name;
5612  } _OrthancPluginLookupDictionary;
5613 
5630  OrthancPluginContext* context,
5632  const char* name)
5633  {
5634  _OrthancPluginLookupDictionary params;
5635  params.target = target;
5636  params.name = name;
5637  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5638  }
5639 
5640 
5641 
5642  typedef struct
5643  {
5644  OrthancPluginRestOutput* output;
5645  const void* answer;
5646  uint32_t answerSize;
5647  uint32_t headersCount;
5648  const char* const* headersKeys;
5649  const char* const* headersValues;
5650  } _OrthancPluginSendMultipartItem2;
5651 
5673  OrthancPluginContext* context,
5674  OrthancPluginRestOutput* output,
5675  const void* answer,
5676  uint32_t answerSize,
5677  uint32_t headersCount,
5678  const char* const* headersKeys,
5679  const char* const* headersValues)
5680  {
5681  _OrthancPluginSendMultipartItem2 params;
5682  params.output = output;
5683  params.answer = answer;
5684  params.answerSize = answerSize;
5685  params.headersCount = headersCount;
5686  params.headersKeys = headersKeys;
5687  params.headersValues = headersValues;
5688 
5689  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5690  }
5691 
5692 
5693  typedef struct
5694  {
5696  } _OrthancPluginIncomingHttpRequestFilter;
5697 
5711  OrthancPluginContext* context,
5713  {
5714  _OrthancPluginIncomingHttpRequestFilter params;
5715  params.callback = callback;
5716 
5717  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5718  }
5719 
5720 
5721 
5722  typedef struct
5723  {
5724  OrthancPluginMemoryBuffer* answerBody;
5725  OrthancPluginMemoryBuffer* answerHeaders;
5726  uint16_t* httpStatus;
5727  OrthancPluginHttpMethod method;
5728  const char* url;
5729  uint32_t headersCount;
5730  const char* const* headersKeys;
5731  const char* const* headersValues;
5732  const void* body;
5733  uint32_t bodySize;
5734  const char* username;
5735  const char* password;
5736  uint32_t timeout;
5737  const char* certificateFile;
5738  const char* certificateKeyFile;
5739  const char* certificateKeyPassword;
5740  uint8_t pkcs11;
5741  } _OrthancPluginCallHttpClient2;
5742 
5743 
5744 
5785  OrthancPluginContext* context,
5786  OrthancPluginMemoryBuffer* answerBody,
5787  OrthancPluginMemoryBuffer* answerHeaders,
5788  uint16_t* httpStatus,
5789  OrthancPluginHttpMethod method,
5790  const char* url,
5791  uint32_t headersCount,
5792  const char* const* headersKeys,
5793  const char* const* headersValues,
5794  const void* body,
5795  uint32_t bodySize,
5796  const char* username,
5797  const char* password,
5798  uint32_t timeout,
5799  const char* certificateFile,
5800  const char* certificateKeyFile,
5801  const char* certificateKeyPassword,
5802  uint8_t pkcs11)
5803  {
5804  _OrthancPluginCallHttpClient2 params;
5805  memset(&params, 0, sizeof(params));
5806 
5807  params.answerBody = answerBody;
5808  params.answerHeaders = answerHeaders;
5809  params.httpStatus = httpStatus;
5810  params.method = method;
5811  params.url = url;
5812  params.headersCount = headersCount;
5813  params.headersKeys = headersKeys;
5814  params.headersValues = headersValues;
5815  params.body = body;
5816  params.bodySize = bodySize;
5817  params.username = username;
5818  params.password = password;
5819  params.timeout = timeout;
5820  params.certificateFile = certificateFile;
5821  params.certificateKeyFile = certificateKeyFile;
5822  params.certificateKeyPassword = certificateKeyPassword;
5823  params.pkcs11 = pkcs11;
5824 
5825  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5826  }
5827 
5828 
5839  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5840  OrthancPluginContext* context)
5841  {
5842  char* result;
5843 
5844  _OrthancPluginRetrieveDynamicString params;
5845  params.result = &result;
5846  params.argument = NULL;
5847 
5848  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5849  {
5850  /* Error */
5851  return NULL;
5852  }
5853  else
5854  {
5855  return result;
5856  }
5857  }
5858 
5859 
5860 
5861 
5862  typedef struct
5863  {
5864  OrthancPluginFindCallback callback;
5865  } _OrthancPluginFindCallback;
5866 
5879  OrthancPluginContext* context,
5880  OrthancPluginFindCallback callback)
5881  {
5882  _OrthancPluginFindCallback params;
5883  params.callback = callback;
5884 
5885  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5886  }
5887 
5888 
5889  typedef struct
5890  {
5891  OrthancPluginFindAnswers *answers;
5892  const OrthancPluginFindQuery *query;
5893  const void *dicom;
5894  uint32_t size;
5895  uint32_t index;
5896  uint32_t *resultUint32;
5897  uint16_t *resultGroup;
5898  uint16_t *resultElement;
5899  char **resultString;
5900  } _OrthancPluginFindOperation;
5901 
5918  OrthancPluginContext* context,
5919  OrthancPluginFindAnswers* answers,
5920  const void* dicom,
5921  uint32_t size)
5922  {
5923  _OrthancPluginFindOperation params;
5924  memset(&params, 0, sizeof(params));
5925  params.answers = answers;
5926  params.dicom = dicom;
5927  params.size = size;
5928 
5929  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
5930  }
5931 
5932 
5947  OrthancPluginContext* context,
5948  OrthancPluginFindAnswers* answers)
5949  {
5950  _OrthancPluginFindOperation params;
5951  memset(&params, 0, sizeof(params));
5952  params.answers = answers;
5953 
5954  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
5955  }
5956 
5957 
5958 
5970  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
5971  OrthancPluginContext* context,
5972  const OrthancPluginFindQuery* query)
5973  {
5974  uint32_t count = 0;
5975 
5976  _OrthancPluginFindOperation params;
5977  memset(&params, 0, sizeof(params));
5978  params.query = query;
5979  params.resultUint32 = &count;
5980 
5981  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
5982  {
5983  /* Error */
5984  return 0;
5985  }
5986  else
5987  {
5988  return count;
5989  }
5990  }
5991 
5992 
6008  OrthancPluginContext* context,
6009  uint16_t* group,
6010  uint16_t* element,
6011  const OrthancPluginFindQuery* query,
6012  uint32_t index)
6013  {
6014  _OrthancPluginFindOperation params;
6015  memset(&params, 0, sizeof(params));
6016  params.query = query;
6017  params.index = index;
6018  params.resultGroup = group;
6019  params.resultElement = element;
6020 
6021  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
6022  }
6023 
6024 
6038  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
6039  OrthancPluginContext* context,
6040  const OrthancPluginFindQuery* query,
6041  uint32_t index)
6042  {
6043  char* result;
6044 
6045  _OrthancPluginFindOperation params;
6046  memset(&params, 0, sizeof(params));
6047  params.query = query;
6048  params.index = index;
6049  params.resultString = &result;
6050 
6051  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
6052  {
6053  /* Error */
6054  return NULL;
6055  }
6056  else
6057  {
6058  return result;
6059  }
6060  }
6061 
6062 
6076  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
6077  OrthancPluginContext* context,
6078  const OrthancPluginFindQuery* query,
6079  uint32_t index)
6080  {
6081  char* result;
6082 
6083  _OrthancPluginFindOperation params;
6084  memset(&params, 0, sizeof(params));
6085  params.query = query;
6086  params.index = index;
6087  params.resultString = &result;
6088 
6089  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
6090  {
6091  /* Error */
6092  return NULL;
6093  }
6094  else
6095  {
6096  return result;
6097  }
6098  }
6099 
6100 
6101 
6102 
6103  typedef struct
6104  {
6105  OrthancPluginMoveCallback callback;
6106  OrthancPluginGetMoveSize getMoveSize;
6107  OrthancPluginApplyMove applyMove;
6108  OrthancPluginFreeMove freeMove;
6109  } _OrthancPluginMoveCallback;
6110 
6125  OrthancPluginContext* context,
6126  OrthancPluginMoveCallback callback,
6127  OrthancPluginGetMoveSize getMoveSize,
6128  OrthancPluginApplyMove applyMove,
6129  OrthancPluginFreeMove freeMove)
6130  {
6131  _OrthancPluginMoveCallback params;
6132  params.callback = callback;
6133  params.getMoveSize = getMoveSize;
6134  params.applyMove = applyMove;
6135  params.freeMove = freeMove;
6136 
6137  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
6138  }
6139 
6140 
6141 
6142  typedef struct
6143  {
6144  OrthancPluginFindMatcher** target;
6145  const void* query;
6146  uint32_t size;
6147  } _OrthancPluginCreateFindMatcher;
6148 
6149 
6164  OrthancPluginContext* context,
6165  const void* query,
6166  uint32_t size)
6167  {
6168  OrthancPluginFindMatcher* target = NULL;
6169 
6170  _OrthancPluginCreateFindMatcher params;
6171  memset(&params, 0, sizeof(params));
6172  params.target = &target;
6173  params.query = query;
6174  params.size = size;
6175 
6176  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
6177  {
6178  return NULL;
6179  }
6180  else
6181  {
6182  return target;
6183  }
6184  }
6185 
6186 
6187  typedef struct
6188  {
6189  OrthancPluginFindMatcher* matcher;
6190  } _OrthancPluginFreeFindMatcher;
6191 
6201  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6202  OrthancPluginContext* context,
6203  OrthancPluginFindMatcher* matcher)
6204  {
6205  _OrthancPluginFreeFindMatcher params;
6206  params.matcher = matcher;
6207 
6208  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6209  }
6210 
6211 
6212  typedef struct
6213  {
6214  const OrthancPluginFindMatcher* matcher;
6215  const void* dicom;
6216  uint32_t size;
6217  int32_t* isMatch;
6218  } _OrthancPluginFindMatcherIsMatch;
6219 
6234  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6235  OrthancPluginContext* context,
6236  const OrthancPluginFindMatcher* matcher,
6237  const void* dicom,
6238  uint32_t size)
6239  {
6240  int32_t isMatch = 0;
6241 
6242  _OrthancPluginFindMatcherIsMatch params;
6243  params.matcher = matcher;
6244  params.dicom = dicom;
6245  params.size = size;
6246  params.isMatch = &isMatch;
6247 
6248  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6249  {
6250  return isMatch;
6251  }
6252  else
6253  {
6254  /* Error: Assume non-match */
6255  return 0;
6256  }
6257  }
6258 
6259 
6260  typedef struct
6261  {
6263  } _OrthancPluginIncomingHttpRequestFilter2;
6264 
6277  OrthancPluginContext* context,
6279  {
6280  _OrthancPluginIncomingHttpRequestFilter2 params;
6281  params.callback = callback;
6282 
6283  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6284  }
6285 
6286 
6287 
6288  typedef struct
6289  {
6290  OrthancPluginPeers** peers;
6291  } _OrthancPluginGetPeers;
6292 
6305  OrthancPluginContext* context)
6306  {
6307  OrthancPluginPeers* peers = NULL;
6308 
6309  _OrthancPluginGetPeers params;
6310  memset(&params, 0, sizeof(params));
6311  params.peers = &peers;
6312 
6313  if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6314  {
6315  return NULL;
6316  }
6317  else
6318  {
6319  return peers;
6320  }
6321  }
6322 
6323 
6324  typedef struct
6325  {
6326  OrthancPluginPeers* peers;
6327  } _OrthancPluginFreePeers;
6328 
6338  ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6339  OrthancPluginContext* context,
6340  OrthancPluginPeers* peers)
6341  {
6342  _OrthancPluginFreePeers params;
6343  params.peers = peers;
6344 
6345  context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6346  }
6347 
6348 
6349  typedef struct
6350  {
6351  uint32_t* target;
6352  const OrthancPluginPeers* peers;
6353  } _OrthancPluginGetPeersCount;
6354 
6368  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6369  OrthancPluginContext* context,
6370  const OrthancPluginPeers* peers)
6371  {
6372  uint32_t target = 0;
6373 
6374  _OrthancPluginGetPeersCount params;
6375  memset(&params, 0, sizeof(params));
6376  params.target = &target;
6377  params.peers = peers;
6378 
6379  if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6380  {
6381  /* Error */
6382  return 0;
6383  }
6384  else
6385  {
6386  return target;
6387  }
6388  }
6389 
6390 
6391  typedef struct
6392  {
6393  const char** target;
6394  const OrthancPluginPeers* peers;
6395  uint32_t peerIndex;
6396  const char* userProperty;
6397  } _OrthancPluginGetPeerProperty;
6398 
6416  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6417  OrthancPluginContext* context,
6418  const OrthancPluginPeers* peers,
6419  uint32_t peerIndex)
6420  {
6421  const char* target = NULL;
6422 
6423  _OrthancPluginGetPeerProperty params;
6424  memset(&params, 0, sizeof(params));
6425  params.target = &target;
6426  params.peers = peers;
6427  params.peerIndex = peerIndex;
6428  params.userProperty = NULL;
6429 
6430  if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6431  {
6432  /* Error */
6433  return NULL;
6434  }
6435  else
6436  {
6437  return target;
6438  }
6439  }
6440 
6441 
6457  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6458  OrthancPluginContext* context,
6459  const OrthancPluginPeers* peers,
6460  uint32_t peerIndex)
6461  {
6462  const char* target = NULL;
6463 
6464  _OrthancPluginGetPeerProperty params;
6465  memset(&params, 0, sizeof(params));
6466  params.target = &target;
6467  params.peers = peers;
6468  params.peerIndex = peerIndex;
6469  params.userProperty = NULL;
6470 
6471  if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6472  {
6473  /* Error */
6474  return NULL;
6475  }
6476  else
6477  {
6478  return target;
6479  }
6480  }
6481 
6482 
6483 
6503  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6504  OrthancPluginContext* context,
6505  const OrthancPluginPeers* peers,
6506  uint32_t peerIndex,
6507  const char* userProperty)
6508  {
6509  const char* target = NULL;
6510 
6511  _OrthancPluginGetPeerProperty params;
6512  memset(&params, 0, sizeof(params));
6513  params.target = &target;
6514  params.peers = peers;
6515  params.peerIndex = peerIndex;
6516  params.userProperty = userProperty;
6517 
6518  if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6519  {
6520  /* No such user property */
6521  return NULL;
6522  }
6523  else
6524  {
6525  return target;
6526  }
6527  }
6528 
6529 
6530 
6531  typedef struct
6532  {
6533  OrthancPluginMemoryBuffer* answerBody;
6534  OrthancPluginMemoryBuffer* answerHeaders;
6535  uint16_t* httpStatus;
6536  const OrthancPluginPeers* peers;
6537  uint32_t peerIndex;
6538  OrthancPluginHttpMethod method;
6539  const char* uri;
6540  uint32_t additionalHeadersCount;
6541  const char* const* additionalHeadersKeys;
6542  const char* const* additionalHeadersValues;
6543  const void* body;
6544  uint32_t bodySize;
6545  uint32_t timeout;
6546  } _OrthancPluginCallPeerApi;
6547 
6584  OrthancPluginContext* context,
6585  OrthancPluginMemoryBuffer* answerBody,
6586  OrthancPluginMemoryBuffer* answerHeaders,
6587  uint16_t* httpStatus,
6588  const OrthancPluginPeers* peers,
6589  uint32_t peerIndex,
6590  OrthancPluginHttpMethod method,
6591  const char* uri,
6592  uint32_t additionalHeadersCount,
6593  const char* const* additionalHeadersKeys,
6594  const char* const* additionalHeadersValues,
6595  const void* body,
6596  uint32_t bodySize,
6597  uint32_t timeout)
6598  {
6599  _OrthancPluginCallPeerApi params;
6600  memset(&params, 0, sizeof(params));
6601 
6602  params.answerBody = answerBody;
6603  params.answerHeaders = answerHeaders;
6604  params.httpStatus = httpStatus;
6605  params.peers = peers;
6606  params.peerIndex = peerIndex;
6607  params.method = method;
6608  params.uri = uri;
6609  params.additionalHeadersCount = additionalHeadersCount;
6610  params.additionalHeadersKeys = additionalHeadersKeys;
6611  params.additionalHeadersValues = additionalHeadersValues;
6612  params.body = body;
6613  params.bodySize = bodySize;
6614  params.timeout = timeout;
6615 
6616  return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6617  }
6618 
6619 
6620 
6621 
6622 
6623  typedef struct
6624  {
6625  OrthancPluginJob** target;
6626  void *job;
6627  OrthancPluginJobFinalize finalize;
6628  const char *type;
6629  OrthancPluginJobGetProgress getProgress;
6630  OrthancPluginJobGetContent getContent;
6631  OrthancPluginJobGetSerialized getSerialized;
6632  OrthancPluginJobStep step;
6633  OrthancPluginJobStop stop;
6634  OrthancPluginJobReset reset;
6635  } _OrthancPluginCreateJob;
6636 
6669  OrthancPluginContext *context,
6670  void *job,
6671  OrthancPluginJobFinalize finalize,
6672  const char *type,
6673  OrthancPluginJobGetProgress getProgress,
6674  OrthancPluginJobGetContent getContent,
6675  OrthancPluginJobGetSerialized getSerialized,
6676  OrthancPluginJobStep step,
6677  OrthancPluginJobStop stop,
6678  OrthancPluginJobReset reset)
6679  {
6680  OrthancPluginJob* target = NULL;
6681 
6682  _OrthancPluginCreateJob params;
6683  memset(&params, 0, sizeof(params));
6684 
6685  params.target = &target;
6686  params.job = job;
6687  params.finalize = finalize;
6688  params.type = type;
6689  params.getProgress = getProgress;
6690  params.getContent = getContent;
6691  params.getSerialized = getSerialized;
6692  params.step = step;
6693  params.stop = stop;
6694  params.reset = reset;
6695 
6696  if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6697  target == NULL)
6698  {
6699  /* Error */
6700  return NULL;
6701  }
6702  else
6703  {
6704  return target;
6705  }
6706  }
6707 
6708 
6709  typedef struct
6710  {
6711  OrthancPluginJob* job;
6712  } _OrthancPluginFreeJob;
6713 
6723  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6724  OrthancPluginContext* context,
6725  OrthancPluginJob* job)
6726  {
6727  _OrthancPluginFreeJob params;
6728  params.job = job;
6729 
6730  context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6731  }
6732 
6733 
6734 
6735  typedef struct
6736  {
6737  char** resultId;
6738  OrthancPluginJob *job;
6739  int priority;
6740  } _OrthancPluginSubmitJob;
6741 
6755  ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6756  OrthancPluginContext *context,
6757  OrthancPluginJob *job,
6758  int priority)
6759  {
6760  char* resultId = NULL;
6761 
6762  _OrthancPluginSubmitJob params;
6763  memset(&params, 0, sizeof(params));
6764 
6765  params.resultId = &resultId;
6766  params.job = job;
6767  params.priority = priority;
6768 
6769  if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6770  resultId == NULL)
6771  {
6772  /* Error */
6773  return NULL;
6774  }
6775  else
6776  {
6777  return resultId;
6778  }
6779  }
6780 
6781 
6782 
6783  typedef struct
6784  {
6785  OrthancPluginJobsUnserializer unserializer;
6786  } _OrthancPluginJobsUnserializer;
6787 
6800  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6801  OrthancPluginContext* context,
6802  OrthancPluginJobsUnserializer unserializer)
6803  {
6804  _OrthancPluginJobsUnserializer params;
6805  params.unserializer = unserializer;
6806 
6807  context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6808  }
6809 
6810 
6811 
6812  typedef struct
6813  {
6814  OrthancPluginRestOutput* output;
6815  const char* details;
6816  uint8_t log;
6817  } _OrthancPluginSetHttpErrorDetails;
6818 
6836  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
6837  OrthancPluginContext* context,
6838  OrthancPluginRestOutput* output,
6839  const char* details,
6840  uint8_t log)
6841  {
6842  _OrthancPluginSetHttpErrorDetails params;
6843  params.output = output;
6844  params.details = details;
6845  params.log = log;
6846  context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
6847  }
6848 
6849 
6850 
6851  typedef struct
6852  {
6853  const char** result;
6854  const char* argument;
6855  } _OrthancPluginRetrieveStaticString;
6856 
6868  ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
6869  OrthancPluginContext* context,
6870  const char* path)
6871  {
6872  const char* result = NULL;
6873 
6874  _OrthancPluginRetrieveStaticString params;
6875  params.result = &result;
6876  params.argument = path;
6877 
6878  if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
6879  {
6880  /* Error */
6881  return NULL;
6882  }
6883  else
6884  {
6885  return result;
6886  }
6887  }
6888 
6889 
6890 
6891  typedef struct
6892  {
6893  const char* name;
6894  float value;
6896  } _OrthancPluginSetMetricsValue;
6897 
6912  ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
6913  OrthancPluginContext* context,
6914  const char* name,
6915  float value,
6917  {
6918  _OrthancPluginSetMetricsValue params;
6919  params.name = name;
6920  params.value = value;
6921  params.type = type;
6922  context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
6923  }
6924 
6925 
6926 
6927  typedef struct
6928  {
6930  } _OrthancPluginRegisterRefreshMetricsCallback;
6931 
6943  OrthancPluginContext* context,
6945  {
6946  _OrthancPluginRegisterRefreshMetricsCallback params;
6947  params.callback = callback;
6948  context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
6949  }
6950 
6951 
6952 
6953 
6954  typedef struct
6955  {
6956  char** target;
6957  const void* dicom;
6958  uint32_t dicomSize;
6960  } _OrthancPluginEncodeDicomWeb;
6961 
6978  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
6979  OrthancPluginContext* context,
6980  const void* dicom,
6981  uint32_t dicomSize,
6983  {
6984  char* target = NULL;
6985 
6986  _OrthancPluginEncodeDicomWeb params;
6987  params.target = &target;
6988  params.dicom = dicom;
6989  params.dicomSize = dicomSize;
6990  params.callback = callback;
6991 
6992  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
6993  {
6994  /* Error */
6995  return NULL;
6996  }
6997  else
6998  {
6999  return target;
7000  }
7001  }
7002 
7003 
7020  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
7021  OrthancPluginContext* context,
7022  const void* dicom,
7023  uint32_t dicomSize,
7025  {
7026  char* target = NULL;
7027 
7028  _OrthancPluginEncodeDicomWeb params;
7029  params.target = &target;
7030  params.dicom = dicom;
7031  params.dicomSize = dicomSize;
7032  params.callback = callback;
7033 
7034  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
7035  {
7036  /* Error */
7037  return NULL;
7038  }
7039  else
7040  {
7041  return target;
7042  }
7043  }
7044 
7045 
7046 
7047  typedef struct
7048  {
7049  char** target;
7050  const void* dicom;
7051  uint32_t dicomSize;
7053  void* payload;
7054  } _OrthancPluginEncodeDicomWeb2;
7055 
7072  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson2(
7073  OrthancPluginContext* context,
7074  const void* dicom,
7075  uint32_t dicomSize,
7077  void* payload)
7078  {
7079  char* target = NULL;
7080 
7081  _OrthancPluginEncodeDicomWeb2 params;
7082  params.target = &target;
7083  params.dicom = dicom;
7084  params.dicomSize = dicomSize;
7085  params.callback = callback;
7086  params.payload = payload;
7087 
7088  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson2, &params) != OrthancPluginErrorCode_Success)
7089  {
7090  /* Error */
7091  return NULL;
7092  }
7093  else
7094  {
7095  return target;
7096  }
7097  }
7098 
7099 
7116  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml2(
7117  OrthancPluginContext* context,
7118  const void* dicom,
7119  uint32_t dicomSize,
7121  void* payload)
7122  {
7123  char* target = NULL;
7124 
7125  _OrthancPluginEncodeDicomWeb2 params;
7126  params.target = &target;
7127  params.dicom = dicom;
7128  params.dicomSize = dicomSize;
7129  params.callback = callback;
7130  params.payload = payload;
7131 
7132  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml2, &params) != OrthancPluginErrorCode_Success)
7133  {
7134  /* Error */
7135  return NULL;
7136  }
7137  else
7138  {
7139  return target;
7140  }
7141  }
7142 
7143 
7144 
7161  void* answer,
7162  const char* key,
7163  const char* value);
7164 
7165 
7182  void* answer,
7183  const void* data,
7184  uint32_t size);
7185 
7186 
7201  typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
7202 
7203 
7219 
7220 
7234  typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
7235 
7236 
7250  typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
7251 
7252 
7253  typedef struct
7254  {
7255  void* answer;
7258  uint16_t* httpStatus;
7259  OrthancPluginHttpMethod method;
7260  const char* url;
7261  uint32_t headersCount;
7262  const char* const* headersKeys;
7263  const char* const* headersValues;
7264  void* request;
7269  const char* username;
7270  const char* password;
7271  uint32_t timeout;
7272  const char* certificateFile;
7273  const char* certificateKeyFile;
7274  const char* certificateKeyPassword;
7275  uint8_t pkcs11;
7276  } _OrthancPluginChunkedHttpClient;
7277 
7278 
7330  OrthancPluginContext* context,
7331  void* answer,
7334  uint16_t* httpStatus,
7335  OrthancPluginHttpMethod method,
7336  const char* url,
7337  uint32_t headersCount,
7338  const char* const* headersKeys,
7339  const char* const* headersValues,
7340  void* request,
7345  const char* username,
7346  const char* password,
7347  uint32_t timeout,
7348  const char* certificateFile,
7349  const char* certificateKeyFile,
7350  const char* certificateKeyPassword,
7351  uint8_t pkcs11)
7352  {
7353  _OrthancPluginChunkedHttpClient params;
7354  memset(&params, 0, sizeof(params));
7355 
7356  /* In common with OrthancPluginHttpClient() */
7357  params.httpStatus = httpStatus;
7358  params.method = method;
7359  params.url = url;
7360  params.headersCount = headersCount;
7361  params.headersKeys = headersKeys;
7362  params.headersValues = headersValues;
7363  params.username = username;
7364  params.password = password;
7365  params.timeout = timeout;
7366  params.certificateFile = certificateFile;
7367  params.certificateKeyFile = certificateKeyFile;
7368  params.certificateKeyPassword = certificateKeyPassword;
7369  params.pkcs11 = pkcs11;
7370 
7371  /* For chunked body/answer */
7372  params.answer = answer;
7373  params.answerAddChunk = answerAddChunk;
7374  params.answerAddHeader = answerAddHeader;
7375  params.request = request;
7376  params.requestIsDone = requestIsDone;
7377  params.requestChunkData = requestChunkData;
7378  params.requestChunkSize = requestChunkSize;
7379  params.requestNext = requestNext;
7380 
7381  return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7382  }
7383 
7384 
7385 
7390  typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7391 
7392 
7393 
7411  const char* url,
7412  const OrthancPluginHttpRequest* request);
7413 
7414 
7430  const void* data,
7431  uint32_t size);
7432 
7433 
7450  OrthancPluginRestOutput* output);
7451 
7452 
7468 
7469  typedef struct
7470  {
7471  const char* pathRegularExpression;
7472  OrthancPluginRestCallback getHandler;
7474  OrthancPluginRestCallback deleteHandler;
7479  } _OrthancPluginChunkedRestCallback;
7480 
7481 
7511  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterChunkedRestCallback(
7512  OrthancPluginContext* context,
7513  const char* pathRegularExpression,
7514  OrthancPluginRestCallback getHandler,
7516  OrthancPluginRestCallback deleteHandler,
7521  {
7522  _OrthancPluginChunkedRestCallback params;
7523  params.pathRegularExpression = pathRegularExpression;
7524  params.getHandler = getHandler;
7525  params.postHandler = postHandler;
7526  params.deleteHandler = deleteHandler;
7527  params.putHandler = putHandler;
7528  params.addChunk = addChunk;
7529  params.execute = execute;
7530  params.finalize = finalize;
7531 
7532  context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
7533  }
7534 
7535 
7536 
7537 
7538 
7539  typedef struct
7540  {
7541  char** result;
7542  uint16_t group;
7543  uint16_t element;
7544  const char* privateCreator;
7545  } _OrthancPluginGetTagName;
7546 
7562  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
7563  OrthancPluginContext* context,
7564  uint16_t group,
7565  uint16_t element,
7566  const char* privateCreator)
7567  {
7568  char* result;
7569 
7570  _OrthancPluginGetTagName params;
7571  params.result = &result;
7572  params.group = group;
7573  params.element = element;
7574  params.privateCreator = privateCreator;
7575 
7576  if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
7577  {
7578  /* Error */
7579  return NULL;
7580  }
7581  else
7582  {
7583  return result;
7584  }
7585  }
7586 
7587 
7588 
7618  void** handler /* out */,
7619  const char* jobId,
7620  const char* transactionUid,
7621  const char* const* sopClassUids,
7622  const char* const* sopInstanceUids,
7623  uint32_t countInstances,
7624  const char* remoteAet,
7625  const char* calledAet);
7626 
7627 
7639  typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
7640 
7641 
7662  void* handler,
7663  const char* sopClassUid,
7664  const char* sopInstanceUid);
7665 
7666 
7667  typedef struct
7668  {
7672  } _OrthancPluginRegisterStorageCommitmentScpCallback;
7673 
7688  OrthancPluginContext* context,
7692  {
7693  _OrthancPluginRegisterStorageCommitmentScpCallback params;
7694  params.factory = factory;
7695  params.destructor = destructor;
7696  params.lookup = lookup;
7697  return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
7698  }
7699 
7700 
7701 
7718  const OrthancPluginDicomInstance* instance);
7719 
7720 
7721  typedef struct
7722  {
7724  } _OrthancPluginIncomingDicomInstanceFilter;
7725 
7749  OrthancPluginContext* context,
7751  {
7752  _OrthancPluginIncomingDicomInstanceFilter params;
7753  params.callback = callback;
7754 
7755  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, &params);
7756  }
7757 
7758 
7772  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceTransferSyntaxUid(
7773  OrthancPluginContext* context,
7774  const OrthancPluginDicomInstance* instance)
7775  {
7776  char* result;
7777 
7778  _OrthancPluginAccessDicomInstance params;
7779  memset(&params, 0, sizeof(params));
7780  params.resultStringToFree = &result;
7781  params.instance = instance;
7782 
7783  if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, &params) != OrthancPluginErrorCode_Success)
7784  {
7785  /* Error */
7786  return NULL;
7787  }
7788  else
7789  {
7790  return result;
7791  }
7792  }
7793 
7794 
7807  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData(
7808  OrthancPluginContext* context,
7809  const OrthancPluginDicomInstance* instance)
7810  {
7811  int64_t hasPixelData;
7812 
7813  _OrthancPluginAccessDicomInstance params;
7814  memset(&params, 0, sizeof(params));
7815  params.resultInt64 = &hasPixelData;
7816  params.instance = instance;
7817 
7818  if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, &params) != OrthancPluginErrorCode_Success ||
7819  hasPixelData < 0 ||
7820  hasPixelData > 1)
7821  {
7822  /* Error */
7823  return -1;
7824  }
7825  else
7826  {
7827  return (hasPixelData != 0);
7828  }
7829  }
7830 
7831 
7832 
7833 
7834 
7835 
7836  typedef struct
7837  {
7838  OrthancPluginDicomInstance** target;
7839  const void* buffer;
7840  uint32_t size;
7841  const char* transferSyntax;
7842  } _OrthancPluginCreateDicomInstance;
7843 
7858  OrthancPluginContext* context,
7859  const void* buffer,
7860  uint32_t size)
7861  {
7862  OrthancPluginDicomInstance* target = NULL;
7863 
7864  _OrthancPluginCreateDicomInstance params;
7865  params.target = &target;
7866  params.buffer = buffer;
7867  params.size = size;
7868 
7869  if (context->InvokeService(context, _OrthancPluginService_CreateDicomInstance, &params) != OrthancPluginErrorCode_Success)
7870  {
7871  /* Error */
7872  return NULL;
7873  }
7874  else
7875  {
7876  return target;
7877  }
7878  }
7879 
7880  typedef struct
7881  {
7883  } _OrthancPluginFreeDicomInstance;
7884 
7895  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeDicomInstance(
7896  OrthancPluginContext* context,
7898  {
7899  _OrthancPluginFreeDicomInstance params;
7900  params.dicom = dicom;
7901 
7902  context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, &params);
7903  }
7904 
7905 
7906  typedef struct
7907  {
7908  uint32_t* targetUint32;
7909  OrthancPluginMemoryBuffer* targetBuffer;
7910  OrthancPluginImage** targetImage;
7911  char** targetStringToFree;
7912  const OrthancPluginDicomInstance* instance;
7913  uint32_t frameIndex;
7916  uint32_t maxStringLength;
7917  OrthancPluginDicomWebBinaryCallback2 dicomWebCallback;
7918  void* dicomWebPayload;
7919  } _OrthancPluginAccessDicomInstance2;
7920 
7932  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetInstanceFramesCount(
7933  OrthancPluginContext* context,
7934  const OrthancPluginDicomInstance* instance)
7935  {
7936  uint32_t count;
7937 
7938  _OrthancPluginAccessDicomInstance2 params;
7939  memset(&params, 0, sizeof(params));
7940  params.targetUint32 = &count;
7941  params.instance = instance;
7942 
7943  if (context->InvokeService(context, _OrthancPluginService_GetInstanceFramesCount, &params) != OrthancPluginErrorCode_Success)
7944  {
7945  /* Error */
7946  return 0;
7947  }
7948  else
7949  {
7950  return count;
7951  }
7952  }
7953 
7954 
7973  OrthancPluginContext* context,
7974  OrthancPluginMemoryBuffer* target,
7975  const OrthancPluginDicomInstance* instance,
7976  uint32_t frameIndex)
7977  {
7978  _OrthancPluginAccessDicomInstance2 params;
7979  memset(&params, 0, sizeof(params));
7980  params.targetBuffer = target;
7981  params.instance = instance;
7982  params.frameIndex = frameIndex;
7983 
7984  return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, &params);
7985  }
7986 
7987 
8001  OrthancPluginContext* context,
8002  const OrthancPluginDicomInstance* instance,
8003  uint32_t frameIndex)
8004  {
8005  OrthancPluginImage* target = NULL;
8006 
8007  _OrthancPluginAccessDicomInstance2 params;
8008  memset(&params, 0, sizeof(params));
8009  params.targetImage = &target;
8010  params.instance = instance;
8011  params.frameIndex = frameIndex;
8012 
8013  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDecodedFrame, &params) != OrthancPluginErrorCode_Success)
8014  {
8015  return NULL;
8016  }
8017  else
8018  {
8019  return target;
8020  }
8021  }
8022 
8023 
8040  OrthancPluginContext* context,
8041  const void* buffer,
8042  uint32_t size,
8043  const char* transferSyntax)
8044  {
8045  OrthancPluginDicomInstance* target = NULL;
8046 
8047  _OrthancPluginCreateDicomInstance params;
8048  params.target = &target;
8049  params.buffer = buffer;
8050  params.size = size;
8051  params.transferSyntax = transferSyntax;
8052 
8053  if (context->InvokeService(context, _OrthancPluginService_TranscodeDicomInstance, &params) != OrthancPluginErrorCode_Success)
8054  {
8055  /* Error */
8056  return NULL;
8057  }
8058  else
8059  {
8060  return target;
8061  }
8062  }
8063 
8078  OrthancPluginContext* context,
8079  OrthancPluginMemoryBuffer* target,
8080  const OrthancPluginDicomInstance* instance)
8081  {
8082  _OrthancPluginAccessDicomInstance2 params;
8083  memset(&params, 0, sizeof(params));
8084  params.targetBuffer = target;
8085  params.instance = instance;
8086 
8087  return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, &params);
8088  }
8089 
8090 
8109  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceAdvancedJson(
8110  OrthancPluginContext* context,
8111  const OrthancPluginDicomInstance* instance,
8114  uint32_t maxStringLength)
8115  {
8116  char* result = NULL;
8117 
8118  _OrthancPluginAccessDicomInstance2 params;
8119  memset(&params, 0, sizeof(params));
8120  params.targetStringToFree = &result;
8121  params.instance = instance;
8122  params.format = format;
8123  params.flags = flags;
8124  params.maxStringLength = maxStringLength;
8125 
8126  if (context->InvokeService(context, _OrthancPluginService_GetInstanceAdvancedJson, &params) != OrthancPluginErrorCode_Success)
8127  {
8128  /* Error */
8129  return NULL;
8130  }
8131  else
8132  {
8133  return result;
8134  }
8135  }
8136 
8137 
8152  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebJson(
8153  OrthancPluginContext* context,
8154  const OrthancPluginDicomInstance* instance,
8156  void* payload)
8157  {
8158  char* target = NULL;
8159 
8160  _OrthancPluginAccessDicomInstance2 params;
8161  params.targetStringToFree = &target;
8162  params.instance = instance;
8163  params.dicomWebCallback = callback;
8164  params.dicomWebPayload = payload;
8165 
8166  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebJson, &params) != OrthancPluginErrorCode_Success)
8167  {
8168  /* Error */
8169  return NULL;
8170  }
8171  else
8172  {
8173  return target;
8174  }
8175  }
8176 
8177 
8192  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebXml(
8193  OrthancPluginContext* context,
8194  const OrthancPluginDicomInstance* instance,
8196  void* payload)
8197  {
8198  char* target = NULL;
8199 
8200  _OrthancPluginAccessDicomInstance2 params;
8201  params.targetStringToFree = &target;
8202  params.instance = instance;
8203  params.dicomWebCallback = callback;
8204  params.dicomWebPayload = payload;
8205 
8206  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebXml, &params) != OrthancPluginErrorCode_Success)
8207  {
8208  /* Error */
8209  return NULL;
8210  }
8211  else
8212  {
8213  return target;
8214  }
8215  }
8216 
8217 
8218 
8238  OrthancPluginMemoryBuffer* transcoded /* out */,
8239  const void* buffer,
8240  uint64_t size,
8241  const char* const* allowedSyntaxes,
8242  uint32_t countSyntaxes,
8243  uint8_t allowNewSopInstanceUid);
8244 
8245 
8246  typedef struct
8247  {
8249  } _OrthancPluginTranscoderCallback;
8250 
8265  OrthancPluginContext* context,
8267  {
8268  _OrthancPluginTranscoderCallback params;
8269  params.callback = callback;
8270 
8271  return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, &params);
8272  }
8273 
8274 
8275 
8276  typedef struct
8277  {
8278  OrthancPluginMemoryBuffer* target;
8279  uint32_t size;
8280  } _OrthancPluginCreateMemoryBuffer;
8281 
8300  OrthancPluginContext* context,
8301  OrthancPluginMemoryBuffer* target,
8302  uint32_t size)
8303  {
8304  _OrthancPluginCreateMemoryBuffer params;
8305  params.target = target;
8306  params.size = size;
8307 
8308  return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, &params);
8309  }
8310 
8311 
8338  OrthancPluginContext* context)
8339  {
8340  char* result;
8341 
8342  _OrthancPluginRetrieveDynamicString params;
8343  params.result = &result;
8344  params.argument = NULL;
8345 
8346  if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
8347  &params) != OrthancPluginErrorCode_Success)
8348  {
8349  /* Error */
8350  return NULL;
8351  }
8352  else
8353  {
8354  return result;
8355  }
8356  }
8357 
8358 
8359 
8360  typedef struct
8361  {
8363  uint64_t size;
8364  } _OrthancPluginCreateMemoryBuffer64;
8365 
8384  OrthancPluginContext* context,
8386  uint64_t size)
8387  {
8388  _OrthancPluginCreateMemoryBuffer64 params;
8389  params.target = target;
8390  params.size = size;
8391 
8392  return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer64, &params);
8393  }
8394 
8395 
8396  typedef struct
8397  {
8402  } _OrthancPluginRegisterStorageArea2;
8403 
8420  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea2(
8421  OrthancPluginContext* context,
8426  {
8427  _OrthancPluginRegisterStorageArea2 params;
8428  params.create = create;
8429  params.readWhole = readWhole;
8430  params.readRange = readRange;
8431  params.remove = remove;
8432  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea2, &params);
8433  }
8434 
8435 
8436 
8437  typedef struct
8438  {
8439  _OrthancPluginCreateDicom createDicom;
8440  const char* privateCreator;
8441  } _OrthancPluginCreateDicom2;
8442 
8468  OrthancPluginContext* context,
8469  OrthancPluginMemoryBuffer* target,
8470  const char* json,
8471  const OrthancPluginImage* pixelData,
8473  const char* privateCreator)
8474  {
8475  _OrthancPluginCreateDicom2 params;
8476  params.createDicom.target = target;
8477  params.createDicom.json = json;
8478  params.createDicom.pixelData = pixelData;
8479  params.createDicom.flags = flags;
8480  params.privateCreator = privateCreator;
8481 
8482  return context->InvokeService(context, _OrthancPluginService_CreateDicom2, &params);
8483  }
8484 
8485 #ifdef __cplusplus
8486 }
8487 #endif
8488 
8489 
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:1811
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:3148
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:2113
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:1199
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5374
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:1265
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1916
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:1177
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:6942
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:1692
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4732
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:8237
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6276
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1245
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:2035
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3536
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3291
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:8420
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1145
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1664
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition: OrthancCPlugin.h:8264
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:1156
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4924
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1306
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1218
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:1730
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:1166
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1646
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6800
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1189
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:2075
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4693
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:1288
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:7511
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition: OrthancCPlugin.h:7748
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5710
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:4649
@ 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:5970
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1096
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1501
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:5946
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:6038
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7639
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:1325
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:6124
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:7617
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5878
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5256
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:7660
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:5217
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5917
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:1461
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:7687
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1104
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1088
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1418
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1486
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:5113
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5179
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:6076
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:6007
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1515
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1080
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:5149
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:7807
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:8192
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition: OrthancCPlugin.h:1056
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition: OrthancCPlugin.h:7772
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:7972
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:8109
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2945
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition: OrthancCPlugin.h:7857
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition: OrthancCPlugin.h:7932
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:8000
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5282
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2912
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:8152
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:3019
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2981
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:3058
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:3099
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition: OrthancCPlugin.h:7895
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition: OrthancCPlugin.h:8077
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition: OrthancCPlugin.h:8039
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2879
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:4595
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:4179
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3970
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4435
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3869
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4470
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:3935
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:4089
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:4134
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5412
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:4047
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4510
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:4004
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:5455
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:1072
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:747
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3902
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:3681
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5501
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4542
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1064
@ 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:2343
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:2378
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:2491
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2592
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3439
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3400
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:2455
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2662
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2627
char * OrthancPluginGenerateRestApiAuthorizationToken(OrthancPluginContext *context)
Generate a token to grant full access to the REST API of Orthanc.
Definition: OrthancCPlugin.h:8337
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2276
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2697
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:2306
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2557
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2407
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2430
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:5075
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2243
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:2202
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2765
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:6836
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2788
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:2145
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2742
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2843
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2818
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2525
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:4226
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:3639
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:5672
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3610
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:3833
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1613
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderExecute)(OrthancPluginServerChunkedRequestReader *reader, OrthancPluginRestOutput *output)
Callback invoked whenever the request body is entirely received.
Definition: OrthancCPlugin.h:7448
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:5784
struct _OrthancPluginJob_t OrthancPluginJob
Opaque structure to a job to be executed by Orthanc.
Definition: OrthancCPlugin.h:1128
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:8467
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:1999
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderFactory)(OrthancPluginServerChunkedRequestReader **reader, const char *url, const OrthancPluginHttpRequest *request)
Callback to create a reader to handle incoming chunked HTTP transfers.
Definition: OrthancCPlugin.h:7409
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:6201
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6338
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int priority)
Submit a new job to the jobs engine of Orthanc.
Definition: OrthancCPlugin.h:6755
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:4880
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:866
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:4827
OrthancPluginResourceType
Definition: OrthancCPlugin.h:700
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3749
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3470
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:1120
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:4317
uint32_t(* OrthancPluginChunkedClientRequestGetChunkSize)(void *request)
Callback to read the size of the current request chunk during a chunked transfer.
Definition: OrthancCPlugin.h:7250
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4771
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, uint32_t size)
Create a 32-bit memory buffer.
Definition: OrthancCPlugin.h:8299
OrthancPluginDicomWebBinaryMode
Definition: OrthancCPlugin.h:955
char * OrthancPluginEncodeDicomWebJson2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7072
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition: OrthancCPlugin.h:7717
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1574
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:5017
OrthancPluginErrorCode(* OrthancPluginChunkedClientRequestNext)(void *request)
Callback to advance in the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7218
struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode
Opaque structure that represents a node in a JSON or XML document used in DICOMweb.
Definition: OrthancCPlugin.h:1137
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1541
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:830
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:912
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:851
void(* OrthancPluginServerChunkedRequestReaderFinalize)(OrthancPluginServerChunkedRequestReader *reader)
Callback invoked to release the resources associated with an incoming HTTP chunked transfer.
Definition: OrthancCPlugin.h:7466
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:6234
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:3366
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:1983
OrthancPluginConstraintType
Definition: OrthancCPlugin.h:881
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3718
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1589
void OrthancPluginSetMetricsValue(OrthancPluginContext *context, const char *name, float value, OrthancPluginMetricsType type)
Set the value of a metrics.
Definition: OrthancCPlugin.h:6912
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:7428
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:7329
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:1048
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:6868
void OrthancPluginFreeMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1951
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:4359
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6416
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3504
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3780
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:5338
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:1391
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5839
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6723
OrthancPluginStorageCommitmentFailureReason
Definition: OrthancCPlugin.h:968
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:7181
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6457
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6304
OrthancPluginMetricsType
Definition: OrthancCPlugin.h:938
char * OrthancPluginEncodeDicomWebXml2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7116
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7020
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4397
uint8_t(* OrthancPluginChunkedClientRequestIsDone)(void *request)
Callback to know whether the request body is entirely read during a chunked transfer.
Definition: OrthancCPlugin.h:7201
char * OrthancPluginGetTagName(OrthancPluginContext *context, uint16_t group, uint16_t element, const char *privateCreator)
Returns the symbolic name of a DICOM tag.
Definition: OrthancCPlugin.h:7562
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5547
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:4968
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1935
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *target, uint64_t size)
Create a 64-bit memory buffer.
Definition: OrthancCPlugin.h:8383
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:7160
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6368
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition: OrthancCPlugin.h:7390
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:776
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:3245
const void *(* OrthancPluginChunkedClientRequestGetChunkData)(void *request)
Callback to read the current chunk of the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7234
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:4279
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:926
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:3210
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:6163
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:815
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:1967
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:320
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3569
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:1356
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:3322
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:6668
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:6583
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:1112
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:6503
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5629
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5583
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:896
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1528
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1781
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1556
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:6978
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:3180
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1630
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:3344
@ OrthancPluginIdentifierConstraint_Wildcard
Definition: OrthancCPlugin.h:870
@ OrthancPluginIdentifierConstraint_Equal
Definition: OrthancCPlugin.h:867
@ OrthancPluginIdentifierConstraint_SmallerOrEqual
Definition: OrthancCPlugin.h:868
@ OrthancPluginIdentifierConstraint_GreaterOrEqual
Definition: OrthancCPlugin.h:869
@ 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:957
@ OrthancPluginDicomWebBinaryMode_BulkDataUri
Definition: OrthancCPlugin.h:958
@ OrthancPluginDicomWebBinaryMode_Ignore
Definition: OrthancCPlugin.h:956
@ 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_SkipGroupLengths
Definition: OrthancCPlugin.h:839
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
Definition: OrthancCPlugin.h:837
@ OrthancPluginDicomToJsonFlags_StopAfterPixelData
Definition: OrthancCPlugin.h:838
@ OrthancPluginDicomToJsonFlags_IncludePrivateTags
Definition: OrthancCPlugin.h:833
@ OrthancPluginJobStepStatus_Continue
Definition: OrthancCPlugin.h:915
@ OrthancPluginJobStepStatus_Success
Definition: OrthancCPlugin.h:913
@ OrthancPluginJobStepStatus_Failure
Definition: OrthancCPlugin.h:914
@ OrthancPluginCreateDicomFlags_DecodeDataUriScheme
Definition: OrthancCPlugin.h:853
@ OrthancPluginCreateDicomFlags_GenerateIdentifiers
Definition: OrthancCPlugin.h:854
@ OrthancPluginConstraintType_SmallerOrEqual
Definition: OrthancCPlugin.h:883
@ OrthancPluginConstraintType_List
Definition: OrthancCPlugin.h:886
@ OrthancPluginConstraintType_GreaterOrEqual
Definition: OrthancCPlugin.h:884
@ OrthancPluginConstraintType_Equal
Definition: OrthancCPlugin.h:882
@ OrthancPluginConstraintType_Wildcard
Definition: OrthancCPlugin.h:885
@ OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
Definition: OrthancCPlugin.h:983
@ OrthancPluginStorageCommitmentFailureReason_Success
Definition: OrthancCPlugin.h:969
@ OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
Definition: OrthancCPlugin.h:992
@ OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
Definition: OrthancCPlugin.h:987
@ OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
Definition: OrthancCPlugin.h:979
@ OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
Definition: OrthancCPlugin.h:975
@ OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
Definition: OrthancCPlugin.h:972
@ OrthancPluginMetricsType_Default
Definition: OrthancCPlugin.h:939
@ OrthancPluginMetricsType_Timer
Definition: OrthancCPlugin.h:946
@ 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:929
@ OrthancPluginJobStopReason_Success
Definition: OrthancCPlugin.h:927
@ OrthancPluginJobStopReason_Canceled
Definition: OrthancCPlugin.h:930
@ OrthancPluginJobStopReason_Paused
Definition: OrthancCPlugin.h:928
@ 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:897
@ OrthancPluginInstanceOrigin_RestApi
Definition: OrthancCPlugin.h:899
@ OrthancPluginInstanceOrigin_Lua
Definition: OrthancCPlugin.h:901
@ OrthancPluginInstanceOrigin_WebDav
Definition: OrthancCPlugin.h:902
@ OrthancPluginInstanceOrigin_DicomProtocol
Definition: OrthancCPlugin.h:898
@ OrthancPluginInstanceOrigin_Plugin
Definition: OrthancCPlugin.h:900
@ 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:1763
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1767
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1768
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1766
uint16_t element
Definition: OrthancCPlugin.h:1765
uint16_t group
Definition: OrthancCPlugin.h:1764
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:1029
uint64_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1038
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1033
A 32-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1007
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1016
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1011