Orthanc Plugin SDK  1.5.4
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1 
109 #pragma once
110 
111 
112 #include <stdio.h>
113 #include <string.h>
114 
115 #ifdef WIN32
116 #define ORTHANC_PLUGINS_API __declspec(dllexport)
117 #else
118 #define ORTHANC_PLUGINS_API
119 #endif
120 
121 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
122 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 5
123 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 4
124 
125 
126 #if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
127 #define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
128  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
129  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
130  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
131  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
132  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
133 #endif
134 
135 
136 
137 /********************************************************************
138  ** Check that function inlining is properly supported. The use of
139  ** inlining is required, to avoid the duplication of object code
140  ** between two compilation modules that would use the Orthanc Plugin
141  ** API.
142  ********************************************************************/
143 
144 /* If the auto-detection of the "inline" keyword below does not work
145  automatically and that your compiler is known to properly support
146  inlining, uncomment the following #define and adapt the definition
147  of "static inline". */
148 
149 /* #define ORTHANC_PLUGIN_INLINE static inline */
150 
151 #ifndef ORTHANC_PLUGIN_INLINE
152 # if __STDC_VERSION__ >= 199901L
153 /* This is C99 or above: http://predef.sourceforge.net/prestd.html */
154 # define ORTHANC_PLUGIN_INLINE static inline
155 # elif defined(__cplusplus)
156 /* This is C++ */
157 # define ORTHANC_PLUGIN_INLINE static inline
158 # elif defined(__GNUC__)
159 /* This is GCC running in C89 mode */
160 # define ORTHANC_PLUGIN_INLINE static __inline
161 # elif defined(_MSC_VER)
162 /* This is Visual Studio running in C89 mode */
163 # define ORTHANC_PLUGIN_INLINE static __inline
164 # else
165 # error Your compiler is not known to support the "inline" keyword
166 # endif
167 #endif
168 
169 
170 
171 /********************************************************************
172  ** Inclusion of standard libraries.
173  ********************************************************************/
174 
180 #include <stdint.h>
181 
182 #include <stdlib.h>
183 
184 
185 
186 /********************************************************************
187  ** Definition of the Orthanc Plugin API.
188  ********************************************************************/
189 
192 #ifdef __cplusplus
193 extern "C"
194 {
195 #endif
196 
200  typedef enum
201  {
300 
301  _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
303 
304 
309  ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
310 
311 
315  typedef enum
316  {
322  _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
324 
325 
330  typedef struct
331  {
336 
340  uint32_t groupsCount;
341 
345  const char* const* groups;
346 
350  uint32_t getCount;
351 
355  const char* const* getKeys;
356 
360  const char* const* getValues;
361 
365  const char* body;
366 
370  uint32_t bodySize;
371 
372 
373  /* --------------------------------------------------
374  New in version 0.8.1
375  -------------------------------------------------- */
376 
380  uint32_t headersCount;
381 
385  const char* const* headersKeys;
386 
390  const char* const* headersValues;
391 
393 
394 
395  typedef enum
396  {
397  /* Generic services */
398  _OrthancPluginService_LogInfo = 1,
399  _OrthancPluginService_LogWarning = 2,
400  _OrthancPluginService_LogError = 3,
401  _OrthancPluginService_GetOrthancPath = 4,
402  _OrthancPluginService_GetOrthancDirectory = 5,
403  _OrthancPluginService_GetConfigurationPath = 6,
404  _OrthancPluginService_SetPluginProperty = 7,
405  _OrthancPluginService_GetGlobalProperty = 8,
406  _OrthancPluginService_SetGlobalProperty = 9,
407  _OrthancPluginService_GetCommandLineArgumentsCount = 10,
408  _OrthancPluginService_GetCommandLineArgument = 11,
409  _OrthancPluginService_GetExpectedDatabaseVersion = 12,
410  _OrthancPluginService_GetConfiguration = 13,
411  _OrthancPluginService_BufferCompression = 14,
412  _OrthancPluginService_ReadFile = 15,
413  _OrthancPluginService_WriteFile = 16,
414  _OrthancPluginService_GetErrorDescription = 17,
415  _OrthancPluginService_CallHttpClient = 18,
416  _OrthancPluginService_RegisterErrorCode = 19,
417  _OrthancPluginService_RegisterDictionaryTag = 20,
418  _OrthancPluginService_DicomBufferToJson = 21,
419  _OrthancPluginService_DicomInstanceToJson = 22,
420  _OrthancPluginService_CreateDicom = 23,
421  _OrthancPluginService_ComputeMd5 = 24,
422  _OrthancPluginService_ComputeSha1 = 25,
423  _OrthancPluginService_LookupDictionary = 26,
424  _OrthancPluginService_CallHttpClient2 = 27,
425  _OrthancPluginService_GenerateUuid = 28,
426  _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
427  _OrthancPluginService_AutodetectMimeType = 30,
428  _OrthancPluginService_SetMetricsValue = 31,
429  _OrthancPluginService_EncodeDicomWebJson = 32,
430  _OrthancPluginService_EncodeDicomWebXml = 33,
431 
432  /* Registration of callbacks */
433  _OrthancPluginService_RegisterRestCallback = 1000,
434  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
435  _OrthancPluginService_RegisterStorageArea = 1002,
436  _OrthancPluginService_RegisterOnChangeCallback = 1003,
437  _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
438  _OrthancPluginService_RegisterWorklistCallback = 1005,
439  _OrthancPluginService_RegisterDecodeImageCallback = 1006,
440  _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
441  _OrthancPluginService_RegisterFindCallback = 1008,
442  _OrthancPluginService_RegisterMoveCallback = 1009,
443  _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
444  _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
445 
446  /* Sending answers to REST calls */
447  _OrthancPluginService_AnswerBuffer = 2000,
448  _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
449  _OrthancPluginService_Redirect = 2002,
450  _OrthancPluginService_SendHttpStatusCode = 2003,
451  _OrthancPluginService_SendUnauthorized = 2004,
452  _OrthancPluginService_SendMethodNotAllowed = 2005,
453  _OrthancPluginService_SetCookie = 2006,
454  _OrthancPluginService_SetHttpHeader = 2007,
455  _OrthancPluginService_StartMultipartAnswer = 2008,
456  _OrthancPluginService_SendMultipartItem = 2009,
457  _OrthancPluginService_SendHttpStatus = 2010,
458  _OrthancPluginService_CompressAndAnswerImage = 2011,
459  _OrthancPluginService_SendMultipartItem2 = 2012,
460  _OrthancPluginService_SetHttpErrorDetails = 2013,
461 
462  /* Access to the Orthanc database and API */
463  _OrthancPluginService_GetDicomForInstance = 3000,
464  _OrthancPluginService_RestApiGet = 3001,
465  _OrthancPluginService_RestApiPost = 3002,
466  _OrthancPluginService_RestApiDelete = 3003,
467  _OrthancPluginService_RestApiPut = 3004,
468  _OrthancPluginService_LookupPatient = 3005,
469  _OrthancPluginService_LookupStudy = 3006,
470  _OrthancPluginService_LookupSeries = 3007,
471  _OrthancPluginService_LookupInstance = 3008,
472  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
473  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
474  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
475  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
476  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
477  _OrthancPluginService_ReconstructMainDicomTags = 3014,
478  _OrthancPluginService_RestApiGet2 = 3015,
479 
480  /* Access to DICOM instances */
481  _OrthancPluginService_GetInstanceRemoteAet = 4000,
482  _OrthancPluginService_GetInstanceSize = 4001,
483  _OrthancPluginService_GetInstanceData = 4002,
484  _OrthancPluginService_GetInstanceJson = 4003,
485  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
486  _OrthancPluginService_HasInstanceMetadata = 4005,
487  _OrthancPluginService_GetInstanceMetadata = 4006,
488  _OrthancPluginService_GetInstanceOrigin = 4007,
489 
490  /* Services for plugins implementing a database back-end */
491  _OrthancPluginService_RegisterDatabaseBackend = 5000,
492  _OrthancPluginService_DatabaseAnswer = 5001,
493  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
494  _OrthancPluginService_StorageAreaCreate = 5003,
495  _OrthancPluginService_StorageAreaRead = 5004,
496  _OrthancPluginService_StorageAreaRemove = 5005,
497 
498  /* Primitives for handling images */
499  _OrthancPluginService_GetImagePixelFormat = 6000,
500  _OrthancPluginService_GetImageWidth = 6001,
501  _OrthancPluginService_GetImageHeight = 6002,
502  _OrthancPluginService_GetImagePitch = 6003,
503  _OrthancPluginService_GetImageBuffer = 6004,
504  _OrthancPluginService_UncompressImage = 6005,
505  _OrthancPluginService_FreeImage = 6006,
506  _OrthancPluginService_CompressImage = 6007,
507  _OrthancPluginService_ConvertPixelFormat = 6008,
508  _OrthancPluginService_GetFontsCount = 6009,
509  _OrthancPluginService_GetFontInfo = 6010,
510  _OrthancPluginService_DrawText = 6011,
511  _OrthancPluginService_CreateImage = 6012,
512  _OrthancPluginService_CreateImageAccessor = 6013,
513  _OrthancPluginService_DecodeDicomImage = 6014,
514 
515  /* Primitives for handling C-Find, C-Move and worklists */
516  _OrthancPluginService_WorklistAddAnswer = 7000,
517  _OrthancPluginService_WorklistMarkIncomplete = 7001,
518  _OrthancPluginService_WorklistIsMatch = 7002,
519  _OrthancPluginService_WorklistGetDicomQuery = 7003,
520  _OrthancPluginService_FindAddAnswer = 7004,
521  _OrthancPluginService_FindMarkIncomplete = 7005,
522  _OrthancPluginService_GetFindQuerySize = 7006,
523  _OrthancPluginService_GetFindQueryTag = 7007,
524  _OrthancPluginService_GetFindQueryTagName = 7008,
525  _OrthancPluginService_GetFindQueryValue = 7009,
526  _OrthancPluginService_CreateFindMatcher = 7010,
527  _OrthancPluginService_FreeFindMatcher = 7011,
528  _OrthancPluginService_FindMatcherIsMatch = 7012,
529 
530  /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
531  _OrthancPluginService_GetPeers = 8000,
532  _OrthancPluginService_FreePeers = 8001,
533  _OrthancPluginService_GetPeersCount = 8003,
534  _OrthancPluginService_GetPeerName = 8004,
535  _OrthancPluginService_GetPeerUrl = 8005,
536  _OrthancPluginService_CallPeerApi = 8006,
537  _OrthancPluginService_GetPeerUserProperty = 8007,
538 
539  /* Primitives for handling jobs (new in 1.4.2) */
540  _OrthancPluginService_CreateJob = 9000,
541  _OrthancPluginService_FreeJob = 9001,
542  _OrthancPluginService_SubmitJob = 9002,
543  _OrthancPluginService_RegisterJobsUnserializer = 9003,
544 
545  _OrthancPluginService_INTERNAL = 0x7fffffff
546  } _OrthancPluginService;
547 
548 
549  typedef enum
550  {
551  _OrthancPluginProperty_Description = 1,
552  _OrthancPluginProperty_RootUri = 2,
553  _OrthancPluginProperty_OrthancExplorer = 3,
554 
555  _OrthancPluginProperty_INTERNAL = 0x7fffffff
556  } _OrthancPluginProperty;
557 
558 
559 
564  typedef enum
565  {
573 
581 
589 
597 
605 
615 
623 
631 
639 
647 
648  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
650 
651 
652 
656  typedef enum
657  {
662  _OrthancPluginContentType_INTERNAL = 0x7fffffff
664 
665 
666 
670  typedef enum
671  {
678  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
680 
681 
682 
687  typedef enum
688  {
706  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
708 
709 
714  typedef enum
715  {
721  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
723 
724 
729  typedef enum
730  {
735  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
737 
738 
743  typedef enum
744  {
773  _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
775 
776 
782  typedef enum
783  {
788  _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
790 
791 
797  typedef enum
798  {
799  OrthancPluginDicomToJsonFlags_None = 0,
807  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
809 
810 
816  typedef enum
817  {
818  OrthancPluginCreateDicomFlags_None = 0,
822  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
824 
825 
831  typedef enum
832  {
838  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
840 
841 
846  typedef enum
847  {
854  _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
856 
857 
861  typedef enum
862  {
869  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
871 
872 
876  typedef enum
877  {
882 
883 
890  typedef enum
891  {
897 
898 
902  typedef enum
903  {
913 
914 
919  typedef enum
920  {
925 
926 
927 
935  typedef struct
936  {
940  void* data;
941 
945  uint32_t size;
947 
948 
949 
950 
955  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
956 
957 
958 
962  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
963 
964 
965 
970  typedef struct _OrthancPluginImage_t OrthancPluginImage;
971 
972 
973 
978  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
979 
980 
981 
986  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
987 
988 
989 
994  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
995 
996 
997 
1002  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1003 
1004 
1005 
1010  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1011 
1012 
1013 
1018  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindMatcher;
1019 
1020 
1021 
1026  typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1027 
1028 
1029 
1034  typedef struct _OrthancPluginJob_t OrthancPluginJob;
1035 
1036 
1037 
1043  typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1044 
1045 
1046 
1052  OrthancPluginRestOutput* output,
1053  const char* url,
1054  const OrthancPluginHttpRequest* request);
1055 
1056 
1057 
1063  OrthancPluginDicomInstance* instance,
1064  const char* instanceId);
1065 
1066 
1067 
1073  OrthancPluginChangeType changeType,
1074  OrthancPluginResourceType resourceType,
1075  const char* resourceId);
1076 
1077 
1078 
1084  OrthancPluginImage** target,
1085  const void* dicom,
1086  const uint32_t size,
1087  uint32_t frameIndex);
1088 
1089 
1090 
1095  typedef void (*OrthancPluginFree) (void* buffer);
1096 
1097 
1098 
1108  const char* bulkDataUri);
1109 
1110 
1111 
1125  const char* uuid,
1126  const void* content,
1127  int64_t size,
1129 
1130 
1131 
1145  void** content,
1146  int64_t* size,
1147  const char* uuid,
1149 
1150 
1151 
1163  const char* uuid,
1165 
1166 
1167 
1183  const OrthancPluginWorklistQuery* query,
1184  const char* issuerAet,
1185  const char* calledAet);
1186 
1187 
1188 
1209  OrthancPluginHttpMethod method,
1210  const char* uri,
1211  const char* ip,
1212  uint32_t headersCount,
1213  const char* const* headersKeys,
1214  const char* const* headersValues);
1215 
1216 
1217 
1240  OrthancPluginHttpMethod method,
1241  const char* uri,
1242  const char* ip,
1243  uint32_t headersCount,
1244  const char* const* headersKeys,
1245  const char* const* headersValues,
1246  uint32_t getArgumentsCount,
1247  const char* const* getArgumentsKeys,
1248  const char* const* getArgumentsValues);
1249 
1250 
1251 
1267  OrthancPluginFindAnswers* answers,
1268  const OrthancPluginFindQuery* query,
1269  const char* issuerAet,
1270  const char* calledAet);
1271 
1272 
1273 
1309  typedef void* (*OrthancPluginMoveCallback) (
1310  OrthancPluginResourceType resourceType,
1311  const char* patientId,
1312  const char* accessionNumber,
1313  const char* studyInstanceUid,
1314  const char* seriesInstanceUid,
1315  const char* sopInstanceUid,
1316  const char* originatorAet,
1317  const char* sourceAet,
1318  const char* targetAet,
1319  uint16_t originatorId);
1320 
1321 
1334  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1335 
1336 
1349  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1350 
1351 
1363  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1364 
1365 
1376  typedef void (*OrthancPluginJobFinalize) (void* job);
1377 
1378 
1389  typedef float (*OrthancPluginJobGetProgress) (void* job);
1390 
1391 
1404  typedef const char* (*OrthancPluginJobGetContent) (void* job);
1405 
1406 
1422  typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1423 
1424 
1438 
1439 
1463 
1464 
1479 
1480 
1494  typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1495  const char* serialized);
1496 
1497 
1498 
1513 
1514 
1515 
1543  uint32_t levelDepth,
1544  const uint16_t* levelTagGroup,
1545  const uint16_t* levelTagElement,
1546  const uint32_t* levelIndex,
1547  uint16_t tagGroup,
1548  uint16_t tagElement,
1550 
1551 
1552 
1556  typedef struct _OrthancPluginContext_t
1557  {
1558  void* pluginsManager;
1559  const char* orthancVersion;
1560  OrthancPluginFree Free;
1561  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1562  _OrthancPluginService service,
1563  const void* params);
1565 
1566 
1567 
1571  typedef struct
1572  {
1573  uint16_t group;
1574  uint16_t element;
1576  uint32_t minMultiplicity;
1577  uint32_t maxMultiplicity;
1579 
1580 
1581 
1590  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1591  OrthancPluginContext* context,
1592  char* str)
1593  {
1594  if (str != NULL)
1595  {
1596  context->Free(str);
1597  }
1598  }
1599 
1600 
1620  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1621  OrthancPluginContext* context,
1622  int expectedMajor,
1623  int expectedMinor,
1624  int expectedRevision)
1625  {
1626  int major, minor, revision;
1627 
1628  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1629  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1630  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1631  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1632  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1633  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1634  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1635  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1636  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1637  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1638  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1639  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1640  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1641  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1642  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1643  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1644  sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1645  sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
1646  sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
1647  sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode))
1648  {
1649  /* Mismatch in the size of the enumerations */
1650  return 0;
1651  }
1652 
1653  /* Assume compatibility with the mainline */
1654  if (!strcmp(context->orthancVersion, "mainline"))
1655  {
1656  return 1;
1657  }
1658 
1659  /* Parse the version of the Orthanc core */
1660  if (
1661 #ifdef _MSC_VER
1662  sscanf_s
1663 #else
1664  sscanf
1665 #endif
1666  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1667  {
1668  return 0;
1669  }
1670 
1671  /* Check the major number of the version */
1672 
1673  if (major > expectedMajor)
1674  {
1675  return 1;
1676  }
1677 
1678  if (major < expectedMajor)
1679  {
1680  return 0;
1681  }
1682 
1683  /* Check the minor number of the version */
1684 
1685  if (minor > expectedMinor)
1686  {
1687  return 1;
1688  }
1689 
1690  if (minor < expectedMinor)
1691  {
1692  return 0;
1693  }
1694 
1695  /* Check the revision number of the version */
1696 
1697  if (revision >= expectedRevision)
1698  {
1699  return 1;
1700  }
1701  else
1702  {
1703  return 0;
1704  }
1705  }
1706 
1707 
1724  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1725  OrthancPluginContext* context)
1726  {
1728  context,
1729  ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1730  ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1731  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1732  }
1733 
1734 
1743  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1744  OrthancPluginContext* context,
1745  OrthancPluginMemoryBuffer* buffer)
1746  {
1747  context->Free(buffer->data);
1748  }
1749 
1750 
1759  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1760  OrthancPluginContext* context,
1761  const char* message)
1762  {
1763  context->InvokeService(context, _OrthancPluginService_LogError, message);
1764  }
1765 
1766 
1775  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
1776  OrthancPluginContext* context,
1777  const char* message)
1778  {
1779  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1780  }
1781 
1782 
1791  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
1792  OrthancPluginContext* context,
1793  const char* message)
1794  {
1795  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
1796  }
1797 
1798 
1799 
1800  typedef struct
1801  {
1802  const char* pathRegularExpression;
1803  OrthancPluginRestCallback callback;
1804  } _OrthancPluginRestCallback;
1805 
1827  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
1828  OrthancPluginContext* context,
1829  const char* pathRegularExpression,
1830  OrthancPluginRestCallback callback)
1831  {
1832  _OrthancPluginRestCallback params;
1833  params.pathRegularExpression = pathRegularExpression;
1834  params.callback = callback;
1835  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
1836  }
1837 
1838 
1839 
1867  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
1868  OrthancPluginContext* context,
1869  const char* pathRegularExpression,
1870  OrthancPluginRestCallback callback)
1871  {
1872  _OrthancPluginRestCallback params;
1873  params.pathRegularExpression = pathRegularExpression;
1874  params.callback = callback;
1875  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
1876  }
1877 
1878 
1879 
1880  typedef struct
1881  {
1883  } _OrthancPluginOnStoredInstanceCallback;
1884 
1896  OrthancPluginContext* context,
1898  {
1899  _OrthancPluginOnStoredInstanceCallback params;
1900  params.callback = callback;
1901 
1902  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
1903  }
1904 
1905 
1906 
1907  typedef struct
1908  {
1909  OrthancPluginRestOutput* output;
1910  const char* answer;
1911  uint32_t answerSize;
1912  const char* mimeType;
1913  } _OrthancPluginAnswerBuffer;
1914 
1927  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
1928  OrthancPluginContext* context,
1929  OrthancPluginRestOutput* output,
1930  const char* answer,
1931  uint32_t answerSize,
1932  const char* mimeType)
1933  {
1934  _OrthancPluginAnswerBuffer params;
1935  params.output = output;
1936  params.answer = answer;
1937  params.answerSize = answerSize;
1938  params.mimeType = mimeType;
1939  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
1940  }
1941 
1942 
1943  typedef struct
1944  {
1945  OrthancPluginRestOutput* output;
1946  OrthancPluginPixelFormat format;
1947  uint32_t width;
1948  uint32_t height;
1949  uint32_t pitch;
1950  const void* buffer;
1951  } _OrthancPluginCompressAndAnswerPngImage;
1952 
1953  typedef struct
1954  {
1955  OrthancPluginRestOutput* output;
1956  OrthancPluginImageFormat imageFormat;
1957  OrthancPluginPixelFormat pixelFormat;
1958  uint32_t width;
1959  uint32_t height;
1960  uint32_t pitch;
1961  const void* buffer;
1962  uint8_t quality;
1963  } _OrthancPluginCompressAndAnswerImage;
1964 
1965 
1984  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
1985  OrthancPluginContext* context,
1986  OrthancPluginRestOutput* output,
1987  OrthancPluginPixelFormat format,
1988  uint32_t width,
1989  uint32_t height,
1990  uint32_t pitch,
1991  const void* buffer)
1992  {
1993  _OrthancPluginCompressAndAnswerImage params;
1994  params.output = output;
1995  params.imageFormat = OrthancPluginImageFormat_Png;
1996  params.pixelFormat = format;
1997  params.width = width;
1998  params.height = height;
1999  params.pitch = pitch;
2000  params.buffer = buffer;
2001  params.quality = 0; /* No quality for PNG */
2002  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2003  }
2004 
2005 
2006 
2007  typedef struct
2008  {
2009  OrthancPluginMemoryBuffer* target;
2010  const char* instanceId;
2011  } _OrthancPluginGetDicomForInstance;
2012 
2026  OrthancPluginContext* context,
2027  OrthancPluginMemoryBuffer* target,
2028  const char* instanceId)
2029  {
2030  _OrthancPluginGetDicomForInstance params;
2031  params.target = target;
2032  params.instanceId = instanceId;
2033  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2034  }
2035 
2036 
2037 
2038  typedef struct
2039  {
2040  OrthancPluginMemoryBuffer* target;
2041  const char* uri;
2042  } _OrthancPluginRestApiGet;
2043 
2059  OrthancPluginContext* context,
2060  OrthancPluginMemoryBuffer* target,
2061  const char* uri)
2062  {
2063  _OrthancPluginRestApiGet params;
2064  params.target = target;
2065  params.uri = uri;
2066  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2067  }
2068 
2069 
2070 
2089  OrthancPluginContext* context,
2090  OrthancPluginMemoryBuffer* target,
2091  const char* uri)
2092  {
2093  _OrthancPluginRestApiGet params;
2094  params.target = target;
2095  params.uri = uri;
2096  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2097  }
2098 
2099 
2100 
2101  typedef struct
2102  {
2103  OrthancPluginMemoryBuffer* target;
2104  const char* uri;
2105  const char* body;
2106  uint32_t bodySize;
2107  } _OrthancPluginRestApiPostPut;
2108 
2126  OrthancPluginContext* context,
2127  OrthancPluginMemoryBuffer* target,
2128  const char* uri,
2129  const char* body,
2130  uint32_t bodySize)
2131  {
2132  _OrthancPluginRestApiPostPut params;
2133  params.target = target;
2134  params.uri = uri;
2135  params.body = body;
2136  params.bodySize = bodySize;
2137  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2138  }
2139 
2140 
2161  OrthancPluginContext* context,
2162  OrthancPluginMemoryBuffer* target,
2163  const char* uri,
2164  const char* body,
2165  uint32_t bodySize)
2166  {
2167  _OrthancPluginRestApiPostPut params;
2168  params.target = target;
2169  params.uri = uri;
2170  params.body = body;
2171  params.bodySize = bodySize;
2172  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2173  }
2174 
2175 
2176 
2190  OrthancPluginContext* context,
2191  const char* uri)
2192  {
2193  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2194  }
2195 
2196 
2213  OrthancPluginContext* context,
2214  const char* uri)
2215  {
2216  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2217  }
2218 
2219 
2220 
2238  OrthancPluginContext* context,
2239  OrthancPluginMemoryBuffer* target,
2240  const char* uri,
2241  const char* body,
2242  uint32_t bodySize)
2243  {
2244  _OrthancPluginRestApiPostPut params;
2245  params.target = target;
2246  params.uri = uri;
2247  params.body = body;
2248  params.bodySize = bodySize;
2249  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2250  }
2251 
2252 
2253 
2274  OrthancPluginContext* context,
2275  OrthancPluginMemoryBuffer* target,
2276  const char* uri,
2277  const char* body,
2278  uint32_t bodySize)
2279  {
2280  _OrthancPluginRestApiPostPut params;
2281  params.target = target;
2282  params.uri = uri;
2283  params.body = body;
2284  params.bodySize = bodySize;
2285  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2286  }
2287 
2288 
2289 
2290  typedef struct
2291  {
2292  OrthancPluginRestOutput* output;
2293  const char* argument;
2294  } _OrthancPluginOutputPlusArgument;
2295 
2307  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2308  OrthancPluginContext* context,
2309  OrthancPluginRestOutput* output,
2310  const char* redirection)
2311  {
2312  _OrthancPluginOutputPlusArgument params;
2313  params.output = output;
2314  params.argument = redirection;
2315  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2316  }
2317 
2318 
2319 
2320  typedef struct
2321  {
2322  char** result;
2323  const char* argument;
2324  } _OrthancPluginRetrieveDynamicString;
2325 
2339  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2340  OrthancPluginContext* context,
2341  const char* patientID)
2342  {
2343  char* result;
2344 
2345  _OrthancPluginRetrieveDynamicString params;
2346  params.result = &result;
2347  params.argument = patientID;
2348 
2349  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2350  {
2351  /* Error */
2352  return NULL;
2353  }
2354  else
2355  {
2356  return result;
2357  }
2358  }
2359 
2360 
2374  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2375  OrthancPluginContext* context,
2376  const char* studyUID)
2377  {
2378  char* result;
2379 
2380  _OrthancPluginRetrieveDynamicString params;
2381  params.result = &result;
2382  params.argument = studyUID;
2383 
2384  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2385  {
2386  /* Error */
2387  return NULL;
2388  }
2389  else
2390  {
2391  return result;
2392  }
2393  }
2394 
2395 
2409  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
2410  OrthancPluginContext* context,
2411  const char* accessionNumber)
2412  {
2413  char* result;
2414 
2415  _OrthancPluginRetrieveDynamicString params;
2416  params.result = &result;
2417  params.argument = accessionNumber;
2418 
2419  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2420  {
2421  /* Error */
2422  return NULL;
2423  }
2424  else
2425  {
2426  return result;
2427  }
2428  }
2429 
2430 
2444  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2445  OrthancPluginContext* context,
2446  const char* seriesUID)
2447  {
2448  char* result;
2449 
2450  _OrthancPluginRetrieveDynamicString params;
2451  params.result = &result;
2452  params.argument = seriesUID;
2453 
2454  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2455  {
2456  /* Error */
2457  return NULL;
2458  }
2459  else
2460  {
2461  return result;
2462  }
2463  }
2464 
2465 
2479  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2480  OrthancPluginContext* context,
2481  const char* sopInstanceUID)
2482  {
2483  char* result;
2484 
2485  _OrthancPluginRetrieveDynamicString params;
2486  params.result = &result;
2487  params.argument = sopInstanceUID;
2488 
2489  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2490  {
2491  /* Error */
2492  return NULL;
2493  }
2494  else
2495  {
2496  return result;
2497  }
2498  }
2499 
2500 
2501 
2502  typedef struct
2503  {
2504  OrthancPluginRestOutput* output;
2505  uint16_t status;
2506  } _OrthancPluginSendHttpStatusCode;
2507 
2524  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2525  OrthancPluginContext* context,
2526  OrthancPluginRestOutput* output,
2527  uint16_t status)
2528  {
2529  _OrthancPluginSendHttpStatusCode params;
2530  params.output = output;
2531  params.status = status;
2532  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2533  }
2534 
2535 
2547  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2548  OrthancPluginContext* context,
2549  OrthancPluginRestOutput* output,
2550  const char* realm)
2551  {
2552  _OrthancPluginOutputPlusArgument params;
2553  params.output = output;
2554  params.argument = realm;
2555  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2556  }
2557 
2558 
2570  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2571  OrthancPluginContext* context,
2572  OrthancPluginRestOutput* output,
2573  const char* allowedMethods)
2574  {
2575  _OrthancPluginOutputPlusArgument params;
2576  params.output = output;
2577  params.argument = allowedMethods;
2578  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2579  }
2580 
2581 
2582  typedef struct
2583  {
2584  OrthancPluginRestOutput* output;
2585  const char* key;
2586  const char* value;
2587  } _OrthancPluginSetHttpHeader;
2588 
2600  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2601  OrthancPluginContext* context,
2602  OrthancPluginRestOutput* output,
2603  const char* cookie,
2604  const char* value)
2605  {
2606  _OrthancPluginSetHttpHeader params;
2607  params.output = output;
2608  params.key = cookie;
2609  params.value = value;
2610  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2611  }
2612 
2613 
2625  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2626  OrthancPluginContext* context,
2627  OrthancPluginRestOutput* output,
2628  const char* key,
2629  const char* value)
2630  {
2631  _OrthancPluginSetHttpHeader params;
2632  params.output = output;
2633  params.key = key;
2634  params.value = value;
2635  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2636  }
2637 
2638 
2639  typedef struct
2640  {
2641  char** resultStringToFree;
2642  const char** resultString;
2643  int64_t* resultInt64;
2644  const char* key;
2645  OrthancPluginDicomInstance* instance;
2646  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2647  } _OrthancPluginAccessDicomInstance;
2648 
2649 
2661  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2662  OrthancPluginContext* context,
2663  OrthancPluginDicomInstance* instance)
2664  {
2665  const char* result;
2666 
2667  _OrthancPluginAccessDicomInstance params;
2668  memset(&params, 0, sizeof(params));
2669  params.resultString = &result;
2670  params.instance = instance;
2671 
2672  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2673  {
2674  /* Error */
2675  return NULL;
2676  }
2677  else
2678  {
2679  return result;
2680  }
2681  }
2682 
2683 
2694  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2695  OrthancPluginContext* context,
2696  OrthancPluginDicomInstance* instance)
2697  {
2698  int64_t size;
2699 
2700  _OrthancPluginAccessDicomInstance params;
2701  memset(&params, 0, sizeof(params));
2702  params.resultInt64 = &size;
2703  params.instance = instance;
2704 
2705  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2706  {
2707  /* Error */
2708  return -1;
2709  }
2710  else
2711  {
2712  return size;
2713  }
2714  }
2715 
2716 
2727  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceData(
2728  OrthancPluginContext* context,
2729  OrthancPluginDicomInstance* instance)
2730  {
2731  const char* result;
2732 
2733  _OrthancPluginAccessDicomInstance params;
2734  memset(&params, 0, sizeof(params));
2735  params.resultString = &result;
2736  params.instance = instance;
2737 
2738  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2739  {
2740  /* Error */
2741  return NULL;
2742  }
2743  else
2744  {
2745  return result;
2746  }
2747  }
2748 
2749 
2763  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
2764  OrthancPluginContext* context,
2765  OrthancPluginDicomInstance* instance)
2766  {
2767  char* result;
2768 
2769  _OrthancPluginAccessDicomInstance params;
2770  memset(&params, 0, sizeof(params));
2771  params.resultStringToFree = &result;
2772  params.instance = instance;
2773 
2774  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
2775  {
2776  /* Error */
2777  return NULL;
2778  }
2779  else
2780  {
2781  return result;
2782  }
2783  }
2784 
2785 
2801  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
2802  OrthancPluginContext* context,
2803  OrthancPluginDicomInstance* instance)
2804  {
2805  char* result;
2806 
2807  _OrthancPluginAccessDicomInstance params;
2808  memset(&params, 0, sizeof(params));
2809  params.resultStringToFree = &result;
2810  params.instance = instance;
2811 
2812  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
2813  {
2814  /* Error */
2815  return NULL;
2816  }
2817  else
2818  {
2819  return result;
2820  }
2821  }
2822 
2823 
2840  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
2841  OrthancPluginContext* context,
2842  OrthancPluginDicomInstance* instance,
2843  const char* metadata)
2844  {
2845  int64_t result;
2846 
2847  _OrthancPluginAccessDicomInstance params;
2848  memset(&params, 0, sizeof(params));
2849  params.resultInt64 = &result;
2850  params.instance = instance;
2851  params.key = metadata;
2852 
2853  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2854  {
2855  /* Error */
2856  return -1;
2857  }
2858  else
2859  {
2860  return (result != 0);
2861  }
2862  }
2863 
2864 
2878  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
2879  OrthancPluginContext* context,
2880  OrthancPluginDicomInstance* instance,
2881  const char* metadata)
2882  {
2883  const char* result;
2884 
2885  _OrthancPluginAccessDicomInstance params;
2886  memset(&params, 0, sizeof(params));
2887  params.resultString = &result;
2888  params.instance = instance;
2889  params.key = metadata;
2890 
2891  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2892  {
2893  /* Error */
2894  return NULL;
2895  }
2896  else
2897  {
2898  return result;
2899  }
2900  }
2901 
2902 
2903 
2904  typedef struct
2905  {
2909  OrthancPluginFree free;
2910  } _OrthancPluginRegisterStorageArea;
2911 
2926  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
2927  OrthancPluginContext* context,
2931  {
2932  _OrthancPluginRegisterStorageArea params;
2933  params.create = create;
2934  params.read = read;
2935  params.remove = remove;
2936 
2937 #ifdef __cplusplus
2938  params.free = ::free;
2939 #else
2940  params.free = free;
2941 #endif
2942 
2943  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
2944  }
2945 
2946 
2947 
2958  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
2959  {
2960  char* result;
2961 
2962  _OrthancPluginRetrieveDynamicString params;
2963  params.result = &result;
2964  params.argument = NULL;
2965 
2966  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
2967  {
2968  /* Error */
2969  return NULL;
2970  }
2971  else
2972  {
2973  return result;
2974  }
2975  }
2976 
2977 
2988  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
2989  {
2990  char* result;
2991 
2992  _OrthancPluginRetrieveDynamicString params;
2993  params.result = &result;
2994  params.argument = NULL;
2995 
2996  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
2997  {
2998  /* Error */
2999  return NULL;
3000  }
3001  else
3002  {
3003  return result;
3004  }
3005  }
3006 
3007 
3023  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3024  {
3025  char* result;
3026 
3027  _OrthancPluginRetrieveDynamicString params;
3028  params.result = &result;
3029  params.argument = NULL;
3030 
3031  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3032  {
3033  /* Error */
3034  return NULL;
3035  }
3036  else
3037  {
3038  return result;
3039  }
3040  }
3041 
3042 
3043 
3044  typedef struct
3045  {
3047  } _OrthancPluginOnChangeCallback;
3048 
3065  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3066  OrthancPluginContext* context,
3068  {
3069  _OrthancPluginOnChangeCallback params;
3070  params.callback = callback;
3071 
3072  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3073  }
3074 
3075 
3076 
3077  typedef struct
3078  {
3079  const char* plugin;
3080  _OrthancPluginProperty property;
3081  const char* value;
3082  } _OrthancPluginSetPluginProperty;
3083 
3084 
3096  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3097  OrthancPluginContext* context,
3098  const char* uri)
3099  {
3100  _OrthancPluginSetPluginProperty params;
3101  params.plugin = OrthancPluginGetName();
3102  params.property = _OrthancPluginProperty_RootUri;
3103  params.value = uri;
3104 
3105  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3106  }
3107 
3108 
3118  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3119  OrthancPluginContext* context,
3120  const char* description)
3121  {
3122  _OrthancPluginSetPluginProperty params;
3123  params.plugin = OrthancPluginGetName();
3124  params.property = _OrthancPluginProperty_Description;
3125  params.value = description;
3126 
3127  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3128  }
3129 
3130 
3140  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3141  OrthancPluginContext* context,
3142  const char* javascript)
3143  {
3144  _OrthancPluginSetPluginProperty params;
3145  params.plugin = OrthancPluginGetName();
3146  params.property = _OrthancPluginProperty_OrthancExplorer;
3147  params.value = javascript;
3148 
3149  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3150  }
3151 
3152 
3153  typedef struct
3154  {
3155  char** result;
3156  int32_t property;
3157  const char* value;
3158  } _OrthancPluginGlobalProperty;
3159 
3160 
3174  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3175  OrthancPluginContext* context,
3176  int32_t property,
3177  const char* defaultValue)
3178  {
3179  char* result;
3180 
3181  _OrthancPluginGlobalProperty params;
3182  params.result = &result;
3183  params.property = property;
3184  params.value = defaultValue;
3185 
3186  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3187  {
3188  /* Error */
3189  return NULL;
3190  }
3191  else
3192  {
3193  return result;
3194  }
3195  }
3196 
3197 
3214  OrthancPluginContext* context,
3215  int32_t property,
3216  const char* value)
3217  {
3218  _OrthancPluginGlobalProperty params;
3219  params.result = NULL;
3220  params.property = property;
3221  params.value = value;
3222 
3223  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3224  }
3225 
3226 
3227 
3228  typedef struct
3229  {
3230  int32_t *resultInt32;
3231  uint32_t *resultUint32;
3232  int64_t *resultInt64;
3233  uint64_t *resultUint64;
3234  } _OrthancPluginReturnSingleValue;
3235 
3244  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3245  OrthancPluginContext* context)
3246  {
3247  uint32_t count = 0;
3248 
3249  _OrthancPluginReturnSingleValue params;
3250  memset(&params, 0, sizeof(params));
3251  params.resultUint32 = &count;
3252 
3253  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3254  {
3255  /* Error */
3256  return 0;
3257  }
3258  else
3259  {
3260  return count;
3261  }
3262  }
3263 
3264 
3265 
3278  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3279  OrthancPluginContext* context,
3280  uint32_t argument)
3281  {
3282  char* result;
3283 
3284  _OrthancPluginGlobalProperty params;
3285  params.result = &result;
3286  params.property = (int32_t) argument;
3287  params.value = NULL;
3288 
3289  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3290  {
3291  /* Error */
3292  return NULL;
3293  }
3294  else
3295  {
3296  return result;
3297  }
3298  }
3299 
3300 
3310  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3311  OrthancPluginContext* context)
3312  {
3313  uint32_t count = 0;
3314 
3315  _OrthancPluginReturnSingleValue params;
3316  memset(&params, 0, sizeof(params));
3317  params.resultUint32 = &count;
3318 
3319  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3320  {
3321  /* Error */
3322  return 0;
3323  }
3324  else
3325  {
3326  return count;
3327  }
3328  }
3329 
3330 
3331 
3343  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3344  {
3345  char* result;
3346 
3347  _OrthancPluginRetrieveDynamicString params;
3348  params.result = &result;
3349  params.argument = NULL;
3350 
3351  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3352  {
3353  /* Error */
3354  return NULL;
3355  }
3356  else
3357  {
3358  return result;
3359  }
3360  }
3361 
3362 
3363 
3364  typedef struct
3365  {
3366  OrthancPluginRestOutput* output;
3367  const char* subType;
3368  const char* contentType;
3369  } _OrthancPluginStartMultipartAnswer;
3370 
3385  OrthancPluginContext* context,
3386  OrthancPluginRestOutput* output,
3387  const char* subType,
3388  const char* contentType)
3389  {
3390  _OrthancPluginStartMultipartAnswer params;
3391  params.output = output;
3392  params.subType = subType;
3393  params.contentType = contentType;
3394  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3395  }
3396 
3397 
3414  OrthancPluginContext* context,
3415  OrthancPluginRestOutput* output,
3416  const char* answer,
3417  uint32_t answerSize)
3418  {
3419  _OrthancPluginAnswerBuffer params;
3420  params.output = output;
3421  params.answer = answer;
3422  params.answerSize = answerSize;
3423  params.mimeType = NULL;
3424  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3425  }
3426 
3427 
3428 
3429  typedef struct
3430  {
3431  OrthancPluginMemoryBuffer* target;
3432  const void* source;
3433  uint32_t size;
3434  OrthancPluginCompressionType compression;
3435  uint8_t uncompress;
3436  } _OrthancPluginBufferCompression;
3437 
3438 
3456  OrthancPluginContext* context,
3457  OrthancPluginMemoryBuffer* target,
3458  const void* source,
3459  uint32_t size,
3460  OrthancPluginCompressionType compression,
3461  uint8_t uncompress)
3462  {
3463  _OrthancPluginBufferCompression params;
3464  params.target = target;
3465  params.source = source;
3466  params.size = size;
3467  params.compression = compression;
3468  params.uncompress = uncompress;
3469 
3470  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3471  }
3472 
3473 
3474 
3475  typedef struct
3476  {
3477  OrthancPluginMemoryBuffer* target;
3478  const char* path;
3479  } _OrthancPluginReadFile;
3480 
3493  OrthancPluginContext* context,
3494  OrthancPluginMemoryBuffer* target,
3495  const char* path)
3496  {
3497  _OrthancPluginReadFile params;
3498  params.target = target;
3499  params.path = path;
3500  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3501  }
3502 
3503 
3504 
3505  typedef struct
3506  {
3507  const char* path;
3508  const void* data;
3509  uint32_t size;
3510  } _OrthancPluginWriteFile;
3511 
3524  OrthancPluginContext* context,
3525  const char* path,
3526  const void* data,
3527  uint32_t size)
3528  {
3529  _OrthancPluginWriteFile params;
3530  params.path = path;
3531  params.data = data;
3532  params.size = size;
3533  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3534  }
3535 
3536 
3537 
3538  typedef struct
3539  {
3540  const char** target;
3541  OrthancPluginErrorCode error;
3542  } _OrthancPluginGetErrorDescription;
3543 
3554  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3555  OrthancPluginContext* context,
3556  OrthancPluginErrorCode error)
3557  {
3558  const char* result = NULL;
3559 
3560  _OrthancPluginGetErrorDescription params;
3561  params.target = &result;
3562  params.error = error;
3563 
3564  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3565  result == NULL)
3566  {
3567  return "Unknown error code";
3568  }
3569  else
3570  {
3571  return result;
3572  }
3573  }
3574 
3575 
3576 
3577  typedef struct
3578  {
3579  OrthancPluginRestOutput* output;
3580  uint16_t status;
3581  const char* body;
3582  uint32_t bodySize;
3583  } _OrthancPluginSendHttpStatus;
3584 
3607  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3608  OrthancPluginContext* context,
3609  OrthancPluginRestOutput* output,
3610  uint16_t status,
3611  const char* body,
3612  uint32_t bodySize)
3613  {
3614  _OrthancPluginSendHttpStatus params;
3615  params.output = output;
3616  params.status = status;
3617  params.body = body;
3618  params.bodySize = bodySize;
3619  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3620  }
3621 
3622 
3623 
3624  typedef struct
3625  {
3626  const OrthancPluginImage* image;
3627  uint32_t* resultUint32;
3628  OrthancPluginPixelFormat* resultPixelFormat;
3629  void** resultBuffer;
3630  } _OrthancPluginGetImageInfo;
3631 
3632 
3644  OrthancPluginContext* context,
3645  const OrthancPluginImage* image)
3646  {
3647  OrthancPluginPixelFormat target;
3648 
3649  _OrthancPluginGetImageInfo params;
3650  memset(&params, 0, sizeof(params));
3651  params.image = image;
3652  params.resultPixelFormat = &target;
3653 
3654  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3655  {
3657  }
3658  else
3659  {
3660  return (OrthancPluginPixelFormat) target;
3661  }
3662  }
3663 
3664 
3665 
3676  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3677  OrthancPluginContext* context,
3678  const OrthancPluginImage* image)
3679  {
3680  uint32_t width;
3681 
3682  _OrthancPluginGetImageInfo params;
3683  memset(&params, 0, sizeof(params));
3684  params.image = image;
3685  params.resultUint32 = &width;
3686 
3687  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3688  {
3689  return 0;
3690  }
3691  else
3692  {
3693  return width;
3694  }
3695  }
3696 
3697 
3698 
3709  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3710  OrthancPluginContext* context,
3711  const OrthancPluginImage* image)
3712  {
3713  uint32_t height;
3714 
3715  _OrthancPluginGetImageInfo params;
3716  memset(&params, 0, sizeof(params));
3717  params.image = image;
3718  params.resultUint32 = &height;
3719 
3720  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3721  {
3722  return 0;
3723  }
3724  else
3725  {
3726  return height;
3727  }
3728  }
3729 
3730 
3731 
3744  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3745  OrthancPluginContext* context,
3746  const OrthancPluginImage* image)
3747  {
3748  uint32_t pitch;
3749 
3750  _OrthancPluginGetImageInfo params;
3751  memset(&params, 0, sizeof(params));
3752  params.image = image;
3753  params.resultUint32 = &pitch;
3754 
3755  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
3756  {
3757  return 0;
3758  }
3759  else
3760  {
3761  return pitch;
3762  }
3763  }
3764 
3765 
3766 
3778  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
3779  OrthancPluginContext* context,
3780  const OrthancPluginImage* image)
3781  {
3782  void* target = NULL;
3783 
3784  _OrthancPluginGetImageInfo params;
3785  memset(&params, 0, sizeof(params));
3786  params.resultBuffer = &target;
3787  params.image = image;
3788 
3789  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
3790  {
3791  return NULL;
3792  }
3793  else
3794  {
3795  return target;
3796  }
3797  }
3798 
3799 
3800  typedef struct
3801  {
3802  OrthancPluginImage** target;
3803  const void* data;
3804  uint32_t size;
3805  OrthancPluginImageFormat format;
3806  } _OrthancPluginUncompressImage;
3807 
3808 
3822  OrthancPluginContext* context,
3823  const void* data,
3824  uint32_t size,
3825  OrthancPluginImageFormat format)
3826  {
3827  OrthancPluginImage* target = NULL;
3828 
3829  _OrthancPluginUncompressImage params;
3830  memset(&params, 0, sizeof(params));
3831  params.target = &target;
3832  params.data = data;
3833  params.size = size;
3834  params.format = format;
3835 
3836  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
3837  {
3838  return NULL;
3839  }
3840  else
3841  {
3842  return target;
3843  }
3844  }
3845 
3846 
3847 
3848 
3849  typedef struct
3850  {
3851  OrthancPluginImage* image;
3852  } _OrthancPluginFreeImage;
3853 
3863  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
3864  OrthancPluginContext* context,
3865  OrthancPluginImage* image)
3866  {
3867  _OrthancPluginFreeImage params;
3868  params.image = image;
3869 
3870  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
3871  }
3872 
3873 
3874 
3875 
3876  typedef struct
3877  {
3878  OrthancPluginMemoryBuffer* target;
3879  OrthancPluginImageFormat imageFormat;
3880  OrthancPluginPixelFormat pixelFormat;
3881  uint32_t width;
3882  uint32_t height;
3883  uint32_t pitch;
3884  const void* buffer;
3885  uint8_t quality;
3886  } _OrthancPluginCompressImage;
3887 
3888 
3909  OrthancPluginContext* context,
3910  OrthancPluginMemoryBuffer* target,
3911  OrthancPluginPixelFormat format,
3912  uint32_t width,
3913  uint32_t height,
3914  uint32_t pitch,
3915  const void* buffer)
3916  {
3917  _OrthancPluginCompressImage params;
3918  memset(&params, 0, sizeof(params));
3919  params.target = target;
3920  params.imageFormat = OrthancPluginImageFormat_Png;
3921  params.pixelFormat = format;
3922  params.width = width;
3923  params.height = height;
3924  params.pitch = pitch;
3925  params.buffer = buffer;
3926  params.quality = 0; /* Unused for PNG */
3927 
3928  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3929  }
3930 
3931 
3954  OrthancPluginContext* context,
3955  OrthancPluginMemoryBuffer* target,
3956  OrthancPluginPixelFormat format,
3957  uint32_t width,
3958  uint32_t height,
3959  uint32_t pitch,
3960  const void* buffer,
3961  uint8_t quality)
3962  {
3963  _OrthancPluginCompressImage params;
3964  memset(&params, 0, sizeof(params));
3965  params.target = target;
3966  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3967  params.pixelFormat = format;
3968  params.width = width;
3969  params.height = height;
3970  params.pitch = pitch;
3971  params.buffer = buffer;
3972  params.quality = quality;
3973 
3974  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3975  }
3976 
3977 
3978 
4000  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
4001  OrthancPluginContext* context,
4002  OrthancPluginRestOutput* output,
4003  OrthancPluginPixelFormat format,
4004  uint32_t width,
4005  uint32_t height,
4006  uint32_t pitch,
4007  const void* buffer,
4008  uint8_t quality)
4009  {
4010  _OrthancPluginCompressAndAnswerImage params;
4011  params.output = output;
4012  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4013  params.pixelFormat = format;
4014  params.width = width;
4015  params.height = height;
4016  params.pitch = pitch;
4017  params.buffer = buffer;
4018  params.quality = quality;
4019  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4020  }
4021 
4022 
4023 
4024 
4025  typedef struct
4026  {
4027  OrthancPluginMemoryBuffer* target;
4028  OrthancPluginHttpMethod method;
4029  const char* url;
4030  const char* username;
4031  const char* password;
4032  const char* body;
4033  uint32_t bodySize;
4034  } _OrthancPluginCallHttpClient;
4035 
4036 
4053  OrthancPluginContext* context,
4054  OrthancPluginMemoryBuffer* target,
4055  const char* url,
4056  const char* username,
4057  const char* password)
4058  {
4059  _OrthancPluginCallHttpClient params;
4060  memset(&params, 0, sizeof(params));
4061 
4062  params.target = target;
4063  params.method = OrthancPluginHttpMethod_Get;
4064  params.url = url;
4065  params.username = username;
4066  params.password = password;
4067 
4068  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4069  }
4070 
4071 
4090  OrthancPluginContext* context,
4091  OrthancPluginMemoryBuffer* target,
4092  const char* url,
4093  const char* body,
4094  uint32_t bodySize,
4095  const char* username,
4096  const char* password)
4097  {
4098  _OrthancPluginCallHttpClient params;
4099  memset(&params, 0, sizeof(params));
4100 
4101  params.target = target;
4102  params.method = OrthancPluginHttpMethod_Post;
4103  params.url = url;
4104  params.body = body;
4105  params.bodySize = bodySize;
4106  params.username = username;
4107  params.password = password;
4108 
4109  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4110  }
4111 
4112 
4131  OrthancPluginContext* context,
4132  OrthancPluginMemoryBuffer* target,
4133  const char* url,
4134  const char* body,
4135  uint32_t bodySize,
4136  const char* username,
4137  const char* password)
4138  {
4139  _OrthancPluginCallHttpClient params;
4140  memset(&params, 0, sizeof(params));
4141 
4142  params.target = target;
4143  params.method = OrthancPluginHttpMethod_Put;
4144  params.url = url;
4145  params.body = body;
4146  params.bodySize = bodySize;
4147  params.username = username;
4148  params.password = password;
4149 
4150  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4151  }
4152 
4153 
4168  OrthancPluginContext* context,
4169  const char* url,
4170  const char* username,
4171  const char* password)
4172  {
4173  _OrthancPluginCallHttpClient params;
4174  memset(&params, 0, sizeof(params));
4175 
4176  params.method = OrthancPluginHttpMethod_Delete;
4177  params.url = url;
4178  params.username = username;
4179  params.password = password;
4180 
4181  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4182  }
4183 
4184 
4185 
4186  typedef struct
4187  {
4188  OrthancPluginImage** target;
4189  const OrthancPluginImage* source;
4190  OrthancPluginPixelFormat targetFormat;
4191  } _OrthancPluginConvertPixelFormat;
4192 
4193 
4206  OrthancPluginContext* context,
4207  const OrthancPluginImage* source,
4208  OrthancPluginPixelFormat targetFormat)
4209  {
4210  OrthancPluginImage* target = NULL;
4211 
4212  _OrthancPluginConvertPixelFormat params;
4213  params.target = &target;
4214  params.source = source;
4215  params.targetFormat = targetFormat;
4216 
4217  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4218  {
4219  return NULL;
4220  }
4221  else
4222  {
4223  return target;
4224  }
4225  }
4226 
4227 
4228 
4240  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4241  OrthancPluginContext* context)
4242  {
4243  uint32_t count = 0;
4244 
4245  _OrthancPluginReturnSingleValue params;
4246  memset(&params, 0, sizeof(params));
4247  params.resultUint32 = &count;
4248 
4249  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4250  {
4251  /* Error */
4252  return 0;
4253  }
4254  else
4255  {
4256  return count;
4257  }
4258  }
4259 
4260 
4261 
4262 
4263  typedef struct
4264  {
4265  uint32_t fontIndex; /* in */
4266  const char** name; /* out */
4267  uint32_t* size; /* out */
4268  } _OrthancPluginGetFontInfo;
4269 
4280  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4281  OrthancPluginContext* context,
4282  uint32_t fontIndex)
4283  {
4284  const char* result = NULL;
4285 
4286  _OrthancPluginGetFontInfo params;
4287  memset(&params, 0, sizeof(params));
4288  params.name = &result;
4289  params.fontIndex = fontIndex;
4290 
4291  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4292  {
4293  return NULL;
4294  }
4295  else
4296  {
4297  return result;
4298  }
4299  }
4300 
4301 
4312  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4313  OrthancPluginContext* context,
4314  uint32_t fontIndex)
4315  {
4316  uint32_t result;
4317 
4318  _OrthancPluginGetFontInfo params;
4319  memset(&params, 0, sizeof(params));
4320  params.size = &result;
4321  params.fontIndex = fontIndex;
4322 
4323  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4324  {
4325  return 0;
4326  }
4327  else
4328  {
4329  return result;
4330  }
4331  }
4332 
4333 
4334 
4335  typedef struct
4336  {
4337  OrthancPluginImage* image;
4338  uint32_t fontIndex;
4339  const char* utf8Text;
4340  int32_t x;
4341  int32_t y;
4342  uint8_t r;
4343  uint8_t g;
4344  uint8_t b;
4345  } _OrthancPluginDrawText;
4346 
4347 
4366  OrthancPluginContext* context,
4367  OrthancPluginImage* image,
4368  uint32_t fontIndex,
4369  const char* utf8Text,
4370  int32_t x,
4371  int32_t y,
4372  uint8_t r,
4373  uint8_t g,
4374  uint8_t b)
4375  {
4376  _OrthancPluginDrawText params;
4377  memset(&params, 0, sizeof(params));
4378  params.image = image;
4379  params.fontIndex = fontIndex;
4380  params.utf8Text = utf8Text;
4381  params.x = x;
4382  params.y = y;
4383  params.r = r;
4384  params.g = g;
4385  params.b = b;
4386 
4387  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4388  }
4389 
4390 
4391 
4392  typedef struct
4393  {
4394  OrthancPluginStorageArea* storageArea;
4395  const char* uuid;
4396  const void* content;
4397  uint64_t size;
4399  } _OrthancPluginStorageAreaCreate;
4400 
4401 
4418  OrthancPluginContext* context,
4419  OrthancPluginStorageArea* storageArea,
4420  const char* uuid,
4421  const void* content,
4422  uint64_t size,
4424  {
4425  _OrthancPluginStorageAreaCreate params;
4426  params.storageArea = storageArea;
4427  params.uuid = uuid;
4428  params.content = content;
4429  params.size = size;
4430  params.type = type;
4431 
4432  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4433  }
4434 
4435 
4436  typedef struct
4437  {
4438  OrthancPluginMemoryBuffer* target;
4439  OrthancPluginStorageArea* storageArea;
4440  const char* uuid;
4442  } _OrthancPluginStorageAreaRead;
4443 
4444 
4460  OrthancPluginContext* context,
4461  OrthancPluginMemoryBuffer* target,
4462  OrthancPluginStorageArea* storageArea,
4463  const char* uuid,
4465  {
4466  _OrthancPluginStorageAreaRead params;
4467  params.target = target;
4468  params.storageArea = storageArea;
4469  params.uuid = uuid;
4470  params.type = type;
4471 
4472  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4473  }
4474 
4475 
4476  typedef struct
4477  {
4478  OrthancPluginStorageArea* storageArea;
4479  const char* uuid;
4481  } _OrthancPluginStorageAreaRemove;
4482 
4497  OrthancPluginContext* context,
4498  OrthancPluginStorageArea* storageArea,
4499  const char* uuid,
4501  {
4502  _OrthancPluginStorageAreaRemove params;
4503  params.storageArea = storageArea;
4504  params.uuid = uuid;
4505  params.type = type;
4506 
4507  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4508  }
4509 
4510 
4511 
4512  typedef struct
4513  {
4514  OrthancPluginErrorCode* target;
4515  int32_t code;
4516  uint16_t httpStatus;
4517  const char* message;
4518  } _OrthancPluginRegisterErrorCode;
4519 
4536  OrthancPluginContext* context,
4537  int32_t code,
4538  uint16_t httpStatus,
4539  const char* message)
4540  {
4541  OrthancPluginErrorCode target;
4542 
4543  _OrthancPluginRegisterErrorCode params;
4544  params.target = &target;
4545  params.code = code;
4546  params.httpStatus = httpStatus;
4547  params.message = message;
4548 
4549  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4550  {
4551  return target;
4552  }
4553  else
4554  {
4555  /* There was an error while assigned the error. Use a generic code. */
4557  }
4558  }
4559 
4560 
4561 
4562  typedef struct
4563  {
4564  uint16_t group;
4565  uint16_t element;
4567  const char* name;
4568  uint32_t minMultiplicity;
4569  uint32_t maxMultiplicity;
4570  } _OrthancPluginRegisterDictionaryTag;
4571 
4592  OrthancPluginContext* context,
4593  uint16_t group,
4594  uint16_t element,
4596  const char* name,
4597  uint32_t minMultiplicity,
4598  uint32_t maxMultiplicity)
4599  {
4600  _OrthancPluginRegisterDictionaryTag params;
4601  params.group = group;
4602  params.element = element;
4603  params.vr = vr;
4604  params.name = name;
4605  params.minMultiplicity = minMultiplicity;
4606  params.maxMultiplicity = maxMultiplicity;
4607 
4608  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4609  }
4610 
4611 
4612 
4613  typedef struct
4614  {
4615  uint16_t group;
4616  uint16_t element;
4618  const char* name;
4619  uint32_t minMultiplicity;
4620  uint32_t maxMultiplicity;
4621  const char* privateCreator;
4622  } _OrthancPluginRegisterPrivateDictionaryTag;
4623 
4645  OrthancPluginContext* context,
4646  uint16_t group,
4647  uint16_t element,
4649  const char* name,
4650  uint32_t minMultiplicity,
4651  uint32_t maxMultiplicity,
4652  const char* privateCreator)
4653  {
4654  _OrthancPluginRegisterPrivateDictionaryTag params;
4655  params.group = group;
4656  params.element = element;
4657  params.vr = vr;
4658  params.name = name;
4659  params.minMultiplicity = minMultiplicity;
4660  params.maxMultiplicity = maxMultiplicity;
4661  params.privateCreator = privateCreator;
4662 
4663  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4664  }
4665 
4666 
4667 
4668  typedef struct
4669  {
4670  OrthancPluginStorageArea* storageArea;
4672  } _OrthancPluginReconstructMainDicomTags;
4673 
4689  OrthancPluginContext* context,
4690  OrthancPluginStorageArea* storageArea,
4692  {
4693  _OrthancPluginReconstructMainDicomTags params;
4694  params.level = level;
4695  params.storageArea = storageArea;
4696 
4697  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
4698  }
4699 
4700 
4701  typedef struct
4702  {
4703  char** result;
4704  const char* instanceId;
4705  const void* buffer;
4706  uint32_t size;
4709  uint32_t maxStringLength;
4710  } _OrthancPluginDicomToJson;
4711 
4712 
4732  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4733  OrthancPluginContext* context,
4734  const void* buffer,
4735  uint32_t size,
4738  uint32_t maxStringLength)
4739  {
4740  char* result;
4741 
4742  _OrthancPluginDicomToJson params;
4743  memset(&params, 0, sizeof(params));
4744  params.result = &result;
4745  params.buffer = buffer;
4746  params.size = size;
4747  params.format = format;
4748  params.flags = flags;
4749  params.maxStringLength = maxStringLength;
4750 
4751  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
4752  {
4753  /* Error */
4754  return NULL;
4755  }
4756  else
4757  {
4758  return result;
4759  }
4760  }
4761 
4762 
4781  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
4782  OrthancPluginContext* context,
4783  const char* instanceId,
4786  uint32_t maxStringLength)
4787  {
4788  char* result;
4789 
4790  _OrthancPluginDicomToJson params;
4791  memset(&params, 0, sizeof(params));
4792  params.result = &result;
4793  params.instanceId = instanceId;
4794  params.format = format;
4795  params.flags = flags;
4796  params.maxStringLength = maxStringLength;
4797 
4798  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
4799  {
4800  /* Error */
4801  return NULL;
4802  }
4803  else
4804  {
4805  return result;
4806  }
4807  }
4808 
4809 
4810  typedef struct
4811  {
4812  OrthancPluginMemoryBuffer* target;
4813  const char* uri;
4814  uint32_t headersCount;
4815  const char* const* headersKeys;
4816  const char* const* headersValues;
4817  int32_t afterPlugins;
4818  } _OrthancPluginRestApiGet2;
4819 
4840  OrthancPluginContext* context,
4841  OrthancPluginMemoryBuffer* target,
4842  const char* uri,
4843  uint32_t headersCount,
4844  const char* const* headersKeys,
4845  const char* const* headersValues,
4846  int32_t afterPlugins)
4847  {
4848  _OrthancPluginRestApiGet2 params;
4849  params.target = target;
4850  params.uri = uri;
4851  params.headersCount = headersCount;
4852  params.headersKeys = headersKeys;
4853  params.headersValues = headersValues;
4854  params.afterPlugins = afterPlugins;
4855 
4856  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
4857  }
4858 
4859 
4860 
4861  typedef struct
4862  {
4864  } _OrthancPluginWorklistCallback;
4865 
4878  OrthancPluginContext* context,
4880  {
4881  _OrthancPluginWorklistCallback params;
4882  params.callback = callback;
4883 
4884  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
4885  }
4886 
4887 
4888 
4889  typedef struct
4890  {
4892  const OrthancPluginWorklistQuery* query;
4893  const void* dicom;
4894  uint32_t size;
4895  } _OrthancPluginWorklistAnswersOperation;
4896 
4914  OrthancPluginContext* context,
4916  const OrthancPluginWorklistQuery* query,
4917  const void* dicom,
4918  uint32_t size)
4919  {
4920  _OrthancPluginWorklistAnswersOperation params;
4921  params.answers = answers;
4922  params.query = query;
4923  params.dicom = dicom;
4924  params.size = size;
4925 
4926  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
4927  }
4928 
4929 
4944  OrthancPluginContext* context,
4946  {
4947  _OrthancPluginWorklistAnswersOperation params;
4948  params.answers = answers;
4949  params.query = NULL;
4950  params.dicom = NULL;
4951  params.size = 0;
4952 
4953  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
4954  }
4955 
4956 
4957  typedef struct
4958  {
4959  const OrthancPluginWorklistQuery* query;
4960  const void* dicom;
4961  uint32_t size;
4962  int32_t* isMatch;
4963  OrthancPluginMemoryBuffer* target;
4964  } _OrthancPluginWorklistQueryOperation;
4965 
4981  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
4982  OrthancPluginContext* context,
4983  const OrthancPluginWorklistQuery* query,
4984  const void* dicom,
4985  uint32_t size)
4986  {
4987  int32_t isMatch = 0;
4988 
4989  _OrthancPluginWorklistQueryOperation params;
4990  params.query = query;
4991  params.dicom = dicom;
4992  params.size = size;
4993  params.isMatch = &isMatch;
4994  params.target = NULL;
4995 
4996  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
4997  {
4998  return isMatch;
4999  }
5000  else
5001  {
5002  /* Error: Assume non-match */
5003  return 0;
5004  }
5005  }
5006 
5007 
5021  OrthancPluginContext* context,
5022  OrthancPluginMemoryBuffer* target,
5023  const OrthancPluginWorklistQuery* query)
5024  {
5025  _OrthancPluginWorklistQueryOperation params;
5026  params.query = query;
5027  params.dicom = NULL;
5028  params.size = 0;
5029  params.isMatch = NULL;
5030  params.target = target;
5031 
5032  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5033  }
5034 
5035 
5047  OrthancPluginContext* context,
5048  OrthancPluginDicomInstance* instance)
5049  {
5051 
5052  _OrthancPluginAccessDicomInstance params;
5053  memset(&params, 0, sizeof(params));
5054  params.resultOrigin = &origin;
5055  params.instance = instance;
5056 
5057  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5058  {
5059  /* Error */
5061  }
5062  else
5063  {
5064  return origin;
5065  }
5066  }
5067 
5068 
5069  typedef struct
5070  {
5071  OrthancPluginMemoryBuffer* target;
5072  const char* json;
5073  const OrthancPluginImage* pixelData;
5075  } _OrthancPluginCreateDicom;
5076 
5096  OrthancPluginContext* context,
5097  OrthancPluginMemoryBuffer* target,
5098  const char* json,
5099  const OrthancPluginImage* pixelData,
5101  {
5102  _OrthancPluginCreateDicom params;
5103  params.target = target;
5104  params.json = json;
5105  params.pixelData = pixelData;
5106  params.flags = flags;
5107 
5108  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5109  }
5110 
5111 
5112  typedef struct
5113  {
5115  } _OrthancPluginDecodeImageCallback;
5116 
5129  OrthancPluginContext* context,
5131  {
5132  _OrthancPluginDecodeImageCallback params;
5133  params.callback = callback;
5134 
5135  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5136  }
5137 
5138 
5139 
5140  typedef struct
5141  {
5142  OrthancPluginImage** target;
5143  OrthancPluginPixelFormat format;
5144  uint32_t width;
5145  uint32_t height;
5146  uint32_t pitch;
5147  void* buffer;
5148  const void* constBuffer;
5149  uint32_t bufferSize;
5150  uint32_t frameIndex;
5151  } _OrthancPluginCreateImage;
5152 
5153 
5167  OrthancPluginContext* context,
5168  OrthancPluginPixelFormat format,
5169  uint32_t width,
5170  uint32_t height)
5171  {
5172  OrthancPluginImage* target = NULL;
5173 
5174  _OrthancPluginCreateImage params;
5175  memset(&params, 0, sizeof(params));
5176  params.target = &target;
5177  params.format = format;
5178  params.width = width;
5179  params.height = height;
5180 
5181  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5182  {
5183  return NULL;
5184  }
5185  else
5186  {
5187  return target;
5188  }
5189  }
5190 
5191 
5210  OrthancPluginContext* context,
5211  OrthancPluginPixelFormat format,
5212  uint32_t width,
5213  uint32_t height,
5214  uint32_t pitch,
5215  void* buffer)
5216  {
5217  OrthancPluginImage* target = NULL;
5218 
5219  _OrthancPluginCreateImage params;
5220  memset(&params, 0, sizeof(params));
5221  params.target = &target;
5222  params.format = format;
5223  params.width = width;
5224  params.height = height;
5225  params.pitch = pitch;
5226  params.buffer = buffer;
5227 
5228  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5229  {
5230  return NULL;
5231  }
5232  else
5233  {
5234  return target;
5235  }
5236  }
5237 
5238 
5239 
5255  OrthancPluginContext* context,
5256  const void* buffer,
5257  uint32_t bufferSize,
5258  uint32_t frameIndex)
5259  {
5260  OrthancPluginImage* target = NULL;
5261 
5262  _OrthancPluginCreateImage params;
5263  memset(&params, 0, sizeof(params));
5264  params.target = &target;
5265  params.constBuffer = buffer;
5266  params.bufferSize = bufferSize;
5267  params.frameIndex = frameIndex;
5268 
5269  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5270  {
5271  return NULL;
5272  }
5273  else
5274  {
5275  return target;
5276  }
5277  }
5278 
5279 
5280 
5281  typedef struct
5282  {
5283  char** result;
5284  const void* buffer;
5285  uint32_t size;
5286  } _OrthancPluginComputeHash;
5287 
5300  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5301  OrthancPluginContext* context,
5302  const void* buffer,
5303  uint32_t size)
5304  {
5305  char* result;
5306 
5307  _OrthancPluginComputeHash params;
5308  params.result = &result;
5309  params.buffer = buffer;
5310  params.size = size;
5311 
5312  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5313  {
5314  /* Error */
5315  return NULL;
5316  }
5317  else
5318  {
5319  return result;
5320  }
5321  }
5322 
5323 
5336  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5337  OrthancPluginContext* context,
5338  const void* buffer,
5339  uint32_t size)
5340  {
5341  char* result;
5342 
5343  _OrthancPluginComputeHash params;
5344  params.result = &result;
5345  params.buffer = buffer;
5346  params.size = size;
5347 
5348  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5349  {
5350  /* Error */
5351  return NULL;
5352  }
5353  else
5354  {
5355  return result;
5356  }
5357  }
5358 
5359 
5360 
5361  typedef struct
5362  {
5364  const char* name;
5365  } _OrthancPluginLookupDictionary;
5366 
5383  OrthancPluginContext* context,
5385  const char* name)
5386  {
5387  _OrthancPluginLookupDictionary params;
5388  params.target = target;
5389  params.name = name;
5390  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5391  }
5392 
5393 
5394 
5395  typedef struct
5396  {
5397  OrthancPluginRestOutput* output;
5398  const char* answer;
5399  uint32_t answerSize;
5400  uint32_t headersCount;
5401  const char* const* headersKeys;
5402  const char* const* headersValues;
5403  } _OrthancPluginSendMultipartItem2;
5404 
5426  OrthancPluginContext* context,
5427  OrthancPluginRestOutput* output,
5428  const char* answer,
5429  uint32_t answerSize,
5430  uint32_t headersCount,
5431  const char* const* headersKeys,
5432  const char* const* headersValues)
5433  {
5434  _OrthancPluginSendMultipartItem2 params;
5435  params.output = output;
5436  params.answer = answer;
5437  params.answerSize = answerSize;
5438  params.headersCount = headersCount;
5439  params.headersKeys = headersKeys;
5440  params.headersValues = headersValues;
5441 
5442  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5443  }
5444 
5445 
5446  typedef struct
5447  {
5449  } _OrthancPluginIncomingHttpRequestFilter;
5450 
5464  OrthancPluginContext* context,
5466  {
5467  _OrthancPluginIncomingHttpRequestFilter params;
5468  params.callback = callback;
5469 
5470  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5471  }
5472 
5473 
5474 
5475  typedef struct
5476  {
5477  OrthancPluginMemoryBuffer* answerBody;
5478  OrthancPluginMemoryBuffer* answerHeaders;
5479  uint16_t* httpStatus;
5480  OrthancPluginHttpMethod method;
5481  const char* url;
5482  uint32_t headersCount;
5483  const char* const* headersKeys;
5484  const char* const* headersValues;
5485  const char* body;
5486  uint32_t bodySize;
5487  const char* username;
5488  const char* password;
5489  uint32_t timeout;
5490  const char* certificateFile;
5491  const char* certificateKeyFile;
5492  const char* certificateKeyPassword;
5493  uint8_t pkcs11;
5494  } _OrthancPluginCallHttpClient2;
5495 
5496 
5497 
5537  OrthancPluginContext* context,
5538  OrthancPluginMemoryBuffer* answerBody,
5539  OrthancPluginMemoryBuffer* answerHeaders,
5540  uint16_t* httpStatus,
5541  OrthancPluginHttpMethod method,
5542  const char* url,
5543  uint32_t headersCount,
5544  const char* const* headersKeys,
5545  const char* const* headersValues,
5546  const char* body,
5547  uint32_t bodySize,
5548  const char* username,
5549  const char* password,
5550  uint32_t timeout,
5551  const char* certificateFile,
5552  const char* certificateKeyFile,
5553  const char* certificateKeyPassword,
5554  uint8_t pkcs11)
5555  {
5556  _OrthancPluginCallHttpClient2 params;
5557  memset(&params, 0, sizeof(params));
5558 
5559  params.answerBody = answerBody;
5560  params.answerHeaders = answerHeaders;
5561  params.httpStatus = httpStatus;
5562  params.method = method;
5563  params.url = url;
5564  params.headersCount = headersCount;
5565  params.headersKeys = headersKeys;
5566  params.headersValues = headersValues;
5567  params.body = body;
5568  params.bodySize = bodySize;
5569  params.username = username;
5570  params.password = password;
5571  params.timeout = timeout;
5572  params.certificateFile = certificateFile;
5573  params.certificateKeyFile = certificateKeyFile;
5574  params.certificateKeyPassword = certificateKeyPassword;
5575  params.pkcs11 = pkcs11;
5576 
5577  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5578  }
5579 
5580 
5591  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5592  OrthancPluginContext* context)
5593  {
5594  char* result;
5595 
5596  _OrthancPluginRetrieveDynamicString params;
5597  params.result = &result;
5598  params.argument = NULL;
5599 
5600  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5601  {
5602  /* Error */
5603  return NULL;
5604  }
5605  else
5606  {
5607  return result;
5608  }
5609  }
5610 
5611 
5612 
5613 
5614  typedef struct
5615  {
5616  OrthancPluginFindCallback callback;
5617  } _OrthancPluginFindCallback;
5618 
5631  OrthancPluginContext* context,
5632  OrthancPluginFindCallback callback)
5633  {
5634  _OrthancPluginFindCallback params;
5635  params.callback = callback;
5636 
5637  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5638  }
5639 
5640 
5641  typedef struct
5642  {
5643  OrthancPluginFindAnswers *answers;
5644  const OrthancPluginFindQuery *query;
5645  const void *dicom;
5646  uint32_t size;
5647  uint32_t index;
5648  uint32_t *resultUint32;
5649  uint16_t *resultGroup;
5650  uint16_t *resultElement;
5651  char **resultString;
5652  } _OrthancPluginFindOperation;
5653 
5670  OrthancPluginContext* context,
5671  OrthancPluginFindAnswers* answers,
5672  const void* dicom,
5673  uint32_t size)
5674  {
5675  _OrthancPluginFindOperation params;
5676  memset(&params, 0, sizeof(params));
5677  params.answers = answers;
5678  params.dicom = dicom;
5679  params.size = size;
5680 
5681  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
5682  }
5683 
5684 
5699  OrthancPluginContext* context,
5700  OrthancPluginFindAnswers* answers)
5701  {
5702  _OrthancPluginFindOperation params;
5703  memset(&params, 0, sizeof(params));
5704  params.answers = answers;
5705 
5706  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
5707  }
5708 
5709 
5710 
5722  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
5723  OrthancPluginContext* context,
5724  const OrthancPluginFindQuery* query)
5725  {
5726  uint32_t count = 0;
5727 
5728  _OrthancPluginFindOperation params;
5729  memset(&params, 0, sizeof(params));
5730  params.query = query;
5731  params.resultUint32 = &count;
5732 
5733  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
5734  {
5735  /* Error */
5736  return 0;
5737  }
5738  else
5739  {
5740  return count;
5741  }
5742  }
5743 
5744 
5760  OrthancPluginContext* context,
5761  uint16_t* group,
5762  uint16_t* element,
5763  const OrthancPluginFindQuery* query,
5764  uint32_t index)
5765  {
5766  _OrthancPluginFindOperation params;
5767  memset(&params, 0, sizeof(params));
5768  params.query = query;
5769  params.index = index;
5770  params.resultGroup = group;
5771  params.resultElement = element;
5772 
5773  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
5774  }
5775 
5776 
5790  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
5791  OrthancPluginContext* context,
5792  const OrthancPluginFindQuery* query,
5793  uint32_t index)
5794  {
5795  char* result;
5796 
5797  _OrthancPluginFindOperation params;
5798  memset(&params, 0, sizeof(params));
5799  params.query = query;
5800  params.index = index;
5801  params.resultString = &result;
5802 
5803  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
5804  {
5805  /* Error */
5806  return NULL;
5807  }
5808  else
5809  {
5810  return result;
5811  }
5812  }
5813 
5814 
5828  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
5829  OrthancPluginContext* context,
5830  const OrthancPluginFindQuery* query,
5831  uint32_t index)
5832  {
5833  char* result;
5834 
5835  _OrthancPluginFindOperation params;
5836  memset(&params, 0, sizeof(params));
5837  params.query = query;
5838  params.index = index;
5839  params.resultString = &result;
5840 
5841  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
5842  {
5843  /* Error */
5844  return NULL;
5845  }
5846  else
5847  {
5848  return result;
5849  }
5850  }
5851 
5852 
5853 
5854 
5855  typedef struct
5856  {
5857  OrthancPluginMoveCallback callback;
5858  OrthancPluginGetMoveSize getMoveSize;
5859  OrthancPluginApplyMove applyMove;
5860  OrthancPluginFreeMove freeMove;
5861  } _OrthancPluginMoveCallback;
5862 
5877  OrthancPluginContext* context,
5878  OrthancPluginMoveCallback callback,
5879  OrthancPluginGetMoveSize getMoveSize,
5880  OrthancPluginApplyMove applyMove,
5881  OrthancPluginFreeMove freeMove)
5882  {
5883  _OrthancPluginMoveCallback params;
5884  params.callback = callback;
5885  params.getMoveSize = getMoveSize;
5886  params.applyMove = applyMove;
5887  params.freeMove = freeMove;
5888 
5889  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
5890  }
5891 
5892 
5893 
5894  typedef struct
5895  {
5896  OrthancPluginFindMatcher** target;
5897  const void* query;
5898  uint32_t size;
5899  } _OrthancPluginCreateFindMatcher;
5900 
5901 
5916  OrthancPluginContext* context,
5917  const void* query,
5918  uint32_t size)
5919  {
5920  OrthancPluginFindMatcher* target = NULL;
5921 
5922  _OrthancPluginCreateFindMatcher params;
5923  memset(&params, 0, sizeof(params));
5924  params.target = &target;
5925  params.query = query;
5926  params.size = size;
5927 
5928  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
5929  {
5930  return NULL;
5931  }
5932  else
5933  {
5934  return target;
5935  }
5936  }
5937 
5938 
5939  typedef struct
5940  {
5941  OrthancPluginFindMatcher* matcher;
5942  } _OrthancPluginFreeFindMatcher;
5943 
5953  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
5954  OrthancPluginContext* context,
5955  OrthancPluginFindMatcher* matcher)
5956  {
5957  _OrthancPluginFreeFindMatcher params;
5958  params.matcher = matcher;
5959 
5960  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
5961  }
5962 
5963 
5964  typedef struct
5965  {
5966  const OrthancPluginFindMatcher* matcher;
5967  const void* dicom;
5968  uint32_t size;
5969  int32_t* isMatch;
5970  } _OrthancPluginFindMatcherIsMatch;
5971 
5986  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
5987  OrthancPluginContext* context,
5988  const OrthancPluginFindMatcher* matcher,
5989  const void* dicom,
5990  uint32_t size)
5991  {
5992  int32_t isMatch = 0;
5993 
5994  _OrthancPluginFindMatcherIsMatch params;
5995  params.matcher = matcher;
5996  params.dicom = dicom;
5997  params.size = size;
5998  params.isMatch = &isMatch;
5999 
6000  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6001  {
6002  return isMatch;
6003  }
6004  else
6005  {
6006  /* Error: Assume non-match */
6007  return 0;
6008  }
6009  }
6010 
6011 
6012  typedef struct
6013  {
6015  } _OrthancPluginIncomingHttpRequestFilter2;
6016 
6029  OrthancPluginContext* context,
6031  {
6032  _OrthancPluginIncomingHttpRequestFilter2 params;
6033  params.callback = callback;
6034 
6035  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6036  }
6037 
6038 
6039 
6040  typedef struct
6041  {
6042  OrthancPluginPeers** peers;
6043  } _OrthancPluginGetPeers;
6044 
6057  OrthancPluginContext* context)
6058  {
6059  OrthancPluginPeers* peers = NULL;
6060 
6061  _OrthancPluginGetPeers params;
6062  memset(&params, 0, sizeof(params));
6063  params.peers = &peers;
6064 
6065  if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6066  {
6067  return NULL;
6068  }
6069  else
6070  {
6071  return peers;
6072  }
6073  }
6074 
6075 
6076  typedef struct
6077  {
6078  OrthancPluginPeers* peers;
6079  } _OrthancPluginFreePeers;
6080 
6090  ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6091  OrthancPluginContext* context,
6092  OrthancPluginPeers* peers)
6093  {
6094  _OrthancPluginFreePeers params;
6095  params.peers = peers;
6096 
6097  context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6098  }
6099 
6100 
6101  typedef struct
6102  {
6103  uint32_t* target;
6104  const OrthancPluginPeers* peers;
6105  } _OrthancPluginGetPeersCount;
6106 
6120  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6121  OrthancPluginContext* context,
6122  const OrthancPluginPeers* peers)
6123  {
6124  uint32_t target = 0;
6125 
6126  _OrthancPluginGetPeersCount params;
6127  memset(&params, 0, sizeof(params));
6128  params.target = &target;
6129  params.peers = peers;
6130 
6131  if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6132  {
6133  /* Error */
6134  return 0;
6135  }
6136  else
6137  {
6138  return target;
6139  }
6140  }
6141 
6142 
6143  typedef struct
6144  {
6145  const char** target;
6146  const OrthancPluginPeers* peers;
6147  uint32_t peerIndex;
6148  const char* userProperty;
6149  } _OrthancPluginGetPeerProperty;
6150 
6168  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6169  OrthancPluginContext* context,
6170  const OrthancPluginPeers* peers,
6171  uint32_t peerIndex)
6172  {
6173  const char* target = NULL;
6174 
6175  _OrthancPluginGetPeerProperty params;
6176  memset(&params, 0, sizeof(params));
6177  params.target = &target;
6178  params.peers = peers;
6179  params.peerIndex = peerIndex;
6180  params.userProperty = NULL;
6181 
6182  if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6183  {
6184  /* Error */
6185  return NULL;
6186  }
6187  else
6188  {
6189  return target;
6190  }
6191  }
6192 
6193 
6209  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6210  OrthancPluginContext* context,
6211  const OrthancPluginPeers* peers,
6212  uint32_t peerIndex)
6213  {
6214  const char* target = NULL;
6215 
6216  _OrthancPluginGetPeerProperty params;
6217  memset(&params, 0, sizeof(params));
6218  params.target = &target;
6219  params.peers = peers;
6220  params.peerIndex = peerIndex;
6221  params.userProperty = NULL;
6222 
6223  if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6224  {
6225  /* Error */
6226  return NULL;
6227  }
6228  else
6229  {
6230  return target;
6231  }
6232  }
6233 
6234 
6235 
6255  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6256  OrthancPluginContext* context,
6257  const OrthancPluginPeers* peers,
6258  uint32_t peerIndex,
6259  const char* userProperty)
6260  {
6261  const char* target = NULL;
6262 
6263  _OrthancPluginGetPeerProperty params;
6264  memset(&params, 0, sizeof(params));
6265  params.target = &target;
6266  params.peers = peers;
6267  params.peerIndex = peerIndex;
6268  params.userProperty = userProperty;
6269 
6270  if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6271  {
6272  /* No such user property */
6273  return NULL;
6274  }
6275  else
6276  {
6277  return target;
6278  }
6279  }
6280 
6281 
6282 
6283  typedef struct
6284  {
6285  OrthancPluginMemoryBuffer* answerBody;
6286  OrthancPluginMemoryBuffer* answerHeaders;
6287  uint16_t* httpStatus;
6288  const OrthancPluginPeers* peers;
6289  uint32_t peerIndex;
6290  OrthancPluginHttpMethod method;
6291  const char* uri;
6292  uint32_t additionalHeadersCount;
6293  const char* const* additionalHeadersKeys;
6294  const char* const* additionalHeadersValues;
6295  const char* body;
6296  uint32_t bodySize;
6297  uint32_t timeout;
6298  } _OrthancPluginCallPeerApi;
6299 
6336  OrthancPluginContext* context,
6337  OrthancPluginMemoryBuffer* answerBody,
6338  OrthancPluginMemoryBuffer* answerHeaders,
6339  uint16_t* httpStatus,
6340  const OrthancPluginPeers* peers,
6341  uint32_t peerIndex,
6342  OrthancPluginHttpMethod method,
6343  const char* uri,
6344  uint32_t additionalHeadersCount,
6345  const char* const* additionalHeadersKeys,
6346  const char* const* additionalHeadersValues,
6347  const char* body,
6348  uint32_t bodySize,
6349  uint32_t timeout)
6350  {
6351  _OrthancPluginCallPeerApi params;
6352  memset(&params, 0, sizeof(params));
6353 
6354  params.answerBody = answerBody;
6355  params.answerHeaders = answerHeaders;
6356  params.httpStatus = httpStatus;
6357  params.peers = peers;
6358  params.peerIndex = peerIndex;
6359  params.method = method;
6360  params.uri = uri;
6361  params.additionalHeadersCount = additionalHeadersCount;
6362  params.additionalHeadersKeys = additionalHeadersKeys;
6363  params.additionalHeadersValues = additionalHeadersValues;
6364  params.body = body;
6365  params.bodySize = bodySize;
6366  params.timeout = timeout;
6367 
6368  return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6369  }
6370 
6371 
6372 
6373 
6374 
6375  typedef struct
6376  {
6377  OrthancPluginJob** target;
6378  void *job;
6379  OrthancPluginJobFinalize finalize;
6380  const char *type;
6381  OrthancPluginJobGetProgress getProgress;
6382  OrthancPluginJobGetContent getContent;
6383  OrthancPluginJobGetSerialized getSerialized;
6384  OrthancPluginJobStep step;
6385  OrthancPluginJobStop stop;
6386  OrthancPluginJobReset reset;
6387  } _OrthancPluginCreateJob;
6388 
6421  OrthancPluginContext *context,
6422  void *job,
6423  OrthancPluginJobFinalize finalize,
6424  const char *type,
6425  OrthancPluginJobGetProgress getProgress,
6426  OrthancPluginJobGetContent getContent,
6427  OrthancPluginJobGetSerialized getSerialized,
6428  OrthancPluginJobStep step,
6429  OrthancPluginJobStop stop,
6430  OrthancPluginJobReset reset)
6431  {
6432  OrthancPluginJob* target = NULL;
6433 
6434  _OrthancPluginCreateJob params;
6435  memset(&params, 0, sizeof(params));
6436 
6437  params.target = &target;
6438  params.job = job;
6439  params.finalize = finalize;
6440  params.type = type;
6441  params.getProgress = getProgress;
6442  params.getContent = getContent;
6443  params.getSerialized = getSerialized;
6444  params.step = step;
6445  params.stop = stop;
6446  params.reset = reset;
6447 
6448  if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6449  target == NULL)
6450  {
6451  /* Error */
6452  return NULL;
6453  }
6454  else
6455  {
6456  return target;
6457  }
6458  }
6459 
6460 
6461  typedef struct
6462  {
6463  OrthancPluginJob* job;
6464  } _OrthancPluginFreeJob;
6465 
6475  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6476  OrthancPluginContext* context,
6477  OrthancPluginJob* job)
6478  {
6479  _OrthancPluginFreeJob params;
6480  params.job = job;
6481 
6482  context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6483  }
6484 
6485 
6486 
6487  typedef struct
6488  {
6489  char** resultId;
6490  OrthancPluginJob *job;
6491  int priority;
6492  } _OrthancPluginSubmitJob;
6493 
6507  ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6508  OrthancPluginContext *context,
6509  OrthancPluginJob *job,
6510  int priority)
6511  {
6512  char* resultId = NULL;
6513 
6514  _OrthancPluginSubmitJob params;
6515  memset(&params, 0, sizeof(params));
6516 
6517  params.resultId = &resultId;
6518  params.job = job;
6519  params.priority = priority;
6520 
6521  if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6522  resultId == NULL)
6523  {
6524  /* Error */
6525  return NULL;
6526  }
6527  else
6528  {
6529  return resultId;
6530  }
6531  }
6532 
6533 
6534 
6535  typedef struct
6536  {
6537  OrthancPluginJobsUnserializer unserializer;
6538  } _OrthancPluginJobsUnserializer;
6539 
6552  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6553  OrthancPluginContext* context,
6554  OrthancPluginJobsUnserializer unserializer)
6555  {
6556  _OrthancPluginJobsUnserializer params;
6557  params.unserializer = unserializer;
6558 
6559  context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6560  }
6561 
6562 
6563 
6564  typedef struct
6565  {
6566  OrthancPluginRestOutput* output;
6567  const char* details;
6568  uint8_t log;
6569  } _OrthancPluginSetHttpErrorDetails;
6570 
6588  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
6589  OrthancPluginContext* context,
6590  OrthancPluginRestOutput* output,
6591  const char* details,
6592  uint8_t log)
6593  {
6594  _OrthancPluginSetHttpErrorDetails params;
6595  params.output = output;
6596  params.details = details;
6597  params.log = log;
6598  context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
6599  }
6600 
6601 
6602 
6603  typedef struct
6604  {
6605  const char** result;
6606  const char* argument;
6607  } _OrthancPluginRetrieveStaticString;
6608 
6620  ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
6621  OrthancPluginContext* context,
6622  const char* path)
6623  {
6624  const char* result = NULL;
6625 
6626  _OrthancPluginRetrieveStaticString params;
6627  params.result = &result;
6628  params.argument = path;
6629 
6630  if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
6631  {
6632  /* Error */
6633  return NULL;
6634  }
6635  else
6636  {
6637  return result;
6638  }
6639  }
6640 
6641 
6642 
6643  typedef struct
6644  {
6645  const char* name;
6646  float value;
6648  } _OrthancPluginSetMetricsValue;
6649 
6664  ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
6665  OrthancPluginContext* context,
6666  const char* name,
6667  float value,
6669  {
6670  _OrthancPluginSetMetricsValue params;
6671  params.name = name;
6672  params.value = value;
6673  params.type = type;
6674  context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
6675  }
6676 
6677 
6678 
6679  typedef struct
6680  {
6682  } _OrthancPluginRegisterRefreshMetricsCallback;
6683 
6695  OrthancPluginContext* context,
6697  {
6698  _OrthancPluginRegisterRefreshMetricsCallback params;
6699  params.callback = callback;
6700  context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
6701  }
6702 
6703 
6704 
6705 
6706  typedef struct
6707  {
6708  char** target;
6709  const void* dicom;
6710  uint32_t dicomSize;
6712  } _OrthancPluginEncodeDicomWeb;
6713 
6729  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
6730  OrthancPluginContext* context,
6731  const void* dicom,
6732  uint32_t dicomSize,
6734  {
6735  char* target = NULL;
6736 
6737  _OrthancPluginEncodeDicomWeb params;
6738  params.target = &target;
6739  params.dicom = dicom;
6740  params.dicomSize = dicomSize;
6741  params.callback = callback;
6742 
6743  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
6744  {
6745  /* Error */
6746  return NULL;
6747  }
6748  else
6749  {
6750  return target;
6751  }
6752  }
6753 
6754 
6770  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
6771  OrthancPluginContext* context,
6772  const void* dicom,
6773  uint32_t dicomSize,
6775  {
6776  char* target = NULL;
6777 
6778  _OrthancPluginEncodeDicomWeb params;
6779  params.target = &target;
6780  params.dicom = dicom;
6781  params.dicomSize = dicomSize;
6782  params.callback = callback;
6783 
6784  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
6785  {
6786  /* Error */
6787  return NULL;
6788  }
6789  else
6790  {
6791  return target;
6792  }
6793  }
6794 
6795 
6796 #ifdef __cplusplus
6797 }
6798 #endif
6799 
6800 
Definition: OrthancCPlugin.h:732
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2661
Definition: OrthancCPlugin.h:834
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:2840
OrthancPluginChangeType
Definition: OrthancCPlugin.h:687
Definition: OrthancCPlugin.h:236
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2524
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6090
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:955
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5669
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2625
Definition: OrthancCPlugin.h:755
Definition: OrthancCPlugin.h:923
Definition: OrthancCPlugin.h:271
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:1791
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5128
Definition: OrthancCPlugin.h:835
The parameters of a REST request.
Definition: OrthancCPlugin.h:330
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2307
OrthancPluginContentType
Definition: OrthancCPlugin.h:656
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2212
Definition: OrthancCPlugin.h:673
Definition: OrthancCPlugin.h:754
struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode
Opaque structure that represents a node in a JSON or XML document used in DICOMweb.
Definition: OrthancCPlugin.h:1043
Definition: OrthancCPlugin.h:866
const char * OrthancPluginGetInstanceData(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2727
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:3908
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:4000
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:876
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:1239
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1724
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:6588
Definition: OrthancCPlugin.h:263
Definition: OrthancCPlugin.h:206
Definition: OrthancCPlugin.h:261
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:861
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1404
Definition: OrthancCPlugin.h:752
Definition: OrthancCPlugin.h:894
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2694
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:4644
Definition: OrthancCPlugin.h:286
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:580
Definition: OrthancCPlugin.h:702
Definition: OrthancCPlugin.h:228
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:390
Definition: OrthancCPlugin.h:273
Definition: OrthancCPlugin.h:275
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:385
Definition: OrthancCPlugin.h:259
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:816
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5336
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:6420
Definition: OrthancCPlugin.h:277
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:564
Definition: OrthancCPlugin.h:867
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:350
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int priority)
Submit a new job to the jobs engine of Orthanc.
Definition: OrthancCPlugin.h:6507
Definition: OrthancCPlugin.h:606
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:2926
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:6620
Definition: OrthancCPlugin.h:850
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2025
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 char *body, uint32_t bodySize, uint32_t timeout)
Call the REST API of an Orthanc peer.
Definition: OrthancCPlugin.h:6335
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:729
Definition: OrthancCPlugin.h:214
Definition: OrthancCPlugin.h:299
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1590
Definition: OrthancCPlugin.h:283
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4280
Definition: OrthancCPlugin.h:234
Definition: OrthancCPlugin.h:289
Definition: OrthancCPlugin.h:281
Definition: OrthancCPlugin.h:318
Definition: OrthancCPlugin.h:225
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5300
Definition: OrthancCPlugin.h:878
Definition: OrthancCPlugin.h:227
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:200
struct _OrthancPluginJob_t OrthancPluginJob
Opaque structure to a job to be executed by Orthanc.
Definition: OrthancCPlugin.h:1034
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4205
Definition: OrthancCPlugin.h:284
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:1181
Definition: OrthancCPlugin.h:696
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4459
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4240
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:3023
Definition: OrthancCPlugin.h:223
OrthancPluginErrorCode OrthancPluginGetFindQueryTag(OrthancPluginContext *context, uint16_t *group, uint16_t *element, const OrthancPluginFindQuery *query, uint32_t index)
Get one tag in a C-Find query.
Definition: OrthancCPlugin.h:5759
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 char *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:5536
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3065
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:604
Definition: OrthancCPlugin.h:800
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:797
Definition: OrthancCPlugin.h:895
Definition: OrthancCPlugin.h:216
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2570
Definition: OrthancCPlugin.h:716
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5591
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1389
Definition: OrthancCPlugin.h:704
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:1927
Definition: OrthancCPlugin.h:893
Definition: OrthancCPlugin.h:690
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5254
Definition: OrthancCPlugin.h:260
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:782
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5382
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1461
Definition: OrthancCPlugin.h:784
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4535
Definition: OrthancCPlugin.h:241
uint16_t group
Definition: OrthancCPlugin.h:1573
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:3778
Definition: OrthancCPlugin.h:745
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1576
Definition: OrthancCPlugin.h:786
Definition: OrthancCPlugin.h:757
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:4913
const char * OrthancPluginGetInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Get the value of some metadata associated with a given DICOM instance.
Definition: OrthancCPlugin.h:2878
Definition: OrthancCPlugin.h:892
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:890
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:986
Definition: OrthancCPlugin.h:731
Definition: OrthancCPlugin.h:253
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:978
Definition: OrthancCPlugin.h:245
Definition: OrthancCPlugin.h:658
Definition: OrthancCPlugin.h:694
Color image in RGB48 format.
Definition: OrthancCPlugin.h:614
OrthancPluginErrorCode OrthancPluginRestApiPutAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const char *body, uint32_t bodySize)
Make a PUT call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2273
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3310
Definition: OrthancCPlugin.h:276
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:572
Definition: OrthancCPlugin.h:274
Definition: OrthancCPlugin.h:217
OrthancPluginConstraintType
Definition: OrthancCPlugin.h:846
OrthancPluginResourceType
Definition: OrthancCPlugin.h:670
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:315
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:1105
Definition: OrthancCPlugin.h:233
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:3709
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:743
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3343
Definition: OrthancCPlugin.h:204
void OrthancPluginSendHttpStatus(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status, const char *body, uint32_t bodySize)
Send a HTTP status, with a custom body.
Definition: OrthancCPlugin.h:3607
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:3821
Definition: OrthancCPlugin.h:279
Definition: OrthancCPlugin.h:747
Definition: OrthancCPlugin.h:220
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:6770
Definition: OrthancCPlugin.h:675
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1051
Definition: OrthancCPlugin.h:270
Definition: OrthancCPlugin.h:717
Definition: OrthancCPlugin.h:750
Definition: OrthancCPlugin.h:287
Definition: OrthancCPlugin.h:880
void OrthancPluginSetMetricsValue(OrthancPluginContext *context, const char *name, float value, OrthancPluginMetricsType type)
Set the value of a metrics.
Definition: OrthancCPlugin.h:6664
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:2988
Definition: OrthancCPlugin.h:238
Definition: OrthancCPlugin.h:719
Definition: OrthancCPlugin.h:769
Definition: OrthancCPlugin.h:262
Color image in RGB24 format.
Definition: OrthancCPlugin.h:596
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6028
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:588
Definition: OrthancCPlugin.h:904
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1571
Definition: OrthancCPlugin.h:272
Definition: OrthancCPlugin.h:210
Definition: OrthancCPlugin.h:689
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:714
OrthancPluginErrorCode OrthancPluginHttpPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *body, uint32_t bodySize, const char *username, const char *password)
Issue a HTTP PUT call.
Definition: OrthancCPlugin.h:4130
Definition: OrthancCPlugin.h:202
OrthancPluginErrorCode OrthancPluginRestApiGet2(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, int32_t afterPlugins)
Make a GET call to the Orthanc REST API, with custom HTTP headers.
Definition: OrthancCPlugin.h:4839
Definition: OrthancCPlugin.h:803
struct _OrthancPluginPeers_t OrthancPluginPeers
Opaque structure to the set of remote Orthanc Peers that are known to the local Orthanc server.
Definition: OrthancCPlugin.h:1026
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3643
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:4365
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3744
Definition: OrthancCPlugin.h:659
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:1984
Definition: OrthancCPlugin.h:292
Definition: OrthancCPlugin.h:298
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1437
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1577
Definition: OrthancCPlugin.h:922
Definition: OrthancCPlugin.h:291
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:1083
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:4732
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1095
Definition: OrthancCPlugin.h:851
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3244
Definition: OrthancCPlugin.h:243
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2547
Definition: OrthancCPlugin.h:212
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:646
Definition: OrthancCPlugin.h:268
Definition: OrthancCPlugin.h:256
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:5953
Definition: OrthancCPlugin.h:288
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:1759
Definition: OrthancCPlugin.h:231
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:5915
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:940
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4312
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:3140
Definition: OrthancCPlugin.h:865
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1512
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2058
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3554
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:380
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:1208
Definition: OrthancCPlugin.h:695
Definition: OrthancCPlugin.h:802
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1743
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:4877
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1124
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:1309
Definition: OrthancCPlugin.h:763
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2189
Definition: OrthancCPlugin.h:767
Definition: OrthancCPlugin.h:674
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3492
Definition: OrthancCPlugin.h:756
Definition: OrthancCPlugin.h:836
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1010
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:5876
Definition: OrthancCPlugin.h:319
Definition: OrthancCPlugin.h:703
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5166
Definition: OrthancCPlugin.h:758
Definition: OrthancCPlugin.h:248
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:2958
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3174
Definition: OrthancCPlugin.h:852
OrthancPluginErrorCode OrthancPluginSendMultipartItem2(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *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:5425
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1162
Definition: OrthancCPlugin.h:785
Definition: OrthancCPlugin.h:257
Definition: OrthancCPlugin.h:295
Definition: OrthancCPlugin.h:317
Definition: OrthancCPlugin.h:911
Definition: OrthancCPlugin.h:697
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4688
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:5790
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6552
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3278
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:4052
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:5209
Definition: OrthancCPlugin.h:265
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5463
Definition: OrthancCPlugin.h:224
char * OrthancPluginDicomInstanceToJson(OrthancPluginContext *context, const char *instanceId, OrthancPluginDicomToJsonFormat format, OrthancPluginDicomToJsonFlags flags, uint32_t maxStringLength)
Format a DICOM instance as a JSON string.
Definition: OrthancCPlugin.h:4781
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:360
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:6255
Definition: OrthancCPlugin.h:770
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:1072
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6056
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:2801
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:3455
Definition: OrthancCPlugin.h:258
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:4943
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:5095
Definition: OrthancCPlugin.h:251
Definition: OrthancCPlugin.h:733
Definition: OrthancCPlugin.h:211
const char * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:365
Definition: OrthancCPlugin.h:264
Definition: OrthancCPlugin.h:218
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:1867
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1266
Definition: OrthancCPlugin.h:700
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5630
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:970
OrthancPluginErrorCode OrthancPluginRestApiPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const char *body, uint32_t bodySize)
Make a PUT call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2237
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3384
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:994
Definition: OrthancCPlugin.h:203
Definition: OrthancCPlugin.h:229
Definition: OrthancCPlugin.h:222
Definition: OrthancCPlugin.h:833
Definition: OrthancCPlugin.h:296
Definition: OrthancCPlugin.h:267
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1363
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:3096
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1422
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4496
Definition: OrthancCPlugin.h:879
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6475
Definition: OrthancCPlugin.h:762
Definition: OrthancCPlugin.h:701
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:355
Definition: OrthancCPlugin.h:765
Definition: OrthancCPlugin.h:692
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2339
Definition: OrthancCPlugin.h:849
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5046
Definition: OrthancCPlugin.h:766
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:3863
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1575
uint16_t element
Definition: OrthancCPlugin.h:1574
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2479
Definition: OrthancCPlugin.h:699
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3213
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1349
Definition: OrthancCPlugin.h:235
Definition: OrthancCPlugin.h:660
OrthancPluginErrorCode OrthancPluginSendMultipartItem(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize)
Send an item as a part of some HTTP multipart answer.
Definition: OrthancCPlugin.h:3413
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:345
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3523
Definition: OrthancCPlugin.h:266
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1144
Definition: OrthancCPlugin.h:269
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2374
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:945
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:630
Definition: OrthancCPlugin.h:863
Definition: OrthancCPlugin.h:249
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1478
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:6729
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance received by Orthanc.
Definition: OrthancCPlugin.h:962
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:340
Definition: OrthancCPlugin.h:250
Definition: OrthancCPlugin.h:676
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:1775
Definition: OrthancCPlugin.h:921
Definition: OrthancCPlugin.h:751
Definition: OrthancCPlugin.h:255
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:4981
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:1620
Definition: OrthancCPlugin.h:771
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:831
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:370
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:5698
Definition: OrthancCPlugin.h:320
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1494
OrthancPluginMetricsType
Definition: OrthancCPlugin.h:902
OrthancPluginDicomWebBinaryMode
Definition: OrthancCPlugin.h:919
Definition: OrthancCPlugin.h:240
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2600
Definition: OrthancCPlugin.h:691
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6120
Definition: OrthancCPlugin.h:761
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2763
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6209
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5722
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:3118
Definition: OrthancCPlugin.h:297
Definition: OrthancCPlugin.h:237
OrthancPluginErrorCode OrthancPluginRestApiPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const char *body, uint32_t bodySize)
Make a POST call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2125
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:1895
Definition: OrthancCPlugin.h:693
Definition: OrthancCPlugin.h:764
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:4591
Definition: OrthancCPlugin.h:252
Definition: OrthancCPlugin.h:215
Definition: OrthancCPlugin.h:768
OrthancPluginErrorCode OrthancPluginHttpPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *body, uint32_t bodySize, const char *username, const char *password)
Issue a HTTP POST call.
Definition: OrthancCPlugin.h:4089
Definition: OrthancCPlugin.h:748
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:622
Definition: OrthancCPlugin.h:848
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:1827
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2409
Definition: OrthancCPlugin.h:760
Definition: OrthancCPlugin.h:746
Definition: OrthancCPlugin.h:207
Definition: OrthancCPlugin.h:672
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5020
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:2088
Definition: OrthancCPlugin.h:864
Definition: OrthancCPlugin.h:226
OrthancPluginErrorCode(* OrthancPluginOnStoredInstanceCallback)(OrthancPluginDicomInstance *instance, const char *instanceId)
Signature of a callback function that is triggered when Orthanc receives a DICOM instance.
Definition: OrthancCPlugin.h:1062
Definition: OrthancCPlugin.h:290
Definition: OrthancCPlugin.h:208
Definition: OrthancCPlugin.h:213
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1002
OrthancPluginErrorCode OrthancPluginRestApiPostAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const char *body, uint32_t bodySize)
Make a POST call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2160
Definition: OrthancCPlugin.h:205
Definition: OrthancCPlugin.h:230
Definition: OrthancCPlugin.h:698
Definition: OrthancCPlugin.h:718
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:6694
Definition: OrthancCPlugin.h:242
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:335
Definition: OrthancCPlugin.h:285
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:4417
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4167
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:935
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6168
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:638
Definition: OrthancCPlugin.h:753
Definition: OrthancCPlugin.h:801
Definition: OrthancCPlugin.h:219
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:5986
Definition: OrthancCPlugin.h:759
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1376
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2444
Definition: OrthancCPlugin.h:209
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1334
Definition: OrthancCPlugin.h:749
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:1540
Definition: OrthancCPlugin.h:278
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3676
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:3953
struct _OrthancPluginFindAnswers_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:1018
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:5828
Definition: OrthancCPlugin.h:239
Definition: OrthancCPlugin.h:232