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