Orthanc Plugin SDK  1.6.0
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1 
111 #pragma once
112 
113 
114 #include <stdio.h>
115 #include <string.h>
116 
117 #ifdef WIN32
118 # define ORTHANC_PLUGINS_API __declspec(dllexport)
119 #elif __GNUC__ >= 4
120 # define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default")))
121 #else
122 # define ORTHANC_PLUGINS_API
123 #endif
124 
125 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
126 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 6
127 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 0
128 
129 
130 #if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
131 #define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
132  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
133  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
134  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
135  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
136  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
137 #endif
138 
139 
140 
141 /********************************************************************
142  ** Check that function inlining is properly supported. The use of
143  ** inlining is required, to avoid the duplication of object code
144  ** between two compilation modules that would use the Orthanc Plugin
145  ** API.
146  ********************************************************************/
147 
148 /* If the auto-detection of the "inline" keyword below does not work
149  automatically and that your compiler is known to properly support
150  inlining, uncomment the following #define and adapt the definition
151  of "static inline". */
152 
153 /* #define ORTHANC_PLUGIN_INLINE static inline */
154 
155 #ifndef ORTHANC_PLUGIN_INLINE
156 # if __STDC_VERSION__ >= 199901L
157 /* This is C99 or above: http://predef.sourceforge.net/prestd.html */
158 # define ORTHANC_PLUGIN_INLINE static inline
159 # elif defined(__cplusplus)
160 /* This is C++ */
161 # define ORTHANC_PLUGIN_INLINE static inline
162 # elif defined(__GNUC__)
163 /* This is GCC running in C89 mode */
164 # define ORTHANC_PLUGIN_INLINE static __inline
165 # elif defined(_MSC_VER)
166 /* This is Visual Studio running in C89 mode */
167 # define ORTHANC_PLUGIN_INLINE static __inline
168 # else
169 # error Your compiler is not known to support the "inline" keyword
170 # endif
171 #endif
172 
173 
174 
175 /********************************************************************
176  ** Inclusion of standard libraries.
177  ********************************************************************/
178 
184 #include <stdint.h>
185 
186 #include <stdlib.h>
187 
188 
189 
190 /********************************************************************
191  ** Definition of the Orthanc Plugin API.
192  ********************************************************************/
193 
196 #ifdef __cplusplus
197 extern "C"
198 {
199 #endif
200 
204  typedef enum
205  {
307 
308  _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
310 
311 
316  ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
317 
318 
322  typedef enum
323  {
329  _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
331 
332 
337  typedef struct
338  {
343 
347  uint32_t groupsCount;
348 
352  const char* const* groups;
353 
357  uint32_t getCount;
358 
362  const char* const* getKeys;
363 
367  const char* const* getValues;
368 
372  const void* body;
373 
377  uint32_t bodySize;
378 
379 
380  /* --------------------------------------------------
381  New in version 0.8.1
382  -------------------------------------------------- */
383 
387  uint32_t headersCount;
388 
392  const char* const* headersKeys;
393 
397  const char* const* headersValues;
398 
400 
401 
402  typedef enum
403  {
404  /* Generic services */
405  _OrthancPluginService_LogInfo = 1,
406  _OrthancPluginService_LogWarning = 2,
407  _OrthancPluginService_LogError = 3,
408  _OrthancPluginService_GetOrthancPath = 4,
409  _OrthancPluginService_GetOrthancDirectory = 5,
410  _OrthancPluginService_GetConfigurationPath = 6,
411  _OrthancPluginService_SetPluginProperty = 7,
412  _OrthancPluginService_GetGlobalProperty = 8,
413  _OrthancPluginService_SetGlobalProperty = 9,
414  _OrthancPluginService_GetCommandLineArgumentsCount = 10,
415  _OrthancPluginService_GetCommandLineArgument = 11,
416  _OrthancPluginService_GetExpectedDatabaseVersion = 12,
417  _OrthancPluginService_GetConfiguration = 13,
418  _OrthancPluginService_BufferCompression = 14,
419  _OrthancPluginService_ReadFile = 15,
420  _OrthancPluginService_WriteFile = 16,
421  _OrthancPluginService_GetErrorDescription = 17,
422  _OrthancPluginService_CallHttpClient = 18,
423  _OrthancPluginService_RegisterErrorCode = 19,
424  _OrthancPluginService_RegisterDictionaryTag = 20,
425  _OrthancPluginService_DicomBufferToJson = 21,
426  _OrthancPluginService_DicomInstanceToJson = 22,
427  _OrthancPluginService_CreateDicom = 23,
428  _OrthancPluginService_ComputeMd5 = 24,
429  _OrthancPluginService_ComputeSha1 = 25,
430  _OrthancPluginService_LookupDictionary = 26,
431  _OrthancPluginService_CallHttpClient2 = 27,
432  _OrthancPluginService_GenerateUuid = 28,
433  _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
434  _OrthancPluginService_AutodetectMimeType = 30,
435  _OrthancPluginService_SetMetricsValue = 31,
436  _OrthancPluginService_EncodeDicomWebJson = 32,
437  _OrthancPluginService_EncodeDicomWebXml = 33,
438  _OrthancPluginService_ChunkedHttpClient = 34, /* New in Orthanc 1.5.7 */
439  _OrthancPluginService_GetTagName = 35, /* New in Orthanc 1.5.7 */
440 
441  /* Registration of callbacks */
442  _OrthancPluginService_RegisterRestCallback = 1000,
443  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
444  _OrthancPluginService_RegisterStorageArea = 1002,
445  _OrthancPluginService_RegisterOnChangeCallback = 1003,
446  _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
447  _OrthancPluginService_RegisterWorklistCallback = 1005,
448  _OrthancPluginService_RegisterDecodeImageCallback = 1006,
449  _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
450  _OrthancPluginService_RegisterFindCallback = 1008,
451  _OrthancPluginService_RegisterMoveCallback = 1009,
452  _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
453  _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
454  _OrthancPluginService_RegisterChunkedRestCallback = 1012, /* New in Orthanc 1.5.7 */
455  _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
456 
457  /* Sending answers to REST calls */
458  _OrthancPluginService_AnswerBuffer = 2000,
459  _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
460  _OrthancPluginService_Redirect = 2002,
461  _OrthancPluginService_SendHttpStatusCode = 2003,
462  _OrthancPluginService_SendUnauthorized = 2004,
463  _OrthancPluginService_SendMethodNotAllowed = 2005,
464  _OrthancPluginService_SetCookie = 2006,
465  _OrthancPluginService_SetHttpHeader = 2007,
466  _OrthancPluginService_StartMultipartAnswer = 2008,
467  _OrthancPluginService_SendMultipartItem = 2009,
468  _OrthancPluginService_SendHttpStatus = 2010,
469  _OrthancPluginService_CompressAndAnswerImage = 2011,
470  _OrthancPluginService_SendMultipartItem2 = 2012,
471  _OrthancPluginService_SetHttpErrorDetails = 2013,
472 
473  /* Access to the Orthanc database and API */
474  _OrthancPluginService_GetDicomForInstance = 3000,
475  _OrthancPluginService_RestApiGet = 3001,
476  _OrthancPluginService_RestApiPost = 3002,
477  _OrthancPluginService_RestApiDelete = 3003,
478  _OrthancPluginService_RestApiPut = 3004,
479  _OrthancPluginService_LookupPatient = 3005,
480  _OrthancPluginService_LookupStudy = 3006,
481  _OrthancPluginService_LookupSeries = 3007,
482  _OrthancPluginService_LookupInstance = 3008,
483  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
484  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
485  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
486  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
487  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
488  _OrthancPluginService_ReconstructMainDicomTags = 3014,
489  _OrthancPluginService_RestApiGet2 = 3015,
490 
491  /* Access to DICOM instances */
492  _OrthancPluginService_GetInstanceRemoteAet = 4000,
493  _OrthancPluginService_GetInstanceSize = 4001,
494  _OrthancPluginService_GetInstanceData = 4002,
495  _OrthancPluginService_GetInstanceJson = 4003,
496  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
497  _OrthancPluginService_HasInstanceMetadata = 4005,
498  _OrthancPluginService_GetInstanceMetadata = 4006,
499  _OrthancPluginService_GetInstanceOrigin = 4007,
500 
501  /* Services for plugins implementing a database back-end */
502  _OrthancPluginService_RegisterDatabaseBackend = 5000,
503  _OrthancPluginService_DatabaseAnswer = 5001,
504  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
505  _OrthancPluginService_StorageAreaCreate = 5003,
506  _OrthancPluginService_StorageAreaRead = 5004,
507  _OrthancPluginService_StorageAreaRemove = 5005,
508 
509  /* Primitives for handling images */
510  _OrthancPluginService_GetImagePixelFormat = 6000,
511  _OrthancPluginService_GetImageWidth = 6001,
512  _OrthancPluginService_GetImageHeight = 6002,
513  _OrthancPluginService_GetImagePitch = 6003,
514  _OrthancPluginService_GetImageBuffer = 6004,
515  _OrthancPluginService_UncompressImage = 6005,
516  _OrthancPluginService_FreeImage = 6006,
517  _OrthancPluginService_CompressImage = 6007,
518  _OrthancPluginService_ConvertPixelFormat = 6008,
519  _OrthancPluginService_GetFontsCount = 6009,
520  _OrthancPluginService_GetFontInfo = 6010,
521  _OrthancPluginService_DrawText = 6011,
522  _OrthancPluginService_CreateImage = 6012,
523  _OrthancPluginService_CreateImageAccessor = 6013,
524  _OrthancPluginService_DecodeDicomImage = 6014,
525 
526  /* Primitives for handling C-Find, C-Move and worklists */
527  _OrthancPluginService_WorklistAddAnswer = 7000,
528  _OrthancPluginService_WorklistMarkIncomplete = 7001,
529  _OrthancPluginService_WorklistIsMatch = 7002,
530  _OrthancPluginService_WorklistGetDicomQuery = 7003,
531  _OrthancPluginService_FindAddAnswer = 7004,
532  _OrthancPluginService_FindMarkIncomplete = 7005,
533  _OrthancPluginService_GetFindQuerySize = 7006,
534  _OrthancPluginService_GetFindQueryTag = 7007,
535  _OrthancPluginService_GetFindQueryTagName = 7008,
536  _OrthancPluginService_GetFindQueryValue = 7009,
537  _OrthancPluginService_CreateFindMatcher = 7010,
538  _OrthancPluginService_FreeFindMatcher = 7011,
539  _OrthancPluginService_FindMatcherIsMatch = 7012,
540 
541  /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
542  _OrthancPluginService_GetPeers = 8000,
543  _OrthancPluginService_FreePeers = 8001,
544  _OrthancPluginService_GetPeersCount = 8003,
545  _OrthancPluginService_GetPeerName = 8004,
546  _OrthancPluginService_GetPeerUrl = 8005,
547  _OrthancPluginService_CallPeerApi = 8006,
548  _OrthancPluginService_GetPeerUserProperty = 8007,
549 
550  /* Primitives for handling jobs (new in 1.4.2) */
551  _OrthancPluginService_CreateJob = 9000,
552  _OrthancPluginService_FreeJob = 9001,
553  _OrthancPluginService_SubmitJob = 9002,
554  _OrthancPluginService_RegisterJobsUnserializer = 9003,
555 
556  _OrthancPluginService_INTERNAL = 0x7fffffff
557  } _OrthancPluginService;
558 
559 
560  typedef enum
561  {
562  _OrthancPluginProperty_Description = 1,
563  _OrthancPluginProperty_RootUri = 2,
564  _OrthancPluginProperty_OrthancExplorer = 3,
565 
566  _OrthancPluginProperty_INTERNAL = 0x7fffffff
567  } _OrthancPluginProperty;
568 
569 
570 
575  typedef enum
576  {
584 
592 
600 
608 
616 
626 
634 
642 
650 
658 
659  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
661 
662 
663 
667  typedef enum
668  {
673  _OrthancPluginContentType_INTERNAL = 0x7fffffff
675 
676 
677 
681  typedef enum
682  {
689  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
691 
692 
693 
698  typedef enum
699  {
717  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
719 
720 
725  typedef enum
726  {
732  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
734 
735 
740  typedef enum
741  {
746  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
748 
749 
754  typedef enum
755  {
784  _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
786 
787 
793  typedef enum
794  {
799  _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
801 
802 
808  typedef enum
809  {
810  OrthancPluginDicomToJsonFlags_None = 0,
818  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
820 
821 
827  typedef enum
828  {
829  OrthancPluginCreateDicomFlags_None = 0,
833  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
835 
836 
842  typedef enum
843  {
849  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
851 
852 
857  typedef enum
858  {
865  _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
867 
868 
872  typedef enum
873  {
880  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
882 
883 
887  typedef enum
888  {
893 
894 
901  typedef enum
902  {
908 
909 
913  typedef enum
914  {
924 
925 
930  typedef enum
931  {
936 
937 
943  typedef enum
944  {
972 
973 
974 
982  typedef struct
983  {
987  void* data;
988 
992  uint32_t size;
994 
995 
996 
997 
1002  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
1003 
1004 
1005 
1009  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
1010 
1011 
1012 
1017  typedef struct _OrthancPluginImage_t OrthancPluginImage;
1018 
1019 
1020 
1025  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
1026 
1027 
1028 
1033  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
1034 
1035 
1036 
1041  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
1042 
1043 
1044 
1049  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1050 
1051 
1052 
1057  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1058 
1059 
1060 
1065  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindMatcher;
1066 
1067 
1068 
1073  typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1074 
1075 
1076 
1081  typedef struct _OrthancPluginJob_t OrthancPluginJob;
1082 
1083 
1084 
1090  typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1091 
1092 
1093 
1099  OrthancPluginRestOutput* output,
1100  const char* url,
1101  const OrthancPluginHttpRequest* request);
1102 
1103 
1104 
1110  OrthancPluginDicomInstance* instance,
1111  const char* instanceId);
1112 
1113 
1114 
1120  OrthancPluginChangeType changeType,
1121  OrthancPluginResourceType resourceType,
1122  const char* resourceId);
1123 
1124 
1125 
1131  OrthancPluginImage** target,
1132  const void* dicom,
1133  const uint32_t size,
1134  uint32_t frameIndex);
1135 
1136 
1137 
1142  typedef void (*OrthancPluginFree) (void* buffer);
1143 
1144 
1145 
1152  typedef void (*OrthancPluginDicomWebSetBinaryNode) (
1155  const char* bulkDataUri);
1156 
1157 
1158 
1172  const char* uuid,
1173  const void* content,
1174  int64_t size,
1176 
1177 
1178 
1198  void** content,
1199  int64_t* size,
1200  const char* uuid,
1202 
1203 
1204 
1216  const char* uuid,
1218 
1219 
1220 
1236  const OrthancPluginWorklistQuery* query,
1237  const char* issuerAet,
1238  const char* calledAet);
1239 
1240 
1241 
1261  typedef int32_t (*OrthancPluginIncomingHttpRequestFilter) (
1262  OrthancPluginHttpMethod method,
1263  const char* uri,
1264  const char* ip,
1265  uint32_t headersCount,
1266  const char* const* headersKeys,
1267  const char* const* headersValues);
1268 
1269 
1270 
1292  typedef int32_t (*OrthancPluginIncomingHttpRequestFilter2) (
1293  OrthancPluginHttpMethod method,
1294  const char* uri,
1295  const char* ip,
1296  uint32_t headersCount,
1297  const char* const* headersKeys,
1298  const char* const* headersValues,
1299  uint32_t getArgumentsCount,
1300  const char* const* getArgumentsKeys,
1301  const char* const* getArgumentsValues);
1302 
1303 
1304 
1320  OrthancPluginFindAnswers* answers,
1321  const OrthancPluginFindQuery* query,
1322  const char* issuerAet,
1323  const char* calledAet);
1324 
1325 
1326 
1362  typedef void* (*OrthancPluginMoveCallback) (
1363  OrthancPluginResourceType resourceType,
1364  const char* patientId,
1365  const char* accessionNumber,
1366  const char* studyInstanceUid,
1367  const char* seriesInstanceUid,
1368  const char* sopInstanceUid,
1369  const char* originatorAet,
1370  const char* sourceAet,
1371  const char* targetAet,
1372  uint16_t originatorId);
1373 
1374 
1387  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1388 
1389 
1402  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1403 
1404 
1416  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1417 
1418 
1429  typedef void (*OrthancPluginJobFinalize) (void* job);
1430 
1431 
1442  typedef float (*OrthancPluginJobGetProgress) (void* job);
1443 
1444 
1457  typedef const char* (*OrthancPluginJobGetContent) (void* job);
1458 
1459 
1475  typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1476 
1477 
1490  typedef OrthancPluginJobStepStatus (*OrthancPluginJobStep) (void* job);
1491 
1492 
1514  typedef OrthancPluginErrorCode (*OrthancPluginJobStop) (void* job,
1516 
1517 
1531  typedef OrthancPluginErrorCode (*OrthancPluginJobReset) (void* job);
1532 
1533 
1547  typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1548  const char* serialized);
1549 
1550 
1551 
1565  typedef void (*OrthancPluginRefreshMetricsCallback) ();
1566 
1567 
1568 
1593  typedef void (*OrthancPluginDicomWebBinaryCallback) (
1596  uint32_t levelDepth,
1597  const uint16_t* levelTagGroup,
1598  const uint16_t* levelTagElement,
1599  const uint32_t* levelIndex,
1600  uint16_t tagGroup,
1601  uint16_t tagElement,
1603 
1604 
1605 
1609  typedef struct _OrthancPluginContext_t
1610  {
1611  void* pluginsManager;
1612  const char* orthancVersion;
1613  OrthancPluginFree Free;
1614  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1615  _OrthancPluginService service,
1616  const void* params);
1618 
1619 
1620 
1624  typedef struct
1625  {
1626  uint16_t group;
1627  uint16_t element;
1629  uint32_t minMultiplicity;
1630  uint32_t maxMultiplicity;
1632 
1633 
1634 
1643  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1644  OrthancPluginContext* context,
1645  char* str)
1646  {
1647  if (str != NULL)
1648  {
1649  context->Free(str);
1650  }
1651  }
1652 
1653 
1673  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1674  OrthancPluginContext* context,
1675  int expectedMajor,
1676  int expectedMinor,
1677  int expectedRevision)
1678  {
1679  int major, minor, revision;
1680 
1681  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1682  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1683  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1684  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1685  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1686  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1687  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1688  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1689  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1690  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1691  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1692  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1693  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1694  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1695  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1696  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1697  sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1698  sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
1699  sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
1700  sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
1701  sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason))
1702  {
1703  /* Mismatch in the size of the enumerations */
1704  return 0;
1705  }
1706 
1707  /* Assume compatibility with the mainline */
1708  if (!strcmp(context->orthancVersion, "mainline"))
1709  {
1710  return 1;
1711  }
1712 
1713  /* Parse the version of the Orthanc core */
1714  if (
1715 #ifdef _MSC_VER
1716  sscanf_s
1717 #else
1718  sscanf
1719 #endif
1720  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1721  {
1722  return 0;
1723  }
1724 
1725  /* Check the major number of the version */
1726 
1727  if (major > expectedMajor)
1728  {
1729  return 1;
1730  }
1731 
1732  if (major < expectedMajor)
1733  {
1734  return 0;
1735  }
1736 
1737  /* Check the minor number of the version */
1738 
1739  if (minor > expectedMinor)
1740  {
1741  return 1;
1742  }
1743 
1744  if (minor < expectedMinor)
1745  {
1746  return 0;
1747  }
1748 
1749  /* Check the revision number of the version */
1750 
1751  if (revision >= expectedRevision)
1752  {
1753  return 1;
1754  }
1755  else
1756  {
1757  return 0;
1758  }
1759  }
1760 
1761 
1778  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1779  OrthancPluginContext* context)
1780  {
1782  context,
1783  ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1784  ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1785  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1786  }
1787 
1788 
1797  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1798  OrthancPluginContext* context,
1799  OrthancPluginMemoryBuffer* buffer)
1800  {
1801  context->Free(buffer->data);
1802  }
1803 
1804 
1813  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1814  OrthancPluginContext* context,
1815  const char* message)
1816  {
1817  context->InvokeService(context, _OrthancPluginService_LogError, message);
1818  }
1819 
1820 
1829  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
1830  OrthancPluginContext* context,
1831  const char* message)
1832  {
1833  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1834  }
1835 
1836 
1845  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
1846  OrthancPluginContext* context,
1847  const char* message)
1848  {
1849  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
1850  }
1851 
1852 
1853 
1854  typedef struct
1855  {
1856  const char* pathRegularExpression;
1857  OrthancPluginRestCallback callback;
1858  } _OrthancPluginRestCallback;
1859 
1881  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
1882  OrthancPluginContext* context,
1883  const char* pathRegularExpression,
1884  OrthancPluginRestCallback callback)
1885  {
1886  _OrthancPluginRestCallback params;
1887  params.pathRegularExpression = pathRegularExpression;
1888  params.callback = callback;
1889  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
1890  }
1891 
1892 
1893 
1921  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
1922  OrthancPluginContext* context,
1923  const char* pathRegularExpression,
1924  OrthancPluginRestCallback callback)
1925  {
1926  _OrthancPluginRestCallback params;
1927  params.pathRegularExpression = pathRegularExpression;
1928  params.callback = callback;
1929  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
1930  }
1931 
1932 
1933 
1934  typedef struct
1935  {
1937  } _OrthancPluginOnStoredInstanceCallback;
1938 
1949  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnStoredInstanceCallback(
1950  OrthancPluginContext* context,
1952  {
1953  _OrthancPluginOnStoredInstanceCallback params;
1954  params.callback = callback;
1955 
1956  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
1957  }
1958 
1959 
1960 
1961  typedef struct
1962  {
1963  OrthancPluginRestOutput* output;
1964  const void* answer;
1965  uint32_t answerSize;
1966  const char* mimeType;
1967  } _OrthancPluginAnswerBuffer;
1968 
1981  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
1982  OrthancPluginContext* context,
1983  OrthancPluginRestOutput* output,
1984  const void* answer,
1985  uint32_t answerSize,
1986  const char* mimeType)
1987  {
1988  _OrthancPluginAnswerBuffer params;
1989  params.output = output;
1990  params.answer = answer;
1991  params.answerSize = answerSize;
1992  params.mimeType = mimeType;
1993  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
1994  }
1995 
1996 
1997  typedef struct
1998  {
1999  OrthancPluginRestOutput* output;
2000  OrthancPluginPixelFormat format;
2001  uint32_t width;
2002  uint32_t height;
2003  uint32_t pitch;
2004  const void* buffer;
2005  } _OrthancPluginCompressAndAnswerPngImage;
2006 
2007  typedef struct
2008  {
2009  OrthancPluginRestOutput* output;
2010  OrthancPluginImageFormat imageFormat;
2011  OrthancPluginPixelFormat pixelFormat;
2012  uint32_t width;
2013  uint32_t height;
2014  uint32_t pitch;
2015  const void* buffer;
2016  uint8_t quality;
2017  } _OrthancPluginCompressAndAnswerImage;
2018 
2019 
2038  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2039  OrthancPluginContext* context,
2040  OrthancPluginRestOutput* output,
2041  OrthancPluginPixelFormat format,
2042  uint32_t width,
2043  uint32_t height,
2044  uint32_t pitch,
2045  const void* buffer)
2046  {
2047  _OrthancPluginCompressAndAnswerImage params;
2048  params.output = output;
2049  params.imageFormat = OrthancPluginImageFormat_Png;
2050  params.pixelFormat = format;
2051  params.width = width;
2052  params.height = height;
2053  params.pitch = pitch;
2054  params.buffer = buffer;
2055  params.quality = 0; /* No quality for PNG */
2056  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2057  }
2058 
2059 
2060 
2061  typedef struct
2062  {
2063  OrthancPluginMemoryBuffer* target;
2064  const char* instanceId;
2065  } _OrthancPluginGetDicomForInstance;
2066 
2080  OrthancPluginContext* context,
2081  OrthancPluginMemoryBuffer* target,
2082  const char* instanceId)
2083  {
2084  _OrthancPluginGetDicomForInstance params;
2085  params.target = target;
2086  params.instanceId = instanceId;
2087  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2088  }
2089 
2090 
2091 
2092  typedef struct
2093  {
2094  OrthancPluginMemoryBuffer* target;
2095  const char* uri;
2096  } _OrthancPluginRestApiGet;
2097 
2112  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiGet(
2113  OrthancPluginContext* context,
2114  OrthancPluginMemoryBuffer* target,
2115  const char* uri)
2116  {
2117  _OrthancPluginRestApiGet params;
2118  params.target = target;
2119  params.uri = uri;
2120  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2121  }
2122 
2123 
2124 
2143  OrthancPluginContext* context,
2144  OrthancPluginMemoryBuffer* target,
2145  const char* uri)
2146  {
2147  _OrthancPluginRestApiGet params;
2148  params.target = target;
2149  params.uri = uri;
2150  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2151  }
2152 
2153 
2154 
2155  typedef struct
2156  {
2157  OrthancPluginMemoryBuffer* target;
2158  const char* uri;
2159  const void* body;
2160  uint32_t bodySize;
2161  } _OrthancPluginRestApiPostPut;
2162 
2179  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiPost(
2180  OrthancPluginContext* context,
2181  OrthancPluginMemoryBuffer* target,
2182  const char* uri,
2183  const void* body,
2184  uint32_t bodySize)
2185  {
2186  _OrthancPluginRestApiPostPut params;
2187  params.target = target;
2188  params.uri = uri;
2189  params.body = body;
2190  params.bodySize = bodySize;
2191  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2192  }
2193 
2194 
2215  OrthancPluginContext* context,
2216  OrthancPluginMemoryBuffer* target,
2217  const char* uri,
2218  const void* body,
2219  uint32_t bodySize)
2220  {
2221  _OrthancPluginRestApiPostPut params;
2222  params.target = target;
2223  params.uri = uri;
2224  params.body = body;
2225  params.bodySize = bodySize;
2226  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2227  }
2228 
2229 
2230 
2243  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiDelete(
2244  OrthancPluginContext* context,
2245  const char* uri)
2246  {
2247  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2248  }
2249 
2250 
2267  OrthancPluginContext* context,
2268  const char* uri)
2269  {
2270  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2271  }
2272 
2273 
2274 
2291  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiPut(
2292  OrthancPluginContext* context,
2293  OrthancPluginMemoryBuffer* target,
2294  const char* uri,
2295  const void* body,
2296  uint32_t bodySize)
2297  {
2298  _OrthancPluginRestApiPostPut params;
2299  params.target = target;
2300  params.uri = uri;
2301  params.body = body;
2302  params.bodySize = bodySize;
2303  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2304  }
2305 
2306 
2307 
2328  OrthancPluginContext* context,
2329  OrthancPluginMemoryBuffer* target,
2330  const char* uri,
2331  const void* body,
2332  uint32_t bodySize)
2333  {
2334  _OrthancPluginRestApiPostPut params;
2335  params.target = target;
2336  params.uri = uri;
2337  params.body = body;
2338  params.bodySize = bodySize;
2339  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2340  }
2341 
2342 
2343 
2344  typedef struct
2345  {
2346  OrthancPluginRestOutput* output;
2347  const char* argument;
2348  } _OrthancPluginOutputPlusArgument;
2349 
2361  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2362  OrthancPluginContext* context,
2363  OrthancPluginRestOutput* output,
2364  const char* redirection)
2365  {
2366  _OrthancPluginOutputPlusArgument params;
2367  params.output = output;
2368  params.argument = redirection;
2369  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2370  }
2371 
2372 
2373 
2374  typedef struct
2375  {
2376  char** result;
2377  const char* argument;
2378  } _OrthancPluginRetrieveDynamicString;
2379 
2393  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2394  OrthancPluginContext* context,
2395  const char* patientID)
2396  {
2397  char* result;
2398 
2399  _OrthancPluginRetrieveDynamicString params;
2400  params.result = &result;
2401  params.argument = patientID;
2402 
2403  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2404  {
2405  /* Error */
2406  return NULL;
2407  }
2408  else
2409  {
2410  return result;
2411  }
2412  }
2413 
2414 
2428  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2429  OrthancPluginContext* context,
2430  const char* studyUID)
2431  {
2432  char* result;
2433 
2434  _OrthancPluginRetrieveDynamicString params;
2435  params.result = &result;
2436  params.argument = studyUID;
2437 
2438  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2439  {
2440  /* Error */
2441  return NULL;
2442  }
2443  else
2444  {
2445  return result;
2446  }
2447  }
2448 
2449 
2463  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
2464  OrthancPluginContext* context,
2465  const char* accessionNumber)
2466  {
2467  char* result;
2468 
2469  _OrthancPluginRetrieveDynamicString params;
2470  params.result = &result;
2471  params.argument = accessionNumber;
2472 
2473  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2474  {
2475  /* Error */
2476  return NULL;
2477  }
2478  else
2479  {
2480  return result;
2481  }
2482  }
2483 
2484 
2498  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2499  OrthancPluginContext* context,
2500  const char* seriesUID)
2501  {
2502  char* result;
2503 
2504  _OrthancPluginRetrieveDynamicString params;
2505  params.result = &result;
2506  params.argument = seriesUID;
2507 
2508  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2509  {
2510  /* Error */
2511  return NULL;
2512  }
2513  else
2514  {
2515  return result;
2516  }
2517  }
2518 
2519 
2533  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2534  OrthancPluginContext* context,
2535  const char* sopInstanceUID)
2536  {
2537  char* result;
2538 
2539  _OrthancPluginRetrieveDynamicString params;
2540  params.result = &result;
2541  params.argument = sopInstanceUID;
2542 
2543  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2544  {
2545  /* Error */
2546  return NULL;
2547  }
2548  else
2549  {
2550  return result;
2551  }
2552  }
2553 
2554 
2555 
2556  typedef struct
2557  {
2558  OrthancPluginRestOutput* output;
2559  uint16_t status;
2560  } _OrthancPluginSendHttpStatusCode;
2561 
2578  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2579  OrthancPluginContext* context,
2580  OrthancPluginRestOutput* output,
2581  uint16_t status)
2582  {
2583  _OrthancPluginSendHttpStatusCode params;
2584  params.output = output;
2585  params.status = status;
2586  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2587  }
2588 
2589 
2601  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2602  OrthancPluginContext* context,
2603  OrthancPluginRestOutput* output,
2604  const char* realm)
2605  {
2606  _OrthancPluginOutputPlusArgument params;
2607  params.output = output;
2608  params.argument = realm;
2609  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2610  }
2611 
2612 
2624  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2625  OrthancPluginContext* context,
2626  OrthancPluginRestOutput* output,
2627  const char* allowedMethods)
2628  {
2629  _OrthancPluginOutputPlusArgument params;
2630  params.output = output;
2631  params.argument = allowedMethods;
2632  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2633  }
2634 
2635 
2636  typedef struct
2637  {
2638  OrthancPluginRestOutput* output;
2639  const char* key;
2640  const char* value;
2641  } _OrthancPluginSetHttpHeader;
2642 
2654  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2655  OrthancPluginContext* context,
2656  OrthancPluginRestOutput* output,
2657  const char* cookie,
2658  const char* value)
2659  {
2660  _OrthancPluginSetHttpHeader params;
2661  params.output = output;
2662  params.key = cookie;
2663  params.value = value;
2664  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2665  }
2666 
2667 
2679  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2680  OrthancPluginContext* context,
2681  OrthancPluginRestOutput* output,
2682  const char* key,
2683  const char* value)
2684  {
2685  _OrthancPluginSetHttpHeader params;
2686  params.output = output;
2687  params.key = key;
2688  params.value = value;
2689  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2690  }
2691 
2692 
2693  typedef struct
2694  {
2695  char** resultStringToFree;
2696  const char** resultString;
2697  int64_t* resultInt64;
2698  const char* key;
2699  OrthancPluginDicomInstance* instance;
2700  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2701  } _OrthancPluginAccessDicomInstance;
2702 
2703 
2715  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2716  OrthancPluginContext* context,
2717  OrthancPluginDicomInstance* instance)
2718  {
2719  const char* result;
2720 
2721  _OrthancPluginAccessDicomInstance params;
2722  memset(&params, 0, sizeof(params));
2723  params.resultString = &result;
2724  params.instance = instance;
2725 
2726  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2727  {
2728  /* Error */
2729  return NULL;
2730  }
2731  else
2732  {
2733  return result;
2734  }
2735  }
2736 
2737 
2748  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2749  OrthancPluginContext* context,
2750  OrthancPluginDicomInstance* instance)
2751  {
2752  int64_t size;
2753 
2754  _OrthancPluginAccessDicomInstance params;
2755  memset(&params, 0, sizeof(params));
2756  params.resultInt64 = &size;
2757  params.instance = instance;
2758 
2759  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2760  {
2761  /* Error */
2762  return -1;
2763  }
2764  else
2765  {
2766  return size;
2767  }
2768  }
2769 
2770 
2781  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceData(
2782  OrthancPluginContext* context,
2783  OrthancPluginDicomInstance* instance)
2784  {
2785  const char* result;
2786 
2787  _OrthancPluginAccessDicomInstance params;
2788  memset(&params, 0, sizeof(params));
2789  params.resultString = &result;
2790  params.instance = instance;
2791 
2792  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2793  {
2794  /* Error */
2795  return NULL;
2796  }
2797  else
2798  {
2799  return result;
2800  }
2801  }
2802 
2803 
2817  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
2818  OrthancPluginContext* context,
2819  OrthancPluginDicomInstance* instance)
2820  {
2821  char* result;
2822 
2823  _OrthancPluginAccessDicomInstance params;
2824  memset(&params, 0, sizeof(params));
2825  params.resultStringToFree = &result;
2826  params.instance = instance;
2827 
2828  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
2829  {
2830  /* Error */
2831  return NULL;
2832  }
2833  else
2834  {
2835  return result;
2836  }
2837  }
2838 
2839 
2855  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
2856  OrthancPluginContext* context,
2857  OrthancPluginDicomInstance* instance)
2858  {
2859  char* result;
2860 
2861  _OrthancPluginAccessDicomInstance params;
2862  memset(&params, 0, sizeof(params));
2863  params.resultStringToFree = &result;
2864  params.instance = instance;
2865 
2866  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
2867  {
2868  /* Error */
2869  return NULL;
2870  }
2871  else
2872  {
2873  return result;
2874  }
2875  }
2876 
2877 
2894  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
2895  OrthancPluginContext* context,
2896  OrthancPluginDicomInstance* instance,
2897  const char* metadata)
2898  {
2899  int64_t result;
2900 
2901  _OrthancPluginAccessDicomInstance params;
2902  memset(&params, 0, sizeof(params));
2903  params.resultInt64 = &result;
2904  params.instance = instance;
2905  params.key = metadata;
2906 
2907  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2908  {
2909  /* Error */
2910  return -1;
2911  }
2912  else
2913  {
2914  return (result != 0);
2915  }
2916  }
2917 
2918 
2935  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
2936  OrthancPluginContext* context,
2937  OrthancPluginDicomInstance* instance,
2938  const char* metadata)
2939  {
2940  const char* result;
2941 
2942  _OrthancPluginAccessDicomInstance params;
2943  memset(&params, 0, sizeof(params));
2944  params.resultString = &result;
2945  params.instance = instance;
2946  params.key = metadata;
2947 
2948  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2949  {
2950  /* Error */
2951  return NULL;
2952  }
2953  else
2954  {
2955  return result;
2956  }
2957  }
2958 
2959 
2960 
2961  typedef struct
2962  {
2966  OrthancPluginFree free;
2967  } _OrthancPluginRegisterStorageArea;
2968 
2983  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
2984  OrthancPluginContext* context,
2988  {
2989  _OrthancPluginRegisterStorageArea params;
2990  params.create = create;
2991  params.read = read;
2992  params.remove = remove;
2993 
2994 #ifdef __cplusplus
2995  params.free = ::free;
2996 #else
2997  params.free = free;
2998 #endif
2999 
3000  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3001  }
3002 
3003 
3004 
3015  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3016  {
3017  char* result;
3018 
3019  _OrthancPluginRetrieveDynamicString params;
3020  params.result = &result;
3021  params.argument = NULL;
3022 
3023  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3024  {
3025  /* Error */
3026  return NULL;
3027  }
3028  else
3029  {
3030  return result;
3031  }
3032  }
3033 
3034 
3045  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3046  {
3047  char* result;
3048 
3049  _OrthancPluginRetrieveDynamicString params;
3050  params.result = &result;
3051  params.argument = NULL;
3052 
3053  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3054  {
3055  /* Error */
3056  return NULL;
3057  }
3058  else
3059  {
3060  return result;
3061  }
3062  }
3063 
3064 
3080  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3081  {
3082  char* result;
3083 
3084  _OrthancPluginRetrieveDynamicString params;
3085  params.result = &result;
3086  params.argument = NULL;
3087 
3088  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3089  {
3090  /* Error */
3091  return NULL;
3092  }
3093  else
3094  {
3095  return result;
3096  }
3097  }
3098 
3099 
3100 
3101  typedef struct
3102  {
3104  } _OrthancPluginOnChangeCallback;
3105 
3122  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3123  OrthancPluginContext* context,
3125  {
3126  _OrthancPluginOnChangeCallback params;
3127  params.callback = callback;
3128 
3129  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3130  }
3131 
3132 
3133 
3134  typedef struct
3135  {
3136  const char* plugin;
3137  _OrthancPluginProperty property;
3138  const char* value;
3139  } _OrthancPluginSetPluginProperty;
3140 
3141 
3153  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3154  OrthancPluginContext* context,
3155  const char* uri)
3156  {
3157  _OrthancPluginSetPluginProperty params;
3158  params.plugin = OrthancPluginGetName();
3159  params.property = _OrthancPluginProperty_RootUri;
3160  params.value = uri;
3161 
3162  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3163  }
3164 
3165 
3175  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3176  OrthancPluginContext* context,
3177  const char* description)
3178  {
3179  _OrthancPluginSetPluginProperty params;
3180  params.plugin = OrthancPluginGetName();
3181  params.property = _OrthancPluginProperty_Description;
3182  params.value = description;
3183 
3184  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3185  }
3186 
3187 
3197  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3198  OrthancPluginContext* context,
3199  const char* javascript)
3200  {
3201  _OrthancPluginSetPluginProperty params;
3202  params.plugin = OrthancPluginGetName();
3203  params.property = _OrthancPluginProperty_OrthancExplorer;
3204  params.value = javascript;
3205 
3206  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3207  }
3208 
3209 
3210  typedef struct
3211  {
3212  char** result;
3213  int32_t property;
3214  const char* value;
3215  } _OrthancPluginGlobalProperty;
3216 
3217 
3231  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3232  OrthancPluginContext* context,
3233  int32_t property,
3234  const char* defaultValue)
3235  {
3236  char* result;
3237 
3238  _OrthancPluginGlobalProperty params;
3239  params.result = &result;
3240  params.property = property;
3241  params.value = defaultValue;
3242 
3243  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3244  {
3245  /* Error */
3246  return NULL;
3247  }
3248  else
3249  {
3250  return result;
3251  }
3252  }
3253 
3254 
3271  OrthancPluginContext* context,
3272  int32_t property,
3273  const char* value)
3274  {
3275  _OrthancPluginGlobalProperty params;
3276  params.result = NULL;
3277  params.property = property;
3278  params.value = value;
3279 
3280  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3281  }
3282 
3283 
3284 
3285  typedef struct
3286  {
3287  int32_t *resultInt32;
3288  uint32_t *resultUint32;
3289  int64_t *resultInt64;
3290  uint64_t *resultUint64;
3291  } _OrthancPluginReturnSingleValue;
3292 
3301  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3302  OrthancPluginContext* context)
3303  {
3304  uint32_t count = 0;
3305 
3306  _OrthancPluginReturnSingleValue params;
3307  memset(&params, 0, sizeof(params));
3308  params.resultUint32 = &count;
3309 
3310  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3311  {
3312  /* Error */
3313  return 0;
3314  }
3315  else
3316  {
3317  return count;
3318  }
3319  }
3320 
3321 
3322 
3335  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3336  OrthancPluginContext* context,
3337  uint32_t argument)
3338  {
3339  char* result;
3340 
3341  _OrthancPluginGlobalProperty params;
3342  params.result = &result;
3343  params.property = (int32_t) argument;
3344  params.value = NULL;
3345 
3346  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3347  {
3348  /* Error */
3349  return NULL;
3350  }
3351  else
3352  {
3353  return result;
3354  }
3355  }
3356 
3357 
3367  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3368  OrthancPluginContext* context)
3369  {
3370  uint32_t count = 0;
3371 
3372  _OrthancPluginReturnSingleValue params;
3373  memset(&params, 0, sizeof(params));
3374  params.resultUint32 = &count;
3375 
3376  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3377  {
3378  /* Error */
3379  return 0;
3380  }
3381  else
3382  {
3383  return count;
3384  }
3385  }
3386 
3387 
3388 
3400  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3401  {
3402  char* result;
3403 
3404  _OrthancPluginRetrieveDynamicString params;
3405  params.result = &result;
3406  params.argument = NULL;
3407 
3408  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3409  {
3410  /* Error */
3411  return NULL;
3412  }
3413  else
3414  {
3415  return result;
3416  }
3417  }
3418 
3419 
3420 
3421  typedef struct
3422  {
3423  OrthancPluginRestOutput* output;
3424  const char* subType;
3425  const char* contentType;
3426  } _OrthancPluginStartMultipartAnswer;
3427 
3442  OrthancPluginContext* context,
3443  OrthancPluginRestOutput* output,
3444  const char* subType,
3445  const char* contentType)
3446  {
3447  _OrthancPluginStartMultipartAnswer params;
3448  params.output = output;
3449  params.subType = subType;
3450  params.contentType = contentType;
3451  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3452  }
3453 
3454 
3471  OrthancPluginContext* context,
3472  OrthancPluginRestOutput* output,
3473  const char* answer,
3474  uint32_t answerSize)
3475  {
3476  _OrthancPluginAnswerBuffer params;
3477  params.output = output;
3478  params.answer = answer;
3479  params.answerSize = answerSize;
3480  params.mimeType = NULL;
3481  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3482  }
3483 
3484 
3485 
3486  typedef struct
3487  {
3488  OrthancPluginMemoryBuffer* target;
3489  const void* source;
3490  uint32_t size;
3491  OrthancPluginCompressionType compression;
3492  uint8_t uncompress;
3493  } _OrthancPluginBufferCompression;
3494 
3495 
3513  OrthancPluginContext* context,
3514  OrthancPluginMemoryBuffer* target,
3515  const void* source,
3516  uint32_t size,
3517  OrthancPluginCompressionType compression,
3518  uint8_t uncompress)
3519  {
3520  _OrthancPluginBufferCompression params;
3521  params.target = target;
3522  params.source = source;
3523  params.size = size;
3524  params.compression = compression;
3525  params.uncompress = uncompress;
3526 
3527  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3528  }
3529 
3530 
3531 
3532  typedef struct
3533  {
3534  OrthancPluginMemoryBuffer* target;
3535  const char* path;
3536  } _OrthancPluginReadFile;
3537 
3549  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginReadFile(
3550  OrthancPluginContext* context,
3551  OrthancPluginMemoryBuffer* target,
3552  const char* path)
3553  {
3554  _OrthancPluginReadFile params;
3555  params.target = target;
3556  params.path = path;
3557  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3558  }
3559 
3560 
3561 
3562  typedef struct
3563  {
3564  const char* path;
3565  const void* data;
3566  uint32_t size;
3567  } _OrthancPluginWriteFile;
3568 
3580  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginWriteFile(
3581  OrthancPluginContext* context,
3582  const char* path,
3583  const void* data,
3584  uint32_t size)
3585  {
3586  _OrthancPluginWriteFile params;
3587  params.path = path;
3588  params.data = data;
3589  params.size = size;
3590  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3591  }
3592 
3593 
3594 
3595  typedef struct
3596  {
3597  const char** target;
3598  OrthancPluginErrorCode error;
3599  } _OrthancPluginGetErrorDescription;
3600 
3611  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3612  OrthancPluginContext* context,
3613  OrthancPluginErrorCode error)
3614  {
3615  const char* result = NULL;
3616 
3617  _OrthancPluginGetErrorDescription params;
3618  params.target = &result;
3619  params.error = error;
3620 
3621  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3622  result == NULL)
3623  {
3624  return "Unknown error code";
3625  }
3626  else
3627  {
3628  return result;
3629  }
3630  }
3631 
3632 
3633 
3634  typedef struct
3635  {
3636  OrthancPluginRestOutput* output;
3637  uint16_t status;
3638  const char* body;
3639  uint32_t bodySize;
3640  } _OrthancPluginSendHttpStatus;
3641 
3664  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3665  OrthancPluginContext* context,
3666  OrthancPluginRestOutput* output,
3667  uint16_t status,
3668  const char* body,
3669  uint32_t bodySize)
3670  {
3671  _OrthancPluginSendHttpStatus params;
3672  params.output = output;
3673  params.status = status;
3674  params.body = body;
3675  params.bodySize = bodySize;
3676  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3677  }
3678 
3679 
3680 
3681  typedef struct
3682  {
3683  const OrthancPluginImage* image;
3684  uint32_t* resultUint32;
3685  OrthancPluginPixelFormat* resultPixelFormat;
3686  void** resultBuffer;
3687  } _OrthancPluginGetImageInfo;
3688 
3689 
3701  OrthancPluginContext* context,
3702  const OrthancPluginImage* image)
3703  {
3704  OrthancPluginPixelFormat target;
3705 
3706  _OrthancPluginGetImageInfo params;
3707  memset(&params, 0, sizeof(params));
3708  params.image = image;
3709  params.resultPixelFormat = &target;
3710 
3711  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3712  {
3714  }
3715  else
3716  {
3717  return (OrthancPluginPixelFormat) target;
3718  }
3719  }
3720 
3721 
3722 
3733  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3734  OrthancPluginContext* context,
3735  const OrthancPluginImage* image)
3736  {
3737  uint32_t width;
3738 
3739  _OrthancPluginGetImageInfo params;
3740  memset(&params, 0, sizeof(params));
3741  params.image = image;
3742  params.resultUint32 = &width;
3743 
3744  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3745  {
3746  return 0;
3747  }
3748  else
3749  {
3750  return width;
3751  }
3752  }
3753 
3754 
3755 
3766  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3767  OrthancPluginContext* context,
3768  const OrthancPluginImage* image)
3769  {
3770  uint32_t height;
3771 
3772  _OrthancPluginGetImageInfo params;
3773  memset(&params, 0, sizeof(params));
3774  params.image = image;
3775  params.resultUint32 = &height;
3776 
3777  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3778  {
3779  return 0;
3780  }
3781  else
3782  {
3783  return height;
3784  }
3785  }
3786 
3787 
3788 
3801  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3802  OrthancPluginContext* context,
3803  const OrthancPluginImage* image)
3804  {
3805  uint32_t pitch;
3806 
3807  _OrthancPluginGetImageInfo params;
3808  memset(&params, 0, sizeof(params));
3809  params.image = image;
3810  params.resultUint32 = &pitch;
3811 
3812  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
3813  {
3814  return 0;
3815  }
3816  else
3817  {
3818  return pitch;
3819  }
3820  }
3821 
3822 
3823 
3835  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
3836  OrthancPluginContext* context,
3837  const OrthancPluginImage* image)
3838  {
3839  void* target = NULL;
3840 
3841  _OrthancPluginGetImageInfo params;
3842  memset(&params, 0, sizeof(params));
3843  params.resultBuffer = &target;
3844  params.image = image;
3845 
3846  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
3847  {
3848  return NULL;
3849  }
3850  else
3851  {
3852  return target;
3853  }
3854  }
3855 
3856 
3857  typedef struct
3858  {
3859  OrthancPluginImage** target;
3860  const void* data;
3861  uint32_t size;
3862  OrthancPluginImageFormat format;
3863  } _OrthancPluginUncompressImage;
3864 
3865 
3878  ORTHANC_PLUGIN_INLINE OrthancPluginImage *OrthancPluginUncompressImage(
3879  OrthancPluginContext* context,
3880  const void* data,
3881  uint32_t size,
3882  OrthancPluginImageFormat format)
3883  {
3884  OrthancPluginImage* target = NULL;
3885 
3886  _OrthancPluginUncompressImage params;
3887  memset(&params, 0, sizeof(params));
3888  params.target = &target;
3889  params.data = data;
3890  params.size = size;
3891  params.format = format;
3892 
3893  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
3894  {
3895  return NULL;
3896  }
3897  else
3898  {
3899  return target;
3900  }
3901  }
3902 
3903 
3904 
3905 
3906  typedef struct
3907  {
3908  OrthancPluginImage* image;
3909  } _OrthancPluginFreeImage;
3910 
3920  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
3921  OrthancPluginContext* context,
3922  OrthancPluginImage* image)
3923  {
3924  _OrthancPluginFreeImage params;
3925  params.image = image;
3926 
3927  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
3928  }
3929 
3930 
3931 
3932 
3933  typedef struct
3934  {
3935  OrthancPluginMemoryBuffer* target;
3936  OrthancPluginImageFormat imageFormat;
3937  OrthancPluginPixelFormat pixelFormat;
3938  uint32_t width;
3939  uint32_t height;
3940  uint32_t pitch;
3941  const void* buffer;
3942  uint8_t quality;
3943  } _OrthancPluginCompressImage;
3944 
3945 
3966  OrthancPluginContext* context,
3967  OrthancPluginMemoryBuffer* target,
3968  OrthancPluginPixelFormat format,
3969  uint32_t width,
3970  uint32_t height,
3971  uint32_t pitch,
3972  const void* buffer)
3973  {
3974  _OrthancPluginCompressImage params;
3975  memset(&params, 0, sizeof(params));
3976  params.target = target;
3977  params.imageFormat = OrthancPluginImageFormat_Png;
3978  params.pixelFormat = format;
3979  params.width = width;
3980  params.height = height;
3981  params.pitch = pitch;
3982  params.buffer = buffer;
3983  params.quality = 0; /* Unused for PNG */
3984 
3985  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3986  }
3987 
3988 
4011  OrthancPluginContext* context,
4012  OrthancPluginMemoryBuffer* target,
4013  OrthancPluginPixelFormat format,
4014  uint32_t width,
4015  uint32_t height,
4016  uint32_t pitch,
4017  const void* buffer,
4018  uint8_t quality)
4019  {
4020  _OrthancPluginCompressImage params;
4021  memset(&params, 0, sizeof(params));
4022  params.target = target;
4023  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4024  params.pixelFormat = format;
4025  params.width = width;
4026  params.height = height;
4027  params.pitch = pitch;
4028  params.buffer = buffer;
4029  params.quality = quality;
4030 
4031  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4032  }
4033 
4034 
4035 
4057  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
4058  OrthancPluginContext* context,
4059  OrthancPluginRestOutput* output,
4060  OrthancPluginPixelFormat format,
4061  uint32_t width,
4062  uint32_t height,
4063  uint32_t pitch,
4064  const void* buffer,
4065  uint8_t quality)
4066  {
4067  _OrthancPluginCompressAndAnswerImage params;
4068  params.output = output;
4069  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4070  params.pixelFormat = format;
4071  params.width = width;
4072  params.height = height;
4073  params.pitch = pitch;
4074  params.buffer = buffer;
4075  params.quality = quality;
4076  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4077  }
4078 
4079 
4080 
4081 
4082  typedef struct
4083  {
4084  OrthancPluginMemoryBuffer* target;
4085  OrthancPluginHttpMethod method;
4086  const char* url;
4087  const char* username;
4088  const char* password;
4089  const void* body;
4090  uint32_t bodySize;
4091  } _OrthancPluginCallHttpClient;
4092 
4093 
4110  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginHttpGet(
4111  OrthancPluginContext* context,
4112  OrthancPluginMemoryBuffer* target,
4113  const char* url,
4114  const char* username,
4115  const char* password)
4116  {
4117  _OrthancPluginCallHttpClient params;
4118  memset(&params, 0, sizeof(params));
4119 
4120  params.target = target;
4121  params.method = OrthancPluginHttpMethod_Get;
4122  params.url = url;
4123  params.username = username;
4124  params.password = password;
4125 
4126  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4127  }
4128 
4129 
4148  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginHttpPost(
4149  OrthancPluginContext* context,
4150  OrthancPluginMemoryBuffer* target,
4151  const char* url,
4152  const void* body,
4153  uint32_t bodySize,
4154  const char* username,
4155  const char* password)
4156  {
4157  _OrthancPluginCallHttpClient params;
4158  memset(&params, 0, sizeof(params));
4159 
4160  params.target = target;
4161  params.method = OrthancPluginHttpMethod_Post;
4162  params.url = url;
4163  params.body = body;
4164  params.bodySize = bodySize;
4165  params.username = username;
4166  params.password = password;
4167 
4168  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4169  }
4170 
4171 
4190  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginHttpPut(
4191  OrthancPluginContext* context,
4192  OrthancPluginMemoryBuffer* target,
4193  const char* url,
4194  const void* body,
4195  uint32_t bodySize,
4196  const char* username,
4197  const char* password)
4198  {
4199  _OrthancPluginCallHttpClient params;
4200  memset(&params, 0, sizeof(params));
4201 
4202  params.target = target;
4203  params.method = OrthancPluginHttpMethod_Put;
4204  params.url = url;
4205  params.body = body;
4206  params.bodySize = bodySize;
4207  params.username = username;
4208  params.password = password;
4209 
4210  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4211  }
4212 
4213 
4228  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginHttpDelete(
4229  OrthancPluginContext* context,
4230  const char* url,
4231  const char* username,
4232  const char* password)
4233  {
4234  _OrthancPluginCallHttpClient params;
4235  memset(&params, 0, sizeof(params));
4236 
4237  params.method = OrthancPluginHttpMethod_Delete;
4238  params.url = url;
4239  params.username = username;
4240  params.password = password;
4241 
4242  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4243  }
4244 
4245 
4246 
4247  typedef struct
4248  {
4249  OrthancPluginImage** target;
4250  const OrthancPluginImage* source;
4251  OrthancPluginPixelFormat targetFormat;
4252  } _OrthancPluginConvertPixelFormat;
4253 
4254 
4266  ORTHANC_PLUGIN_INLINE OrthancPluginImage *OrthancPluginConvertPixelFormat(
4267  OrthancPluginContext* context,
4268  const OrthancPluginImage* source,
4269  OrthancPluginPixelFormat targetFormat)
4270  {
4271  OrthancPluginImage* target = NULL;
4272 
4273  _OrthancPluginConvertPixelFormat params;
4274  params.target = &target;
4275  params.source = source;
4276  params.targetFormat = targetFormat;
4277 
4278  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4279  {
4280  return NULL;
4281  }
4282  else
4283  {
4284  return target;
4285  }
4286  }
4287 
4288 
4289 
4301  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4302  OrthancPluginContext* context)
4303  {
4304  uint32_t count = 0;
4305 
4306  _OrthancPluginReturnSingleValue params;
4307  memset(&params, 0, sizeof(params));
4308  params.resultUint32 = &count;
4309 
4310  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4311  {
4312  /* Error */
4313  return 0;
4314  }
4315  else
4316  {
4317  return count;
4318  }
4319  }
4320 
4321 
4322 
4323 
4324  typedef struct
4325  {
4326  uint32_t fontIndex; /* in */
4327  const char** name; /* out */
4328  uint32_t* size; /* out */
4329  } _OrthancPluginGetFontInfo;
4330 
4341  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4342  OrthancPluginContext* context,
4343  uint32_t fontIndex)
4344  {
4345  const char* result = NULL;
4346 
4347  _OrthancPluginGetFontInfo params;
4348  memset(&params, 0, sizeof(params));
4349  params.name = &result;
4350  params.fontIndex = fontIndex;
4351 
4352  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4353  {
4354  return NULL;
4355  }
4356  else
4357  {
4358  return result;
4359  }
4360  }
4361 
4362 
4373  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4374  OrthancPluginContext* context,
4375  uint32_t fontIndex)
4376  {
4377  uint32_t result;
4378 
4379  _OrthancPluginGetFontInfo params;
4380  memset(&params, 0, sizeof(params));
4381  params.size = &result;
4382  params.fontIndex = fontIndex;
4383 
4384  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4385  {
4386  return 0;
4387  }
4388  else
4389  {
4390  return result;
4391  }
4392  }
4393 
4394 
4395 
4396  typedef struct
4397  {
4398  OrthancPluginImage* image;
4399  uint32_t fontIndex;
4400  const char* utf8Text;
4401  int32_t x;
4402  int32_t y;
4403  uint8_t r;
4404  uint8_t g;
4405  uint8_t b;
4406  } _OrthancPluginDrawText;
4407 
4408 
4426  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginDrawText(
4427  OrthancPluginContext* context,
4428  OrthancPluginImage* image,
4429  uint32_t fontIndex,
4430  const char* utf8Text,
4431  int32_t x,
4432  int32_t y,
4433  uint8_t r,
4434  uint8_t g,
4435  uint8_t b)
4436  {
4437  _OrthancPluginDrawText params;
4438  memset(&params, 0, sizeof(params));
4439  params.image = image;
4440  params.fontIndex = fontIndex;
4441  params.utf8Text = utf8Text;
4442  params.x = x;
4443  params.y = y;
4444  params.r = r;
4445  params.g = g;
4446  params.b = b;
4447 
4448  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4449  }
4450 
4451 
4452 
4453  typedef struct
4454  {
4455  OrthancPluginStorageArea* storageArea;
4456  const char* uuid;
4457  const void* content;
4458  uint64_t size;
4460  } _OrthancPluginStorageAreaCreate;
4461 
4462 
4479  OrthancPluginContext* context,
4480  OrthancPluginStorageArea* storageArea,
4481  const char* uuid,
4482  const void* content,
4483  uint64_t size,
4485  {
4486  _OrthancPluginStorageAreaCreate params;
4487  params.storageArea = storageArea;
4488  params.uuid = uuid;
4489  params.content = content;
4490  params.size = size;
4491  params.type = type;
4492 
4493  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4494  }
4495 
4496 
4497  typedef struct
4498  {
4499  OrthancPluginMemoryBuffer* target;
4500  OrthancPluginStorageArea* storageArea;
4501  const char* uuid;
4503  } _OrthancPluginStorageAreaRead;
4504 
4505 
4521  OrthancPluginContext* context,
4522  OrthancPluginMemoryBuffer* target,
4523  OrthancPluginStorageArea* storageArea,
4524  const char* uuid,
4526  {
4527  _OrthancPluginStorageAreaRead params;
4528  params.target = target;
4529  params.storageArea = storageArea;
4530  params.uuid = uuid;
4531  params.type = type;
4532 
4533  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4534  }
4535 
4536 
4537  typedef struct
4538  {
4539  OrthancPluginStorageArea* storageArea;
4540  const char* uuid;
4542  } _OrthancPluginStorageAreaRemove;
4543 
4558  OrthancPluginContext* context,
4559  OrthancPluginStorageArea* storageArea,
4560  const char* uuid,
4562  {
4563  _OrthancPluginStorageAreaRemove params;
4564  params.storageArea = storageArea;
4565  params.uuid = uuid;
4566  params.type = type;
4567 
4568  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4569  }
4570 
4571 
4572 
4573  typedef struct
4574  {
4575  OrthancPluginErrorCode* target;
4576  int32_t code;
4577  uint16_t httpStatus;
4578  const char* message;
4579  } _OrthancPluginRegisterErrorCode;
4580 
4597  OrthancPluginContext* context,
4598  int32_t code,
4599  uint16_t httpStatus,
4600  const char* message)
4601  {
4602  OrthancPluginErrorCode target;
4603 
4604  _OrthancPluginRegisterErrorCode params;
4605  params.target = &target;
4606  params.code = code;
4607  params.httpStatus = httpStatus;
4608  params.message = message;
4609 
4610  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4611  {
4612  return target;
4613  }
4614  else
4615  {
4616  /* There was an error while assigned the error. Use a generic code. */
4618  }
4619  }
4620 
4621 
4622 
4623  typedef struct
4624  {
4625  uint16_t group;
4626  uint16_t element;
4628  const char* name;
4629  uint32_t minMultiplicity;
4630  uint32_t maxMultiplicity;
4631  } _OrthancPluginRegisterDictionaryTag;
4632 
4653  OrthancPluginContext* context,
4654  uint16_t group,
4655  uint16_t element,
4657  const char* name,
4658  uint32_t minMultiplicity,
4659  uint32_t maxMultiplicity)
4660  {
4661  _OrthancPluginRegisterDictionaryTag params;
4662  params.group = group;
4663  params.element = element;
4664  params.vr = vr;
4665  params.name = name;
4666  params.minMultiplicity = minMultiplicity;
4667  params.maxMultiplicity = maxMultiplicity;
4668 
4669  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4670  }
4671 
4672 
4673 
4674  typedef struct
4675  {
4676  uint16_t group;
4677  uint16_t element;
4679  const char* name;
4680  uint32_t minMultiplicity;
4681  uint32_t maxMultiplicity;
4682  const char* privateCreator;
4683  } _OrthancPluginRegisterPrivateDictionaryTag;
4684 
4706  OrthancPluginContext* context,
4707  uint16_t group,
4708  uint16_t element,
4710  const char* name,
4711  uint32_t minMultiplicity,
4712  uint32_t maxMultiplicity,
4713  const char* privateCreator)
4714  {
4715  _OrthancPluginRegisterPrivateDictionaryTag params;
4716  params.group = group;
4717  params.element = element;
4718  params.vr = vr;
4719  params.name = name;
4720  params.minMultiplicity = minMultiplicity;
4721  params.maxMultiplicity = maxMultiplicity;
4722  params.privateCreator = privateCreator;
4723 
4724  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4725  }
4726 
4727 
4728 
4729  typedef struct
4730  {
4731  OrthancPluginStorageArea* storageArea;
4733  } _OrthancPluginReconstructMainDicomTags;
4734 
4750  OrthancPluginContext* context,
4751  OrthancPluginStorageArea* storageArea,
4753  {
4754  _OrthancPluginReconstructMainDicomTags params;
4755  params.level = level;
4756  params.storageArea = storageArea;
4757 
4758  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
4759  }
4760 
4761 
4762  typedef struct
4763  {
4764  char** result;
4765  const char* instanceId;
4766  const void* buffer;
4767  uint32_t size;
4770  uint32_t maxStringLength;
4771  } _OrthancPluginDicomToJson;
4772 
4773 
4793  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4794  OrthancPluginContext* context,
4795  const void* buffer,
4796  uint32_t size,
4799  uint32_t maxStringLength)
4800  {
4801  char* result;
4802 
4803  _OrthancPluginDicomToJson params;
4804  memset(&params, 0, sizeof(params));
4805  params.result = &result;
4806  params.buffer = buffer;
4807  params.size = size;
4808  params.format = format;
4809  params.flags = flags;
4810  params.maxStringLength = maxStringLength;
4811 
4812  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
4813  {
4814  /* Error */
4815  return NULL;
4816  }
4817  else
4818  {
4819  return result;
4820  }
4821  }
4822 
4823 
4842  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
4843  OrthancPluginContext* context,
4844  const char* instanceId,
4847  uint32_t maxStringLength)
4848  {
4849  char* result;
4850 
4851  _OrthancPluginDicomToJson params;
4852  memset(&params, 0, sizeof(params));
4853  params.result = &result;
4854  params.instanceId = instanceId;
4855  params.format = format;
4856  params.flags = flags;
4857  params.maxStringLength = maxStringLength;
4858 
4859  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
4860  {
4861  /* Error */
4862  return NULL;
4863  }
4864  else
4865  {
4866  return result;
4867  }
4868  }
4869 
4870 
4871  typedef struct
4872  {
4873  OrthancPluginMemoryBuffer* target;
4874  const char* uri;
4875  uint32_t headersCount;
4876  const char* const* headersKeys;
4877  const char* const* headersValues;
4878  int32_t afterPlugins;
4879  } _OrthancPluginRestApiGet2;
4880 
4900  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiGet2(
4901  OrthancPluginContext* context,
4902  OrthancPluginMemoryBuffer* target,
4903  const char* uri,
4904  uint32_t headersCount,
4905  const char* const* headersKeys,
4906  const char* const* headersValues,
4907  int32_t afterPlugins)
4908  {
4909  _OrthancPluginRestApiGet2 params;
4910  params.target = target;
4911  params.uri = uri;
4912  params.headersCount = headersCount;
4913  params.headersKeys = headersKeys;
4914  params.headersValues = headersValues;
4915  params.afterPlugins = afterPlugins;
4916 
4917  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
4918  }
4919 
4920 
4921 
4922  typedef struct
4923  {
4925  } _OrthancPluginWorklistCallback;
4926 
4939  OrthancPluginContext* context,
4941  {
4942  _OrthancPluginWorklistCallback params;
4943  params.callback = callback;
4944 
4945  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
4946  }
4947 
4948 
4949 
4950  typedef struct
4951  {
4953  const OrthancPluginWorklistQuery* query;
4954  const void* dicom;
4955  uint32_t size;
4956  } _OrthancPluginWorklistAnswersOperation;
4957 
4975  OrthancPluginContext* context,
4977  const OrthancPluginWorklistQuery* query,
4978  const void* dicom,
4979  uint32_t size)
4980  {
4981  _OrthancPluginWorklistAnswersOperation params;
4982  params.answers = answers;
4983  params.query = query;
4984  params.dicom = dicom;
4985  params.size = size;
4986 
4987  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
4988  }
4989 
4990 
5005  OrthancPluginContext* context,
5007  {
5008  _OrthancPluginWorklistAnswersOperation params;
5009  params.answers = answers;
5010  params.query = NULL;
5011  params.dicom = NULL;
5012  params.size = 0;
5013 
5014  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5015  }
5016 
5017 
5018  typedef struct
5019  {
5020  const OrthancPluginWorklistQuery* query;
5021  const void* dicom;
5022  uint32_t size;
5023  int32_t* isMatch;
5024  OrthancPluginMemoryBuffer* target;
5025  } _OrthancPluginWorklistQueryOperation;
5026 
5042  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5043  OrthancPluginContext* context,
5044  const OrthancPluginWorklistQuery* query,
5045  const void* dicom,
5046  uint32_t size)
5047  {
5048  int32_t isMatch = 0;
5049 
5050  _OrthancPluginWorklistQueryOperation params;
5051  params.query = query;
5052  params.dicom = dicom;
5053  params.size = size;
5054  params.isMatch = &isMatch;
5055  params.target = NULL;
5056 
5057  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5058  {
5059  return isMatch;
5060  }
5061  else
5062  {
5063  /* Error: Assume non-match */
5064  return 0;
5065  }
5066  }
5067 
5068 
5082  OrthancPluginContext* context,
5083  OrthancPluginMemoryBuffer* target,
5084  const OrthancPluginWorklistQuery* query)
5085  {
5086  _OrthancPluginWorklistQueryOperation params;
5087  params.query = query;
5088  params.dicom = NULL;
5089  params.size = 0;
5090  params.isMatch = NULL;
5091  params.target = target;
5092 
5093  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5094  }
5095 
5096 
5108  OrthancPluginContext* context,
5109  OrthancPluginDicomInstance* instance)
5110  {
5112 
5113  _OrthancPluginAccessDicomInstance params;
5114  memset(&params, 0, sizeof(params));
5115  params.resultOrigin = &origin;
5116  params.instance = instance;
5117 
5118  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5119  {
5120  /* Error */
5122  }
5123  else
5124  {
5125  return origin;
5126  }
5127  }
5128 
5129 
5130  typedef struct
5131  {
5132  OrthancPluginMemoryBuffer* target;
5133  const char* json;
5134  const OrthancPluginImage* pixelData;
5136  } _OrthancPluginCreateDicom;
5137 
5156  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginCreateDicom(
5157  OrthancPluginContext* context,
5158  OrthancPluginMemoryBuffer* target,
5159  const char* json,
5160  const OrthancPluginImage* pixelData,
5162  {
5163  _OrthancPluginCreateDicom params;
5164  params.target = target;
5165  params.json = json;
5166  params.pixelData = pixelData;
5167  params.flags = flags;
5168 
5169  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5170  }
5171 
5172 
5173  typedef struct
5174  {
5176  } _OrthancPluginDecodeImageCallback;
5177 
5190  OrthancPluginContext* context,
5192  {
5193  _OrthancPluginDecodeImageCallback params;
5194  params.callback = callback;
5195 
5196  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5197  }
5198 
5199 
5200 
5201  typedef struct
5202  {
5203  OrthancPluginImage** target;
5204  OrthancPluginPixelFormat format;
5205  uint32_t width;
5206  uint32_t height;
5207  uint32_t pitch;
5208  void* buffer;
5209  const void* constBuffer;
5210  uint32_t bufferSize;
5211  uint32_t frameIndex;
5212  } _OrthancPluginCreateImage;
5213 
5214 
5227  ORTHANC_PLUGIN_INLINE OrthancPluginImage* OrthancPluginCreateImage(
5228  OrthancPluginContext* context,
5229  OrthancPluginPixelFormat format,
5230  uint32_t width,
5231  uint32_t height)
5232  {
5233  OrthancPluginImage* target = NULL;
5234 
5235  _OrthancPluginCreateImage params;
5236  memset(&params, 0, sizeof(params));
5237  params.target = &target;
5238  params.format = format;
5239  params.width = width;
5240  params.height = height;
5241 
5242  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5243  {
5244  return NULL;
5245  }
5246  else
5247  {
5248  return target;
5249  }
5250  }
5251 
5252 
5271  OrthancPluginContext* context,
5272  OrthancPluginPixelFormat format,
5273  uint32_t width,
5274  uint32_t height,
5275  uint32_t pitch,
5276  void* buffer)
5277  {
5278  OrthancPluginImage* target = NULL;
5279 
5280  _OrthancPluginCreateImage params;
5281  memset(&params, 0, sizeof(params));
5282  params.target = &target;
5283  params.format = format;
5284  params.width = width;
5285  params.height = height;
5286  params.pitch = pitch;
5287  params.buffer = buffer;
5288 
5289  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5290  {
5291  return NULL;
5292  }
5293  else
5294  {
5295  return target;
5296  }
5297  }
5298 
5299 
5300 
5315  ORTHANC_PLUGIN_INLINE OrthancPluginImage* OrthancPluginDecodeDicomImage(
5316  OrthancPluginContext* context,
5317  const void* buffer,
5318  uint32_t bufferSize,
5319  uint32_t frameIndex)
5320  {
5321  OrthancPluginImage* target = NULL;
5322 
5323  _OrthancPluginCreateImage params;
5324  memset(&params, 0, sizeof(params));
5325  params.target = &target;
5326  params.constBuffer = buffer;
5327  params.bufferSize = bufferSize;
5328  params.frameIndex = frameIndex;
5329 
5330  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5331  {
5332  return NULL;
5333  }
5334  else
5335  {
5336  return target;
5337  }
5338  }
5339 
5340 
5341 
5342  typedef struct
5343  {
5344  char** result;
5345  const void* buffer;
5346  uint32_t size;
5347  } _OrthancPluginComputeHash;
5348 
5361  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5362  OrthancPluginContext* context,
5363  const void* buffer,
5364  uint32_t size)
5365  {
5366  char* result;
5367 
5368  _OrthancPluginComputeHash params;
5369  params.result = &result;
5370  params.buffer = buffer;
5371  params.size = size;
5372 
5373  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5374  {
5375  /* Error */
5376  return NULL;
5377  }
5378  else
5379  {
5380  return result;
5381  }
5382  }
5383 
5384 
5397  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5398  OrthancPluginContext* context,
5399  const void* buffer,
5400  uint32_t size)
5401  {
5402  char* result;
5403 
5404  _OrthancPluginComputeHash params;
5405  params.result = &result;
5406  params.buffer = buffer;
5407  params.size = size;
5408 
5409  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5410  {
5411  /* Error */
5412  return NULL;
5413  }
5414  else
5415  {
5416  return result;
5417  }
5418  }
5419 
5420 
5421 
5422  typedef struct
5423  {
5425  const char* name;
5426  } _OrthancPluginLookupDictionary;
5427 
5444  OrthancPluginContext* context,
5446  const char* name)
5447  {
5448  _OrthancPluginLookupDictionary params;
5449  params.target = target;
5450  params.name = name;
5451  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5452  }
5453 
5454 
5455 
5456  typedef struct
5457  {
5458  OrthancPluginRestOutput* output;
5459  const char* answer;
5460  uint32_t answerSize;
5461  uint32_t headersCount;
5462  const char* const* headersKeys;
5463  const char* const* headersValues;
5464  } _OrthancPluginSendMultipartItem2;
5465 
5487  OrthancPluginContext* context,
5488  OrthancPluginRestOutput* output,
5489  const char* answer,
5490  uint32_t answerSize,
5491  uint32_t headersCount,
5492  const char* const* headersKeys,
5493  const char* const* headersValues)
5494  {
5495  _OrthancPluginSendMultipartItem2 params;
5496  params.output = output;
5497  params.answer = answer;
5498  params.answerSize = answerSize;
5499  params.headersCount = headersCount;
5500  params.headersKeys = headersKeys;
5501  params.headersValues = headersValues;
5502 
5503  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5504  }
5505 
5506 
5507  typedef struct
5508  {
5510  } _OrthancPluginIncomingHttpRequestFilter;
5511 
5525  OrthancPluginContext* context,
5527  {
5528  _OrthancPluginIncomingHttpRequestFilter params;
5529  params.callback = callback;
5530 
5531  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5532  }
5533 
5534 
5535 
5536  typedef struct
5537  {
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 void* 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  } _OrthancPluginCallHttpClient2;
5556 
5557 
5558 
5598  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginHttpClient(
5599  OrthancPluginContext* context,
5600  OrthancPluginMemoryBuffer* answerBody,
5601  OrthancPluginMemoryBuffer* answerHeaders,
5602  uint16_t* httpStatus,
5603  OrthancPluginHttpMethod method,
5604  const char* url,
5605  uint32_t headersCount,
5606  const char* const* headersKeys,
5607  const char* const* headersValues,
5608  const void* body,
5609  uint32_t bodySize,
5610  const char* username,
5611  const char* password,
5612  uint32_t timeout,
5613  const char* certificateFile,
5614  const char* certificateKeyFile,
5615  const char* certificateKeyPassword,
5616  uint8_t pkcs11)
5617  {
5618  _OrthancPluginCallHttpClient2 params;
5619  memset(&params, 0, sizeof(params));
5620 
5621  params.answerBody = answerBody;
5622  params.answerHeaders = answerHeaders;
5623  params.httpStatus = httpStatus;
5624  params.method = method;
5625  params.url = url;
5626  params.headersCount = headersCount;
5627  params.headersKeys = headersKeys;
5628  params.headersValues = headersValues;
5629  params.body = body;
5630  params.bodySize = bodySize;
5631  params.username = username;
5632  params.password = password;
5633  params.timeout = timeout;
5634  params.certificateFile = certificateFile;
5635  params.certificateKeyFile = certificateKeyFile;
5636  params.certificateKeyPassword = certificateKeyPassword;
5637  params.pkcs11 = pkcs11;
5638 
5639  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5640  }
5641 
5642 
5653  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5654  OrthancPluginContext* context)
5655  {
5656  char* result;
5657 
5658  _OrthancPluginRetrieveDynamicString params;
5659  params.result = &result;
5660  params.argument = NULL;
5661 
5662  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5663  {
5664  /* Error */
5665  return NULL;
5666  }
5667  else
5668  {
5669  return result;
5670  }
5671  }
5672 
5673 
5674 
5675 
5676  typedef struct
5677  {
5678  OrthancPluginFindCallback callback;
5679  } _OrthancPluginFindCallback;
5680 
5693  OrthancPluginContext* context,
5694  OrthancPluginFindCallback callback)
5695  {
5696  _OrthancPluginFindCallback params;
5697  params.callback = callback;
5698 
5699  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5700  }
5701 
5702 
5703  typedef struct
5704  {
5705  OrthancPluginFindAnswers *answers;
5706  const OrthancPluginFindQuery *query;
5707  const void *dicom;
5708  uint32_t size;
5709  uint32_t index;
5710  uint32_t *resultUint32;
5711  uint16_t *resultGroup;
5712  uint16_t *resultElement;
5713  char **resultString;
5714  } _OrthancPluginFindOperation;
5715 
5731  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginFindAddAnswer(
5732  OrthancPluginContext* context,
5733  OrthancPluginFindAnswers* answers,
5734  const void* dicom,
5735  uint32_t size)
5736  {
5737  _OrthancPluginFindOperation params;
5738  memset(&params, 0, sizeof(params));
5739  params.answers = answers;
5740  params.dicom = dicom;
5741  params.size = size;
5742 
5743  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
5744  }
5745 
5746 
5761  OrthancPluginContext* context,
5762  OrthancPluginFindAnswers* answers)
5763  {
5764  _OrthancPluginFindOperation params;
5765  memset(&params, 0, sizeof(params));
5766  params.answers = answers;
5767 
5768  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
5769  }
5770 
5771 
5772 
5784  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
5785  OrthancPluginContext* context,
5786  const OrthancPluginFindQuery* query)
5787  {
5788  uint32_t count = 0;
5789 
5790  _OrthancPluginFindOperation params;
5791  memset(&params, 0, sizeof(params));
5792  params.query = query;
5793  params.resultUint32 = &count;
5794 
5795  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
5796  {
5797  /* Error */
5798  return 0;
5799  }
5800  else
5801  {
5802  return count;
5803  }
5804  }
5805 
5806 
5822  OrthancPluginContext* context,
5823  uint16_t* group,
5824  uint16_t* element,
5825  const OrthancPluginFindQuery* query,
5826  uint32_t index)
5827  {
5828  _OrthancPluginFindOperation params;
5829  memset(&params, 0, sizeof(params));
5830  params.query = query;
5831  params.index = index;
5832  params.resultGroup = group;
5833  params.resultElement = element;
5834 
5835  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
5836  }
5837 
5838 
5852  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
5853  OrthancPluginContext* context,
5854  const OrthancPluginFindQuery* query,
5855  uint32_t index)
5856  {
5857  char* result;
5858 
5859  _OrthancPluginFindOperation params;
5860  memset(&params, 0, sizeof(params));
5861  params.query = query;
5862  params.index = index;
5863  params.resultString = &result;
5864 
5865  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
5866  {
5867  /* Error */
5868  return NULL;
5869  }
5870  else
5871  {
5872  return result;
5873  }
5874  }
5875 
5876 
5890  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
5891  OrthancPluginContext* context,
5892  const OrthancPluginFindQuery* query,
5893  uint32_t index)
5894  {
5895  char* result;
5896 
5897  _OrthancPluginFindOperation params;
5898  memset(&params, 0, sizeof(params));
5899  params.query = query;
5900  params.index = index;
5901  params.resultString = &result;
5902 
5903  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
5904  {
5905  /* Error */
5906  return NULL;
5907  }
5908  else
5909  {
5910  return result;
5911  }
5912  }
5913 
5914 
5915 
5916 
5917  typedef struct
5918  {
5919  OrthancPluginMoveCallback callback;
5920  OrthancPluginGetMoveSize getMoveSize;
5921  OrthancPluginApplyMove applyMove;
5922  OrthancPluginFreeMove freeMove;
5923  } _OrthancPluginMoveCallback;
5924 
5939  OrthancPluginContext* context,
5940  OrthancPluginMoveCallback callback,
5941  OrthancPluginGetMoveSize getMoveSize,
5942  OrthancPluginApplyMove applyMove,
5943  OrthancPluginFreeMove freeMove)
5944  {
5945  _OrthancPluginMoveCallback params;
5946  params.callback = callback;
5947  params.getMoveSize = getMoveSize;
5948  params.applyMove = applyMove;
5949  params.freeMove = freeMove;
5950 
5951  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
5952  }
5953 
5954 
5955 
5956  typedef struct
5957  {
5958  OrthancPluginFindMatcher** target;
5959  const void* query;
5960  uint32_t size;
5961  } _OrthancPluginCreateFindMatcher;
5962 
5963 
5978  OrthancPluginContext* context,
5979  const void* query,
5980  uint32_t size)
5981  {
5982  OrthancPluginFindMatcher* target = NULL;
5983 
5984  _OrthancPluginCreateFindMatcher params;
5985  memset(&params, 0, sizeof(params));
5986  params.target = &target;
5987  params.query = query;
5988  params.size = size;
5989 
5990  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
5991  {
5992  return NULL;
5993  }
5994  else
5995  {
5996  return target;
5997  }
5998  }
5999 
6000 
6001  typedef struct
6002  {
6003  OrthancPluginFindMatcher* matcher;
6004  } _OrthancPluginFreeFindMatcher;
6005 
6015  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6016  OrthancPluginContext* context,
6017  OrthancPluginFindMatcher* matcher)
6018  {
6019  _OrthancPluginFreeFindMatcher params;
6020  params.matcher = matcher;
6021 
6022  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6023  }
6024 
6025 
6026  typedef struct
6027  {
6028  const OrthancPluginFindMatcher* matcher;
6029  const void* dicom;
6030  uint32_t size;
6031  int32_t* isMatch;
6032  } _OrthancPluginFindMatcherIsMatch;
6033 
6048  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6049  OrthancPluginContext* context,
6050  const OrthancPluginFindMatcher* matcher,
6051  const void* dicom,
6052  uint32_t size)
6053  {
6054  int32_t isMatch = 0;
6055 
6056  _OrthancPluginFindMatcherIsMatch params;
6057  params.matcher = matcher;
6058  params.dicom = dicom;
6059  params.size = size;
6060  params.isMatch = &isMatch;
6061 
6062  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6063  {
6064  return isMatch;
6065  }
6066  else
6067  {
6068  /* Error: Assume non-match */
6069  return 0;
6070  }
6071  }
6072 
6073 
6074  typedef struct
6075  {
6077  } _OrthancPluginIncomingHttpRequestFilter2;
6078 
6091  OrthancPluginContext* context,
6093  {
6094  _OrthancPluginIncomingHttpRequestFilter2 params;
6095  params.callback = callback;
6096 
6097  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6098  }
6099 
6100 
6101 
6102  typedef struct
6103  {
6104  OrthancPluginPeers** peers;
6105  } _OrthancPluginGetPeers;
6106 
6118  ORTHANC_PLUGIN_INLINE OrthancPluginPeers* OrthancPluginGetPeers(
6119  OrthancPluginContext* context)
6120  {
6121  OrthancPluginPeers* peers = NULL;
6122 
6123  _OrthancPluginGetPeers params;
6124  memset(&params, 0, sizeof(params));
6125  params.peers = &peers;
6126 
6127  if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6128  {
6129  return NULL;
6130  }
6131  else
6132  {
6133  return peers;
6134  }
6135  }
6136 
6137 
6138  typedef struct
6139  {
6140  OrthancPluginPeers* peers;
6141  } _OrthancPluginFreePeers;
6142 
6152  ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6153  OrthancPluginContext* context,
6154  OrthancPluginPeers* peers)
6155  {
6156  _OrthancPluginFreePeers params;
6157  params.peers = peers;
6158 
6159  context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6160  }
6161 
6162 
6163  typedef struct
6164  {
6165  uint32_t* target;
6166  const OrthancPluginPeers* peers;
6167  } _OrthancPluginGetPeersCount;
6168 
6182  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6183  OrthancPluginContext* context,
6184  const OrthancPluginPeers* peers)
6185  {
6186  uint32_t target = 0;
6187 
6188  _OrthancPluginGetPeersCount params;
6189  memset(&params, 0, sizeof(params));
6190  params.target = &target;
6191  params.peers = peers;
6192 
6193  if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6194  {
6195  /* Error */
6196  return 0;
6197  }
6198  else
6199  {
6200  return target;
6201  }
6202  }
6203 
6204 
6205  typedef struct
6206  {
6207  const char** target;
6208  const OrthancPluginPeers* peers;
6209  uint32_t peerIndex;
6210  const char* userProperty;
6211  } _OrthancPluginGetPeerProperty;
6212 
6230  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6231  OrthancPluginContext* context,
6232  const OrthancPluginPeers* peers,
6233  uint32_t peerIndex)
6234  {
6235  const char* target = NULL;
6236 
6237  _OrthancPluginGetPeerProperty params;
6238  memset(&params, 0, sizeof(params));
6239  params.target = &target;
6240  params.peers = peers;
6241  params.peerIndex = peerIndex;
6242  params.userProperty = NULL;
6243 
6244  if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6245  {
6246  /* Error */
6247  return NULL;
6248  }
6249  else
6250  {
6251  return target;
6252  }
6253  }
6254 
6255 
6271  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6272  OrthancPluginContext* context,
6273  const OrthancPluginPeers* peers,
6274  uint32_t peerIndex)
6275  {
6276  const char* target = NULL;
6277 
6278  _OrthancPluginGetPeerProperty params;
6279  memset(&params, 0, sizeof(params));
6280  params.target = &target;
6281  params.peers = peers;
6282  params.peerIndex = peerIndex;
6283  params.userProperty = NULL;
6284 
6285  if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6286  {
6287  /* Error */
6288  return NULL;
6289  }
6290  else
6291  {
6292  return target;
6293  }
6294  }
6295 
6296 
6297 
6317  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6318  OrthancPluginContext* context,
6319  const OrthancPluginPeers* peers,
6320  uint32_t peerIndex,
6321  const char* userProperty)
6322  {
6323  const char* target = NULL;
6324 
6325  _OrthancPluginGetPeerProperty params;
6326  memset(&params, 0, sizeof(params));
6327  params.target = &target;
6328  params.peers = peers;
6329  params.peerIndex = peerIndex;
6330  params.userProperty = userProperty;
6331 
6332  if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6333  {
6334  /* No such user property */
6335  return NULL;
6336  }
6337  else
6338  {
6339  return target;
6340  }
6341  }
6342 
6343 
6344 
6345  typedef struct
6346  {
6347  OrthancPluginMemoryBuffer* answerBody;
6348  OrthancPluginMemoryBuffer* answerHeaders;
6349  uint16_t* httpStatus;
6350  const OrthancPluginPeers* peers;
6351  uint32_t peerIndex;
6352  OrthancPluginHttpMethod method;
6353  const char* uri;
6354  uint32_t additionalHeadersCount;
6355  const char* const* additionalHeadersKeys;
6356  const char* const* additionalHeadersValues;
6357  const void* body;
6358  uint32_t bodySize;
6359  uint32_t timeout;
6360  } _OrthancPluginCallPeerApi;
6361 
6397  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginCallPeerApi(
6398  OrthancPluginContext* context,
6399  OrthancPluginMemoryBuffer* answerBody,
6400  OrthancPluginMemoryBuffer* answerHeaders,
6401  uint16_t* httpStatus,
6402  const OrthancPluginPeers* peers,
6403  uint32_t peerIndex,
6404  OrthancPluginHttpMethod method,
6405  const char* uri,
6406  uint32_t additionalHeadersCount,
6407  const char* const* additionalHeadersKeys,
6408  const char* const* additionalHeadersValues,
6409  const void* body,
6410  uint32_t bodySize,
6411  uint32_t timeout)
6412  {
6413  _OrthancPluginCallPeerApi params;
6414  memset(&params, 0, sizeof(params));
6415 
6416  params.answerBody = answerBody;
6417  params.answerHeaders = answerHeaders;
6418  params.httpStatus = httpStatus;
6419  params.peers = peers;
6420  params.peerIndex = peerIndex;
6421  params.method = method;
6422  params.uri = uri;
6423  params.additionalHeadersCount = additionalHeadersCount;
6424  params.additionalHeadersKeys = additionalHeadersKeys;
6425  params.additionalHeadersValues = additionalHeadersValues;
6426  params.body = body;
6427  params.bodySize = bodySize;
6428  params.timeout = timeout;
6429 
6430  return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6431  }
6432 
6433 
6434 
6435 
6436 
6437  typedef struct
6438  {
6439  OrthancPluginJob** target;
6440  void *job;
6441  OrthancPluginJobFinalize finalize;
6442  const char *type;
6443  OrthancPluginJobGetProgress getProgress;
6444  OrthancPluginJobGetContent getContent;
6445  OrthancPluginJobGetSerialized getSerialized;
6446  OrthancPluginJobStep step;
6447  OrthancPluginJobStop stop;
6448  OrthancPluginJobReset reset;
6449  } _OrthancPluginCreateJob;
6450 
6482  ORTHANC_PLUGIN_INLINE OrthancPluginJob *OrthancPluginCreateJob(
6483  OrthancPluginContext *context,
6484  void *job,
6485  OrthancPluginJobFinalize finalize,
6486  const char *type,
6487  OrthancPluginJobGetProgress getProgress,
6488  OrthancPluginJobGetContent getContent,
6489  OrthancPluginJobGetSerialized getSerialized,
6490  OrthancPluginJobStep step,
6491  OrthancPluginJobStop stop,
6492  OrthancPluginJobReset reset)
6493  {
6494  OrthancPluginJob* target = NULL;
6495 
6496  _OrthancPluginCreateJob params;
6497  memset(&params, 0, sizeof(params));
6498 
6499  params.target = &target;
6500  params.job = job;
6501  params.finalize = finalize;
6502  params.type = type;
6503  params.getProgress = getProgress;
6504  params.getContent = getContent;
6505  params.getSerialized = getSerialized;
6506  params.step = step;
6507  params.stop = stop;
6508  params.reset = reset;
6509 
6510  if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6511  target == NULL)
6512  {
6513  /* Error */
6514  return NULL;
6515  }
6516  else
6517  {
6518  return target;
6519  }
6520  }
6521 
6522 
6523  typedef struct
6524  {
6525  OrthancPluginJob* job;
6526  } _OrthancPluginFreeJob;
6527 
6537  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6538  OrthancPluginContext* context,
6539  OrthancPluginJob* job)
6540  {
6541  _OrthancPluginFreeJob params;
6542  params.job = job;
6543 
6544  context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6545  }
6546 
6547 
6548 
6549  typedef struct
6550  {
6551  char** resultId;
6552  OrthancPluginJob *job;
6553  int priority;
6554  } _OrthancPluginSubmitJob;
6555 
6569  ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6570  OrthancPluginContext *context,
6571  OrthancPluginJob *job,
6572  int priority)
6573  {
6574  char* resultId = NULL;
6575 
6576  _OrthancPluginSubmitJob params;
6577  memset(&params, 0, sizeof(params));
6578 
6579  params.resultId = &resultId;
6580  params.job = job;
6581  params.priority = priority;
6582 
6583  if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6584  resultId == NULL)
6585  {
6586  /* Error */
6587  return NULL;
6588  }
6589  else
6590  {
6591  return resultId;
6592  }
6593  }
6594 
6595 
6596 
6597  typedef struct
6598  {
6599  OrthancPluginJobsUnserializer unserializer;
6600  } _OrthancPluginJobsUnserializer;
6601 
6614  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6615  OrthancPluginContext* context,
6616  OrthancPluginJobsUnserializer unserializer)
6617  {
6618  _OrthancPluginJobsUnserializer params;
6619  params.unserializer = unserializer;
6620 
6621  context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6622  }
6623 
6624 
6625 
6626  typedef struct
6627  {
6628  OrthancPluginRestOutput* output;
6629  const char* details;
6630  uint8_t log;
6631  } _OrthancPluginSetHttpErrorDetails;
6632 
6650  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
6651  OrthancPluginContext* context,
6652  OrthancPluginRestOutput* output,
6653  const char* details,
6654  uint8_t log)
6655  {
6656  _OrthancPluginSetHttpErrorDetails params;
6657  params.output = output;
6658  params.details = details;
6659  params.log = log;
6660  context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
6661  }
6662 
6663 
6664 
6665  typedef struct
6666  {
6667  const char** result;
6668  const char* argument;
6669  } _OrthancPluginRetrieveStaticString;
6670 
6682  ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
6683  OrthancPluginContext* context,
6684  const char* path)
6685  {
6686  const char* result = NULL;
6687 
6688  _OrthancPluginRetrieveStaticString params;
6689  params.result = &result;
6690  params.argument = path;
6691 
6692  if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
6693  {
6694  /* Error */
6695  return NULL;
6696  }
6697  else
6698  {
6699  return result;
6700  }
6701  }
6702 
6703 
6704 
6705  typedef struct
6706  {
6707  const char* name;
6708  float value;
6710  } _OrthancPluginSetMetricsValue;
6711 
6726  ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
6727  OrthancPluginContext* context,
6728  const char* name,
6729  float value,
6731  {
6732  _OrthancPluginSetMetricsValue params;
6733  params.name = name;
6734  params.value = value;
6735  params.type = type;
6736  context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
6737  }
6738 
6739 
6740 
6741  typedef struct
6742  {
6744  } _OrthancPluginRegisterRefreshMetricsCallback;
6745 
6756  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRefreshMetricsCallback(
6757  OrthancPluginContext* context,
6759  {
6760  _OrthancPluginRegisterRefreshMetricsCallback params;
6761  params.callback = callback;
6762  context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
6763  }
6764 
6765 
6766 
6767 
6768  typedef struct
6769  {
6770  char** target;
6771  const void* dicom;
6772  uint32_t dicomSize;
6774  } _OrthancPluginEncodeDicomWeb;
6775 
6791  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
6792  OrthancPluginContext* context,
6793  const void* dicom,
6794  uint32_t dicomSize,
6796  {
6797  char* target = NULL;
6798 
6799  _OrthancPluginEncodeDicomWeb params;
6800  params.target = &target;
6801  params.dicom = dicom;
6802  params.dicomSize = dicomSize;
6803  params.callback = callback;
6804 
6805  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
6806  {
6807  /* Error */
6808  return NULL;
6809  }
6810  else
6811  {
6812  return target;
6813  }
6814  }
6815 
6816 
6832  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
6833  OrthancPluginContext* context,
6834  const void* dicom,
6835  uint32_t dicomSize,
6837  {
6838  char* target = NULL;
6839 
6840  _OrthancPluginEncodeDicomWeb params;
6841  params.target = &target;
6842  params.dicom = dicom;
6843  params.dicomSize = dicomSize;
6844  params.callback = callback;
6845 
6846  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
6847  {
6848  /* Error */
6849  return NULL;
6850  }
6851  else
6852  {
6853  return target;
6854  }
6855  }
6856 
6857 
6858 
6875  void* answer,
6876  const char* key,
6877  const char* value);
6878 
6879 
6896  void* answer,
6897  const void* data,
6898  uint32_t size);
6899 
6900 
6915  typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
6916 
6917 
6933 
6934 
6948  typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
6949 
6950 
6964  typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
6965 
6966 
6967  typedef struct
6968  {
6969  void* answer;
6972  uint16_t* httpStatus;
6973  OrthancPluginHttpMethod method;
6974  const char* url;
6975  uint32_t headersCount;
6976  const char* const* headersKeys;
6977  const char* const* headersValues;
6978  void* request;
6983  const char* username;
6984  const char* password;
6985  uint32_t timeout;
6986  const char* certificateFile;
6987  const char* certificateKeyFile;
6988  const char* certificateKeyPassword;
6989  uint8_t pkcs11;
6990  } _OrthancPluginChunkedHttpClient;
6991 
6992 
7044  OrthancPluginContext* context,
7045  void* answer,
7048  uint16_t* httpStatus,
7049  OrthancPluginHttpMethod method,
7050  const char* url,
7051  uint32_t headersCount,
7052  const char* const* headersKeys,
7053  const char* const* headersValues,
7054  void* request,
7059  const char* username,
7060  const char* password,
7061  uint32_t timeout,
7062  const char* certificateFile,
7063  const char* certificateKeyFile,
7064  const char* certificateKeyPassword,
7065  uint8_t pkcs11)
7066  {
7067  _OrthancPluginChunkedHttpClient params;
7068  memset(&params, 0, sizeof(params));
7069 
7070  /* In common with OrthancPluginHttpClient() */
7071  params.httpStatus = httpStatus;
7072  params.method = method;
7073  params.url = url;
7074  params.headersCount = headersCount;
7075  params.headersKeys = headersKeys;
7076  params.headersValues = headersValues;
7077  params.username = username;
7078  params.password = password;
7079  params.timeout = timeout;
7080  params.certificateFile = certificateFile;
7081  params.certificateKeyFile = certificateKeyFile;
7082  params.certificateKeyPassword = certificateKeyPassword;
7083  params.pkcs11 = pkcs11;
7084 
7085  /* For chunked body/answer */
7086  params.answer = answer;
7087  params.answerAddChunk = answerAddChunk;
7088  params.answerAddHeader = answerAddHeader;
7089  params.request = request;
7090  params.requestIsDone = requestIsDone;
7091  params.requestChunkData = requestChunkData;
7092  params.requestChunkSize = requestChunkSize;
7093  params.requestNext = requestNext;
7094 
7095  return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7096  }
7097 
7098 
7099 
7104  typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7105 
7106 
7107 
7125  const char* url,
7126  const OrthancPluginHttpRequest* request);
7127 
7128 
7144  const void* data,
7145  uint32_t size);
7146 
7147 
7164  OrthancPluginRestOutput* output);
7165 
7166 
7182 
7183  typedef struct
7184  {
7185  const char* pathRegularExpression;
7186  OrthancPluginRestCallback getHandler;
7188  OrthancPluginRestCallback deleteHandler;
7193  } _OrthancPluginChunkedRestCallback;
7194 
7195 
7225  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterChunkedRestCallback(
7226  OrthancPluginContext* context,
7227  const char* pathRegularExpression,
7228  OrthancPluginRestCallback getHandler,
7230  OrthancPluginRestCallback deleteHandler,
7235  {
7236  _OrthancPluginChunkedRestCallback params;
7237  params.pathRegularExpression = pathRegularExpression;
7238  params.getHandler = getHandler;
7239  params.postHandler = postHandler;
7240  params.deleteHandler = deleteHandler;
7241  params.putHandler = putHandler;
7242  params.addChunk = addChunk;
7243  params.execute = execute;
7244  params.finalize = finalize;
7245 
7246  context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
7247  }
7248 
7249 
7250 
7251 
7252 
7253  typedef struct
7254  {
7255  char** result;
7256  uint16_t group;
7257  uint16_t element;
7258  const char* privateCreator;
7259  } _OrthancPluginGetTagName;
7260 
7276  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
7277  OrthancPluginContext* context,
7278  uint16_t group,
7279  uint16_t element,
7280  const char* privateCreator)
7281  {
7282  char* result;
7283 
7284  _OrthancPluginGetTagName params;
7285  params.result = &result;
7286  params.group = group;
7287  params.element = element;
7288  params.privateCreator = privateCreator;
7289 
7290  if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
7291  {
7292  /* Error */
7293  return NULL;
7294  }
7295  else
7296  {
7297  return result;
7298  }
7299  }
7300 
7301 
7302 
7332  void** handler /* out */,
7333  const char* jobId,
7334  const char* transactionUid,
7335  const char* const* sopClassUids,
7336  const char* const* sopInstanceUids,
7337  uint32_t countInstances,
7338  const char* remoteAet,
7339  const char* calledAet);
7340 
7341 
7353  typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
7354 
7355 
7376  void* handler,
7377  const char* sopClassUid,
7378  const char* sopInstanceUid);
7379 
7380 
7381  typedef struct
7382  {
7386  } _OrthancPluginRegisterStorageCommitmentScpCallback;
7387 
7401  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageCommitmentScpCallback(
7402  OrthancPluginContext* context,
7406  {
7407  _OrthancPluginRegisterStorageCommitmentScpCallback params;
7408  params.factory = factory;
7409  params.destructor = destructor;
7410  params.lookup = lookup;
7411  context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
7412  }
7413 
7414 #ifdef __cplusplus
7415 }
7416 #endif
7417 
7418 
OrthancPluginJobGetProgress
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1439
OrthancPluginMetricsType_Default
Definition: OrthancCPlugin.h:912
OrthancPluginChangeType_NewPatient
Definition: OrthancCPlugin.h:701
OrthancPluginErrorCode_SQLiteStatementAlreadyUsed
Definition: OrthancCPlugin.h:252
OrthancPluginConvertPixelFormat
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4263
OrthancPluginGetMoveSize
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1384
OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
Definition: OrthancCPlugin.h:813
OrthancPluginErrorCode_CannotExecuteLua
Definition: OrthancCPlugin.h:296
OrthancPluginGetInstanceOrigin
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5104
OrthancPluginCheckVersion
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1775
OrthancPluginErrorCode_NoWorklistHandler
Definition: OrthancCPlugin.h:306
OrthancPluginCompressionType_Gzip
Definition: OrthancCPlugin.h:726
OrthancPluginExtendOrthancExplorer
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:3194
OrthancPluginHttpClient
OrthancPluginErrorCode OrthancPluginHttpClient(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, OrthancPluginHttpMethod method, const char *url, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, const void *body, uint32_t bodySize, const char *username, const char *password, uint32_t timeout, const char *certificateFile, const char *certificateKeyFile, const char *certificateKeyPassword, uint8_t pkcs11)
Issue a HTTP call with full flexibility.
Definition: OrthancCPlugin.h:5595
OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii
Definition: OrthancCPlugin.h:812
OrthancPluginErrorCode_SQLiteBindOutOfRange
Definition: OrthancCPlugin.h:260
OrthancPluginRegisterOnStoredInstanceCallback
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:1946
OrthancPluginValueRepresentation_AS
Definition: OrthancCPlugin.h:754
OrthancPluginValueRepresentation_UT
Definition: OrthancCPlugin.h:779
OrthancPluginErrorCode_SystemCommand
Definition: OrthancCPlugin.h:220
OrthancPluginErrorCode_NotEnoughMemory
Definition: OrthancCPlugin.h:214
OrthancPluginChangeType_UpdatedAttachment
Definition: OrthancCPlugin.h:709
OrthancPluginSendHttpStatus
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:3661
OrthancPluginInstanceOrigin_Plugin
Definition: OrthancCPlugin.h:874
OrthancPluginFindAddAnswer
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5728
OrthancPluginGetOrthancDirectory
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:3042
OrthancPluginDicomToJsonFlags_IncludePrivateTags
Definition: OrthancCPlugin.h:809
OrthancPluginAnswerBuffer
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:1978
OrthancPluginPixelFormat_RGBA32
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:612
OrthancPluginChangeType_StableStudy
Definition: OrthancCPlugin.h:706
OrthancPluginRestApiDelete
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2240
OrthancPluginValueRepresentation_FD
Definition: OrthancCPlugin.h:760
OrthancPluginRestApiPutAfterPlugins
OrthancPluginErrorCode OrthancPluginRestApiPutAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a PUT call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2324
OrthancPluginErrorCode_Unauthorized
Definition: OrthancCPlugin.h:239
OrthancPluginServerChunkedRequestReaderFactory
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderFactory)(OrthancPluginServerChunkedRequestReader **reader, const char *url, const OrthancPluginHttpRequest *request)
Callback to create a reader to handle incoming chunked HTTP transfers.
Definition: OrthancCPlugin.h:7120
OrthancPluginErrorCode_CreateDicomNoPayload
Definition: OrthancCPlugin.h:287
OrthancPluginErrorCode_InexistentTag
Definition: OrthancCPlugin.h:231
OrthancPluginComputeSha1
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5394
OrthancPluginErrorCode_CreateDicomUseContent
Definition: OrthancCPlugin.h:286
OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:646
OrthancPluginErrorCode_Timeout
Definition: OrthancCPlugin.h:226
OrthancPluginResourceType_Patient
Definition: OrthancCPlugin.h:680
OrthancPluginErrorCode_JsonToLuaTable
Definition: OrthancCPlugin.h:294
OrthancPluginErrorCode_LuaReturnsNoString
Definition: OrthancCPlugin.h:300
OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:638
OrthancPluginCreateDicomFlags_DecodeDataUriScheme
Definition: OrthancCPlugin.h:827
OrthancPluginCreateImage
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5224
OrthancPluginLookupSeries
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2495
OrthancPluginServerChunkedRequestReaderAddChunk
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderAddChunk)(OrthancPluginServerChunkedRequestReader *reader, const void *data, uint32_t size)
Callback invoked whenever a new data chunk is available during a chunked transfer.
Definition: OrthancCPlugin.h:7139
OrthancPluginJobGetSerialized
const typedef char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1472
OrthancPluginJobGetContent
const typedef char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1454
OrthancPluginChangeType_OrthancStopped
Definition: OrthancCPlugin.h:708
OrthancPluginErrorCode_LuaAlreadyExecuted
Definition: OrthancCPlugin.h:297
OrthancPluginDicomToJsonFlags
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:805
OrthancPluginErrorCode_SQLiteCannotStep
Definition: OrthancCPlugin.h:259
OrthancPluginCompressAndAnswerJpegImage
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:4054
OrthancPluginGetPeerUrl
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6268
OrthancPluginValueRepresentation_ST
Definition: OrthancCPlugin.h:773
OrthancPluginImageFormat
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:737
OrthancPluginConstraintType_Wildcard
Definition: OrthancCPlugin.h:859
OrthancPluginStorageAreaRead
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4517
OrthancPluginRegisterDecodeImageCallback
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5186
OrthancPluginRestApiPostAfterPlugins
OrthancPluginErrorCode OrthancPluginRestApiPostAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a POST call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2211
OrthancPluginErrorCode_SQLiteCannotOpen
Definition: OrthancCPlugin.h:251
OrthancPluginChangeType_CompletedSeries
Definition: OrthancCPlugin.h:697
OrthancPluginErrorCode_SQLiteFlush
Definition: OrthancCPlugin.h:257
OrthancPluginErrorCode_SQLiteExecute
Definition: OrthancCPlugin.h:253
OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
Definition: OrthancCPlugin.h:948
OrthancPluginHttpRequest
The parameters of a REST request.
Definition: OrthancCPlugin.h:334
OrthancPluginInstanceOrigin_Unknown
Definition: OrthancCPlugin.h:871
OrthancPluginValueRepresentation_DA
Definition: OrthancCPlugin.h:757
OrthancPluginGetInstanceRemoteAet
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2712
OrthancPluginIdentifierConstraint_SmallerOrEqual
Definition: OrthancCPlugin.h:842
OrthancPluginGetImageWidth
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3730
OrthancPluginConstraintType
OrthancPluginConstraintType
Definition: OrthancCPlugin.h:854
OrthancPluginGetPeerName
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6227
OrthancPluginErrorCode_InternalError
Definition: OrthancCPlugin.h:209
OrthancPluginChangeType_NewChildInstance
Definition: OrthancCPlugin.h:699
OrthancPluginWorklistCallback
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:1231
OrthancPluginChangeType_UpdatedPeers
Definition: OrthancCPlugin.h:711
OrthancPluginGetImagePitch
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3798
OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
Definition: OrthancCPlugin.h:956
OrthancPluginErrorCode_BadApplicationEntityTitle
Definition: OrthancCPlugin.h:274
OrthancPluginGetInstanceJson
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2814
OrthancPluginErrorCode_NoCMoveHandler
Definition: OrthancCPlugin.h:276
OrthancPluginErrorCode_SQLiteCannotRun
Definition: OrthancCPlugin.h:258
OrthancPluginDicomToJsonFlags_IncludeBinary
Definition: OrthancCPlugin.h:808
OrthancPluginJobStopReason_Failure
Definition: OrthancCPlugin.h:902
OrthancPluginCreateDicomFlags_GenerateIdentifiers
Definition: OrthancCPlugin.h:828
OrthancPluginErrorCode_SQLitePrepareStatement
Definition: OrthancCPlugin.h:261
OrthancPluginRestCallback
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1095
OrthancPluginReconstructMainDicomTags
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4746
OrthancPluginGetTagName
char * OrthancPluginGetTagName(OrthancPluginContext *context, uint16_t group, uint16_t element, const char *privateCreator)
Returns the symbolic name of a DICOM tag.
Definition: OrthancCPlugin.h:7273
OrthancPluginGetFindQueryTag
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:5818
OrthancPluginLookupDictionary
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5440
OrthancPluginDicomBufferToJson
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:4790
OrthancPluginGetConfigurationPath
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:3077
OrthancPluginHttpDelete
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4225
OrthancPluginCompressionType
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:722
OrthancPluginJobStep
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1487
OrthancPluginErrorCode_InexistentFile
Definition: OrthancCPlugin.h:223
OrthancPluginErrorCode_ParameterOutOfRange
Definition: OrthancCPlugin.h:213
OrthancPluginContentType_Dicom
Definition: OrthancCPlugin.h:667
OrthancPluginErrorCode_UnknownResource
Definition: OrthancCPlugin.h:227
OrthancPluginErrorCode_DirectoryExpected
Definition: OrthancCPlugin.h:267
OrthancPluginResourceType_Instance
Definition: OrthancCPlugin.h:683
OrthancPluginRegisterIncomingHttpRequestFilter
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5521
OrthancPluginErrorCode_Success
Definition: OrthancCPlugin.h:210
OrthancPluginCompressPngImage
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:3962
OrthancPluginErrorCode_MakeDirectory
Definition: OrthancCPlugin.h:273
OrthancPluginErrorCode_UnsupportedMediaType
Definition: OrthancCPlugin.h:309
OrthancPluginChangeType_NewInstance
Definition: OrthancCPlugin.h:700
OrthancPluginDrawText
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:4423
OrthancPluginResourceType_None
Definition: OrthancCPlugin.h:684
OrthancPluginSetMetricsValue
void OrthancPluginSetMetricsValue(OrthancPluginContext *context, const char *name, float value, OrthancPluginMetricsType type)
Set the value of a metrics.
Definition: OrthancCPlugin.h:6723
OrthancPluginErrorCode_CannotStoreInstance
Definition: OrthancCPlugin.h:283
OrthancPluginHttpMethod_Get
Definition: OrthancCPlugin.h:321
OrthancPluginCreateDicomFlags
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:824
OrthancPluginWorklistAddAnswer
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:4971
OrthancPluginPixelFormat_Grayscale8
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:580
OrthancPluginStorageArea
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:1022
OrthancPluginSendHttpStatusCode
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2575
OrthancPluginIdentifierConstraint
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:839
OrthancPluginRestApiDeleteAfterPlugins
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2263
OrthancPluginPeers
struct _OrthancPluginPeers_t OrthancPluginPeers
Opaque structure to the set of remote Orthanc Peers that are known to the local Orthanc server.
Definition: OrthancCPlugin.h:1070
OrthancPluginRefreshMetricsCallback
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1562
OrthancPluginDicomWebBinaryMode_BulkDataUri
Definition: OrthancCPlugin.h:931
OrthancPluginPixelFormat_Unknown
Definition: OrthancCPlugin.h:614
OrthancPluginValueRepresentation_LO
Definition: OrthancCPlugin.h:763
OrthancPluginRegisterIncomingHttpRequestFilter2
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6087
OrthancPluginValueRepresentation_AE
Definition: OrthancCPlugin.h:753
OrthancPluginRestApiGet2
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:4897
OrthancPluginResourceType
OrthancPluginResourceType
Definition: OrthancCPlugin.h:678
OrthancPluginCreateFindMatcher
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:5974
OrthancPluginErrorCode_NoSopClassOrInstance
Definition: OrthancCPlugin.h:279
OrthancPluginJobStop
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1511
OrthancPluginValueRepresentation_AT
Definition: OrthancCPlugin.h:755
OrthancPluginReadFile
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3546
OrthancPluginCallPeerApi
OrthancPluginErrorCode OrthancPluginCallPeerApi(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, const OrthancPluginPeers *peers, uint32_t peerIndex, OrthancPluginHttpMethod method, const char *uri, uint32_t additionalHeadersCount, const char *const *additionalHeadersKeys, const char *const *additionalHeadersValues, const void *body, uint32_t bodySize, uint32_t timeout)
Call the REST API of an Orthanc peer.
Definition: OrthancCPlugin.h:6394
OrthancPluginOnChangeCallback
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:1116
OrthancPluginInstanceOrigin_RestApi
Definition: OrthancCPlugin.h:873
OrthancPluginChunkedClientRequestIsDone
uint8_t(* OrthancPluginChunkedClientRequestIsDone)(void *request)
Callback to know whether the request body is entirely read during a chunked transfer.
Definition: OrthancCPlugin.h:6912
OrthancPluginErrorCode_NoApplicationEntityFilter
Definition: OrthancCPlugin.h:278
OrthancPluginLookupStudyWithAccessionNumber
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2460
OrthancPluginCompressionType_ZlibWithSize
Definition: OrthancCPlugin.h:725
OrthancPluginGetCommandLineArgumentsCount
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3298
OrthancPluginErrorCode_ReadOnly
Definition: OrthancCPlugin.h:232
OrthancPluginErrorCode_SQLiteTransactionAlreadyStarted
Definition: OrthancCPlugin.h:262
OrthancPluginValueRepresentation_TM
Definition: OrthancCPlugin.h:774
OrthancPluginErrorCode_StorageAreaPlugin
Definition: OrthancCPlugin.h:242
OrthancPluginWorklistQuery
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1030
OrthancPluginEncodeDicomWebXml
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:6829
OrthancPluginImageFormat_Jpeg
Definition: OrthancCPlugin.h:740
OrthancPluginErrorCode_BadRequest
Definition: OrthancCPlugin.h:218
OrthancPluginDicomWebSetBinaryNode
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:1149
OrthancPluginRestApiGet
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2109
OrthancPluginConstraintType_SmallerOrEqual
Definition: OrthancCPlugin.h:857
OrthancPluginRestOutput
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:999
OrthancPluginServerChunkedRequestReaderFinalize
void(* OrthancPluginServerChunkedRequestReaderFinalize)(OrthancPluginServerChunkedRequestReader *reader)
Callback invoked to release the resources associated with an incoming HTTP chunked transfer.
Definition: OrthancCPlugin.h:7177
OrthancPluginCompressionType_Zlib
Definition: OrthancCPlugin.h:724
OrthancPluginErrorCode_NoCStoreHandler
Definition: OrthancCPlugin.h:277
OrthancPluginErrorCode_CreateDicomParentEncoding
Definition: OrthancCPlugin.h:291
OrthancPluginDicomToJsonFormat_Short
Definition: OrthancCPlugin.h:793
OrthancPluginLogError
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:1810
OrthancPluginPixelFormat_RGB48
Color image in RGB48 format.
Definition: OrthancCPlugin.h:622
OrthancPluginCompressAndAnswerPngImage
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:2035
OrthancPluginGetInstanceSize
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2745
OrthancPluginValueRepresentation_SL
Definition: OrthancCPlugin.h:770
OrthancPluginErrorCode_DicomFindUnavailable
Definition: OrthancCPlugin.h:281
OrthancPluginErrorCode_InexistentItem
Definition: OrthancCPlugin.h:217
OrthancPluginJobStopReason_Canceled
Definition: OrthancCPlugin.h:903
OrthancPluginDicomToJsonFormat
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:790
OrthancPluginErrorCode_IncompatibleDatabaseVersion
Definition: OrthancCPlugin.h:228
OrthancPluginErrorCode_AlreadyExistingTag
Definition: OrthancCPlugin.h:307
OrthancPluginErrorCode_CreateDicomNotString
Definition: OrthancCPlugin.h:284
OrthancPluginErrorCode_BadFont
Definition: OrthancCPlugin.h:240
OrthancPluginConstraintType_Equal
Definition: OrthancCPlugin.h:856
OrthancPluginErrorCode_IncompatibleImageSize
Definition: OrthancCPlugin.h:234
OrthancPluginErrorCode_SQLiteTransactionCommit
Definition: OrthancCPlugin.h:263
OrthancPluginHttpMethod_Post
Definition: OrthancCPlugin.h:322
OrthancPluginErrorCode_UnknownPluginService
Definition: OrthancCPlugin.h:236
OrthancPluginErrorCode_CorruptedFile
Definition: OrthancCPlugin.h:230
OrthancPluginDicomWebBinaryMode_InlineBinary
Definition: OrthancCPlugin.h:930
OrthancPluginIncomingHttpRequestFilter
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:1258
OrthancPluginChangeType_StableSeries
Definition: OrthancCPlugin.h:705
OrthancPluginGetOrthancPath
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:3012
OrthancPluginStorageCreate
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1168
OrthancPluginContentType
OrthancPluginContentType
Definition: OrthancCPlugin.h:664
OrthancPluginGenerateUuid
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5650
OrthancPluginValueRepresentation_LT
Definition: OrthancCPlugin.h:764
OrthancPluginFreeMemoryBuffer
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1794
OrthancPluginSendMultipartItem
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:3467
OrthancPluginMetricsType_Timer
Definition: OrthancCPlugin.h:919
OrthancPluginChunkedClientRequestGetChunkData
const typedef void *(* OrthancPluginChunkedClientRequestGetChunkData)(void *request)
Callback to read the current chunk of the request body during a chunked transfer.
Definition: OrthancCPlugin.h:6945
OrthancPluginServerChunkedRequestReaderExecute
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderExecute)(OrthancPluginServerChunkedRequestReader *reader, OrthancPluginRestOutput *output)
Callback invoked whenever the request body is entirely received.
Definition: OrthancCPlugin.h:7159
OrthancPluginInstanceOrigin_Lua
Definition: OrthancCPlugin.h:875
OrthancPluginGetInstanceData
const char * OrthancPluginGetInstanceData(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2778
OrthancPluginSetRootUri
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:3150
OrthancPluginCompressionType_GzipWithSize
Definition: OrthancCPlugin.h:727
OrthancPluginStartMultipartAnswer
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3438
OrthancPluginErrorCode_CannotOrderSlices
Definition: OrthancCPlugin.h:305
OrthancPluginGetImageBuffer
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:3832
OrthancPluginStorageRemove
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1212
OrthancPluginErrorCode_SQLiteTransactionBegin
Definition: OrthancCPlugin.h:264
OrthancPluginErrorCode_BadJobOrdering
Definition: OrthancCPlugin.h:293
OrthancPluginValueRepresentation_DS
Definition: OrthancCPlugin.h:758
OrthancPluginInstanceOrigin
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:869
OrthancPluginRestApiPut
OrthancPluginErrorCode OrthancPluginRestApiPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a PUT call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2288
OrthancPluginErrorCode_CreateDicomOverrideTag
Definition: OrthancCPlugin.h:285
OrthancPluginDicomWebBinaryMode_Ignore
Definition: OrthancCPlugin.h:929
OrthancPluginGetFontsCount
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4298
OrthancPluginRegisterStorageCommitmentScpCallback
void OrthancPluginRegisterStorageCommitmentScpCallback(OrthancPluginContext *context, OrthancPluginStorageCommitmentFactory factory, OrthancPluginStorageCommitmentDestructor destructor, OrthancPluginStorageCommitmentLookup lookup)
Register a callback to handle incoming requests to the storage commitment SCP.
Definition: OrthancCPlugin.h:7398
OrthancPluginChangeType_StablePatient
Definition: OrthancCPlugin.h:704
OrthancPluginGetInstanceSimplifiedJson
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:2852
OrthancPluginGetExpectedDatabaseVersion
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3364
OrthancPluginRegisterOnChangeCallback
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3119
OrthancPluginChangeType_OrthancStarted
Definition: OrthancCPlugin.h:707
OrthancPluginFreeJob
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6534
OrthancPluginChangeType_NewSeries
Definition: OrthancCPlugin.h:702
OrthancPluginDicomToJsonFormat_Human
Definition: OrthancCPlugin.h:794
OrthancPluginChunkedClientAnswerAddChunk
OrthancPluginErrorCode(* OrthancPluginChunkedClientAnswerAddChunk)(void *answer, const void *data, uint32_t size)
Callback executed when an answer chunk is received during a chunked transfer.
Definition: OrthancCPlugin.h:6892
OrthancPluginServerChunkedRequestReader
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition: OrthancCPlugin.h:7101
OrthancPluginIdentifierConstraint_GreaterOrEqual
Definition: OrthancCPlugin.h:843
OrthancPluginValueRepresentation
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:751
OrthancPluginErrorCode_CannotWriteFile
Definition: OrthancCPlugin.h:224
OrthancPluginIdentifierConstraint_Equal
Definition: OrthancCPlugin.h:841
OrthancPluginGetInstanceMetadata
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:2932
OrthancPluginErrorCode_Database
Definition: OrthancCPlugin.h:221
OrthancPluginErrorCode_DirectoryOverFile
Definition: OrthancCPlugin.h:265
OrthancPluginRegisterWorklistCallback
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:4935
OrthancPluginCreateDicom
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:5153
OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered
Definition: OrthancCPlugin.h:302
OrthancPluginGetFontSize
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4370
OrthancPluginGetErrorDescription
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3608
OrthancPluginErrorCode_DatabaseUnavailable
Definition: OrthancCPlugin.h:246
OrthancPluginSetGlobalProperty
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3267
OrthancPluginDecodeImageCallback
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:1127
OrthancPluginRegisterRestCallback
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:1878
OrthancPluginChangeType_Deleted
Definition: OrthancCPlugin.h:698
OrthancPluginMoveCallback
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:1359
OrthancPluginImageFormat_Dicom
Definition: OrthancCPlugin.h:741
OrthancPluginGetGlobalProperty
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3228
OrthancPluginValueRepresentation_SH
Definition: OrthancCPlugin.h:769
OrthancPluginGetImageHeight
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:3763
OrthancPluginValueRepresentation_OB
Definition: OrthancCPlugin.h:765
OrthancPluginValueRepresentation_DT
Definition: OrthancCPlugin.h:759
OrthancPluginValueRepresentation_UL
Definition: OrthancCPlugin.h:776
OrthancPluginPixelFormat_RGB24
Color image in RGB24 format.
Definition: OrthancCPlugin.h:604
OrthancPluginValueRepresentation_SQ
Definition: OrthancCPlugin.h:771
OrthancPluginFindAnswers
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1054
OrthancPluginRegisterErrorCode
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4593
OrthancPluginComputeMd5
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5358
OrthancPluginErrorCode_SQLiteRegisterFunction
Definition: OrthancCPlugin.h:256
OrthancPluginErrorCode_NoStorageCommitmentHandler
Definition: OrthancCPlugin.h:308
OrthancPluginValueRepresentation_CS
Definition: OrthancCPlugin.h:756
OrthancPluginMemoryBuffer::data
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:984
OrthancPluginPixelFormat_SignedGrayscale16
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:596
OrthancPluginFreeFindMatcher
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:6012
OrthancPluginCompressJpegImage
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:4007
OrthancPluginHttpMethod_Put
Definition: OrthancCPlugin.h:323
OrthancPluginStorageAreaCreate
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:4475
OrthancPluginStorageCommitmentLookup
OrthancPluginErrorCode(* OrthancPluginStorageCommitmentLookup)(OrthancPluginStorageCommitmentFailureReason *target, void *handler, const char *sopClassUid, const char *sopInstanceUid)
Callback to get the status of one DICOM instance in the storage commitment SCP.
Definition: OrthancCPlugin.h:7371
OrthancPluginRegisterChunkedRestCallback
void OrthancPluginRegisterChunkedRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback getHandler, OrthancPluginServerChunkedRequestReaderFactory postHandler, OrthancPluginRestCallback deleteHandler, OrthancPluginServerChunkedRequestReaderFactory putHandler, OrthancPluginServerChunkedRequestReaderAddChunk addChunk, OrthancPluginServerChunkedRequestReaderExecute execute, OrthancPluginServerChunkedRequestReaderFinalize finalize)
Register a REST callback to handle chunked HTTP transfers.
Definition: OrthancCPlugin.h:7222
OrthancPluginErrorCode_NotImplemented
Definition: OrthancCPlugin.h:212
OrthancPluginDicomToJsonFlags_IncludePixelData
Definition: OrthancCPlugin.h:811
OrthancPluginRegisterMoveCallback
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:5935
OrthancPluginRegisterJobsUnserializer
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6611
OrthancPluginErrorCode_UnknownModality
Definition: OrthancCPlugin.h:292
OrthancPluginErrorCode_CreateDicomBadParent
Definition: OrthancCPlugin.h:289
OrthancPluginHttpPost
OrthancPluginErrorCode OrthancPluginHttpPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const void *body, uint32_t bodySize, const char *username, const char *password)
Issue a HTTP POST call.
Definition: OrthancCPlugin.h:4145
OrthancPluginHttpPut
OrthancPluginErrorCode OrthancPluginHttpPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const void *body, uint32_t bodySize, const char *username, const char *password)
Issue a HTTP PUT call.
Definition: OrthancCPlugin.h:4187
OrthancPluginDicomInstanceToJson
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:4839
OrthancPluginChangeType_UpdatedModalities
Definition: OrthancCPlugin.h:712
OrthancPluginValueRepresentation_UN
Definition: OrthancCPlugin.h:777
OrthancPluginSetDescription
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:3172
OrthancPluginDicomWebBinaryMode
OrthancPluginDicomWebBinaryMode
Definition: OrthancCPlugin.h:927
OrthancPluginIdentifierConstraint_Wildcard
Definition: OrthancCPlugin.h:844
OrthancPluginPixelFormat_Grayscale64
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:654
OrthancPluginConstraintType_GreaterOrEqual
Definition: OrthancCPlugin.h:858
OrthancPluginErrorCode_NoCFindHandler
Definition: OrthancCPlugin.h:275
OrthancPluginValueRepresentation_IS
Definition: OrthancCPlugin.h:762
OrthancPluginErrorCode_BadGeometry
Definition: OrthancCPlugin.h:248
OrthancPluginLogWarning
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:1826
OrthancPluginValueRepresentation_UI
Definition: OrthancCPlugin.h:775
OrthancPluginGetImagePixelFormat
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3697
OrthancPluginStorageCommitmentFailureReason_Success
Definition: OrthancCPlugin.h:942
OrthancPluginErrorCode_CreateDicomParentIsInstance
Definition: OrthancCPlugin.h:290
OrthancPluginFree
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1139
OrthancPluginRedirect
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2358
OrthancPluginValueRepresentation_SS
Definition: OrthancCPlugin.h:772
OrthancPluginJobReset
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1528
OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
Definition: OrthancCPlugin.h:960
OrthancPluginGetFindQueryTagName
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:5849
OrthancPluginCreateJob
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:6479
OrthancPluginWorklistMarkIncomplete
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5001
OrthancPluginEncodeDicomWebJson
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:6788
OrthancPluginErrorCode_SQLiteCommitWithoutTransaction
Definition: OrthancCPlugin.h:255
OrthancPluginValueRepresentation_PN
Definition: OrthancCPlugin.h:768
OrthancPluginErrorCode
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:201
OrthancPluginErrorCode_Plugin
Definition: OrthancCPlugin.h:211
OrthancPluginErrorCode_UriSyntax
Definition: OrthancCPlugin.h:222
OrthancPluginStorageRead
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1194
OrthancPluginJobsUnserializer
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1544
OrthancPluginChangeType_UpdatedMetadata
Definition: OrthancCPlugin.h:710
OrthancPluginMemoryBuffer
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:979
OrthancPluginValueRepresentation_FL
Definition: OrthancCPlugin.h:761
OrthancPluginFreePeers
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6149
OrthancPluginWorklistAnswers
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1038
OrthancPluginRegisterFindCallback
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5689
OrthancPluginImage
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1014
OrthancPluginConstraintType_List
Definition: OrthancCPlugin.h:860
OrthancPluginJob
struct _OrthancPluginJob_t OrthancPluginJob
Opaque structure to a job to be executed by Orthanc.
Definition: OrthancCPlugin.h:1078
OrthancPluginErrorCode_BadSequenceOfCalls
Definition: OrthancCPlugin.h:216
OrthancPluginContentType_Unknown
Definition: OrthancCPlugin.h:666
OrthancPluginIncomingHttpRequestFilter2
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:1289
OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
Definition: OrthancCPlugin.h:965
OrthancPluginFindMatcher
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:1062
OrthancPluginHttpMethod
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:319
OrthancPluginFindCallback
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1316
OrthancPluginFreeImage
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:3917
OrthancPluginDicomWebNode
struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode
Opaque structure that represents a node in a JSON or XML document used in DICOMweb.
Definition: OrthancCPlugin.h:1087
OrthancPluginAutodetectMimeType
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:6679
OrthancPluginErrorCode_DicomMoveUnavailable
Definition: OrthancCPlugin.h:282
OrthancPluginErrorCode_DicomPortInUse
Definition: OrthancCPlugin.h:269
OrthancPluginFreeMove
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1413
OrthancPluginGetFontName
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4338
OrthancPluginSetCookie
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2651
OrthancPluginJobFinalize
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1426
OrthancPluginApplyMove
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1399
OrthancPluginErrorCode_EmptyRequest
Definition: OrthancCPlugin.h:243
OrthancPluginErrorCode_CanceledJob
Definition: OrthancCPlugin.h:247
OrthancPluginJobStepStatus_Failure
Definition: OrthancCPlugin.h:887
OrthancPluginPixelFormat_Grayscale32
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:630
OrthancPluginGetPeers
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6115
OrthancPluginErrorCode_NoPresentationContext
Definition: OrthancCPlugin.h:280
OrthancPluginErrorCode_NetworkProtocol
Definition: OrthancCPlugin.h:219
OrthancPluginSubmitJob
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int priority)
Submit a new job to the jobs engine of Orthanc.
Definition: OrthancCPlugin.h:6566
OrthancPluginDicomToJsonFormat_Full
Definition: OrthancCPlugin.h:792
OrthancPluginRegisterRefreshMetricsCallback
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:6753
OrthancPluginHttpMethod_Delete
Definition: OrthancCPlugin.h:324
OrthancPluginErrorCode_UnknownDicomTag
Definition: OrthancCPlugin.h:237
OrthancPluginInstanceOrigin_DicomProtocol
Definition: OrthancCPlugin.h:872
OrthancPluginResourceType_Series
Definition: OrthancCPlugin.h:682
OrthancPluginErrorCode_IncompatibleImageFormat
Definition: OrthancCPlugin.h:233
OrthancPluginChangeType_NewStudy
Definition: OrthancCPlugin.h:703
OrthancPluginErrorCode_FullStorage
Definition: OrthancCPlugin.h:229
OrthancPluginDictionaryEntry
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1621
OrthancPluginCreateImageAccessor
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:5267
OrthancPluginJobStopReason_Paused
Definition: OrthancCPlugin.h:901
OrthancPluginGetPeerUserProperty
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:6314
OrthancPluginLookupPatient
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2390
OrthancPluginJobStopReason_Success
Definition: OrthancCPlugin.h:900
OrthancPluginErrorCode_SQLiteAlreadyOpened
Definition: OrthancCPlugin.h:250
OrthancPluginFreeString
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1640
OrthancPluginWriteFile
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3577
OrthancPluginGetCommandLineArgument
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3332
OrthancPluginJobStepStatus_Continue
Definition: OrthancCPlugin.h:888
OrthancPluginErrorCode_RegularFileExpected
Definition: OrthancCPlugin.h:271
OrthancPluginLookupInstance
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2530
OrthancPluginChunkedHttpClient
OrthancPluginErrorCode OrthancPluginChunkedHttpClient(OrthancPluginContext *context, void *answer, OrthancPluginChunkedClientAnswerAddChunk answerAddChunk, OrthancPluginChunkedClientAnswerAddHeader answerAddHeader, uint16_t *httpStatus, OrthancPluginHttpMethod method, const char *url, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, void *request, OrthancPluginChunkedClientRequestIsDone requestIsDone, OrthancPluginChunkedClientRequestGetChunkData requestChunkData, OrthancPluginChunkedClientRequestGetChunkSize requestChunkSize, OrthancPluginChunkedClientRequestNext requestNext, const char *username, const char *password, uint32_t timeout, const char *certificateFile, const char *certificateKeyFile, const char *certificateKeyPassword, uint8_t pkcs11)
Issue a HTTP call, using chunked HTTP transfers.
Definition: OrthancCPlugin.h:7040
OrthancPluginErrorCode_SslDisabled
Definition: OrthancCPlugin.h:304
OrthancPluginErrorCode_CreateDicomUseDataUriScheme
Definition: OrthancCPlugin.h:288
OrthancPluginContext
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginChangeType
OrthancPluginChangeType
Definition: OrthancCPlugin.h:695
OrthancPluginErrorCode_CannotCreateLua
Definition: OrthancCPlugin.h:295
OrthancPluginErrorCode_BadHttpStatusInRest
Definition: OrthancCPlugin.h:270
OrthancPluginErrorCode_StorageAreaAlreadyRegistered
Definition: OrthancCPlugin.h:301
OrthancPluginJobStepStatus
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:884
OrthancPluginUncompressImage
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:3875
OrthancPluginRegisterRestCallbackNoLock
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:1918
OrthancPluginCheckVersionAdvanced
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:1670
OrthancPluginValueRepresentation_US
Definition: OrthancCPlugin.h:778
OrthancPluginWorklistIsMatch
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:5039
OrthancPluginErrorCode_DatabaseNotInitialized
Definition: OrthancCPlugin.h:303
OrthancPluginDicomToJsonFlags_IncludeUnknownTags
Definition: OrthancCPlugin.h:810
OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
Definition: OrthancCPlugin.h:952
OrthancPluginMemoryBuffer::size
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:989
OrthancPluginJobStopReason
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:898
OrthancPluginRegisterPrivateDictionaryTag
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:4702
OrthancPluginStorageAreaRemove
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4554
OrthancPluginGetPeersCount
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6179
OrthancPluginGetFindQuerySize
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5781
OrthancPluginLogInfo
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:1842
OrthancPluginErrorCode_SQLiteRollbackWithoutTransaction
Definition: OrthancCPlugin.h:254
OrthancPluginHasInstanceMetadata
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:2891
OrthancPluginFindMarkIncomplete
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:5757
OrthancPluginFindQuery
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1046
OrthancPluginDicomInstance
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance received by Orthanc.
Definition: OrthancCPlugin.h:1006
OrthancPluginHttpGet
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:4107
OrthancPluginErrorCode_BadFileFormat
Definition: OrthancCPlugin.h:225
OrthancPluginErrorCode_BadJson
Definition: OrthancCPlugin.h:238
OrthancPluginChunkedClientRequestGetChunkSize
uint32_t(* OrthancPluginChunkedClientRequestGetChunkSize)(void *request)
Callback to read the size of the current request chunk during a chunked transfer.
Definition: OrthancCPlugin.h:6961
OrthancPluginResourceType_Study
Definition: OrthancCPlugin.h:681
OrthancPluginStorageCommitmentFailureReason
OrthancPluginStorageCommitmentFailureReason
Definition: OrthancCPlugin.h:940
OrthancPluginContentType_DicomAsJson
Definition: OrthancCPlugin.h:668
OrthancPluginDicomWebBinaryCallback
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:1590
OrthancPluginErrorCode_HttpPortInUse
Definition: OrthancCPlugin.h:268
OrthancPluginErrorCode_PathToExecutable
Definition: OrthancCPlugin.h:272
OrthancPluginMetricsType
OrthancPluginMetricsType
Definition: OrthancCPlugin.h:910
OrthancPluginBufferCompression
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:3509
OrthancPluginGetDicomForInstance
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2076
OrthancPluginOnStoredInstanceCallback
OrthancPluginErrorCode(* OrthancPluginOnStoredInstanceCallback)(OrthancPluginDicomInstance *instance, const char *instanceId)
Signature of a callback function that is triggered when Orthanc receives a DICOM instance.
Definition: OrthancCPlugin.h:1106
OrthancPluginWorklistGetDicomQuery
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5078
OrthancPluginErrorCode_NullPointer
Definition: OrthancCPlugin.h:245
OrthancPluginSetHttpErrorDetails
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:6647
OrthancPluginErrorCode_SharedLibrary
Definition: OrthancCPlugin.h:235
OrthancPluginChunkedClientAnswerAddHeader
OrthancPluginErrorCode(* OrthancPluginChunkedClientAnswerAddHeader)(void *answer, const char *key, const char *value)
Callback executed when a HTTP header is received during a chunked transfer.
Definition: OrthancCPlugin.h:6871
OrthancPluginErrorCode_FileStorageCannotWrite
Definition: OrthancCPlugin.h:266
OrthancPluginFindMatcherIsMatch
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:6045
OrthancPluginValueRepresentation_OW
Definition: OrthancCPlugin.h:767
OrthancPluginValueRepresentation_OF
Definition: OrthancCPlugin.h:766
OrthancPluginChunkedClientRequestNext
OrthancPluginErrorCode(* OrthancPluginChunkedClientRequestNext)(void *request)
Callback to advance in the request body during a chunked transfer.
Definition: OrthancCPlugin.h:6929
OrthancPluginErrorCode_SQLiteNotOpened
Definition: OrthancCPlugin.h:249
OrthancPluginRestApiPost
OrthancPluginErrorCode OrthancPluginRestApiPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a POST call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2176
OrthancPluginRegisterStorageArea
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:2980
OrthancPluginStorageCommitmentFactory
OrthancPluginErrorCode(* OrthancPluginStorageCommitmentFactory)(void **handler, const char *jobId, const char *transactionUid, const char *const *sopClassUids, const char *const *sopInstanceUids, uint32_t countInstances, const char *remoteAet, const char *calledAet)
Callback executed by the storage commitment SCP.
Definition: OrthancCPlugin.h:7328
OrthancPluginJobStepStatus_Success
Definition: OrthancCPlugin.h:886
OrthancPluginErrorCode_BadParameterType
Definition: OrthancCPlugin.h:215
OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
Definition: OrthancCPlugin.h:945
OrthancPluginRestApiGetAfterPlugins
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:2139
OrthancPluginSendMultipartItem2
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:5483
OrthancPluginGetFindQueryValue
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:5887
OrthancPluginImageFormat_Png
Definition: OrthancCPlugin.h:739
OrthancPluginPixelFormat
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:572
OrthancPluginErrorCode_LuaBadOutput
Definition: OrthancCPlugin.h:298
OrthancPluginSendUnauthorized
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2598
OrthancPluginErrorCode_DatabasePlugin
Definition: OrthancCPlugin.h:241
OrthancPluginPixelFormat_Grayscale16
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:588
OrthancPluginSendMethodNotAllowed
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2621
OrthancPluginStorageCommitmentDestructor
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7350
OrthancPluginSetHttpHeader
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2676
OrthancPluginRegisterDictionaryTag
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:4649
OrthancPluginErrorCode_NotLuaPredicate
Definition: OrthancCPlugin.h:299
OrthancPluginLookupStudy
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2425
OrthancPluginErrorCode_NotAcceptable
Definition: OrthancCPlugin.h:244
OrthancPluginDecodeDicomImage
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5312
OrthancPluginGetConfiguration
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3397