Orthanc Plugin SDK  1.10.0
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1 
106 #pragma once
107 
108 
109 #include <stdio.h>
110 #include <string.h>
111 
112 #ifdef WIN32
113 # define ORTHANC_PLUGINS_API __declspec(dllexport)
114 #elif __GNUC__ >= 4
115 # define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default")))
116 #else
117 # define ORTHANC_PLUGINS_API
118 #endif
119 
120 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
121 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 10
122 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 0
123 
124 
125 #if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
126 #define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
127  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
128  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
129  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
130  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
131  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
132 #endif
133 
134 
135 
136 /********************************************************************
137  ** Check that function inlining is properly supported. The use of
138  ** inlining is required, to avoid the duplication of object code
139  ** between two compilation modules that would use the Orthanc Plugin
140  ** API.
141  ********************************************************************/
142 
143 /* If the auto-detection of the "inline" keyword below does not work
144  automatically and that your compiler is known to properly support
145  inlining, uncomment the following #define and adapt the definition
146  of "static inline". */
147 
148 /* #define ORTHANC_PLUGIN_INLINE static inline */
149 
150 #ifndef ORTHANC_PLUGIN_INLINE
151 # if __STDC_VERSION__ >= 199901L
152 /* This is C99 or above: http://predef.sourceforge.net/prestd.html */
153 # define ORTHANC_PLUGIN_INLINE static inline
154 # elif defined(__cplusplus)
155 /* This is C++ */
156 # define ORTHANC_PLUGIN_INLINE static inline
157 # elif defined(__GNUC__)
158 /* This is GCC running in C89 mode */
159 # define ORTHANC_PLUGIN_INLINE static __inline
160 # elif defined(_MSC_VER)
161 /* This is Visual Studio running in C89 mode */
162 # define ORTHANC_PLUGIN_INLINE static __inline
163 # else
164 # error Your compiler is not known to support the "inline" keyword
165 # endif
166 #endif
167 
168 
169 
170 /********************************************************************
171  ** Inclusion of standard libraries.
172  ********************************************************************/
173 
179 #include <stdint.h>
180 
181 #include <stdlib.h>
182 
183 
184 
185 /********************************************************************
186  ** Definition of the Orthanc Plugin API.
187  ********************************************************************/
188 
191 #ifdef __cplusplus
192 extern "C"
193 {
194 #endif
195 
199  typedef enum
200  {
308 
309  _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
311 
312 
317  ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
318 
319 
323  typedef enum
324  {
330  _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
332 
333 
338  typedef struct
339  {
344 
348  uint32_t groupsCount;
349 
353  const char* const* groups;
354 
358  uint32_t getCount;
359 
363  const char* const* getKeys;
364 
368  const char* const* getValues;
369 
373  const void* body;
374 
378  uint32_t bodySize;
379 
380 
381  /* --------------------------------------------------
382  New in version 0.8.1
383  -------------------------------------------------- */
384 
388  uint32_t headersCount;
389 
393  const char* const* headersKeys;
394 
398  const char* const* headersValues;
399 
401 
402 
403  typedef enum
404  {
405  /* Generic services */
406  _OrthancPluginService_LogInfo = 1,
407  _OrthancPluginService_LogWarning = 2,
408  _OrthancPluginService_LogError = 3,
409  _OrthancPluginService_GetOrthancPath = 4,
410  _OrthancPluginService_GetOrthancDirectory = 5,
411  _OrthancPluginService_GetConfigurationPath = 6,
412  _OrthancPluginService_SetPluginProperty = 7,
413  _OrthancPluginService_GetGlobalProperty = 8,
414  _OrthancPluginService_SetGlobalProperty = 9,
415  _OrthancPluginService_GetCommandLineArgumentsCount = 10,
416  _OrthancPluginService_GetCommandLineArgument = 11,
417  _OrthancPluginService_GetExpectedDatabaseVersion = 12,
418  _OrthancPluginService_GetConfiguration = 13,
419  _OrthancPluginService_BufferCompression = 14,
420  _OrthancPluginService_ReadFile = 15,
421  _OrthancPluginService_WriteFile = 16,
422  _OrthancPluginService_GetErrorDescription = 17,
423  _OrthancPluginService_CallHttpClient = 18,
424  _OrthancPluginService_RegisterErrorCode = 19,
425  _OrthancPluginService_RegisterDictionaryTag = 20,
426  _OrthancPluginService_DicomBufferToJson = 21,
427  _OrthancPluginService_DicomInstanceToJson = 22,
428  _OrthancPluginService_CreateDicom = 23,
429  _OrthancPluginService_ComputeMd5 = 24,
430  _OrthancPluginService_ComputeSha1 = 25,
431  _OrthancPluginService_LookupDictionary = 26,
432  _OrthancPluginService_CallHttpClient2 = 27,
433  _OrthancPluginService_GenerateUuid = 28,
434  _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
435  _OrthancPluginService_AutodetectMimeType = 30,
436  _OrthancPluginService_SetMetricsValue = 31,
437  _OrthancPluginService_EncodeDicomWebJson = 32,
438  _OrthancPluginService_EncodeDicomWebXml = 33,
439  _OrthancPluginService_ChunkedHttpClient = 34, /* New in Orthanc 1.5.7 */
440  _OrthancPluginService_GetTagName = 35, /* New in Orthanc 1.5.7 */
441  _OrthancPluginService_EncodeDicomWebJson2 = 36, /* New in Orthanc 1.7.0 */
442  _OrthancPluginService_EncodeDicomWebXml2 = 37, /* New in Orthanc 1.7.0 */
443  _OrthancPluginService_CreateMemoryBuffer = 38, /* New in Orthanc 1.7.0 */
444  _OrthancPluginService_GenerateRestApiAuthorizationToken = 39, /* New in Orthanc 1.8.1 */
445  _OrthancPluginService_CreateMemoryBuffer64 = 40, /* New in Orthanc 1.9.0 */
446  _OrthancPluginService_CreateDicom2 = 41, /* New in Orthanc 1.9.0 */
447 
448  /* Registration of callbacks */
449  _OrthancPluginService_RegisterRestCallback = 1000,
450  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
451  _OrthancPluginService_RegisterStorageArea = 1002,
452  _OrthancPluginService_RegisterOnChangeCallback = 1003,
453  _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
454  _OrthancPluginService_RegisterWorklistCallback = 1005,
455  _OrthancPluginService_RegisterDecodeImageCallback = 1006,
456  _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
457  _OrthancPluginService_RegisterFindCallback = 1008,
458  _OrthancPluginService_RegisterMoveCallback = 1009,
459  _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
460  _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
461  _OrthancPluginService_RegisterChunkedRestCallback = 1012, /* New in Orthanc 1.5.7 */
462  _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
463  _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
464  _OrthancPluginService_RegisterTranscoderCallback = 1015, /* New in Orthanc 1.7.0 */
465  _OrthancPluginService_RegisterStorageArea2 = 1016, /* New in Orthanc 1.9.0 */
466  _OrthancPluginService_RegisterIncomingCStoreInstanceFilter = 1017, /* New in Orthanc 1.10.0 */
467  _OrthancPluginService_RegisterReceivedInstanceCallback = 1018, /* New in Orthanc 1.10.0 */
468 
469  /* Sending answers to REST calls */
470  _OrthancPluginService_AnswerBuffer = 2000,
471  _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
472  _OrthancPluginService_Redirect = 2002,
473  _OrthancPluginService_SendHttpStatusCode = 2003,
474  _OrthancPluginService_SendUnauthorized = 2004,
475  _OrthancPluginService_SendMethodNotAllowed = 2005,
476  _OrthancPluginService_SetCookie = 2006,
477  _OrthancPluginService_SetHttpHeader = 2007,
478  _OrthancPluginService_StartMultipartAnswer = 2008,
479  _OrthancPluginService_SendMultipartItem = 2009,
480  _OrthancPluginService_SendHttpStatus = 2010,
481  _OrthancPluginService_CompressAndAnswerImage = 2011,
482  _OrthancPluginService_SendMultipartItem2 = 2012,
483  _OrthancPluginService_SetHttpErrorDetails = 2013,
484 
485  /* Access to the Orthanc database and API */
486  _OrthancPluginService_GetDicomForInstance = 3000,
487  _OrthancPluginService_RestApiGet = 3001,
488  _OrthancPluginService_RestApiPost = 3002,
489  _OrthancPluginService_RestApiDelete = 3003,
490  _OrthancPluginService_RestApiPut = 3004,
491  _OrthancPluginService_LookupPatient = 3005,
492  _OrthancPluginService_LookupStudy = 3006,
493  _OrthancPluginService_LookupSeries = 3007,
494  _OrthancPluginService_LookupInstance = 3008,
495  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
496  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
497  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
498  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
499  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
500  _OrthancPluginService_ReconstructMainDicomTags = 3014,
501  _OrthancPluginService_RestApiGet2 = 3015,
502  _OrthancPluginService_CallRestApi = 3016, /* New in Orthanc 1.9.2 */
503 
504  /* Access to DICOM instances */
505  _OrthancPluginService_GetInstanceRemoteAet = 4000,
506  _OrthancPluginService_GetInstanceSize = 4001,
507  _OrthancPluginService_GetInstanceData = 4002,
508  _OrthancPluginService_GetInstanceJson = 4003,
509  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
510  _OrthancPluginService_HasInstanceMetadata = 4005,
511  _OrthancPluginService_GetInstanceMetadata = 4006,
512  _OrthancPluginService_GetInstanceOrigin = 4007,
513  _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
514  _OrthancPluginService_HasInstancePixelData = 4009,
515  _OrthancPluginService_CreateDicomInstance = 4010, /* New in Orthanc 1.7.0 */
516  _OrthancPluginService_FreeDicomInstance = 4011, /* New in Orthanc 1.7.0 */
517  _OrthancPluginService_GetInstanceFramesCount = 4012, /* New in Orthanc 1.7.0 */
518  _OrthancPluginService_GetInstanceRawFrame = 4013, /* New in Orthanc 1.7.0 */
519  _OrthancPluginService_GetInstanceDecodedFrame = 4014, /* New in Orthanc 1.7.0 */
520  _OrthancPluginService_TranscodeDicomInstance = 4015, /* New in Orthanc 1.7.0 */
521  _OrthancPluginService_SerializeDicomInstance = 4016, /* New in Orthanc 1.7.0 */
522  _OrthancPluginService_GetInstanceAdvancedJson = 4017, /* New in Orthanc 1.7.0 */
523  _OrthancPluginService_GetInstanceDicomWebJson = 4018, /* New in Orthanc 1.7.0 */
524  _OrthancPluginService_GetInstanceDicomWebXml = 4019, /* New in Orthanc 1.7.0 */
525 
526  /* Services for plugins implementing a database back-end */
527  _OrthancPluginService_RegisterDatabaseBackend = 5000, /* New in Orthanc 0.8.6 */
528  _OrthancPluginService_DatabaseAnswer = 5001,
529  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002, /* New in Orthanc 0.9.4 */
530  _OrthancPluginService_StorageAreaCreate = 5003,
531  _OrthancPluginService_StorageAreaRead = 5004,
532  _OrthancPluginService_StorageAreaRemove = 5005,
533  _OrthancPluginService_RegisterDatabaseBackendV3 = 5006, /* New in Orthanc 1.9.2 */
534 
535  /* Primitives for handling images */
536  _OrthancPluginService_GetImagePixelFormat = 6000,
537  _OrthancPluginService_GetImageWidth = 6001,
538  _OrthancPluginService_GetImageHeight = 6002,
539  _OrthancPluginService_GetImagePitch = 6003,
540  _OrthancPluginService_GetImageBuffer = 6004,
541  _OrthancPluginService_UncompressImage = 6005,
542  _OrthancPluginService_FreeImage = 6006,
543  _OrthancPluginService_CompressImage = 6007,
544  _OrthancPluginService_ConvertPixelFormat = 6008,
545  _OrthancPluginService_GetFontsCount = 6009,
546  _OrthancPluginService_GetFontInfo = 6010,
547  _OrthancPluginService_DrawText = 6011,
548  _OrthancPluginService_CreateImage = 6012,
549  _OrthancPluginService_CreateImageAccessor = 6013,
550  _OrthancPluginService_DecodeDicomImage = 6014,
551 
552  /* Primitives for handling C-Find, C-Move and worklists */
553  _OrthancPluginService_WorklistAddAnswer = 7000,
554  _OrthancPluginService_WorklistMarkIncomplete = 7001,
555  _OrthancPluginService_WorklistIsMatch = 7002,
556  _OrthancPluginService_WorklistGetDicomQuery = 7003,
557  _OrthancPluginService_FindAddAnswer = 7004,
558  _OrthancPluginService_FindMarkIncomplete = 7005,
559  _OrthancPluginService_GetFindQuerySize = 7006,
560  _OrthancPluginService_GetFindQueryTag = 7007,
561  _OrthancPluginService_GetFindQueryTagName = 7008,
562  _OrthancPluginService_GetFindQueryValue = 7009,
563  _OrthancPluginService_CreateFindMatcher = 7010,
564  _OrthancPluginService_FreeFindMatcher = 7011,
565  _OrthancPluginService_FindMatcherIsMatch = 7012,
566 
567  /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
568  _OrthancPluginService_GetPeers = 8000,
569  _OrthancPluginService_FreePeers = 8001,
570  _OrthancPluginService_GetPeersCount = 8003,
571  _OrthancPluginService_GetPeerName = 8004,
572  _OrthancPluginService_GetPeerUrl = 8005,
573  _OrthancPluginService_CallPeerApi = 8006,
574  _OrthancPluginService_GetPeerUserProperty = 8007,
575 
576  /* Primitives for handling jobs (new in 1.4.2) */
577  _OrthancPluginService_CreateJob = 9000,
578  _OrthancPluginService_FreeJob = 9001,
579  _OrthancPluginService_SubmitJob = 9002,
580  _OrthancPluginService_RegisterJobsUnserializer = 9003,
581 
582  _OrthancPluginService_INTERNAL = 0x7fffffff
583  } _OrthancPluginService;
584 
585 
586  typedef enum
587  {
588  _OrthancPluginProperty_Description = 1,
589  _OrthancPluginProperty_RootUri = 2,
590  _OrthancPluginProperty_OrthancExplorer = 3,
591 
592  _OrthancPluginProperty_INTERNAL = 0x7fffffff
593  } _OrthancPluginProperty;
594 
595 
596 
601  typedef enum
602  {
610 
618 
626 
634 
642 
652 
660 
668 
676 
684 
685  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
687 
688 
689 
693  typedef enum
694  {
700  _OrthancPluginContentType_INTERNAL = 0x7fffffff
702 
703 
704 
708  typedef enum
709  {
716  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
718 
719 
720 
725  typedef enum
726  {
747  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
749 
750 
755  typedef enum
756  {
762  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
764 
765 
770  typedef enum
771  {
776  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
778 
779 
784  typedef enum
785  {
814  _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
816 
817 
823  typedef enum
824  {
829  _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
831 
832 
838  typedef enum
839  {
840  OrthancPluginDicomToJsonFlags_None = 0,
850  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
852 
853 
859  typedef enum
860  {
861  OrthancPluginCreateDicomFlags_None = 0,
865  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
867 
868 
874  typedef enum
875  {
881  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
883 
884 
889  typedef enum
890  {
897  _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
899 
900 
904  typedef enum
905  {
913  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
915 
916 
920  typedef enum
921  {
926 
927 
934  typedef enum
935  {
941 
942 
946  typedef enum
947  {
957 
958 
963  typedef enum
964  {
969 
970 
976  typedef enum
977  {
1005 
1006 
1010  typedef enum
1011  {
1016  _OrthancPluginReceivedInstanceAction_INTERNAL = 0x7fffffff
1018 
1019 
1027  typedef struct
1028  {
1032  void* data;
1033 
1037  uint32_t size;
1039 
1040 
1041 
1049  typedef struct
1050  {
1054  void* data;
1055 
1059  uint64_t size;
1061 
1062 
1063 
1064 
1069  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
1070 
1071 
1072 
1077  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
1078 
1079 
1080 
1085  typedef struct _OrthancPluginImage_t OrthancPluginImage;
1086 
1087 
1088 
1093  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
1094 
1095 
1096 
1101  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
1102 
1103 
1104 
1109  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
1110 
1111 
1112 
1117  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1118 
1119 
1120 
1125  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1126 
1127 
1128 
1133  typedef struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher;
1134 
1135 
1136 
1141  typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1142 
1143 
1144 
1149  typedef struct _OrthancPluginJob_t OrthancPluginJob;
1150 
1151 
1152 
1158  typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1159 
1160 
1161 
1167  OrthancPluginRestOutput* output,
1168  const char* url,
1169  const OrthancPluginHttpRequest* request);
1170 
1171 
1172 
1178  const OrthancPluginDicomInstance* instance,
1179  const char* instanceId);
1180 
1181 
1182 
1188  OrthancPluginChangeType changeType,
1189  OrthancPluginResourceType resourceType,
1190  const char* resourceId);
1191 
1192 
1193 
1199  OrthancPluginImage** target,
1200  const void* dicom,
1201  const uint32_t size,
1202  uint32_t frameIndex);
1203 
1204 
1205 
1210  typedef void (*OrthancPluginFree) (void* buffer);
1211 
1212 
1213 
1223  const char* bulkDataUri);
1224 
1225 
1226 
1240  const char* uuid,
1241  const void* content,
1242  int64_t size,
1244 
1245 
1246 
1267  void** content,
1268  int64_t* size,
1269  const char* uuid,
1271 
1272 
1273 
1288  const char* uuid,
1290 
1291 
1292 
1311  const char* uuid,
1313  uint64_t rangeStart);
1314 
1315 
1316 
1328  const char* uuid,
1330 
1331 
1332 
1348  const OrthancPluginWorklistQuery* query,
1349  const char* issuerAet,
1350  const char* calledAet);
1351 
1352 
1353 
1378  OrthancPluginHttpMethod method,
1379  const char* uri,
1380  const char* ip,
1381  uint32_t headersCount,
1382  const char* const* headersKeys,
1383  const char* const* headersValues);
1384 
1385 
1386 
1413  OrthancPluginHttpMethod method,
1414  const char* uri,
1415  const char* ip,
1416  uint32_t headersCount,
1417  const char* const* headersKeys,
1418  const char* const* headersValues,
1419  uint32_t getArgumentsCount,
1420  const char* const* getArgumentsKeys,
1421  const char* const* getArgumentsValues);
1422 
1423 
1424 
1440  OrthancPluginFindAnswers* answers,
1441  const OrthancPluginFindQuery* query,
1442  const char* issuerAet,
1443  const char* calledAet);
1444 
1445 
1446 
1482  typedef void* (*OrthancPluginMoveCallback) (
1483  OrthancPluginResourceType resourceType,
1484  const char* patientId,
1485  const char* accessionNumber,
1486  const char* studyInstanceUid,
1487  const char* seriesInstanceUid,
1488  const char* sopInstanceUid,
1489  const char* originatorAet,
1490  const char* sourceAet,
1491  const char* targetAet,
1492  uint16_t originatorId);
1493 
1494 
1507  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1508 
1509 
1522  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1523 
1524 
1536  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1537 
1538 
1549  typedef void (*OrthancPluginJobFinalize) (void* job);
1550 
1551 
1562  typedef float (*OrthancPluginJobGetProgress) (void* job);
1563 
1564 
1577  typedef const char* (*OrthancPluginJobGetContent) (void* job);
1578 
1579 
1595  typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1596 
1597 
1611 
1612 
1636 
1637 
1652 
1653 
1667  typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1668  const char* serialized);
1669 
1670 
1671 
1686 
1687 
1688 
1716  uint32_t levelDepth,
1717  const uint16_t* levelTagGroup,
1718  const uint16_t* levelTagElement,
1719  const uint32_t* levelIndex,
1720  uint16_t tagGroup,
1721  uint16_t tagElement,
1723 
1724 
1725 
1754  uint32_t levelDepth,
1755  const uint16_t* levelTagGroup,
1756  const uint16_t* levelTagElement,
1757  const uint32_t* levelIndex,
1758  uint16_t tagGroup,
1759  uint16_t tagElement,
1761  void* payload);
1762 
1763 
1764 
1768  typedef struct _OrthancPluginContext_t
1769  {
1770  void* pluginsManager;
1771  const char* orthancVersion;
1772  OrthancPluginFree Free;
1773  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1774  _OrthancPluginService service,
1775  const void* params);
1777 
1778 
1779 
1783  typedef struct
1784  {
1785  uint16_t group;
1786  uint16_t element;
1788  uint32_t minMultiplicity;
1789  uint32_t maxMultiplicity;
1791 
1792 
1793 
1802  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1803  OrthancPluginContext* context,
1804  char* str)
1805  {
1806  if (str != NULL)
1807  {
1808  context->Free(str);
1809  }
1810  }
1811 
1812 
1832  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1833  OrthancPluginContext* context,
1834  int expectedMajor,
1835  int expectedMinor,
1836  int expectedRevision)
1837  {
1838  int major, minor, revision;
1839 
1840  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1841  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1842  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1843  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1844  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1845  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1846  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1847  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1848  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1849  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1850  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1851  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1852  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1853  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1854  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1855  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1856  sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1857  sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
1858  sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
1859  sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
1860  sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason) ||
1861  sizeof(int32_t) != sizeof(OrthancPluginReceivedInstanceAction))
1862  {
1863  /* Mismatch in the size of the enumerations */
1864  return 0;
1865  }
1866 
1867  /* Assume compatibility with the mainline */
1868  if (!strcmp(context->orthancVersion, "mainline"))
1869  {
1870  return 1;
1871  }
1872 
1873  /* Parse the version of the Orthanc core */
1874  if (
1875 #ifdef _MSC_VER
1876  sscanf_s
1877 #else
1878  sscanf
1879 #endif
1880  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1881  {
1882  return 0;
1883  }
1884 
1885  /* Check the major number of the version */
1886 
1887  if (major > expectedMajor)
1888  {
1889  return 1;
1890  }
1891 
1892  if (major < expectedMajor)
1893  {
1894  return 0;
1895  }
1896 
1897  /* Check the minor number of the version */
1898 
1899  if (minor > expectedMinor)
1900  {
1901  return 1;
1902  }
1903 
1904  if (minor < expectedMinor)
1905  {
1906  return 0;
1907  }
1908 
1909  /* Check the revision number of the version */
1910 
1911  if (revision >= expectedRevision)
1912  {
1913  return 1;
1914  }
1915  else
1916  {
1917  return 0;
1918  }
1919  }
1920 
1921 
1938  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1939  OrthancPluginContext* context)
1940  {
1942  context,
1943  ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1944  ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1945  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1946  }
1947 
1948 
1957  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1958  OrthancPluginContext* context,
1959  OrthancPluginMemoryBuffer* buffer)
1960  {
1961  context->Free(buffer->data);
1962  }
1963 
1964 
1973  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer64(
1974  OrthancPluginContext* context,
1976  {
1977  context->Free(buffer->data);
1978  }
1979 
1980 
1989  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1990  OrthancPluginContext* context,
1991  const char* message)
1992  {
1993  context->InvokeService(context, _OrthancPluginService_LogError, message);
1994  }
1995 
1996 
2005  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
2006  OrthancPluginContext* context,
2007  const char* message)
2008  {
2009  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
2010  }
2011 
2012 
2021  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
2022  OrthancPluginContext* context,
2023  const char* message)
2024  {
2025  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
2026  }
2027 
2028 
2029 
2030  typedef struct
2031  {
2032  const char* pathRegularExpression;
2033  OrthancPluginRestCallback callback;
2034  } _OrthancPluginRestCallback;
2035 
2057  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
2058  OrthancPluginContext* context,
2059  const char* pathRegularExpression,
2060  OrthancPluginRestCallback callback)
2061  {
2062  _OrthancPluginRestCallback params;
2063  params.pathRegularExpression = pathRegularExpression;
2064  params.callback = callback;
2065  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
2066  }
2067 
2068 
2069 
2097  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
2098  OrthancPluginContext* context,
2099  const char* pathRegularExpression,
2100  OrthancPluginRestCallback callback)
2101  {
2102  _OrthancPluginRestCallback params;
2103  params.pathRegularExpression = pathRegularExpression;
2104  params.callback = callback;
2105  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
2106  }
2107 
2108 
2109 
2110  typedef struct
2111  {
2113  } _OrthancPluginOnStoredInstanceCallback;
2114 
2136  OrthancPluginContext* context,
2138  {
2139  _OrthancPluginOnStoredInstanceCallback params;
2140  params.callback = callback;
2141 
2142  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
2143  }
2144 
2145 
2146 
2147  typedef struct
2148  {
2149  OrthancPluginRestOutput* output;
2150  const void* answer;
2151  uint32_t answerSize;
2152  const char* mimeType;
2153  } _OrthancPluginAnswerBuffer;
2154 
2167  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
2168  OrthancPluginContext* context,
2169  OrthancPluginRestOutput* output,
2170  const void* answer,
2171  uint32_t answerSize,
2172  const char* mimeType)
2173  {
2174  _OrthancPluginAnswerBuffer params;
2175  params.output = output;
2176  params.answer = answer;
2177  params.answerSize = answerSize;
2178  params.mimeType = mimeType;
2179  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
2180  }
2181 
2182 
2183  typedef struct
2184  {
2185  OrthancPluginRestOutput* output;
2186  OrthancPluginPixelFormat format;
2187  uint32_t width;
2188  uint32_t height;
2189  uint32_t pitch;
2190  const void* buffer;
2191  } _OrthancPluginCompressAndAnswerPngImage;
2192 
2193  typedef struct
2194  {
2195  OrthancPluginRestOutput* output;
2196  OrthancPluginImageFormat imageFormat;
2197  OrthancPluginPixelFormat pixelFormat;
2198  uint32_t width;
2199  uint32_t height;
2200  uint32_t pitch;
2201  const void* buffer;
2202  uint8_t quality;
2203  } _OrthancPluginCompressAndAnswerImage;
2204 
2205 
2224  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2225  OrthancPluginContext* context,
2226  OrthancPluginRestOutput* output,
2227  OrthancPluginPixelFormat format,
2228  uint32_t width,
2229  uint32_t height,
2230  uint32_t pitch,
2231  const void* buffer)
2232  {
2233  _OrthancPluginCompressAndAnswerImage params;
2234  params.output = output;
2235  params.imageFormat = OrthancPluginImageFormat_Png;
2236  params.pixelFormat = format;
2237  params.width = width;
2238  params.height = height;
2239  params.pitch = pitch;
2240  params.buffer = buffer;
2241  params.quality = 0; /* No quality for PNG */
2242  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2243  }
2244 
2245 
2246 
2247  typedef struct
2248  {
2249  OrthancPluginMemoryBuffer* target;
2250  const char* instanceId;
2251  } _OrthancPluginGetDicomForInstance;
2252 
2266  OrthancPluginContext* context,
2267  OrthancPluginMemoryBuffer* target,
2268  const char* instanceId)
2269  {
2270  _OrthancPluginGetDicomForInstance params;
2271  params.target = target;
2272  params.instanceId = instanceId;
2273  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2274  }
2275 
2276 
2277 
2278  typedef struct
2279  {
2280  OrthancPluginMemoryBuffer* target;
2281  const char* uri;
2282  } _OrthancPluginRestApiGet;
2283 
2299  OrthancPluginContext* context,
2300  OrthancPluginMemoryBuffer* target,
2301  const char* uri)
2302  {
2303  _OrthancPluginRestApiGet params;
2304  params.target = target;
2305  params.uri = uri;
2306  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2307  }
2308 
2309 
2310 
2329  OrthancPluginContext* context,
2330  OrthancPluginMemoryBuffer* target,
2331  const char* uri)
2332  {
2333  _OrthancPluginRestApiGet params;
2334  params.target = target;
2335  params.uri = uri;
2336  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2337  }
2338 
2339 
2340 
2341  typedef struct
2342  {
2343  OrthancPluginMemoryBuffer* target;
2344  const char* uri;
2345  const void* body;
2346  uint32_t bodySize;
2347  } _OrthancPluginRestApiPostPut;
2348 
2366  OrthancPluginContext* context,
2367  OrthancPluginMemoryBuffer* target,
2368  const char* uri,
2369  const void* body,
2370  uint32_t bodySize)
2371  {
2372  _OrthancPluginRestApiPostPut params;
2373  params.target = target;
2374  params.uri = uri;
2375  params.body = body;
2376  params.bodySize = bodySize;
2377  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2378  }
2379 
2380 
2401  OrthancPluginContext* context,
2402  OrthancPluginMemoryBuffer* target,
2403  const char* uri,
2404  const void* body,
2405  uint32_t bodySize)
2406  {
2407  _OrthancPluginRestApiPostPut params;
2408  params.target = target;
2409  params.uri = uri;
2410  params.body = body;
2411  params.bodySize = bodySize;
2412  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2413  }
2414 
2415 
2416 
2430  OrthancPluginContext* context,
2431  const char* uri)
2432  {
2433  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2434  }
2435 
2436 
2453  OrthancPluginContext* context,
2454  const char* uri)
2455  {
2456  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2457  }
2458 
2459 
2460 
2478  OrthancPluginContext* context,
2479  OrthancPluginMemoryBuffer* target,
2480  const char* uri,
2481  const void* body,
2482  uint32_t bodySize)
2483  {
2484  _OrthancPluginRestApiPostPut params;
2485  params.target = target;
2486  params.uri = uri;
2487  params.body = body;
2488  params.bodySize = bodySize;
2489  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2490  }
2491 
2492 
2493 
2514  OrthancPluginContext* context,
2515  OrthancPluginMemoryBuffer* target,
2516  const char* uri,
2517  const void* body,
2518  uint32_t bodySize)
2519  {
2520  _OrthancPluginRestApiPostPut params;
2521  params.target = target;
2522  params.uri = uri;
2523  params.body = body;
2524  params.bodySize = bodySize;
2525  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2526  }
2527 
2528 
2529 
2530  typedef struct
2531  {
2532  OrthancPluginRestOutput* output;
2533  const char* argument;
2534  } _OrthancPluginOutputPlusArgument;
2535 
2547  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2548  OrthancPluginContext* context,
2549  OrthancPluginRestOutput* output,
2550  const char* redirection)
2551  {
2552  _OrthancPluginOutputPlusArgument params;
2553  params.output = output;
2554  params.argument = redirection;
2555  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2556  }
2557 
2558 
2559 
2560  typedef struct
2561  {
2562  char** result;
2563  const char* argument;
2564  } _OrthancPluginRetrieveDynamicString;
2565 
2579  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2580  OrthancPluginContext* context,
2581  const char* patientID)
2582  {
2583  char* result;
2584 
2585  _OrthancPluginRetrieveDynamicString params;
2586  params.result = &result;
2587  params.argument = patientID;
2588 
2589  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2590  {
2591  /* Error */
2592  return NULL;
2593  }
2594  else
2595  {
2596  return result;
2597  }
2598  }
2599 
2600 
2614  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2615  OrthancPluginContext* context,
2616  const char* studyUID)
2617  {
2618  char* result;
2619 
2620  _OrthancPluginRetrieveDynamicString params;
2621  params.result = &result;
2622  params.argument = studyUID;
2623 
2624  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2625  {
2626  /* Error */
2627  return NULL;
2628  }
2629  else
2630  {
2631  return result;
2632  }
2633  }
2634 
2635 
2649  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
2650  OrthancPluginContext* context,
2651  const char* accessionNumber)
2652  {
2653  char* result;
2654 
2655  _OrthancPluginRetrieveDynamicString params;
2656  params.result = &result;
2657  params.argument = accessionNumber;
2658 
2659  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2660  {
2661  /* Error */
2662  return NULL;
2663  }
2664  else
2665  {
2666  return result;
2667  }
2668  }
2669 
2670 
2684  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2685  OrthancPluginContext* context,
2686  const char* seriesUID)
2687  {
2688  char* result;
2689 
2690  _OrthancPluginRetrieveDynamicString params;
2691  params.result = &result;
2692  params.argument = seriesUID;
2693 
2694  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2695  {
2696  /* Error */
2697  return NULL;
2698  }
2699  else
2700  {
2701  return result;
2702  }
2703  }
2704 
2705 
2719  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2720  OrthancPluginContext* context,
2721  const char* sopInstanceUID)
2722  {
2723  char* result;
2724 
2725  _OrthancPluginRetrieveDynamicString params;
2726  params.result = &result;
2727  params.argument = sopInstanceUID;
2728 
2729  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2730  {
2731  /* Error */
2732  return NULL;
2733  }
2734  else
2735  {
2736  return result;
2737  }
2738  }
2739 
2740 
2741 
2742  typedef struct
2743  {
2744  OrthancPluginRestOutput* output;
2745  uint16_t status;
2746  } _OrthancPluginSendHttpStatusCode;
2747 
2764  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2765  OrthancPluginContext* context,
2766  OrthancPluginRestOutput* output,
2767  uint16_t status)
2768  {
2769  _OrthancPluginSendHttpStatusCode params;
2770  params.output = output;
2771  params.status = status;
2772  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2773  }
2774 
2775 
2787  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2788  OrthancPluginContext* context,
2789  OrthancPluginRestOutput* output,
2790  const char* realm)
2791  {
2792  _OrthancPluginOutputPlusArgument params;
2793  params.output = output;
2794  params.argument = realm;
2795  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2796  }
2797 
2798 
2810  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2811  OrthancPluginContext* context,
2812  OrthancPluginRestOutput* output,
2813  const char* allowedMethods)
2814  {
2815  _OrthancPluginOutputPlusArgument params;
2816  params.output = output;
2817  params.argument = allowedMethods;
2818  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2819  }
2820 
2821 
2822  typedef struct
2823  {
2824  OrthancPluginRestOutput* output;
2825  const char* key;
2826  const char* value;
2827  } _OrthancPluginSetHttpHeader;
2828 
2840  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2841  OrthancPluginContext* context,
2842  OrthancPluginRestOutput* output,
2843  const char* cookie,
2844  const char* value)
2845  {
2846  _OrthancPluginSetHttpHeader params;
2847  params.output = output;
2848  params.key = cookie;
2849  params.value = value;
2850  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2851  }
2852 
2853 
2865  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2866  OrthancPluginContext* context,
2867  OrthancPluginRestOutput* output,
2868  const char* key,
2869  const char* value)
2870  {
2871  _OrthancPluginSetHttpHeader params;
2872  params.output = output;
2873  params.key = key;
2874  params.value = value;
2875  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2876  }
2877 
2878 
2879  typedef struct
2880  {
2881  char** resultStringToFree;
2882  const char** resultString;
2883  int64_t* resultInt64;
2884  const char* key;
2885  const OrthancPluginDicomInstance* instance;
2886  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2887  } _OrthancPluginAccessDicomInstance;
2888 
2889 
2901  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2902  OrthancPluginContext* context,
2903  const OrthancPluginDicomInstance* instance)
2904  {
2905  const char* result;
2906 
2907  _OrthancPluginAccessDicomInstance params;
2908  memset(&params, 0, sizeof(params));
2909  params.resultString = &result;
2910  params.instance = instance;
2911 
2912  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2913  {
2914  /* Error */
2915  return NULL;
2916  }
2917  else
2918  {
2919  return result;
2920  }
2921  }
2922 
2923 
2934  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2935  OrthancPluginContext* context,
2936  const OrthancPluginDicomInstance* instance)
2937  {
2938  int64_t size;
2939 
2940  _OrthancPluginAccessDicomInstance params;
2941  memset(&params, 0, sizeof(params));
2942  params.resultInt64 = &size;
2943  params.instance = instance;
2944 
2945  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2946  {
2947  /* Error */
2948  return -1;
2949  }
2950  else
2951  {
2952  return size;
2953  }
2954  }
2955 
2956 
2967  ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData(
2968  OrthancPluginContext* context,
2969  const OrthancPluginDicomInstance* instance)
2970  {
2971  const char* result;
2972 
2973  _OrthancPluginAccessDicomInstance params;
2974  memset(&params, 0, sizeof(params));
2975  params.resultString = &result;
2976  params.instance = instance;
2977 
2978  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2979  {
2980  /* Error */
2981  return NULL;
2982  }
2983  else
2984  {
2985  return result;
2986  }
2987  }
2988 
2989 
3003  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
3004  OrthancPluginContext* context,
3005  const OrthancPluginDicomInstance* instance)
3006  {
3007  char* result;
3008 
3009  _OrthancPluginAccessDicomInstance params;
3010  memset(&params, 0, sizeof(params));
3011  params.resultStringToFree = &result;
3012  params.instance = instance;
3013 
3014  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
3015  {
3016  /* Error */
3017  return NULL;
3018  }
3019  else
3020  {
3021  return result;
3022  }
3023  }
3024 
3025 
3041  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
3042  OrthancPluginContext* context,
3043  const OrthancPluginDicomInstance* instance)
3044  {
3045  char* result;
3046 
3047  _OrthancPluginAccessDicomInstance params;
3048  memset(&params, 0, sizeof(params));
3049  params.resultStringToFree = &result;
3050  params.instance = instance;
3051 
3052  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
3053  {
3054  /* Error */
3055  return NULL;
3056  }
3057  else
3058  {
3059  return result;
3060  }
3061  }
3062 
3063 
3080  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
3081  OrthancPluginContext* context,
3082  const OrthancPluginDicomInstance* instance,
3083  const char* metadata)
3084  {
3085  int64_t result;
3086 
3087  _OrthancPluginAccessDicomInstance params;
3088  memset(&params, 0, sizeof(params));
3089  params.resultInt64 = &result;
3090  params.instance = instance;
3091  params.key = metadata;
3092 
3093  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3094  {
3095  /* Error */
3096  return -1;
3097  }
3098  else
3099  {
3100  return (result != 0);
3101  }
3102  }
3103 
3104 
3121  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
3122  OrthancPluginContext* context,
3123  const OrthancPluginDicomInstance* instance,
3124  const char* metadata)
3125  {
3126  const char* result;
3127 
3128  _OrthancPluginAccessDicomInstance params;
3129  memset(&params, 0, sizeof(params));
3130  params.resultString = &result;
3131  params.instance = instance;
3132  params.key = metadata;
3133 
3134  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3135  {
3136  /* Error */
3137  return NULL;
3138  }
3139  else
3140  {
3141  return result;
3142  }
3143  }
3144 
3145 
3146 
3147  typedef struct
3148  {
3152  OrthancPluginFree free;
3153  } _OrthancPluginRegisterStorageArea;
3154 
3170  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
3171  OrthancPluginContext* context,
3175  {
3176  _OrthancPluginRegisterStorageArea params;
3177  params.create = create;
3178  params.read = read;
3179  params.remove = remove;
3180 
3181 #ifdef __cplusplus
3182  params.free = ::free;
3183 #else
3184  params.free = free;
3185 #endif
3186 
3187  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3188  }
3189 
3190 
3191 
3202  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3203  {
3204  char* result;
3205 
3206  _OrthancPluginRetrieveDynamicString params;
3207  params.result = &result;
3208  params.argument = NULL;
3209 
3210  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3211  {
3212  /* Error */
3213  return NULL;
3214  }
3215  else
3216  {
3217  return result;
3218  }
3219  }
3220 
3221 
3232  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3233  {
3234  char* result;
3235 
3236  _OrthancPluginRetrieveDynamicString params;
3237  params.result = &result;
3238  params.argument = NULL;
3239 
3240  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3241  {
3242  /* Error */
3243  return NULL;
3244  }
3245  else
3246  {
3247  return result;
3248  }
3249  }
3250 
3251 
3267  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3268  {
3269  char* result;
3270 
3271  _OrthancPluginRetrieveDynamicString params;
3272  params.result = &result;
3273  params.argument = NULL;
3274 
3275  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3276  {
3277  /* Error */
3278  return NULL;
3279  }
3280  else
3281  {
3282  return result;
3283  }
3284  }
3285 
3286 
3287 
3288  typedef struct
3289  {
3291  } _OrthancPluginOnChangeCallback;
3292 
3313  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3314  OrthancPluginContext* context,
3316  {
3317  _OrthancPluginOnChangeCallback params;
3318  params.callback = callback;
3319 
3320  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3321  }
3322 
3323 
3324 
3325  typedef struct
3326  {
3327  const char* plugin;
3328  _OrthancPluginProperty property;
3329  const char* value;
3330  } _OrthancPluginSetPluginProperty;
3331 
3332 
3344  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3345  OrthancPluginContext* context,
3346  const char* uri)
3347  {
3348  _OrthancPluginSetPluginProperty params;
3349  params.plugin = OrthancPluginGetName();
3350  params.property = _OrthancPluginProperty_RootUri;
3351  params.value = uri;
3352 
3353  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3354  }
3355 
3356 
3366  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3367  OrthancPluginContext* context,
3368  const char* description)
3369  {
3370  _OrthancPluginSetPluginProperty params;
3371  params.plugin = OrthancPluginGetName();
3372  params.property = _OrthancPluginProperty_Description;
3373  params.value = description;
3374 
3375  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3376  }
3377 
3378 
3388  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3389  OrthancPluginContext* context,
3390  const char* javascript)
3391  {
3392  _OrthancPluginSetPluginProperty params;
3393  params.plugin = OrthancPluginGetName();
3394  params.property = _OrthancPluginProperty_OrthancExplorer;
3395  params.value = javascript;
3396 
3397  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3398  }
3399 
3400 
3401  typedef struct
3402  {
3403  char** result;
3404  int32_t property;
3405  const char* value;
3406  } _OrthancPluginGlobalProperty;
3407 
3408 
3422  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3423  OrthancPluginContext* context,
3424  int32_t property,
3425  const char* defaultValue)
3426  {
3427  char* result;
3428 
3429  _OrthancPluginGlobalProperty params;
3430  params.result = &result;
3431  params.property = property;
3432  params.value = defaultValue;
3433 
3434  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3435  {
3436  /* Error */
3437  return NULL;
3438  }
3439  else
3440  {
3441  return result;
3442  }
3443  }
3444 
3445 
3462  OrthancPluginContext* context,
3463  int32_t property,
3464  const char* value)
3465  {
3466  _OrthancPluginGlobalProperty params;
3467  params.result = NULL;
3468  params.property = property;
3469  params.value = value;
3470 
3471  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3472  }
3473 
3474 
3475 
3476  typedef struct
3477  {
3478  int32_t *resultInt32;
3479  uint32_t *resultUint32;
3480  int64_t *resultInt64;
3481  uint64_t *resultUint64;
3482  } _OrthancPluginReturnSingleValue;
3483 
3492  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3493  OrthancPluginContext* context)
3494  {
3495  uint32_t count = 0;
3496 
3497  _OrthancPluginReturnSingleValue params;
3498  memset(&params, 0, sizeof(params));
3499  params.resultUint32 = &count;
3500 
3501  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3502  {
3503  /* Error */
3504  return 0;
3505  }
3506  else
3507  {
3508  return count;
3509  }
3510  }
3511 
3512 
3513 
3526  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3527  OrthancPluginContext* context,
3528  uint32_t argument)
3529  {
3530  char* result;
3531 
3532  _OrthancPluginGlobalProperty params;
3533  params.result = &result;
3534  params.property = (int32_t) argument;
3535  params.value = NULL;
3536 
3537  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3538  {
3539  /* Error */
3540  return NULL;
3541  }
3542  else
3543  {
3544  return result;
3545  }
3546  }
3547 
3548 
3558  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3559  OrthancPluginContext* context)
3560  {
3561  uint32_t count = 0;
3562 
3563  _OrthancPluginReturnSingleValue params;
3564  memset(&params, 0, sizeof(params));
3565  params.resultUint32 = &count;
3566 
3567  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3568  {
3569  /* Error */
3570  return 0;
3571  }
3572  else
3573  {
3574  return count;
3575  }
3576  }
3577 
3578 
3579 
3591  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3592  {
3593  char* result;
3594 
3595  _OrthancPluginRetrieveDynamicString params;
3596  params.result = &result;
3597  params.argument = NULL;
3598 
3599  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3600  {
3601  /* Error */
3602  return NULL;
3603  }
3604  else
3605  {
3606  return result;
3607  }
3608  }
3609 
3610 
3611 
3612  typedef struct
3613  {
3614  OrthancPluginRestOutput* output;
3615  const char* subType;
3616  const char* contentType;
3617  } _OrthancPluginStartMultipartAnswer;
3618 
3633  OrthancPluginContext* context,
3634  OrthancPluginRestOutput* output,
3635  const char* subType,
3636  const char* contentType)
3637  {
3638  _OrthancPluginStartMultipartAnswer params;
3639  params.output = output;
3640  params.subType = subType;
3641  params.contentType = contentType;
3642  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3643  }
3644 
3645 
3662  OrthancPluginContext* context,
3663  OrthancPluginRestOutput* output,
3664  const void* answer,
3665  uint32_t answerSize)
3666  {
3667  _OrthancPluginAnswerBuffer params;
3668  params.output = output;
3669  params.answer = answer;
3670  params.answerSize = answerSize;
3671  params.mimeType = NULL;
3672  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3673  }
3674 
3675 
3676 
3677  typedef struct
3678  {
3679  OrthancPluginMemoryBuffer* target;
3680  const void* source;
3681  uint32_t size;
3682  OrthancPluginCompressionType compression;
3683  uint8_t uncompress;
3684  } _OrthancPluginBufferCompression;
3685 
3686 
3704  OrthancPluginContext* context,
3705  OrthancPluginMemoryBuffer* target,
3706  const void* source,
3707  uint32_t size,
3708  OrthancPluginCompressionType compression,
3709  uint8_t uncompress)
3710  {
3711  _OrthancPluginBufferCompression params;
3712  params.target = target;
3713  params.source = source;
3714  params.size = size;
3715  params.compression = compression;
3716  params.uncompress = uncompress;
3717 
3718  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3719  }
3720 
3721 
3722 
3723  typedef struct
3724  {
3725  OrthancPluginMemoryBuffer* target;
3726  const char* path;
3727  } _OrthancPluginReadFile;
3728 
3741  OrthancPluginContext* context,
3742  OrthancPluginMemoryBuffer* target,
3743  const char* path)
3744  {
3745  _OrthancPluginReadFile params;
3746  params.target = target;
3747  params.path = path;
3748  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3749  }
3750 
3751 
3752 
3753  typedef struct
3754  {
3755  const char* path;
3756  const void* data;
3757  uint32_t size;
3758  } _OrthancPluginWriteFile;
3759 
3772  OrthancPluginContext* context,
3773  const char* path,
3774  const void* data,
3775  uint32_t size)
3776  {
3777  _OrthancPluginWriteFile params;
3778  params.path = path;
3779  params.data = data;
3780  params.size = size;
3781  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3782  }
3783 
3784 
3785 
3786  typedef struct
3787  {
3788  const char** target;
3789  OrthancPluginErrorCode error;
3790  } _OrthancPluginGetErrorDescription;
3791 
3802  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3803  OrthancPluginContext* context,
3804  OrthancPluginErrorCode error)
3805  {
3806  const char* result = NULL;
3807 
3808  _OrthancPluginGetErrorDescription params;
3809  params.target = &result;
3810  params.error = error;
3811 
3812  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3813  result == NULL)
3814  {
3815  return "Unknown error code";
3816  }
3817  else
3818  {
3819  return result;
3820  }
3821  }
3822 
3823 
3824 
3825  typedef struct
3826  {
3827  OrthancPluginRestOutput* output;
3828  uint16_t status;
3829  const char* body;
3830  uint32_t bodySize;
3831  } _OrthancPluginSendHttpStatus;
3832 
3855  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3856  OrthancPluginContext* context,
3857  OrthancPluginRestOutput* output,
3858  uint16_t status,
3859  const char* body,
3860  uint32_t bodySize)
3861  {
3862  _OrthancPluginSendHttpStatus params;
3863  params.output = output;
3864  params.status = status;
3865  params.body = body;
3866  params.bodySize = bodySize;
3867  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3868  }
3869 
3870 
3871 
3872  typedef struct
3873  {
3874  const OrthancPluginImage* image;
3875  uint32_t* resultUint32;
3876  OrthancPluginPixelFormat* resultPixelFormat;
3877  void** resultBuffer;
3878  } _OrthancPluginGetImageInfo;
3879 
3880 
3892  OrthancPluginContext* context,
3893  const OrthancPluginImage* image)
3894  {
3895  OrthancPluginPixelFormat target;
3896 
3897  _OrthancPluginGetImageInfo params;
3898  memset(&params, 0, sizeof(params));
3899  params.image = image;
3900  params.resultPixelFormat = &target;
3901 
3902  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3903  {
3905  }
3906  else
3907  {
3908  return (OrthancPluginPixelFormat) target;
3909  }
3910  }
3911 
3912 
3913 
3924  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3925  OrthancPluginContext* context,
3926  const OrthancPluginImage* image)
3927  {
3928  uint32_t width;
3929 
3930  _OrthancPluginGetImageInfo params;
3931  memset(&params, 0, sizeof(params));
3932  params.image = image;
3933  params.resultUint32 = &width;
3934 
3935  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3936  {
3937  return 0;
3938  }
3939  else
3940  {
3941  return width;
3942  }
3943  }
3944 
3945 
3946 
3957  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3958  OrthancPluginContext* context,
3959  const OrthancPluginImage* image)
3960  {
3961  uint32_t height;
3962 
3963  _OrthancPluginGetImageInfo params;
3964  memset(&params, 0, sizeof(params));
3965  params.image = image;
3966  params.resultUint32 = &height;
3967 
3968  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3969  {
3970  return 0;
3971  }
3972  else
3973  {
3974  return height;
3975  }
3976  }
3977 
3978 
3979 
3992  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3993  OrthancPluginContext* context,
3994  const OrthancPluginImage* image)
3995  {
3996  uint32_t pitch;
3997 
3998  _OrthancPluginGetImageInfo params;
3999  memset(&params, 0, sizeof(params));
4000  params.image = image;
4001  params.resultUint32 = &pitch;
4002 
4003  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
4004  {
4005  return 0;
4006  }
4007  else
4008  {
4009  return pitch;
4010  }
4011  }
4012 
4013 
4014 
4026  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
4027  OrthancPluginContext* context,
4028  const OrthancPluginImage* image)
4029  {
4030  void* target = NULL;
4031 
4032  _OrthancPluginGetImageInfo params;
4033  memset(&params, 0, sizeof(params));
4034  params.resultBuffer = &target;
4035  params.image = image;
4036 
4037  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
4038  {
4039  return NULL;
4040  }
4041  else
4042  {
4043  return target;
4044  }
4045  }
4046 
4047 
4048  typedef struct
4049  {
4050  OrthancPluginImage** target;
4051  const void* data;
4052  uint32_t size;
4053  OrthancPluginImageFormat format;
4054  } _OrthancPluginUncompressImage;
4055 
4056 
4070  OrthancPluginContext* context,
4071  const void* data,
4072  uint32_t size,
4073  OrthancPluginImageFormat format)
4074  {
4075  OrthancPluginImage* target = NULL;
4076 
4077  _OrthancPluginUncompressImage params;
4078  memset(&params, 0, sizeof(params));
4079  params.target = &target;
4080  params.data = data;
4081  params.size = size;
4082  params.format = format;
4083 
4084  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
4085  {
4086  return NULL;
4087  }
4088  else
4089  {
4090  return target;
4091  }
4092  }
4093 
4094 
4095 
4096 
4097  typedef struct
4098  {
4099  OrthancPluginImage* image;
4100  } _OrthancPluginFreeImage;
4101 
4111  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
4112  OrthancPluginContext* context,
4113  OrthancPluginImage* image)
4114  {
4115  _OrthancPluginFreeImage params;
4116  params.image = image;
4117 
4118  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
4119  }
4120 
4121 
4122 
4123 
4124  typedef struct
4125  {
4126  OrthancPluginMemoryBuffer* target;
4127  OrthancPluginImageFormat imageFormat;
4128  OrthancPluginPixelFormat pixelFormat;
4129  uint32_t width;
4130  uint32_t height;
4131  uint32_t pitch;
4132  const void* buffer;
4133  uint8_t quality;
4134  } _OrthancPluginCompressImage;
4135 
4136 
4157  OrthancPluginContext* context,
4158  OrthancPluginMemoryBuffer* target,
4159  OrthancPluginPixelFormat format,
4160  uint32_t width,
4161  uint32_t height,
4162  uint32_t pitch,
4163  const void* buffer)
4164  {
4165  _OrthancPluginCompressImage params;
4166  memset(&params, 0, sizeof(params));
4167  params.target = target;
4168  params.imageFormat = OrthancPluginImageFormat_Png;
4169  params.pixelFormat = format;
4170  params.width = width;
4171  params.height = height;
4172  params.pitch = pitch;
4173  params.buffer = buffer;
4174  params.quality = 0; /* Unused for PNG */
4175 
4176  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4177  }
4178 
4179 
4202  OrthancPluginContext* context,
4203  OrthancPluginMemoryBuffer* target,
4204  OrthancPluginPixelFormat format,
4205  uint32_t width,
4206  uint32_t height,
4207  uint32_t pitch,
4208  const void* buffer,
4209  uint8_t quality)
4210  {
4211  _OrthancPluginCompressImage params;
4212  memset(&params, 0, sizeof(params));
4213  params.target = target;
4214  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4215  params.pixelFormat = format;
4216  params.width = width;
4217  params.height = height;
4218  params.pitch = pitch;
4219  params.buffer = buffer;
4220  params.quality = quality;
4221 
4222  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4223  }
4224 
4225 
4226 
4248  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
4249  OrthancPluginContext* context,
4250  OrthancPluginRestOutput* output,
4251  OrthancPluginPixelFormat format,
4252  uint32_t width,
4253  uint32_t height,
4254  uint32_t pitch,
4255  const void* buffer,
4256  uint8_t quality)
4257  {
4258  _OrthancPluginCompressAndAnswerImage params;
4259  params.output = output;
4260  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4261  params.pixelFormat = format;
4262  params.width = width;
4263  params.height = height;
4264  params.pitch = pitch;
4265  params.buffer = buffer;
4266  params.quality = quality;
4267  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4268  }
4269 
4270 
4271 
4272 
4273  typedef struct
4274  {
4275  OrthancPluginMemoryBuffer* target;
4276  OrthancPluginHttpMethod method;
4277  const char* url;
4278  const char* username;
4279  const char* password;
4280  const void* body;
4281  uint32_t bodySize;
4282  } _OrthancPluginCallHttpClient;
4283 
4284 
4302  OrthancPluginContext* context,
4303  OrthancPluginMemoryBuffer* target,
4304  const char* url,
4305  const char* username,
4306  const char* password)
4307  {
4308  _OrthancPluginCallHttpClient params;
4309  memset(&params, 0, sizeof(params));
4310 
4311  params.target = target;
4312  params.method = OrthancPluginHttpMethod_Get;
4313  params.url = url;
4314  params.username = username;
4315  params.password = password;
4316 
4317  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4318  }
4319 
4320 
4340  OrthancPluginContext* context,
4341  OrthancPluginMemoryBuffer* target,
4342  const char* url,
4343  const void* body,
4344  uint32_t bodySize,
4345  const char* username,
4346  const char* password)
4347  {
4348  _OrthancPluginCallHttpClient params;
4349  memset(&params, 0, sizeof(params));
4350 
4351  params.target = target;
4352  params.method = OrthancPluginHttpMethod_Post;
4353  params.url = url;
4354  params.body = body;
4355  params.bodySize = bodySize;
4356  params.username = username;
4357  params.password = password;
4358 
4359  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4360  }
4361 
4362 
4382  OrthancPluginContext* context,
4383  OrthancPluginMemoryBuffer* target,
4384  const char* url,
4385  const void* body,
4386  uint32_t bodySize,
4387  const char* username,
4388  const char* password)
4389  {
4390  _OrthancPluginCallHttpClient params;
4391  memset(&params, 0, sizeof(params));
4392 
4393  params.target = target;
4394  params.method = OrthancPluginHttpMethod_Put;
4395  params.url = url;
4396  params.body = body;
4397  params.bodySize = bodySize;
4398  params.username = username;
4399  params.password = password;
4400 
4401  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4402  }
4403 
4404 
4420  OrthancPluginContext* context,
4421  const char* url,
4422  const char* username,
4423  const char* password)
4424  {
4425  _OrthancPluginCallHttpClient params;
4426  memset(&params, 0, sizeof(params));
4427 
4428  params.method = OrthancPluginHttpMethod_Delete;
4429  params.url = url;
4430  params.username = username;
4431  params.password = password;
4432 
4433  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4434  }
4435 
4436 
4437 
4438  typedef struct
4439  {
4440  OrthancPluginImage** target;
4441  const OrthancPluginImage* source;
4442  OrthancPluginPixelFormat targetFormat;
4443  } _OrthancPluginConvertPixelFormat;
4444 
4445 
4458  OrthancPluginContext* context,
4459  const OrthancPluginImage* source,
4460  OrthancPluginPixelFormat targetFormat)
4461  {
4462  OrthancPluginImage* target = NULL;
4463 
4464  _OrthancPluginConvertPixelFormat params;
4465  params.target = &target;
4466  params.source = source;
4467  params.targetFormat = targetFormat;
4468 
4469  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4470  {
4471  return NULL;
4472  }
4473  else
4474  {
4475  return target;
4476  }
4477  }
4478 
4479 
4480 
4492  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4493  OrthancPluginContext* context)
4494  {
4495  uint32_t count = 0;
4496 
4497  _OrthancPluginReturnSingleValue params;
4498  memset(&params, 0, sizeof(params));
4499  params.resultUint32 = &count;
4500 
4501  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4502  {
4503  /* Error */
4504  return 0;
4505  }
4506  else
4507  {
4508  return count;
4509  }
4510  }
4511 
4512 
4513 
4514 
4515  typedef struct
4516  {
4517  uint32_t fontIndex; /* in */
4518  const char** name; /* out */
4519  uint32_t* size; /* out */
4520  } _OrthancPluginGetFontInfo;
4521 
4532  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4533  OrthancPluginContext* context,
4534  uint32_t fontIndex)
4535  {
4536  const char* result = NULL;
4537 
4538  _OrthancPluginGetFontInfo params;
4539  memset(&params, 0, sizeof(params));
4540  params.name = &result;
4541  params.fontIndex = fontIndex;
4542 
4543  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4544  {
4545  return NULL;
4546  }
4547  else
4548  {
4549  return result;
4550  }
4551  }
4552 
4553 
4564  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4565  OrthancPluginContext* context,
4566  uint32_t fontIndex)
4567  {
4568  uint32_t result;
4569 
4570  _OrthancPluginGetFontInfo params;
4571  memset(&params, 0, sizeof(params));
4572  params.size = &result;
4573  params.fontIndex = fontIndex;
4574 
4575  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4576  {
4577  return 0;
4578  }
4579  else
4580  {
4581  return result;
4582  }
4583  }
4584 
4585 
4586 
4587  typedef struct
4588  {
4589  OrthancPluginImage* image;
4590  uint32_t fontIndex;
4591  const char* utf8Text;
4592  int32_t x;
4593  int32_t y;
4594  uint8_t r;
4595  uint8_t g;
4596  uint8_t b;
4597  } _OrthancPluginDrawText;
4598 
4599 
4618  OrthancPluginContext* context,
4619  OrthancPluginImage* image,
4620  uint32_t fontIndex,
4621  const char* utf8Text,
4622  int32_t x,
4623  int32_t y,
4624  uint8_t r,
4625  uint8_t g,
4626  uint8_t b)
4627  {
4628  _OrthancPluginDrawText params;
4629  memset(&params, 0, sizeof(params));
4630  params.image = image;
4631  params.fontIndex = fontIndex;
4632  params.utf8Text = utf8Text;
4633  params.x = x;
4634  params.y = y;
4635  params.r = r;
4636  params.g = g;
4637  params.b = b;
4638 
4639  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4640  }
4641 
4642 
4643 
4644  typedef struct
4645  {
4646  OrthancPluginStorageArea* storageArea;
4647  const char* uuid;
4648  const void* content;
4649  uint64_t size;
4651  } _OrthancPluginStorageAreaCreate;
4652 
4653 
4672  OrthancPluginContext* context,
4673  OrthancPluginStorageArea* storageArea,
4674  const char* uuid,
4675  const void* content,
4676  uint64_t size,
4678  {
4679  _OrthancPluginStorageAreaCreate params;
4680  params.storageArea = storageArea;
4681  params.uuid = uuid;
4682  params.content = content;
4683  params.size = size;
4684  params.type = type;
4685 
4686  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4687  }
4688 
4689 
4690  typedef struct
4691  {
4692  OrthancPluginMemoryBuffer* target;
4693  OrthancPluginStorageArea* storageArea;
4694  const char* uuid;
4696  } _OrthancPluginStorageAreaRead;
4697 
4698 
4716  OrthancPluginContext* context,
4717  OrthancPluginMemoryBuffer* target,
4718  OrthancPluginStorageArea* storageArea,
4719  const char* uuid,
4721  {
4722  _OrthancPluginStorageAreaRead params;
4723  params.target = target;
4724  params.storageArea = storageArea;
4725  params.uuid = uuid;
4726  params.type = type;
4727 
4728  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4729  }
4730 
4731 
4732  typedef struct
4733  {
4734  OrthancPluginStorageArea* storageArea;
4735  const char* uuid;
4737  } _OrthancPluginStorageAreaRemove;
4738 
4755  OrthancPluginContext* context,
4756  OrthancPluginStorageArea* storageArea,
4757  const char* uuid,
4759  {
4760  _OrthancPluginStorageAreaRemove params;
4761  params.storageArea = storageArea;
4762  params.uuid = uuid;
4763  params.type = type;
4764 
4765  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4766  }
4767 
4768 
4769 
4770  typedef struct
4771  {
4772  OrthancPluginErrorCode* target;
4773  int32_t code;
4774  uint16_t httpStatus;
4775  const char* message;
4776  } _OrthancPluginRegisterErrorCode;
4777 
4794  OrthancPluginContext* context,
4795  int32_t code,
4796  uint16_t httpStatus,
4797  const char* message)
4798  {
4799  OrthancPluginErrorCode target;
4800 
4801  _OrthancPluginRegisterErrorCode params;
4802  params.target = &target;
4803  params.code = code;
4804  params.httpStatus = httpStatus;
4805  params.message = message;
4806 
4807  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4808  {
4809  return target;
4810  }
4811  else
4812  {
4813  /* There was an error while assigned the error. Use a generic code. */
4815  }
4816  }
4817 
4818 
4819 
4820  typedef struct
4821  {
4822  uint16_t group;
4823  uint16_t element;
4825  const char* name;
4826  uint32_t minMultiplicity;
4827  uint32_t maxMultiplicity;
4828  } _OrthancPluginRegisterDictionaryTag;
4829 
4850  OrthancPluginContext* context,
4851  uint16_t group,
4852  uint16_t element,
4854  const char* name,
4855  uint32_t minMultiplicity,
4856  uint32_t maxMultiplicity)
4857  {
4858  _OrthancPluginRegisterDictionaryTag params;
4859  params.group = group;
4860  params.element = element;
4861  params.vr = vr;
4862  params.name = name;
4863  params.minMultiplicity = minMultiplicity;
4864  params.maxMultiplicity = maxMultiplicity;
4865 
4866  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4867  }
4868 
4869 
4870 
4871  typedef struct
4872  {
4873  uint16_t group;
4874  uint16_t element;
4876  const char* name;
4877  uint32_t minMultiplicity;
4878  uint32_t maxMultiplicity;
4879  const char* privateCreator;
4880  } _OrthancPluginRegisterPrivateDictionaryTag;
4881 
4903  OrthancPluginContext* context,
4904  uint16_t group,
4905  uint16_t element,
4907  const char* name,
4908  uint32_t minMultiplicity,
4909  uint32_t maxMultiplicity,
4910  const char* privateCreator)
4911  {
4912  _OrthancPluginRegisterPrivateDictionaryTag params;
4913  params.group = group;
4914  params.element = element;
4915  params.vr = vr;
4916  params.name = name;
4917  params.minMultiplicity = minMultiplicity;
4918  params.maxMultiplicity = maxMultiplicity;
4919  params.privateCreator = privateCreator;
4920 
4921  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4922  }
4923 
4924 
4925 
4926  typedef struct
4927  {
4928  OrthancPluginStorageArea* storageArea;
4930  } _OrthancPluginReconstructMainDicomTags;
4931 
4947  OrthancPluginContext* context,
4948  OrthancPluginStorageArea* storageArea,
4950  {
4951  _OrthancPluginReconstructMainDicomTags params;
4952  params.level = level;
4953  params.storageArea = storageArea;
4954 
4955  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
4956  }
4957 
4958 
4959  typedef struct
4960  {
4961  char** result;
4962  const char* instanceId;
4963  const void* buffer;
4964  uint32_t size;
4967  uint32_t maxStringLength;
4968  } _OrthancPluginDicomToJson;
4969 
4970 
4990  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4991  OrthancPluginContext* context,
4992  const void* buffer,
4993  uint32_t size,
4996  uint32_t maxStringLength)
4997  {
4998  char* result;
4999 
5000  _OrthancPluginDicomToJson params;
5001  memset(&params, 0, sizeof(params));
5002  params.result = &result;
5003  params.buffer = buffer;
5004  params.size = size;
5005  params.format = format;
5006  params.flags = flags;
5007  params.maxStringLength = maxStringLength;
5008 
5009  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
5010  {
5011  /* Error */
5012  return NULL;
5013  }
5014  else
5015  {
5016  return result;
5017  }
5018  }
5019 
5020 
5039  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
5040  OrthancPluginContext* context,
5041  const char* instanceId,
5044  uint32_t maxStringLength)
5045  {
5046  char* result;
5047 
5048  _OrthancPluginDicomToJson params;
5049  memset(&params, 0, sizeof(params));
5050  params.result = &result;
5051  params.instanceId = instanceId;
5052  params.format = format;
5053  params.flags = flags;
5054  params.maxStringLength = maxStringLength;
5055 
5056  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
5057  {
5058  /* Error */
5059  return NULL;
5060  }
5061  else
5062  {
5063  return result;
5064  }
5065  }
5066 
5067 
5068  typedef struct
5069  {
5070  OrthancPluginMemoryBuffer* target;
5071  const char* uri;
5072  uint32_t headersCount;
5073  const char* const* headersKeys;
5074  const char* const* headersValues;
5075  int32_t afterPlugins;
5076  } _OrthancPluginRestApiGet2;
5077 
5098  OrthancPluginContext* context,
5099  OrthancPluginMemoryBuffer* target,
5100  const char* uri,
5101  uint32_t headersCount,
5102  const char* const* headersKeys,
5103  const char* const* headersValues,
5104  int32_t afterPlugins)
5105  {
5106  _OrthancPluginRestApiGet2 params;
5107  params.target = target;
5108  params.uri = uri;
5109  params.headersCount = headersCount;
5110  params.headersKeys = headersKeys;
5111  params.headersValues = headersValues;
5112  params.afterPlugins = afterPlugins;
5113 
5114  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
5115  }
5116 
5117 
5118 
5119  typedef struct
5120  {
5122  } _OrthancPluginWorklistCallback;
5123 
5136  OrthancPluginContext* context,
5138  {
5139  _OrthancPluginWorklistCallback params;
5140  params.callback = callback;
5141 
5142  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
5143  }
5144 
5145 
5146 
5147  typedef struct
5148  {
5150  const OrthancPluginWorklistQuery* query;
5151  const void* dicom;
5152  uint32_t size;
5153  } _OrthancPluginWorklistAnswersOperation;
5154 
5172  OrthancPluginContext* context,
5174  const OrthancPluginWorklistQuery* query,
5175  const void* dicom,
5176  uint32_t size)
5177  {
5178  _OrthancPluginWorklistAnswersOperation params;
5179  params.answers = answers;
5180  params.query = query;
5181  params.dicom = dicom;
5182  params.size = size;
5183 
5184  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
5185  }
5186 
5187 
5202  OrthancPluginContext* context,
5204  {
5205  _OrthancPluginWorklistAnswersOperation params;
5206  params.answers = answers;
5207  params.query = NULL;
5208  params.dicom = NULL;
5209  params.size = 0;
5210 
5211  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5212  }
5213 
5214 
5215  typedef struct
5216  {
5217  const OrthancPluginWorklistQuery* query;
5218  const void* dicom;
5219  uint32_t size;
5220  int32_t* isMatch;
5221  OrthancPluginMemoryBuffer* target;
5222  } _OrthancPluginWorklistQueryOperation;
5223 
5239  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5240  OrthancPluginContext* context,
5241  const OrthancPluginWorklistQuery* query,
5242  const void* dicom,
5243  uint32_t size)
5244  {
5245  int32_t isMatch = 0;
5246 
5247  _OrthancPluginWorklistQueryOperation params;
5248  params.query = query;
5249  params.dicom = dicom;
5250  params.size = size;
5251  params.isMatch = &isMatch;
5252  params.target = NULL;
5253 
5254  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5255  {
5256  return isMatch;
5257  }
5258  else
5259  {
5260  /* Error: Assume non-match */
5261  return 0;
5262  }
5263  }
5264 
5265 
5279  OrthancPluginContext* context,
5280  OrthancPluginMemoryBuffer* target,
5281  const OrthancPluginWorklistQuery* query)
5282  {
5283  _OrthancPluginWorklistQueryOperation params;
5284  params.query = query;
5285  params.dicom = NULL;
5286  params.size = 0;
5287  params.isMatch = NULL;
5288  params.target = target;
5289 
5290  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5291  }
5292 
5293 
5305  OrthancPluginContext* context,
5306  const OrthancPluginDicomInstance* instance)
5307  {
5309 
5310  _OrthancPluginAccessDicomInstance params;
5311  memset(&params, 0, sizeof(params));
5312  params.resultOrigin = &origin;
5313  params.instance = instance;
5314 
5315  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5316  {
5317  /* Error */
5319  }
5320  else
5321  {
5322  return origin;
5323  }
5324  }
5325 
5326 
5327  typedef struct
5328  {
5329  OrthancPluginMemoryBuffer* target;
5330  const char* json;
5331  const OrthancPluginImage* pixelData;
5333  } _OrthancPluginCreateDicom;
5334 
5361  OrthancPluginContext* context,
5362  OrthancPluginMemoryBuffer* target,
5363  const char* json,
5364  const OrthancPluginImage* pixelData,
5366  {
5367  _OrthancPluginCreateDicom params;
5368  params.target = target;
5369  params.json = json;
5370  params.pixelData = pixelData;
5371  params.flags = flags;
5372 
5373  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5374  }
5375 
5376 
5377  typedef struct
5378  {
5380  } _OrthancPluginDecodeImageCallback;
5381 
5397  OrthancPluginContext* context,
5399  {
5400  _OrthancPluginDecodeImageCallback params;
5401  params.callback = callback;
5402 
5403  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5404  }
5405 
5406 
5407 
5408  typedef struct
5409  {
5410  OrthancPluginImage** target;
5411  OrthancPluginPixelFormat format;
5412  uint32_t width;
5413  uint32_t height;
5414  uint32_t pitch;
5415  void* buffer;
5416  const void* constBuffer;
5417  uint32_t bufferSize;
5418  uint32_t frameIndex;
5419  } _OrthancPluginCreateImage;
5420 
5421 
5435  OrthancPluginContext* context,
5436  OrthancPluginPixelFormat format,
5437  uint32_t width,
5438  uint32_t height)
5439  {
5440  OrthancPluginImage* target = NULL;
5441 
5442  _OrthancPluginCreateImage params;
5443  memset(&params, 0, sizeof(params));
5444  params.target = &target;
5445  params.format = format;
5446  params.width = width;
5447  params.height = height;
5448 
5449  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5450  {
5451  return NULL;
5452  }
5453  else
5454  {
5455  return target;
5456  }
5457  }
5458 
5459 
5478  OrthancPluginContext* context,
5479  OrthancPluginPixelFormat format,
5480  uint32_t width,
5481  uint32_t height,
5482  uint32_t pitch,
5483  void* buffer)
5484  {
5485  OrthancPluginImage* target = NULL;
5486 
5487  _OrthancPluginCreateImage params;
5488  memset(&params, 0, sizeof(params));
5489  params.target = &target;
5490  params.format = format;
5491  params.width = width;
5492  params.height = height;
5493  params.pitch = pitch;
5494  params.buffer = buffer;
5495 
5496  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5497  {
5498  return NULL;
5499  }
5500  else
5501  {
5502  return target;
5503  }
5504  }
5505 
5506 
5507 
5524  OrthancPluginContext* context,
5525  const void* buffer,
5526  uint32_t bufferSize,
5527  uint32_t frameIndex)
5528  {
5529  OrthancPluginImage* target = NULL;
5530 
5531  _OrthancPluginCreateImage params;
5532  memset(&params, 0, sizeof(params));
5533  params.target = &target;
5534  params.constBuffer = buffer;
5535  params.bufferSize = bufferSize;
5536  params.frameIndex = frameIndex;
5537 
5538  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5539  {
5540  return NULL;
5541  }
5542  else
5543  {
5544  return target;
5545  }
5546  }
5547 
5548 
5549 
5550  typedef struct
5551  {
5552  char** result;
5553  const void* buffer;
5554  uint32_t size;
5555  } _OrthancPluginComputeHash;
5556 
5569  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5570  OrthancPluginContext* context,
5571  const void* buffer,
5572  uint32_t size)
5573  {
5574  char* result;
5575 
5576  _OrthancPluginComputeHash params;
5577  params.result = &result;
5578  params.buffer = buffer;
5579  params.size = size;
5580 
5581  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5582  {
5583  /* Error */
5584  return NULL;
5585  }
5586  else
5587  {
5588  return result;
5589  }
5590  }
5591 
5592 
5605  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5606  OrthancPluginContext* context,
5607  const void* buffer,
5608  uint32_t size)
5609  {
5610  char* result;
5611 
5612  _OrthancPluginComputeHash params;
5613  params.result = &result;
5614  params.buffer = buffer;
5615  params.size = size;
5616 
5617  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5618  {
5619  /* Error */
5620  return NULL;
5621  }
5622  else
5623  {
5624  return result;
5625  }
5626  }
5627 
5628 
5629 
5630  typedef struct
5631  {
5633  const char* name;
5634  } _OrthancPluginLookupDictionary;
5635 
5652  OrthancPluginContext* context,
5654  const char* name)
5655  {
5656  _OrthancPluginLookupDictionary params;
5657  params.target = target;
5658  params.name = name;
5659  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5660  }
5661 
5662 
5663 
5664  typedef struct
5665  {
5666  OrthancPluginRestOutput* output;
5667  const void* answer;
5668  uint32_t answerSize;
5669  uint32_t headersCount;
5670  const char* const* headersKeys;
5671  const char* const* headersValues;
5672  } _OrthancPluginSendMultipartItem2;
5673 
5695  OrthancPluginContext* context,
5696  OrthancPluginRestOutput* output,
5697  const void* answer,
5698  uint32_t answerSize,
5699  uint32_t headersCount,
5700  const char* const* headersKeys,
5701  const char* const* headersValues)
5702  {
5703  _OrthancPluginSendMultipartItem2 params;
5704  params.output = output;
5705  params.answer = answer;
5706  params.answerSize = answerSize;
5707  params.headersCount = headersCount;
5708  params.headersKeys = headersKeys;
5709  params.headersValues = headersValues;
5710 
5711  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5712  }
5713 
5714 
5715  typedef struct
5716  {
5718  } _OrthancPluginIncomingHttpRequestFilter;
5719 
5733  OrthancPluginContext* context,
5735  {
5736  _OrthancPluginIncomingHttpRequestFilter params;
5737  params.callback = callback;
5738 
5739  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5740  }
5741 
5742 
5743 
5744  typedef struct
5745  {
5746  OrthancPluginMemoryBuffer* answerBody;
5747  OrthancPluginMemoryBuffer* answerHeaders;
5748  uint16_t* httpStatus;
5749  OrthancPluginHttpMethod method;
5750  const char* url;
5751  uint32_t headersCount;
5752  const char* const* headersKeys;
5753  const char* const* headersValues;
5754  const void* body;
5755  uint32_t bodySize;
5756  const char* username;
5757  const char* password;
5758  uint32_t timeout;
5759  const char* certificateFile;
5760  const char* certificateKeyFile;
5761  const char* certificateKeyPassword;
5762  uint8_t pkcs11;
5763  } _OrthancPluginCallHttpClient2;
5764 
5765 
5766 
5808  OrthancPluginContext* context,
5809  OrthancPluginMemoryBuffer* answerBody,
5810  OrthancPluginMemoryBuffer* answerHeaders,
5811  uint16_t* httpStatus,
5812  OrthancPluginHttpMethod method,
5813  const char* url,
5814  uint32_t headersCount,
5815  const char* const* headersKeys,
5816  const char* const* headersValues,
5817  const void* body,
5818  uint32_t bodySize,
5819  const char* username,
5820  const char* password,
5821  uint32_t timeout,
5822  const char* certificateFile,
5823  const char* certificateKeyFile,
5824  const char* certificateKeyPassword,
5825  uint8_t pkcs11)
5826  {
5827  _OrthancPluginCallHttpClient2 params;
5828  memset(&params, 0, sizeof(params));
5829 
5830  params.answerBody = answerBody;
5831  params.answerHeaders = answerHeaders;
5832  params.httpStatus = httpStatus;
5833  params.method = method;
5834  params.url = url;
5835  params.headersCount = headersCount;
5836  params.headersKeys = headersKeys;
5837  params.headersValues = headersValues;
5838  params.body = body;
5839  params.bodySize = bodySize;
5840  params.username = username;
5841  params.password = password;
5842  params.timeout = timeout;
5843  params.certificateFile = certificateFile;
5844  params.certificateKeyFile = certificateKeyFile;
5845  params.certificateKeyPassword = certificateKeyPassword;
5846  params.pkcs11 = pkcs11;
5847 
5848  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5849  }
5850 
5851 
5862  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5863  OrthancPluginContext* context)
5864  {
5865  char* result;
5866 
5867  _OrthancPluginRetrieveDynamicString params;
5868  params.result = &result;
5869  params.argument = NULL;
5870 
5871  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5872  {
5873  /* Error */
5874  return NULL;
5875  }
5876  else
5877  {
5878  return result;
5879  }
5880  }
5881 
5882 
5883 
5884 
5885  typedef struct
5886  {
5887  OrthancPluginFindCallback callback;
5888  } _OrthancPluginFindCallback;
5889 
5902  OrthancPluginContext* context,
5903  OrthancPluginFindCallback callback)
5904  {
5905  _OrthancPluginFindCallback params;
5906  params.callback = callback;
5907 
5908  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5909  }
5910 
5911 
5912  typedef struct
5913  {
5914  OrthancPluginFindAnswers *answers;
5915  const OrthancPluginFindQuery *query;
5916  const void *dicom;
5917  uint32_t size;
5918  uint32_t index;
5919  uint32_t *resultUint32;
5920  uint16_t *resultGroup;
5921  uint16_t *resultElement;
5922  char **resultString;
5923  } _OrthancPluginFindOperation;
5924 
5941  OrthancPluginContext* context,
5942  OrthancPluginFindAnswers* answers,
5943  const void* dicom,
5944  uint32_t size)
5945  {
5946  _OrthancPluginFindOperation params;
5947  memset(&params, 0, sizeof(params));
5948  params.answers = answers;
5949  params.dicom = dicom;
5950  params.size = size;
5951 
5952  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
5953  }
5954 
5955 
5970  OrthancPluginContext* context,
5971  OrthancPluginFindAnswers* answers)
5972  {
5973  _OrthancPluginFindOperation params;
5974  memset(&params, 0, sizeof(params));
5975  params.answers = answers;
5976 
5977  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
5978  }
5979 
5980 
5981 
5993  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
5994  OrthancPluginContext* context,
5995  const OrthancPluginFindQuery* query)
5996  {
5997  uint32_t count = 0;
5998 
5999  _OrthancPluginFindOperation params;
6000  memset(&params, 0, sizeof(params));
6001  params.query = query;
6002  params.resultUint32 = &count;
6003 
6004  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
6005  {
6006  /* Error */
6007  return 0;
6008  }
6009  else
6010  {
6011  return count;
6012  }
6013  }
6014 
6015 
6031  OrthancPluginContext* context,
6032  uint16_t* group,
6033  uint16_t* element,
6034  const OrthancPluginFindQuery* query,
6035  uint32_t index)
6036  {
6037  _OrthancPluginFindOperation params;
6038  memset(&params, 0, sizeof(params));
6039  params.query = query;
6040  params.index = index;
6041  params.resultGroup = group;
6042  params.resultElement = element;
6043 
6044  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
6045  }
6046 
6047 
6061  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
6062  OrthancPluginContext* context,
6063  const OrthancPluginFindQuery* query,
6064  uint32_t index)
6065  {
6066  char* result;
6067 
6068  _OrthancPluginFindOperation params;
6069  memset(&params, 0, sizeof(params));
6070  params.query = query;
6071  params.index = index;
6072  params.resultString = &result;
6073 
6074  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
6075  {
6076  /* Error */
6077  return NULL;
6078  }
6079  else
6080  {
6081  return result;
6082  }
6083  }
6084 
6085 
6099  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
6100  OrthancPluginContext* context,
6101  const OrthancPluginFindQuery* query,
6102  uint32_t index)
6103  {
6104  char* result;
6105 
6106  _OrthancPluginFindOperation params;
6107  memset(&params, 0, sizeof(params));
6108  params.query = query;
6109  params.index = index;
6110  params.resultString = &result;
6111 
6112  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
6113  {
6114  /* Error */
6115  return NULL;
6116  }
6117  else
6118  {
6119  return result;
6120  }
6121  }
6122 
6123 
6124 
6125 
6126  typedef struct
6127  {
6128  OrthancPluginMoveCallback callback;
6129  OrthancPluginGetMoveSize getMoveSize;
6130  OrthancPluginApplyMove applyMove;
6131  OrthancPluginFreeMove freeMove;
6132  } _OrthancPluginMoveCallback;
6133 
6148  OrthancPluginContext* context,
6149  OrthancPluginMoveCallback callback,
6150  OrthancPluginGetMoveSize getMoveSize,
6151  OrthancPluginApplyMove applyMove,
6152  OrthancPluginFreeMove freeMove)
6153  {
6154  _OrthancPluginMoveCallback params;
6155  params.callback = callback;
6156  params.getMoveSize = getMoveSize;
6157  params.applyMove = applyMove;
6158  params.freeMove = freeMove;
6159 
6160  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
6161  }
6162 
6163 
6164 
6165  typedef struct
6166  {
6167  OrthancPluginFindMatcher** target;
6168  const void* query;
6169  uint32_t size;
6170  } _OrthancPluginCreateFindMatcher;
6171 
6172 
6187  OrthancPluginContext* context,
6188  const void* query,
6189  uint32_t size)
6190  {
6191  OrthancPluginFindMatcher* target = NULL;
6192 
6193  _OrthancPluginCreateFindMatcher params;
6194  memset(&params, 0, sizeof(params));
6195  params.target = &target;
6196  params.query = query;
6197  params.size = size;
6198 
6199  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
6200  {
6201  return NULL;
6202  }
6203  else
6204  {
6205  return target;
6206  }
6207  }
6208 
6209 
6210  typedef struct
6211  {
6212  OrthancPluginFindMatcher* matcher;
6213  } _OrthancPluginFreeFindMatcher;
6214 
6224  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6225  OrthancPluginContext* context,
6226  OrthancPluginFindMatcher* matcher)
6227  {
6228  _OrthancPluginFreeFindMatcher params;
6229  params.matcher = matcher;
6230 
6231  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6232  }
6233 
6234 
6235  typedef struct
6236  {
6237  const OrthancPluginFindMatcher* matcher;
6238  const void* dicom;
6239  uint32_t size;
6240  int32_t* isMatch;
6241  } _OrthancPluginFindMatcherIsMatch;
6242 
6257  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6258  OrthancPluginContext* context,
6259  const OrthancPluginFindMatcher* matcher,
6260  const void* dicom,
6261  uint32_t size)
6262  {
6263  int32_t isMatch = 0;
6264 
6265  _OrthancPluginFindMatcherIsMatch params;
6266  params.matcher = matcher;
6267  params.dicom = dicom;
6268  params.size = size;
6269  params.isMatch = &isMatch;
6270 
6271  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6272  {
6273  return isMatch;
6274  }
6275  else
6276  {
6277  /* Error: Assume non-match */
6278  return 0;
6279  }
6280  }
6281 
6282 
6283  typedef struct
6284  {
6286  } _OrthancPluginIncomingHttpRequestFilter2;
6287 
6300  OrthancPluginContext* context,
6302  {
6303  _OrthancPluginIncomingHttpRequestFilter2 params;
6304  params.callback = callback;
6305 
6306  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6307  }
6308 
6309 
6310 
6311  typedef struct
6312  {
6313  OrthancPluginPeers** peers;
6314  } _OrthancPluginGetPeers;
6315 
6328  OrthancPluginContext* context)
6329  {
6330  OrthancPluginPeers* peers = NULL;
6331 
6332  _OrthancPluginGetPeers params;
6333  memset(&params, 0, sizeof(params));
6334  params.peers = &peers;
6335 
6336  if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6337  {
6338  return NULL;
6339  }
6340  else
6341  {
6342  return peers;
6343  }
6344  }
6345 
6346 
6347  typedef struct
6348  {
6349  OrthancPluginPeers* peers;
6350  } _OrthancPluginFreePeers;
6351 
6361  ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6362  OrthancPluginContext* context,
6363  OrthancPluginPeers* peers)
6364  {
6365  _OrthancPluginFreePeers params;
6366  params.peers = peers;
6367 
6368  context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6369  }
6370 
6371 
6372  typedef struct
6373  {
6374  uint32_t* target;
6375  const OrthancPluginPeers* peers;
6376  } _OrthancPluginGetPeersCount;
6377 
6391  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6392  OrthancPluginContext* context,
6393  const OrthancPluginPeers* peers)
6394  {
6395  uint32_t target = 0;
6396 
6397  _OrthancPluginGetPeersCount params;
6398  memset(&params, 0, sizeof(params));
6399  params.target = &target;
6400  params.peers = peers;
6401 
6402  if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6403  {
6404  /* Error */
6405  return 0;
6406  }
6407  else
6408  {
6409  return target;
6410  }
6411  }
6412 
6413 
6414  typedef struct
6415  {
6416  const char** target;
6417  const OrthancPluginPeers* peers;
6418  uint32_t peerIndex;
6419  const char* userProperty;
6420  } _OrthancPluginGetPeerProperty;
6421 
6439  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6440  OrthancPluginContext* context,
6441  const OrthancPluginPeers* peers,
6442  uint32_t peerIndex)
6443  {
6444  const char* target = NULL;
6445 
6446  _OrthancPluginGetPeerProperty params;
6447  memset(&params, 0, sizeof(params));
6448  params.target = &target;
6449  params.peers = peers;
6450  params.peerIndex = peerIndex;
6451  params.userProperty = NULL;
6452 
6453  if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6454  {
6455  /* Error */
6456  return NULL;
6457  }
6458  else
6459  {
6460  return target;
6461  }
6462  }
6463 
6464 
6480  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6481  OrthancPluginContext* context,
6482  const OrthancPluginPeers* peers,
6483  uint32_t peerIndex)
6484  {
6485  const char* target = NULL;
6486 
6487  _OrthancPluginGetPeerProperty params;
6488  memset(&params, 0, sizeof(params));
6489  params.target = &target;
6490  params.peers = peers;
6491  params.peerIndex = peerIndex;
6492  params.userProperty = NULL;
6493 
6494  if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6495  {
6496  /* Error */
6497  return NULL;
6498  }
6499  else
6500  {
6501  return target;
6502  }
6503  }
6504 
6505 
6506 
6526  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6527  OrthancPluginContext* context,
6528  const OrthancPluginPeers* peers,
6529  uint32_t peerIndex,
6530  const char* userProperty)
6531  {
6532  const char* target = NULL;
6533 
6534  _OrthancPluginGetPeerProperty params;
6535  memset(&params, 0, sizeof(params));
6536  params.target = &target;
6537  params.peers = peers;
6538  params.peerIndex = peerIndex;
6539  params.userProperty = userProperty;
6540 
6541  if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6542  {
6543  /* No such user property */
6544  return NULL;
6545  }
6546  else
6547  {
6548  return target;
6549  }
6550  }
6551 
6552 
6553 
6554  typedef struct
6555  {
6556  OrthancPluginMemoryBuffer* answerBody;
6557  OrthancPluginMemoryBuffer* answerHeaders;
6558  uint16_t* httpStatus;
6559  const OrthancPluginPeers* peers;
6560  uint32_t peerIndex;
6561  OrthancPluginHttpMethod method;
6562  const char* uri;
6563  uint32_t additionalHeadersCount;
6564  const char* const* additionalHeadersKeys;
6565  const char* const* additionalHeadersValues;
6566  const void* body;
6567  uint32_t bodySize;
6568  uint32_t timeout;
6569  } _OrthancPluginCallPeerApi;
6570 
6608  OrthancPluginContext* context,
6609  OrthancPluginMemoryBuffer* answerBody,
6610  OrthancPluginMemoryBuffer* answerHeaders,
6611  uint16_t* httpStatus,
6612  const OrthancPluginPeers* peers,
6613  uint32_t peerIndex,
6614  OrthancPluginHttpMethod method,
6615  const char* uri,
6616  uint32_t additionalHeadersCount,
6617  const char* const* additionalHeadersKeys,
6618  const char* const* additionalHeadersValues,
6619  const void* body,
6620  uint32_t bodySize,
6621  uint32_t timeout)
6622  {
6623  _OrthancPluginCallPeerApi params;
6624  memset(&params, 0, sizeof(params));
6625 
6626  params.answerBody = answerBody;
6627  params.answerHeaders = answerHeaders;
6628  params.httpStatus = httpStatus;
6629  params.peers = peers;
6630  params.peerIndex = peerIndex;
6631  params.method = method;
6632  params.uri = uri;
6633  params.additionalHeadersCount = additionalHeadersCount;
6634  params.additionalHeadersKeys = additionalHeadersKeys;
6635  params.additionalHeadersValues = additionalHeadersValues;
6636  params.body = body;
6637  params.bodySize = bodySize;
6638  params.timeout = timeout;
6639 
6640  return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6641  }
6642 
6643 
6644 
6645 
6646 
6647  typedef struct
6648  {
6649  OrthancPluginJob** target;
6650  void *job;
6651  OrthancPluginJobFinalize finalize;
6652  const char *type;
6653  OrthancPluginJobGetProgress getProgress;
6654  OrthancPluginJobGetContent getContent;
6655  OrthancPluginJobGetSerialized getSerialized;
6656  OrthancPluginJobStep step;
6657  OrthancPluginJobStop stop;
6658  OrthancPluginJobReset reset;
6659  } _OrthancPluginCreateJob;
6660 
6693  OrthancPluginContext *context,
6694  void *job,
6695  OrthancPluginJobFinalize finalize,
6696  const char *type,
6697  OrthancPluginJobGetProgress getProgress,
6698  OrthancPluginJobGetContent getContent,
6699  OrthancPluginJobGetSerialized getSerialized,
6700  OrthancPluginJobStep step,
6701  OrthancPluginJobStop stop,
6702  OrthancPluginJobReset reset)
6703  {
6704  OrthancPluginJob* target = NULL;
6705 
6706  _OrthancPluginCreateJob params;
6707  memset(&params, 0, sizeof(params));
6708 
6709  params.target = &target;
6710  params.job = job;
6711  params.finalize = finalize;
6712  params.type = type;
6713  params.getProgress = getProgress;
6714  params.getContent = getContent;
6715  params.getSerialized = getSerialized;
6716  params.step = step;
6717  params.stop = stop;
6718  params.reset = reset;
6719 
6720  if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6721  target == NULL)
6722  {
6723  /* Error */
6724  return NULL;
6725  }
6726  else
6727  {
6728  return target;
6729  }
6730  }
6731 
6732 
6733  typedef struct
6734  {
6735  OrthancPluginJob* job;
6736  } _OrthancPluginFreeJob;
6737 
6747  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6748  OrthancPluginContext* context,
6749  OrthancPluginJob* job)
6750  {
6751  _OrthancPluginFreeJob params;
6752  params.job = job;
6753 
6754  context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6755  }
6756 
6757 
6758 
6759  typedef struct
6760  {
6761  char** resultId;
6762  OrthancPluginJob *job;
6763  int priority;
6764  } _OrthancPluginSubmitJob;
6765 
6779  ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6780  OrthancPluginContext *context,
6781  OrthancPluginJob *job,
6782  int priority)
6783  {
6784  char* resultId = NULL;
6785 
6786  _OrthancPluginSubmitJob params;
6787  memset(&params, 0, sizeof(params));
6788 
6789  params.resultId = &resultId;
6790  params.job = job;
6791  params.priority = priority;
6792 
6793  if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6794  resultId == NULL)
6795  {
6796  /* Error */
6797  return NULL;
6798  }
6799  else
6800  {
6801  return resultId;
6802  }
6803  }
6804 
6805 
6806 
6807  typedef struct
6808  {
6809  OrthancPluginJobsUnserializer unserializer;
6810  } _OrthancPluginJobsUnserializer;
6811 
6824  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6825  OrthancPluginContext* context,
6826  OrthancPluginJobsUnserializer unserializer)
6827  {
6828  _OrthancPluginJobsUnserializer params;
6829  params.unserializer = unserializer;
6830 
6831  context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6832  }
6833 
6834 
6835 
6836  typedef struct
6837  {
6838  OrthancPluginRestOutput* output;
6839  const char* details;
6840  uint8_t log;
6841  } _OrthancPluginSetHttpErrorDetails;
6842 
6860  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
6861  OrthancPluginContext* context,
6862  OrthancPluginRestOutput* output,
6863  const char* details,
6864  uint8_t log)
6865  {
6866  _OrthancPluginSetHttpErrorDetails params;
6867  params.output = output;
6868  params.details = details;
6869  params.log = log;
6870  context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
6871  }
6872 
6873 
6874 
6875  typedef struct
6876  {
6877  const char** result;
6878  const char* argument;
6879  } _OrthancPluginRetrieveStaticString;
6880 
6892  ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
6893  OrthancPluginContext* context,
6894  const char* path)
6895  {
6896  const char* result = NULL;
6897 
6898  _OrthancPluginRetrieveStaticString params;
6899  params.result = &result;
6900  params.argument = path;
6901 
6902  if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
6903  {
6904  /* Error */
6905  return NULL;
6906  }
6907  else
6908  {
6909  return result;
6910  }
6911  }
6912 
6913 
6914 
6915  typedef struct
6916  {
6917  const char* name;
6918  float value;
6920  } _OrthancPluginSetMetricsValue;
6921 
6936  ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
6937  OrthancPluginContext* context,
6938  const char* name,
6939  float value,
6941  {
6942  _OrthancPluginSetMetricsValue params;
6943  params.name = name;
6944  params.value = value;
6945  params.type = type;
6946  context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
6947  }
6948 
6949 
6950 
6951  typedef struct
6952  {
6954  } _OrthancPluginRegisterRefreshMetricsCallback;
6955 
6967  OrthancPluginContext* context,
6969  {
6970  _OrthancPluginRegisterRefreshMetricsCallback params;
6971  params.callback = callback;
6972  context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
6973  }
6974 
6975 
6976 
6977 
6978  typedef struct
6979  {
6980  char** target;
6981  const void* dicom;
6982  uint32_t dicomSize;
6984  } _OrthancPluginEncodeDicomWeb;
6985 
7002  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
7003  OrthancPluginContext* context,
7004  const void* dicom,
7005  uint32_t dicomSize,
7007  {
7008  char* target = NULL;
7009 
7010  _OrthancPluginEncodeDicomWeb params;
7011  params.target = &target;
7012  params.dicom = dicom;
7013  params.dicomSize = dicomSize;
7014  params.callback = callback;
7015 
7016  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
7017  {
7018  /* Error */
7019  return NULL;
7020  }
7021  else
7022  {
7023  return target;
7024  }
7025  }
7026 
7027 
7044  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
7045  OrthancPluginContext* context,
7046  const void* dicom,
7047  uint32_t dicomSize,
7049  {
7050  char* target = NULL;
7051 
7052  _OrthancPluginEncodeDicomWeb params;
7053  params.target = &target;
7054  params.dicom = dicom;
7055  params.dicomSize = dicomSize;
7056  params.callback = callback;
7057 
7058  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
7059  {
7060  /* Error */
7061  return NULL;
7062  }
7063  else
7064  {
7065  return target;
7066  }
7067  }
7068 
7069 
7070 
7071  typedef struct
7072  {
7073  char** target;
7074  const void* dicom;
7075  uint32_t dicomSize;
7077  void* payload;
7078  } _OrthancPluginEncodeDicomWeb2;
7079 
7096  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson2(
7097  OrthancPluginContext* context,
7098  const void* dicom,
7099  uint32_t dicomSize,
7101  void* payload)
7102  {
7103  char* target = NULL;
7104 
7105  _OrthancPluginEncodeDicomWeb2 params;
7106  params.target = &target;
7107  params.dicom = dicom;
7108  params.dicomSize = dicomSize;
7109  params.callback = callback;
7110  params.payload = payload;
7111 
7112  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson2, &params) != OrthancPluginErrorCode_Success)
7113  {
7114  /* Error */
7115  return NULL;
7116  }
7117  else
7118  {
7119  return target;
7120  }
7121  }
7122 
7123 
7140  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml2(
7141  OrthancPluginContext* context,
7142  const void* dicom,
7143  uint32_t dicomSize,
7145  void* payload)
7146  {
7147  char* target = NULL;
7148 
7149  _OrthancPluginEncodeDicomWeb2 params;
7150  params.target = &target;
7151  params.dicom = dicom;
7152  params.dicomSize = dicomSize;
7153  params.callback = callback;
7154  params.payload = payload;
7155 
7156  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml2, &params) != OrthancPluginErrorCode_Success)
7157  {
7158  /* Error */
7159  return NULL;
7160  }
7161  else
7162  {
7163  return target;
7164  }
7165  }
7166 
7167 
7168 
7185  void* answer,
7186  const char* key,
7187  const char* value);
7188 
7189 
7206  void* answer,
7207  const void* data,
7208  uint32_t size);
7209 
7210 
7225  typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
7226 
7227 
7243 
7244 
7258  typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
7259 
7260 
7274  typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
7275 
7276 
7277  typedef struct
7278  {
7279  void* answer;
7282  uint16_t* httpStatus;
7283  OrthancPluginHttpMethod method;
7284  const char* url;
7285  uint32_t headersCount;
7286  const char* const* headersKeys;
7287  const char* const* headersValues;
7288  void* request;
7293  const char* username;
7294  const char* password;
7295  uint32_t timeout;
7296  const char* certificateFile;
7297  const char* certificateKeyFile;
7298  const char* certificateKeyPassword;
7299  uint8_t pkcs11;
7300  } _OrthancPluginChunkedHttpClient;
7301 
7302 
7354  OrthancPluginContext* context,
7355  void* answer,
7358  uint16_t* httpStatus,
7359  OrthancPluginHttpMethod method,
7360  const char* url,
7361  uint32_t headersCount,
7362  const char* const* headersKeys,
7363  const char* const* headersValues,
7364  void* request,
7369  const char* username,
7370  const char* password,
7371  uint32_t timeout,
7372  const char* certificateFile,
7373  const char* certificateKeyFile,
7374  const char* certificateKeyPassword,
7375  uint8_t pkcs11)
7376  {
7377  _OrthancPluginChunkedHttpClient params;
7378  memset(&params, 0, sizeof(params));
7379 
7380  /* In common with OrthancPluginHttpClient() */
7381  params.httpStatus = httpStatus;
7382  params.method = method;
7383  params.url = url;
7384  params.headersCount = headersCount;
7385  params.headersKeys = headersKeys;
7386  params.headersValues = headersValues;
7387  params.username = username;
7388  params.password = password;
7389  params.timeout = timeout;
7390  params.certificateFile = certificateFile;
7391  params.certificateKeyFile = certificateKeyFile;
7392  params.certificateKeyPassword = certificateKeyPassword;
7393  params.pkcs11 = pkcs11;
7394 
7395  /* For chunked body/answer */
7396  params.answer = answer;
7397  params.answerAddChunk = answerAddChunk;
7398  params.answerAddHeader = answerAddHeader;
7399  params.request = request;
7400  params.requestIsDone = requestIsDone;
7401  params.requestChunkData = requestChunkData;
7402  params.requestChunkSize = requestChunkSize;
7403  params.requestNext = requestNext;
7404 
7405  return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7406  }
7407 
7408 
7409 
7414  typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7415 
7416 
7417 
7435  const char* url,
7436  const OrthancPluginHttpRequest* request);
7437 
7438 
7454  const void* data,
7455  uint32_t size);
7456 
7457 
7474  OrthancPluginRestOutput* output);
7475 
7476 
7492 
7493  typedef struct
7494  {
7495  const char* pathRegularExpression;
7496  OrthancPluginRestCallback getHandler;
7498  OrthancPluginRestCallback deleteHandler;
7503  } _OrthancPluginChunkedRestCallback;
7504 
7505 
7535  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterChunkedRestCallback(
7536  OrthancPluginContext* context,
7537  const char* pathRegularExpression,
7538  OrthancPluginRestCallback getHandler,
7540  OrthancPluginRestCallback deleteHandler,
7545  {
7546  _OrthancPluginChunkedRestCallback params;
7547  params.pathRegularExpression = pathRegularExpression;
7548  params.getHandler = getHandler;
7549  params.postHandler = postHandler;
7550  params.deleteHandler = deleteHandler;
7551  params.putHandler = putHandler;
7552  params.addChunk = addChunk;
7553  params.execute = execute;
7554  params.finalize = finalize;
7555 
7556  context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
7557  }
7558 
7559 
7560 
7561 
7562 
7563  typedef struct
7564  {
7565  char** result;
7566  uint16_t group;
7567  uint16_t element;
7568  const char* privateCreator;
7569  } _OrthancPluginGetTagName;
7570 
7586  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
7587  OrthancPluginContext* context,
7588  uint16_t group,
7589  uint16_t element,
7590  const char* privateCreator)
7591  {
7592  char* result;
7593 
7594  _OrthancPluginGetTagName params;
7595  params.result = &result;
7596  params.group = group;
7597  params.element = element;
7598  params.privateCreator = privateCreator;
7599 
7600  if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
7601  {
7602  /* Error */
7603  return NULL;
7604  }
7605  else
7606  {
7607  return result;
7608  }
7609  }
7610 
7611 
7612 
7642  void** handler /* out */,
7643  const char* jobId,
7644  const char* transactionUid,
7645  const char* const* sopClassUids,
7646  const char* const* sopInstanceUids,
7647  uint32_t countInstances,
7648  const char* remoteAet,
7649  const char* calledAet);
7650 
7651 
7663  typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
7664 
7665 
7686  void* handler,
7687  const char* sopClassUid,
7688  const char* sopInstanceUid);
7689 
7690 
7691  typedef struct
7692  {
7696  } _OrthancPluginRegisterStorageCommitmentScpCallback;
7697 
7712  OrthancPluginContext* context,
7716  {
7717  _OrthancPluginRegisterStorageCommitmentScpCallback params;
7718  params.factory = factory;
7719  params.destructor = destructor;
7720  params.lookup = lookup;
7721  return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
7722  }
7723 
7724 
7725 
7752  const OrthancPluginDicomInstance* instance);
7753 
7754 
7755  typedef struct
7756  {
7758  } _OrthancPluginIncomingDicomInstanceFilter;
7759 
7773  OrthancPluginContext* context,
7775  {
7776  _OrthancPluginIncomingDicomInstanceFilter params;
7777  params.callback = callback;
7778 
7779  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, &params);
7780  }
7781 
7782 
7814  uint16_t* dimseStatus /* out */,
7815  const OrthancPluginDicomInstance* instance);
7816 
7817 
7818  typedef struct
7819  {
7821  } _OrthancPluginIncomingCStoreInstanceFilter;
7822 
7836  OrthancPluginContext* context,
7838  {
7839  _OrthancPluginIncomingCStoreInstanceFilter params;
7840  params.callback = callback;
7841 
7842  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingCStoreInstanceFilter, &params);
7843  }
7844 
7881  OrthancPluginMemoryBuffer64* modifiedDicomBuffer,
7882  const void* receivedDicomBuffer,
7883  uint64_t receivedDicomBufferSize,
7885 
7886 
7887  typedef struct
7888  {
7890  } _OrthancPluginReceivedInstanceCallback;
7891 
7913  OrthancPluginContext* context,
7915  {
7916  _OrthancPluginReceivedInstanceCallback params;
7917  params.callback = callback;
7918 
7919  return context->InvokeService(context, _OrthancPluginService_RegisterReceivedInstanceCallback, &params);
7920  }
7921 
7935  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceTransferSyntaxUid(
7936  OrthancPluginContext* context,
7937  const OrthancPluginDicomInstance* instance)
7938  {
7939  char* result;
7940 
7941  _OrthancPluginAccessDicomInstance params;
7942  memset(&params, 0, sizeof(params));
7943  params.resultStringToFree = &result;
7944  params.instance = instance;
7945 
7946  if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, &params) != OrthancPluginErrorCode_Success)
7947  {
7948  /* Error */
7949  return NULL;
7950  }
7951  else
7952  {
7953  return result;
7954  }
7955  }
7956 
7957 
7970  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData(
7971  OrthancPluginContext* context,
7972  const OrthancPluginDicomInstance* instance)
7973  {
7974  int64_t hasPixelData;
7975 
7976  _OrthancPluginAccessDicomInstance params;
7977  memset(&params, 0, sizeof(params));
7978  params.resultInt64 = &hasPixelData;
7979  params.instance = instance;
7980 
7981  if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, &params) != OrthancPluginErrorCode_Success ||
7982  hasPixelData < 0 ||
7983  hasPixelData > 1)
7984  {
7985  /* Error */
7986  return -1;
7987  }
7988  else
7989  {
7990  return (hasPixelData != 0);
7991  }
7992  }
7993 
7994 
7995 
7996 
7997 
7998 
7999  typedef struct
8000  {
8001  OrthancPluginDicomInstance** target;
8002  const void* buffer;
8003  uint32_t size;
8004  const char* transferSyntax;
8005  } _OrthancPluginCreateDicomInstance;
8006 
8021  OrthancPluginContext* context,
8022  const void* buffer,
8023  uint32_t size)
8024  {
8025  OrthancPluginDicomInstance* target = NULL;
8026 
8027  _OrthancPluginCreateDicomInstance params;
8028  params.target = &target;
8029  params.buffer = buffer;
8030  params.size = size;
8031 
8032  if (context->InvokeService(context, _OrthancPluginService_CreateDicomInstance, &params) != OrthancPluginErrorCode_Success)
8033  {
8034  /* Error */
8035  return NULL;
8036  }
8037  else
8038  {
8039  return target;
8040  }
8041  }
8042 
8043  typedef struct
8044  {
8046  } _OrthancPluginFreeDicomInstance;
8047 
8058  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeDicomInstance(
8059  OrthancPluginContext* context,
8061  {
8062  _OrthancPluginFreeDicomInstance params;
8063  params.dicom = dicom;
8064 
8065  context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, &params);
8066  }
8067 
8068 
8069  typedef struct
8070  {
8071  uint32_t* targetUint32;
8072  OrthancPluginMemoryBuffer* targetBuffer;
8073  OrthancPluginImage** targetImage;
8074  char** targetStringToFree;
8075  const OrthancPluginDicomInstance* instance;
8076  uint32_t frameIndex;
8079  uint32_t maxStringLength;
8080  OrthancPluginDicomWebBinaryCallback2 dicomWebCallback;
8081  void* dicomWebPayload;
8082  } _OrthancPluginAccessDicomInstance2;
8083 
8095  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetInstanceFramesCount(
8096  OrthancPluginContext* context,
8097  const OrthancPluginDicomInstance* instance)
8098  {
8099  uint32_t count;
8100 
8101  _OrthancPluginAccessDicomInstance2 params;
8102  memset(&params, 0, sizeof(params));
8103  params.targetUint32 = &count;
8104  params.instance = instance;
8105 
8106  if (context->InvokeService(context, _OrthancPluginService_GetInstanceFramesCount, &params) != OrthancPluginErrorCode_Success)
8107  {
8108  /* Error */
8109  return 0;
8110  }
8111  else
8112  {
8113  return count;
8114  }
8115  }
8116 
8117 
8136  OrthancPluginContext* context,
8137  OrthancPluginMemoryBuffer* target,
8138  const OrthancPluginDicomInstance* instance,
8139  uint32_t frameIndex)
8140  {
8141  _OrthancPluginAccessDicomInstance2 params;
8142  memset(&params, 0, sizeof(params));
8143  params.targetBuffer = target;
8144  params.instance = instance;
8145  params.frameIndex = frameIndex;
8146 
8147  return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, &params);
8148  }
8149 
8150 
8164  OrthancPluginContext* context,
8165  const OrthancPluginDicomInstance* instance,
8166  uint32_t frameIndex)
8167  {
8168  OrthancPluginImage* target = NULL;
8169 
8170  _OrthancPluginAccessDicomInstance2 params;
8171  memset(&params, 0, sizeof(params));
8172  params.targetImage = &target;
8173  params.instance = instance;
8174  params.frameIndex = frameIndex;
8175 
8176  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDecodedFrame, &params) != OrthancPluginErrorCode_Success)
8177  {
8178  return NULL;
8179  }
8180  else
8181  {
8182  return target;
8183  }
8184  }
8185 
8186 
8203  OrthancPluginContext* context,
8204  const void* buffer,
8205  uint32_t size,
8206  const char* transferSyntax)
8207  {
8208  OrthancPluginDicomInstance* target = NULL;
8209 
8210  _OrthancPluginCreateDicomInstance params;
8211  params.target = &target;
8212  params.buffer = buffer;
8213  params.size = size;
8214  params.transferSyntax = transferSyntax;
8215 
8216  if (context->InvokeService(context, _OrthancPluginService_TranscodeDicomInstance, &params) != OrthancPluginErrorCode_Success)
8217  {
8218  /* Error */
8219  return NULL;
8220  }
8221  else
8222  {
8223  return target;
8224  }
8225  }
8226 
8241  OrthancPluginContext* context,
8242  OrthancPluginMemoryBuffer* target,
8243  const OrthancPluginDicomInstance* instance)
8244  {
8245  _OrthancPluginAccessDicomInstance2 params;
8246  memset(&params, 0, sizeof(params));
8247  params.targetBuffer = target;
8248  params.instance = instance;
8249 
8250  return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, &params);
8251  }
8252 
8253 
8272  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceAdvancedJson(
8273  OrthancPluginContext* context,
8274  const OrthancPluginDicomInstance* instance,
8277  uint32_t maxStringLength)
8278  {
8279  char* result = NULL;
8280 
8281  _OrthancPluginAccessDicomInstance2 params;
8282  memset(&params, 0, sizeof(params));
8283  params.targetStringToFree = &result;
8284  params.instance = instance;
8285  params.format = format;
8286  params.flags = flags;
8287  params.maxStringLength = maxStringLength;
8288 
8289  if (context->InvokeService(context, _OrthancPluginService_GetInstanceAdvancedJson, &params) != OrthancPluginErrorCode_Success)
8290  {
8291  /* Error */
8292  return NULL;
8293  }
8294  else
8295  {
8296  return result;
8297  }
8298  }
8299 
8300 
8315  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebJson(
8316  OrthancPluginContext* context,
8317  const OrthancPluginDicomInstance* instance,
8319  void* payload)
8320  {
8321  char* target = NULL;
8322 
8323  _OrthancPluginAccessDicomInstance2 params;
8324  params.targetStringToFree = &target;
8325  params.instance = instance;
8326  params.dicomWebCallback = callback;
8327  params.dicomWebPayload = payload;
8328 
8329  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebJson, &params) != OrthancPluginErrorCode_Success)
8330  {
8331  /* Error */
8332  return NULL;
8333  }
8334  else
8335  {
8336  return target;
8337  }
8338  }
8339 
8340 
8355  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebXml(
8356  OrthancPluginContext* context,
8357  const OrthancPluginDicomInstance* instance,
8359  void* payload)
8360  {
8361  char* target = NULL;
8362 
8363  _OrthancPluginAccessDicomInstance2 params;
8364  params.targetStringToFree = &target;
8365  params.instance = instance;
8366  params.dicomWebCallback = callback;
8367  params.dicomWebPayload = payload;
8368 
8369  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebXml, &params) != OrthancPluginErrorCode_Success)
8370  {
8371  /* Error */
8372  return NULL;
8373  }
8374  else
8375  {
8376  return target;
8377  }
8378  }
8379 
8380 
8381 
8401  OrthancPluginMemoryBuffer* transcoded /* out */,
8402  const void* buffer,
8403  uint64_t size,
8404  const char* const* allowedSyntaxes,
8405  uint32_t countSyntaxes,
8406  uint8_t allowNewSopInstanceUid);
8407 
8408 
8409  typedef struct
8410  {
8412  } _OrthancPluginTranscoderCallback;
8413 
8428  OrthancPluginContext* context,
8430  {
8431  _OrthancPluginTranscoderCallback params;
8432  params.callback = callback;
8433 
8434  return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, &params);
8435  }
8436 
8437 
8438 
8439  typedef struct
8440  {
8441  OrthancPluginMemoryBuffer* target;
8442  uint32_t size;
8443  } _OrthancPluginCreateMemoryBuffer;
8444 
8463  OrthancPluginContext* context,
8464  OrthancPluginMemoryBuffer* target,
8465  uint32_t size)
8466  {
8467  _OrthancPluginCreateMemoryBuffer params;
8468  params.target = target;
8469  params.size = size;
8470 
8471  return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, &params);
8472  }
8473 
8474 
8501  OrthancPluginContext* context)
8502  {
8503  char* result;
8504 
8505  _OrthancPluginRetrieveDynamicString params;
8506  params.result = &result;
8507  params.argument = NULL;
8508 
8509  if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
8510  &params) != OrthancPluginErrorCode_Success)
8511  {
8512  /* Error */
8513  return NULL;
8514  }
8515  else
8516  {
8517  return result;
8518  }
8519  }
8520 
8521 
8522 
8523  typedef struct
8524  {
8526  uint64_t size;
8527  } _OrthancPluginCreateMemoryBuffer64;
8528 
8547  OrthancPluginContext* context,
8549  uint64_t size)
8550  {
8551  _OrthancPluginCreateMemoryBuffer64 params;
8552  params.target = target;
8553  params.size = size;
8554 
8555  return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer64, &params);
8556  }
8557 
8558 
8559  typedef struct
8560  {
8565  } _OrthancPluginRegisterStorageArea2;
8566 
8583  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea2(
8584  OrthancPluginContext* context,
8589  {
8590  _OrthancPluginRegisterStorageArea2 params;
8591  params.create = create;
8592  params.readWhole = readWhole;
8593  params.readRange = readRange;
8594  params.remove = remove;
8595  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea2, &params);
8596  }
8597 
8598 
8599 
8600  typedef struct
8601  {
8602  _OrthancPluginCreateDicom createDicom;
8603  const char* privateCreator;
8604  } _OrthancPluginCreateDicom2;
8605 
8631  OrthancPluginContext* context,
8632  OrthancPluginMemoryBuffer* target,
8633  const char* json,
8634  const OrthancPluginImage* pixelData,
8636  const char* privateCreator)
8637  {
8638  _OrthancPluginCreateDicom2 params;
8639  params.createDicom.target = target;
8640  params.createDicom.json = json;
8641  params.createDicom.pixelData = pixelData;
8642  params.createDicom.flags = flags;
8643  params.privateCreator = privateCreator;
8644 
8645  return context->InvokeService(context, _OrthancPluginService_CreateDicom2, &params);
8646  }
8647 
8648 
8649 
8650 
8651 
8652 
8653  typedef struct
8654  {
8655  OrthancPluginMemoryBuffer* answerBody;
8656  OrthancPluginMemoryBuffer* answerHeaders;
8657  uint16_t* httpStatus;
8658  OrthancPluginHttpMethod method;
8659  const char* uri;
8660  uint32_t headersCount;
8661  const char* const* headersKeys;
8662  const char* const* headersValues;
8663  const void* body;
8664  uint32_t bodySize;
8665  uint8_t afterPlugins;
8666  } _OrthancPluginCallRestApi;
8667 
8699  OrthancPluginContext* context,
8700  OrthancPluginMemoryBuffer* answerBody,
8701  OrthancPluginMemoryBuffer* answerHeaders,
8702  uint16_t* httpStatus,
8703  OrthancPluginHttpMethod method,
8704  const char* uri,
8705  uint32_t headersCount,
8706  const char* const* headersKeys,
8707  const char* const* headersValues,
8708  const void* body,
8709  uint32_t bodySize,
8710  uint8_t afterPlugins)
8711  {
8712  _OrthancPluginCallRestApi params;
8713  memset(&params, 0, sizeof(params));
8714 
8715  params.answerBody = answerBody;
8716  params.answerHeaders = answerHeaders;
8717  params.httpStatus = httpStatus;
8718  params.method = method;
8719  params.uri = uri;
8720  params.headersCount = headersCount;
8721  params.headersKeys = headersKeys;
8722  params.headersValues = headersValues;
8723  params.body = body;
8724  params.bodySize = bodySize;
8725  params.afterPlugins = afterPlugins;
8726 
8727  return context->InvokeService(context, _OrthancPluginService_CallRestApi, &params);
8728  }
8729 
8730 
8731 #ifdef __cplusplus
8732 }
8733 #endif
8734 
8735 
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:1832
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:3170
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:2135
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:1220
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5396
OrthancPluginChangeType
Definition: OrthancCPlugin.h:726
OrthancPluginErrorCode(* OrthancPluginStorageReadWhole)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type)
Callback for reading a whole file from the storage area.
Definition: OrthancCPlugin.h:1286
OrthancPluginErrorCode OrthancPluginRegisterIncomingCStoreInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingCStoreInstanceFilter callback)
Register a callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition: OrthancCPlugin.h:7835
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1938
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:1198
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:6966
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:1713
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4754
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:8400
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6299
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1266
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:2057
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3558
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:7912
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3313
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:8583
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1166
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1685
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition: OrthancCPlugin.h:8427
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:1177
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4946
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1327
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1239
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:1751
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:1187
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1667
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6824
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1210
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:2097
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4715
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:1309
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:7535
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition: OrthancCPlugin.h:7772
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5732
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:4671
@ OrthancPluginChangeType_OrthancStopped
Definition: OrthancCPlugin.h:738
@ OrthancPluginChangeType_OrthancStarted
Definition: OrthancCPlugin.h:737
@ OrthancPluginChangeType_Deleted
Definition: OrthancCPlugin.h:728
@ OrthancPluginChangeType_JobFailure
Definition: OrthancCPlugin.h:745
@ OrthancPluginChangeType_NewInstance
Definition: OrthancCPlugin.h:730
@ OrthancPluginChangeType_NewPatient
Definition: OrthancCPlugin.h:731
@ OrthancPluginChangeType_JobSubmitted
Definition: OrthancCPlugin.h:743
@ OrthancPluginChangeType_NewSeries
Definition: OrthancCPlugin.h:732
@ OrthancPluginChangeType_StablePatient
Definition: OrthancCPlugin.h:734
@ OrthancPluginChangeType_UpdatedPeers
Definition: OrthancCPlugin.h:741
@ OrthancPluginChangeType_StableStudy
Definition: OrthancCPlugin.h:736
@ OrthancPluginChangeType_CompletedSeries
Definition: OrthancCPlugin.h:727
@ OrthancPluginChangeType_NewChildInstance
Definition: OrthancCPlugin.h:729
@ OrthancPluginChangeType_UpdatedAttachment
Definition: OrthancCPlugin.h:739
@ OrthancPluginChangeType_UpdatedMetadata
Definition: OrthancCPlugin.h:740
@ OrthancPluginChangeType_StableSeries
Definition: OrthancCPlugin.h:735
@ OrthancPluginChangeType_UpdatedModalities
Definition: OrthancCPlugin.h:742
@ OrthancPluginChangeType_JobSuccess
Definition: OrthancCPlugin.h:744
@ OrthancPluginChangeType_NewStudy
Definition: OrthancCPlugin.h:733
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5993
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1117
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1522
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:5969
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:6061
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7663
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:1346
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:6147
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:7641
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5901
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5278
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:7684
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:5239
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5940
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:1482
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:7711
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1125
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1109
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1439
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1507
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:5135
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5201
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:6099
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:6030
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1536
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1101
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:5171
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:7970
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:8355
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition: OrthancCPlugin.h:1077
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition: OrthancCPlugin.h:7935
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:8135
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:8272
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2967
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition: OrthancCPlugin.h:8020
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition: OrthancCPlugin.h:8095
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:8163
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5304
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2934
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:8315
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:3041
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:3003
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:3080
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:3121
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition: OrthancCPlugin.h:8058
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition: OrthancCPlugin.h:8240
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition: OrthancCPlugin.h:8202
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2901
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:602
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:4617
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:4201
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3992
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4457
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3891
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4492
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:3957
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:4111
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:4156
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5434
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:4069
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4532
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:4026
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:5477
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:771
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:1093
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:756
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3924
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:3703
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5523
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4564
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1085
@ OrthancPluginPixelFormat_RGBA32
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:641
@ OrthancPluginPixelFormat_RGB48
Color image in RGB48 format.
Definition: OrthancCPlugin.h:651
@ OrthancPluginPixelFormat_Grayscale8
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:609
@ OrthancPluginPixelFormat_SignedGrayscale16
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:625
@ OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:667
@ OrthancPluginPixelFormat_RGB24
Color image in RGB24 format.
Definition: OrthancCPlugin.h:633
@ OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:675
@ OrthancPluginPixelFormat_Unknown
Definition: OrthancCPlugin.h:643
@ OrthancPluginPixelFormat_Grayscale64
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:683
@ OrthancPluginPixelFormat_Grayscale32
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:659
@ OrthancPluginPixelFormat_Grayscale16
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:617
@ OrthancPluginImageFormat_Png
Definition: OrthancCPlugin.h:772
@ OrthancPluginImageFormat_Jpeg
Definition: OrthancCPlugin.h:773
@ OrthancPluginImageFormat_Dicom
Definition: OrthancCPlugin.h:774
@ OrthancPluginCompressionType_Gzip
Definition: OrthancCPlugin.h:759
@ OrthancPluginCompressionType_ZlibWithSize
Definition: OrthancCPlugin.h:758
@ OrthancPluginCompressionType_Zlib
Definition: OrthancCPlugin.h:757
@ OrthancPluginCompressionType_GzipWithSize
Definition: OrthancCPlugin.h:760
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:2365
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:2400
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:2513
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2614
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3461
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3422
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:2477
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2684
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2649
char * OrthancPluginGenerateRestApiAuthorizationToken(OrthancPluginContext *context)
Generate a token to grant full access to the REST API of Orthanc.
Definition: OrthancCPlugin.h:8500
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2298
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2719
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:2328
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2579
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2429
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2452
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:8698
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:5097
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2265
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:2224
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2787
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:6860
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2810
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:2167
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2764
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2865
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2840
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2547
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:4248
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:3661
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:5694
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3632
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:3855
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1634
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderExecute)(OrthancPluginServerChunkedRequestReader *reader, OrthancPluginRestOutput *output)
Callback invoked whenever the request body is entirely received.
Definition: OrthancCPlugin.h:7472
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:5807
struct _OrthancPluginJob_t OrthancPluginJob
Opaque structure to a job to be executed by Orthanc.
Definition: OrthancCPlugin.h:1149
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:8630
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:7880
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:2021
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderFactory)(OrthancPluginServerChunkedRequestReader **reader, const char *url, const OrthancPluginHttpRequest *request)
Callback to create a reader to handle incoming chunked HTTP transfers.
Definition: OrthancCPlugin.h:7433
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:6224
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6361
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int priority)
Submit a new job to the jobs engine of Orthanc.
Definition: OrthancCPlugin.h:6779
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:4902
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:875
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:4849
OrthancPluginResourceType
Definition: OrthancCPlugin.h:709
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3771
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3492
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:200
struct _OrthancPluginPeers_t OrthancPluginPeers
Opaque structure to the set of remote Orthanc Peers that are known to the local Orthanc server.
Definition: OrthancCPlugin.h:1141
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:4339
uint32_t(* OrthancPluginChunkedClientRequestGetChunkSize)(void *request)
Callback to read the size of the current request chunk during a chunked transfer.
Definition: OrthancCPlugin.h:7274
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4793
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, uint32_t size)
Create a 32-bit memory buffer.
Definition: OrthancCPlugin.h:8462
OrthancPluginDicomWebBinaryMode
Definition: OrthancCPlugin.h:964
char * OrthancPluginEncodeDicomWebJson2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7096
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition: OrthancCPlugin.h:7751
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1595
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:5039
OrthancPluginErrorCode(* OrthancPluginChunkedClientRequestNext)(void *request)
Callback to advance in the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7242
struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode
Opaque structure that represents a node in a JSON or XML document used in DICOMweb.
Definition: OrthancCPlugin.h:1158
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1562
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:839
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:921
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:860
void(* OrthancPluginServerChunkedRequestReaderFinalize)(OrthancPluginServerChunkedRequestReader *reader)
Callback invoked to release the resources associated with an incoming HTTP chunked transfer.
Definition: OrthancCPlugin.h:7490
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:6257
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:3388
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:2005
OrthancPluginConstraintType
Definition: OrthancCPlugin.h:890
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3740
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1610
void OrthancPluginSetMetricsValue(OrthancPluginContext *context, const char *name, float value, OrthancPluginMetricsType type)
Set the value of a metrics.
Definition: OrthancCPlugin.h:6936
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:7452
OrthancPluginReceivedInstanceAction
Definition: OrthancCPlugin.h:1011
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:7353
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:1069
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:6892
void OrthancPluginFreeMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1973
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:4381
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6439
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3526
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3802
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:5360
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:1412
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5862
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6747
OrthancPluginStorageCommitmentFailureReason
Definition: OrthancCPlugin.h:977
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:7205
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6480
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6327
OrthancPluginMetricsType
Definition: OrthancCPlugin.h:947
char * OrthancPluginEncodeDicomWebXml2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7140
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7044
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4419
uint8_t(* OrthancPluginChunkedClientRequestIsDone)(void *request)
Callback to know whether the request body is entirely read during a chunked transfer.
Definition: OrthancCPlugin.h:7225
char * OrthancPluginGetTagName(OrthancPluginContext *context, uint16_t group, uint16_t element, const char *privateCreator)
Returns the symbolic name of a DICOM tag.
Definition: OrthancCPlugin.h:7586
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5569
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:4990
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1957
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *target, uint64_t size)
Create a 64-bit memory buffer.
Definition: OrthancCPlugin.h:8546
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:7184
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6391
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition: OrthancCPlugin.h:7414
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:785
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:3267
const void *(* OrthancPluginChunkedClientRequestGetChunkData)(void *request)
Callback to read the current chunk of the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7258
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:4301
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:935
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:3232
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:6186
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:824
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:1989
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:324
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3591
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:1377
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:3344
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:6692
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:6607
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:1133
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:6526
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5651
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5605
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:905
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1549
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1802
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1577
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7002
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:3202
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1651
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginContentType
Definition: OrthancCPlugin.h:694
int32_t(* OrthancPluginIncomingCStoreInstanceFilter)(uint16_t *dimseStatus, const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition: OrthancCPlugin.h:7813
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:3366
@ OrthancPluginIdentifierConstraint_Wildcard
Definition: OrthancCPlugin.h:879
@ OrthancPluginIdentifierConstraint_Equal
Definition: OrthancCPlugin.h:876
@ OrthancPluginIdentifierConstraint_SmallerOrEqual
Definition: OrthancCPlugin.h:877
@ OrthancPluginIdentifierConstraint_GreaterOrEqual
Definition: OrthancCPlugin.h:878
@ OrthancPluginResourceType_Instance
Definition: OrthancCPlugin.h:713
@ OrthancPluginResourceType_None
Definition: OrthancCPlugin.h:714
@ OrthancPluginResourceType_Series
Definition: OrthancCPlugin.h:712
@ OrthancPluginResourceType_Study
Definition: OrthancCPlugin.h:711
@ OrthancPluginResourceType_Patient
Definition: OrthancCPlugin.h:710
@ OrthancPluginErrorCode_CreateDicomBadParent
Definition: OrthancCPlugin.h:286
@ OrthancPluginErrorCode_SQLiteFlush
Definition: OrthancCPlugin.h:254
@ OrthancPluginErrorCode_IncompatibleDatabaseVersion
Definition: OrthancCPlugin.h:220
@ OrthancPluginErrorCode_BadSequenceOfCalls
Definition: OrthancCPlugin.h:208
@ OrthancPluginErrorCode_SharedLibrary
Definition: OrthancCPlugin.h:227
@ OrthancPluginErrorCode_NullPointer
Definition: OrthancCPlugin.h:237
@ OrthancPluginErrorCode_NotLuaPredicate
Definition: OrthancCPlugin.h:296
@ OrthancPluginErrorCode_LuaAlreadyExecuted
Definition: OrthancCPlugin.h:294
@ OrthancPluginErrorCode_NotAcceptable
Definition: OrthancCPlugin.h:236
@ OrthancPluginErrorCode_FullStorage
Definition: OrthancCPlugin.h:221
@ OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered
Definition: OrthancCPlugin.h:299
@ OrthancPluginErrorCode_InexistentFile
Definition: OrthancCPlugin.h:215
@ OrthancPluginErrorCode_CreateDicomParentEncoding
Definition: OrthancCPlugin.h:288
@ OrthancPluginErrorCode_CannotOrderSlices
Definition: OrthancCPlugin.h:302
@ OrthancPluginErrorCode_InternalError
Definition: OrthancCPlugin.h:201
@ OrthancPluginErrorCode_DiscontinuedAbi
Definition: OrthancCPlugin.h:242
@ OrthancPluginErrorCode_NoCFindHandler
Definition: OrthancCPlugin.h:272
@ OrthancPluginErrorCode_SQLiteCommitWithoutTransaction
Definition: OrthancCPlugin.h:252
@ OrthancPluginErrorCode_DatabasePlugin
Definition: OrthancCPlugin.h:233
@ OrthancPluginErrorCode_SQLiteStatementAlreadyUsed
Definition: OrthancCPlugin.h:249
@ OrthancPluginErrorCode_SQLiteCannotRun
Definition: OrthancCPlugin.h:255
@ OrthancPluginErrorCode_UnknownPluginService
Definition: OrthancCPlugin.h:228
@ OrthancPluginErrorCode_JsonToLuaTable
Definition: OrthancCPlugin.h:291
@ OrthancPluginErrorCode_CreateDicomOverrideTag
Definition: OrthancCPlugin.h:282
@ OrthancPluginErrorCode_SQLiteBindOutOfRange
Definition: OrthancCPlugin.h:257
@ OrthancPluginErrorCode_ParameterOutOfRange
Definition: OrthancCPlugin.h:205
@ OrthancPluginErrorCode_SQLiteRegisterFunction
Definition: OrthancCPlugin.h:253
@ OrthancPluginErrorCode_SQLiteTransactionBegin
Definition: OrthancCPlugin.h:261
@ OrthancPluginErrorCode_CreateDicomNoPayload
Definition: OrthancCPlugin.h:284
@ OrthancPluginErrorCode_Unauthorized
Definition: OrthancCPlugin.h:231
@ OrthancPluginErrorCode_RegularFileExpected
Definition: OrthancCPlugin.h:268
@ OrthancPluginErrorCode_DicomPortInUse
Definition: OrthancCPlugin.h:266
@ OrthancPluginErrorCode_BadApplicationEntityTitle
Definition: OrthancCPlugin.h:271
@ OrthancPluginErrorCode_NoCStoreHandler
Definition: OrthancCPlugin.h:274
@ OrthancPluginErrorCode_PathToExecutable
Definition: OrthancCPlugin.h:269
@ OrthancPluginErrorCode_NoSopClassOrInstance
Definition: OrthancCPlugin.h:276
@ OrthancPluginErrorCode_BadFont
Definition: OrthancCPlugin.h:232
@ OrthancPluginErrorCode_DatabaseUnavailable
Definition: OrthancCPlugin.h:238
@ OrthancPluginErrorCode_CannotCreateLua
Definition: OrthancCPlugin.h:292
@ OrthancPluginErrorCode_SQLiteExecute
Definition: OrthancCPlugin.h:250
@ OrthancPluginErrorCode_UriSyntax
Definition: OrthancCPlugin.h:214
@ OrthancPluginErrorCode_DirectoryOverFile
Definition: OrthancCPlugin.h:262
@ OrthancPluginErrorCode_Revision
Definition: OrthancCPlugin.h:245
@ OrthancPluginErrorCode_InexistentTag
Definition: OrthancCPlugin.h:223
@ OrthancPluginErrorCode_IncompatibleImageFormat
Definition: OrthancCPlugin.h:225
@ OrthancPluginErrorCode_UnsupportedMediaType
Definition: OrthancCPlugin.h:307
@ OrthancPluginErrorCode_DicomFindUnavailable
Definition: OrthancCPlugin.h:278
@ OrthancPluginErrorCode_SQLiteCannotStep
Definition: OrthancCPlugin.h:256
@ OrthancPluginErrorCode_CreateDicomParentIsInstance
Definition: OrthancCPlugin.h:287
@ OrthancPluginErrorCode_StorageAreaAlreadyRegistered
Definition: OrthancCPlugin.h:298
@ OrthancPluginErrorCode_LuaReturnsNoString
Definition: OrthancCPlugin.h:297
@ OrthancPluginErrorCode_UnknownResource
Definition: OrthancCPlugin.h:219
@ OrthancPluginErrorCode_CreateDicomNotString
Definition: OrthancCPlugin.h:281
@ OrthancPluginErrorCode_HttpPortInUse
Definition: OrthancCPlugin.h:265
@ OrthancPluginErrorCode_SslDisabled
Definition: OrthancCPlugin.h:301
@ OrthancPluginErrorCode_UnknownModality
Definition: OrthancCPlugin.h:289
@ OrthancPluginErrorCode_BadHttpStatusInRest
Definition: OrthancCPlugin.h:267
@ OrthancPluginErrorCode_BadGeometry
Definition: OrthancCPlugin.h:240
@ OrthancPluginErrorCode_AlreadyExistingTag
Definition: OrthancCPlugin.h:304
@ OrthancPluginErrorCode_FileStorageCannotWrite
Definition: OrthancCPlugin.h:263
@ OrthancPluginErrorCode_CreateDicomUseDataUriScheme
Definition: OrthancCPlugin.h:285
@ OrthancPluginErrorCode_DirectoryExpected
Definition: OrthancCPlugin.h:264
@ OrthancPluginErrorCode_NoCMoveHandler
Definition: OrthancCPlugin.h:273
@ OrthancPluginErrorCode_SQLitePrepareStatement
Definition: OrthancCPlugin.h:258
@ OrthancPluginErrorCode_CorruptedFile
Definition: OrthancCPlugin.h:222
@ OrthancPluginErrorCode_StorageAreaPlugin
Definition: OrthancCPlugin.h:234
@ OrthancPluginErrorCode_BadJobOrdering
Definition: OrthancCPlugin.h:290
@ OrthancPluginErrorCode_DatabaseCannotSerialize
Definition: OrthancCPlugin.h:244
@ OrthancPluginErrorCode_CanceledJob
Definition: OrthancCPlugin.h:239
@ OrthancPluginErrorCode_BadRange
Definition: OrthancCPlugin.h:243
@ OrthancPluginErrorCode_NotImplemented
Definition: OrthancCPlugin.h:204
@ OrthancPluginErrorCode_SslInitialization
Definition: OrthancCPlugin.h:241
@ OrthancPluginErrorCode_IncompatibleImageSize
Definition: OrthancCPlugin.h:226
@ OrthancPluginErrorCode_BadFileFormat
Definition: OrthancCPlugin.h:217
@ OrthancPluginErrorCode_BadRequest
Definition: OrthancCPlugin.h:210
@ OrthancPluginErrorCode_SystemCommand
Definition: OrthancCPlugin.h:212
@ OrthancPluginErrorCode_NoStorageCommitmentHandler
Definition: OrthancCPlugin.h:305
@ OrthancPluginErrorCode_SQLiteAlreadyOpened
Definition: OrthancCPlugin.h:247
@ OrthancPluginErrorCode_Plugin
Definition: OrthancCPlugin.h:203
@ OrthancPluginErrorCode_CannotExecuteLua
Definition: OrthancCPlugin.h:293
@ OrthancPluginErrorCode_SQLiteRollbackWithoutTransaction
Definition: OrthancCPlugin.h:251
@ OrthancPluginErrorCode_UnknownDicomTag
Definition: OrthancCPlugin.h:229
@ OrthancPluginErrorCode_NoPresentationContext
Definition: OrthancCPlugin.h:277
@ OrthancPluginErrorCode_EmptyRequest
Definition: OrthancCPlugin.h:235
@ OrthancPluginErrorCode_DatabaseNotInitialized
Definition: OrthancCPlugin.h:300
@ OrthancPluginErrorCode_DicomMoveUnavailable
Definition: OrthancCPlugin.h:279
@ OrthancPluginErrorCode_SQLiteTransactionCommit
Definition: OrthancCPlugin.h:260
@ OrthancPluginErrorCode_BadJson
Definition: OrthancCPlugin.h:230
@ OrthancPluginErrorCode_Success
Definition: OrthancCPlugin.h:202
@ OrthancPluginErrorCode_NetworkProtocol
Definition: OrthancCPlugin.h:211
@ OrthancPluginErrorCode_NoApplicationEntityFilter
Definition: OrthancCPlugin.h:275
@ OrthancPluginErrorCode_InexistentItem
Definition: OrthancCPlugin.h:209
@ OrthancPluginErrorCode_Timeout
Definition: OrthancCPlugin.h:218
@ OrthancPluginErrorCode_LuaBadOutput
Definition: OrthancCPlugin.h:295
@ OrthancPluginErrorCode_SQLiteTransactionAlreadyStarted
Definition: OrthancCPlugin.h:259
@ OrthancPluginErrorCode_NoCGetHandler
Definition: OrthancCPlugin.h:306
@ OrthancPluginErrorCode_SQLiteNotOpened
Definition: OrthancCPlugin.h:246
@ OrthancPluginErrorCode_ReadOnly
Definition: OrthancCPlugin.h:224
@ OrthancPluginErrorCode_CannotStoreInstance
Definition: OrthancCPlugin.h:280
@ OrthancPluginErrorCode_CannotWriteFile
Definition: OrthancCPlugin.h:216
@ OrthancPluginErrorCode_BadParameterType
Definition: OrthancCPlugin.h:207
@ OrthancPluginErrorCode_NotEnoughMemory
Definition: OrthancCPlugin.h:206
@ OrthancPluginErrorCode_CreateDicomUseContent
Definition: OrthancCPlugin.h:283
@ OrthancPluginErrorCode_Database
Definition: OrthancCPlugin.h:213
@ OrthancPluginErrorCode_SQLiteCannotOpen
Definition: OrthancCPlugin.h:248
@ OrthancPluginErrorCode_MakeDirectory
Definition: OrthancCPlugin.h:270
@ OrthancPluginErrorCode_NoWorklistHandler
Definition: OrthancCPlugin.h:303
@ OrthancPluginDicomWebBinaryMode_InlineBinary
Definition: OrthancCPlugin.h:966
@ OrthancPluginDicomWebBinaryMode_BulkDataUri
Definition: OrthancCPlugin.h:967
@ OrthancPluginDicomWebBinaryMode_Ignore
Definition: OrthancCPlugin.h:965
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii
Definition: OrthancCPlugin.h:845
@ OrthancPluginDicomToJsonFlags_IncludeBinary
Definition: OrthancCPlugin.h:841
@ OrthancPluginDicomToJsonFlags_IncludePixelData
Definition: OrthancCPlugin.h:844
@ OrthancPluginDicomToJsonFlags_IncludeUnknownTags
Definition: OrthancCPlugin.h:843
@ OrthancPluginDicomToJsonFlags_SkipGroupLengths
Definition: OrthancCPlugin.h:848
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
Definition: OrthancCPlugin.h:846
@ OrthancPluginDicomToJsonFlags_StopAfterPixelData
Definition: OrthancCPlugin.h:847
@ OrthancPluginDicomToJsonFlags_IncludePrivateTags
Definition: OrthancCPlugin.h:842
@ OrthancPluginJobStepStatus_Continue
Definition: OrthancCPlugin.h:924
@ OrthancPluginJobStepStatus_Success
Definition: OrthancCPlugin.h:922
@ OrthancPluginJobStepStatus_Failure
Definition: OrthancCPlugin.h:923
@ OrthancPluginCreateDicomFlags_DecodeDataUriScheme
Definition: OrthancCPlugin.h:862
@ OrthancPluginCreateDicomFlags_GenerateIdentifiers
Definition: OrthancCPlugin.h:863
@ OrthancPluginConstraintType_SmallerOrEqual
Definition: OrthancCPlugin.h:892
@ OrthancPluginConstraintType_List
Definition: OrthancCPlugin.h:895
@ OrthancPluginConstraintType_GreaterOrEqual
Definition: OrthancCPlugin.h:893
@ OrthancPluginConstraintType_Equal
Definition: OrthancCPlugin.h:891
@ OrthancPluginConstraintType_Wildcard
Definition: OrthancCPlugin.h:894
@ OrthancPluginReceivedInstanceAction_KeepAsIs
Definition: OrthancCPlugin.h:1012
@ OrthancPluginReceivedInstanceAction_Discard
Definition: OrthancCPlugin.h:1014
@ OrthancPluginReceivedInstanceAction_Modify
Definition: OrthancCPlugin.h:1013
@ OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
Definition: OrthancCPlugin.h:992
@ OrthancPluginStorageCommitmentFailureReason_Success
Definition: OrthancCPlugin.h:978
@ OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
Definition: OrthancCPlugin.h:1001
@ OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
Definition: OrthancCPlugin.h:996
@ OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
Definition: OrthancCPlugin.h:988
@ OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
Definition: OrthancCPlugin.h:984
@ OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
Definition: OrthancCPlugin.h:981
@ OrthancPluginMetricsType_Default
Definition: OrthancCPlugin.h:948
@ OrthancPluginMetricsType_Timer
Definition: OrthancCPlugin.h:955
@ OrthancPluginValueRepresentation_PN
Definition: OrthancCPlugin.h:801
@ OrthancPluginValueRepresentation_UL
Definition: OrthancCPlugin.h:809
@ OrthancPluginValueRepresentation_UN
Definition: OrthancCPlugin.h:810
@ OrthancPluginValueRepresentation_DA
Definition: OrthancCPlugin.h:790
@ OrthancPluginValueRepresentation_OF
Definition: OrthancCPlugin.h:799
@ OrthancPluginValueRepresentation_OW
Definition: OrthancCPlugin.h:800
@ OrthancPluginValueRepresentation_CS
Definition: OrthancCPlugin.h:789
@ OrthancPluginValueRepresentation_US
Definition: OrthancCPlugin.h:811
@ OrthancPluginValueRepresentation_SH
Definition: OrthancCPlugin.h:802
@ OrthancPluginValueRepresentation_FL
Definition: OrthancCPlugin.h:794
@ OrthancPluginValueRepresentation_DT
Definition: OrthancCPlugin.h:792
@ OrthancPluginValueRepresentation_TM
Definition: OrthancCPlugin.h:807
@ OrthancPluginValueRepresentation_SQ
Definition: OrthancCPlugin.h:804
@ OrthancPluginValueRepresentation_DS
Definition: OrthancCPlugin.h:791
@ OrthancPluginValueRepresentation_OB
Definition: OrthancCPlugin.h:798
@ OrthancPluginValueRepresentation_SL
Definition: OrthancCPlugin.h:803
@ OrthancPluginValueRepresentation_ST
Definition: OrthancCPlugin.h:806
@ OrthancPluginValueRepresentation_IS
Definition: OrthancCPlugin.h:795
@ OrthancPluginValueRepresentation_LT
Definition: OrthancCPlugin.h:797
@ OrthancPluginValueRepresentation_SS
Definition: OrthancCPlugin.h:805
@ OrthancPluginValueRepresentation_UT
Definition: OrthancCPlugin.h:812
@ OrthancPluginValueRepresentation_LO
Definition: OrthancCPlugin.h:796
@ OrthancPluginValueRepresentation_AE
Definition: OrthancCPlugin.h:786
@ OrthancPluginValueRepresentation_FD
Definition: OrthancCPlugin.h:793
@ OrthancPluginValueRepresentation_UI
Definition: OrthancCPlugin.h:808
@ OrthancPluginValueRepresentation_AS
Definition: OrthancCPlugin.h:787
@ OrthancPluginValueRepresentation_AT
Definition: OrthancCPlugin.h:788
@ OrthancPluginJobStopReason_Failure
Definition: OrthancCPlugin.h:938
@ OrthancPluginJobStopReason_Success
Definition: OrthancCPlugin.h:936
@ OrthancPluginJobStopReason_Canceled
Definition: OrthancCPlugin.h:939
@ OrthancPluginJobStopReason_Paused
Definition: OrthancCPlugin.h:937
@ OrthancPluginDicomToJsonFormat_Full
Definition: OrthancCPlugin.h:825
@ OrthancPluginDicomToJsonFormat_Human
Definition: OrthancCPlugin.h:827
@ OrthancPluginDicomToJsonFormat_Short
Definition: OrthancCPlugin.h:826
@ OrthancPluginHttpMethod_Delete
Definition: OrthancCPlugin.h:328
@ OrthancPluginHttpMethod_Post
Definition: OrthancCPlugin.h:326
@ OrthancPluginHttpMethod_Put
Definition: OrthancCPlugin.h:327
@ OrthancPluginHttpMethod_Get
Definition: OrthancCPlugin.h:325
@ OrthancPluginInstanceOrigin_Unknown
Definition: OrthancCPlugin.h:906
@ OrthancPluginInstanceOrigin_RestApi
Definition: OrthancCPlugin.h:908
@ OrthancPluginInstanceOrigin_Lua
Definition: OrthancCPlugin.h:910
@ OrthancPluginInstanceOrigin_WebDav
Definition: OrthancCPlugin.h:911
@ OrthancPluginInstanceOrigin_DicomProtocol
Definition: OrthancCPlugin.h:907
@ OrthancPluginInstanceOrigin_Plugin
Definition: OrthancCPlugin.h:909
@ OrthancPluginContentType_Dicom
Definition: OrthancCPlugin.h:696
@ OrthancPluginContentType_DicomAsJson
Definition: OrthancCPlugin.h:697
@ OrthancPluginContentType_Unknown
Definition: OrthancCPlugin.h:695
@ OrthancPluginContentType_DicomUntilPixelData
Definition: OrthancCPlugin.h:698
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1784
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1788
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1789
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1787
uint16_t element
Definition: OrthancCPlugin.h:1786
uint16_t group
Definition: OrthancCPlugin.h:1785
The parameters of a REST request.
Definition: OrthancCPlugin.h:339
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:368
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:353
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:378
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:348
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:393
const void * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:373
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:363
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:388
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:343
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:358
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:398
A 64-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1050
uint64_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1059
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1054
A 32-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1028
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1037
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1032