Orthanc Plugin SDK  1.6.1
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1 
112 #pragma once
113 
114 
115 #include <stdio.h>
116 #include <string.h>
117 
118 #ifdef WIN32
119 # define ORTHANC_PLUGINS_API __declspec(dllexport)
120 #elif __GNUC__ >= 4
121 # define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default")))
122 #else
123 # define ORTHANC_PLUGINS_API
124 #endif
125 
126 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
127 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 6
128 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 1
129 
130 
131 #if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
132 #define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
133  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
134  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
135  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
136  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
137  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
138 #endif
139 
140 
141 
142 /********************************************************************
143  ** Check that function inlining is properly supported. The use of
144  ** inlining is required, to avoid the duplication of object code
145  ** between two compilation modules that would use the Orthanc Plugin
146  ** API.
147  ********************************************************************/
148 
149 /* If the auto-detection of the "inline" keyword below does not work
150  automatically and that your compiler is known to properly support
151  inlining, uncomment the following #define and adapt the definition
152  of "static inline". */
153 
154 /* #define ORTHANC_PLUGIN_INLINE static inline */
155 
156 #ifndef ORTHANC_PLUGIN_INLINE
157 # if __STDC_VERSION__ >= 199901L
158 /* This is C99 or above: http://predef.sourceforge.net/prestd.html */
159 # define ORTHANC_PLUGIN_INLINE static inline
160 # elif defined(__cplusplus)
161 /* This is C++ */
162 # define ORTHANC_PLUGIN_INLINE static inline
163 # elif defined(__GNUC__)
164 /* This is GCC running in C89 mode */
165 # define ORTHANC_PLUGIN_INLINE static __inline
166 # elif defined(_MSC_VER)
167 /* This is Visual Studio running in C89 mode */
168 # define ORTHANC_PLUGIN_INLINE static __inline
169 # else
170 # error Your compiler is not known to support the "inline" keyword
171 # endif
172 #endif
173 
174 
175 
176 /********************************************************************
177  ** Inclusion of standard libraries.
178  ********************************************************************/
179 
185 #include <stdint.h>
186 
187 #include <stdlib.h>
188 
189 
190 
191 /********************************************************************
192  ** Definition of the Orthanc Plugin API.
193  ********************************************************************/
194 
197 #ifdef __cplusplus
198 extern "C"
199 {
200 #endif
201 
205  typedef enum
206  {
309 
310  _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
312 
313 
318  ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
319 
320 
324  typedef enum
325  {
331  _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
333 
334 
339  typedef struct
340  {
345 
349  uint32_t groupsCount;
350 
354  const char* const* groups;
355 
359  uint32_t getCount;
360 
364  const char* const* getKeys;
365 
369  const char* const* getValues;
370 
374  const void* body;
375 
379  uint32_t bodySize;
380 
381 
382  /* --------------------------------------------------
383  New in version 0.8.1
384  -------------------------------------------------- */
385 
389  uint32_t headersCount;
390 
394  const char* const* headersKeys;
395 
399  const char* const* headersValues;
400 
402 
403 
404  typedef enum
405  {
406  /* Generic services */
407  _OrthancPluginService_LogInfo = 1,
408  _OrthancPluginService_LogWarning = 2,
409  _OrthancPluginService_LogError = 3,
410  _OrthancPluginService_GetOrthancPath = 4,
411  _OrthancPluginService_GetOrthancDirectory = 5,
412  _OrthancPluginService_GetConfigurationPath = 6,
413  _OrthancPluginService_SetPluginProperty = 7,
414  _OrthancPluginService_GetGlobalProperty = 8,
415  _OrthancPluginService_SetGlobalProperty = 9,
416  _OrthancPluginService_GetCommandLineArgumentsCount = 10,
417  _OrthancPluginService_GetCommandLineArgument = 11,
418  _OrthancPluginService_GetExpectedDatabaseVersion = 12,
419  _OrthancPluginService_GetConfiguration = 13,
420  _OrthancPluginService_BufferCompression = 14,
421  _OrthancPluginService_ReadFile = 15,
422  _OrthancPluginService_WriteFile = 16,
423  _OrthancPluginService_GetErrorDescription = 17,
424  _OrthancPluginService_CallHttpClient = 18,
425  _OrthancPluginService_RegisterErrorCode = 19,
426  _OrthancPluginService_RegisterDictionaryTag = 20,
427  _OrthancPluginService_DicomBufferToJson = 21,
428  _OrthancPluginService_DicomInstanceToJson = 22,
429  _OrthancPluginService_CreateDicom = 23,
430  _OrthancPluginService_ComputeMd5 = 24,
431  _OrthancPluginService_ComputeSha1 = 25,
432  _OrthancPluginService_LookupDictionary = 26,
433  _OrthancPluginService_CallHttpClient2 = 27,
434  _OrthancPluginService_GenerateUuid = 28,
435  _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
436  _OrthancPluginService_AutodetectMimeType = 30,
437  _OrthancPluginService_SetMetricsValue = 31,
438  _OrthancPluginService_EncodeDicomWebJson = 32,
439  _OrthancPluginService_EncodeDicomWebXml = 33,
440  _OrthancPluginService_ChunkedHttpClient = 34, /* New in Orthanc 1.5.7 */
441  _OrthancPluginService_GetTagName = 35, /* New in Orthanc 1.5.7 */
442 
443  /* Registration of callbacks */
444  _OrthancPluginService_RegisterRestCallback = 1000,
445  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
446  _OrthancPluginService_RegisterStorageArea = 1002,
447  _OrthancPluginService_RegisterOnChangeCallback = 1003,
448  _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
449  _OrthancPluginService_RegisterWorklistCallback = 1005,
450  _OrthancPluginService_RegisterDecodeImageCallback = 1006,
451  _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
452  _OrthancPluginService_RegisterFindCallback = 1008,
453  _OrthancPluginService_RegisterMoveCallback = 1009,
454  _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
455  _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
456  _OrthancPluginService_RegisterChunkedRestCallback = 1012, /* New in Orthanc 1.5.7 */
457  _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
458  _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
459 
460  /* Sending answers to REST calls */
461  _OrthancPluginService_AnswerBuffer = 2000,
462  _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
463  _OrthancPluginService_Redirect = 2002,
464  _OrthancPluginService_SendHttpStatusCode = 2003,
465  _OrthancPluginService_SendUnauthorized = 2004,
466  _OrthancPluginService_SendMethodNotAllowed = 2005,
467  _OrthancPluginService_SetCookie = 2006,
468  _OrthancPluginService_SetHttpHeader = 2007,
469  _OrthancPluginService_StartMultipartAnswer = 2008,
470  _OrthancPluginService_SendMultipartItem = 2009,
471  _OrthancPluginService_SendHttpStatus = 2010,
472  _OrthancPluginService_CompressAndAnswerImage = 2011,
473  _OrthancPluginService_SendMultipartItem2 = 2012,
474  _OrthancPluginService_SetHttpErrorDetails = 2013,
475 
476  /* Access to the Orthanc database and API */
477  _OrthancPluginService_GetDicomForInstance = 3000,
478  _OrthancPluginService_RestApiGet = 3001,
479  _OrthancPluginService_RestApiPost = 3002,
480  _OrthancPluginService_RestApiDelete = 3003,
481  _OrthancPluginService_RestApiPut = 3004,
482  _OrthancPluginService_LookupPatient = 3005,
483  _OrthancPluginService_LookupStudy = 3006,
484  _OrthancPluginService_LookupSeries = 3007,
485  _OrthancPluginService_LookupInstance = 3008,
486  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
487  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
488  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
489  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
490  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
491  _OrthancPluginService_ReconstructMainDicomTags = 3014,
492  _OrthancPluginService_RestApiGet2 = 3015,
493 
494  /* Access to DICOM instances */
495  _OrthancPluginService_GetInstanceRemoteAet = 4000,
496  _OrthancPluginService_GetInstanceSize = 4001,
497  _OrthancPluginService_GetInstanceData = 4002,
498  _OrthancPluginService_GetInstanceJson = 4003,
499  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
500  _OrthancPluginService_HasInstanceMetadata = 4005,
501  _OrthancPluginService_GetInstanceMetadata = 4006,
502  _OrthancPluginService_GetInstanceOrigin = 4007,
503  _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
504  _OrthancPluginService_HasInstancePixelData = 4009,
505 
506  /* Services for plugins implementing a database back-end */
507  _OrthancPluginService_RegisterDatabaseBackend = 5000,
508  _OrthancPluginService_DatabaseAnswer = 5001,
509  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
510  _OrthancPluginService_StorageAreaCreate = 5003,
511  _OrthancPluginService_StorageAreaRead = 5004,
512  _OrthancPluginService_StorageAreaRemove = 5005,
513 
514  /* Primitives for handling images */
515  _OrthancPluginService_GetImagePixelFormat = 6000,
516  _OrthancPluginService_GetImageWidth = 6001,
517  _OrthancPluginService_GetImageHeight = 6002,
518  _OrthancPluginService_GetImagePitch = 6003,
519  _OrthancPluginService_GetImageBuffer = 6004,
520  _OrthancPluginService_UncompressImage = 6005,
521  _OrthancPluginService_FreeImage = 6006,
522  _OrthancPluginService_CompressImage = 6007,
523  _OrthancPluginService_ConvertPixelFormat = 6008,
524  _OrthancPluginService_GetFontsCount = 6009,
525  _OrthancPluginService_GetFontInfo = 6010,
526  _OrthancPluginService_DrawText = 6011,
527  _OrthancPluginService_CreateImage = 6012,
528  _OrthancPluginService_CreateImageAccessor = 6013,
529  _OrthancPluginService_DecodeDicomImage = 6014,
530 
531  /* Primitives for handling C-Find, C-Move and worklists */
532  _OrthancPluginService_WorklistAddAnswer = 7000,
533  _OrthancPluginService_WorklistMarkIncomplete = 7001,
534  _OrthancPluginService_WorklistIsMatch = 7002,
535  _OrthancPluginService_WorklistGetDicomQuery = 7003,
536  _OrthancPluginService_FindAddAnswer = 7004,
537  _OrthancPluginService_FindMarkIncomplete = 7005,
538  _OrthancPluginService_GetFindQuerySize = 7006,
539  _OrthancPluginService_GetFindQueryTag = 7007,
540  _OrthancPluginService_GetFindQueryTagName = 7008,
541  _OrthancPluginService_GetFindQueryValue = 7009,
542  _OrthancPluginService_CreateFindMatcher = 7010,
543  _OrthancPluginService_FreeFindMatcher = 7011,
544  _OrthancPluginService_FindMatcherIsMatch = 7012,
545 
546  /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
547  _OrthancPluginService_GetPeers = 8000,
548  _OrthancPluginService_FreePeers = 8001,
549  _OrthancPluginService_GetPeersCount = 8003,
550  _OrthancPluginService_GetPeerName = 8004,
551  _OrthancPluginService_GetPeerUrl = 8005,
552  _OrthancPluginService_CallPeerApi = 8006,
553  _OrthancPluginService_GetPeerUserProperty = 8007,
554 
555  /* Primitives for handling jobs (new in 1.4.2) */
556  _OrthancPluginService_CreateJob = 9000,
557  _OrthancPluginService_FreeJob = 9001,
558  _OrthancPluginService_SubmitJob = 9002,
559  _OrthancPluginService_RegisterJobsUnserializer = 9003,
560 
561  _OrthancPluginService_INTERNAL = 0x7fffffff
562  } _OrthancPluginService;
563 
564 
565  typedef enum
566  {
567  _OrthancPluginProperty_Description = 1,
568  _OrthancPluginProperty_RootUri = 2,
569  _OrthancPluginProperty_OrthancExplorer = 3,
570 
571  _OrthancPluginProperty_INTERNAL = 0x7fffffff
572  } _OrthancPluginProperty;
573 
574 
575 
580  typedef enum
581  {
589 
597 
605 
613 
621 
631 
639 
647 
655 
663 
664  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
666 
667 
668 
672  typedef enum
673  {
678  _OrthancPluginContentType_INTERNAL = 0x7fffffff
680 
681 
682 
686  typedef enum
687  {
694  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
696 
697 
698 
703  typedef enum
704  {
722  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
724 
725 
730  typedef enum
731  {
737  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
739 
740 
745  typedef enum
746  {
751  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
753 
754 
759  typedef enum
760  {
789  _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
791 
792 
798  typedef enum
799  {
804  _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
806 
807 
813  typedef enum
814  {
815  OrthancPluginDicomToJsonFlags_None = 0,
823  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
825 
826 
832  typedef enum
833  {
834  OrthancPluginCreateDicomFlags_None = 0,
838  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
840 
841 
847  typedef enum
848  {
854  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
856 
857 
862  typedef enum
863  {
870  _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
872 
873 
877  typedef enum
878  {
885  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
887 
888 
892  typedef enum
893  {
898 
899 
906  typedef enum
907  {
913 
914 
918  typedef enum
919  {
929 
930 
935  typedef enum
936  {
941 
942 
948  typedef enum
949  {
977 
978 
979 
987  typedef struct
988  {
992  void* data;
993 
997  uint32_t size;
999 
1000 
1001 
1002 
1007  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
1008 
1009 
1010 
1014  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
1015 
1016 
1017 
1022  typedef struct _OrthancPluginImage_t OrthancPluginImage;
1023 
1024 
1025 
1030  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
1031 
1032 
1033 
1038  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
1039 
1040 
1041 
1046  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
1047 
1048 
1049 
1054  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1055 
1056 
1057 
1062  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1063 
1064 
1065 
1070  typedef struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher;
1071 
1072 
1073 
1078  typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1079 
1080 
1081 
1086  typedef struct _OrthancPluginJob_t OrthancPluginJob;
1087 
1088 
1089 
1095  typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1096 
1097 
1098 
1104  OrthancPluginRestOutput* output,
1105  const char* url,
1106  const OrthancPluginHttpRequest* request);
1107 
1108 
1109 
1115  const OrthancPluginDicomInstance* instance,
1116  const char* instanceId);
1117 
1118 
1119 
1125  OrthancPluginChangeType changeType,
1126  OrthancPluginResourceType resourceType,
1127  const char* resourceId);
1128 
1129 
1130 
1136  OrthancPluginImage** target,
1137  const void* dicom,
1138  const uint32_t size,
1139  uint32_t frameIndex);
1140 
1141 
1142 
1147  typedef void (*OrthancPluginFree) (void* buffer);
1148 
1149 
1150 
1157  typedef void (*OrthancPluginDicomWebSetBinaryNode) (
1160  const char* bulkDataUri);
1161 
1162 
1163 
1177  const char* uuid,
1178  const void* content,
1179  int64_t size,
1181 
1182 
1183 
1203  void** content,
1204  int64_t* size,
1205  const char* uuid,
1207 
1208 
1209 
1221  const char* uuid,
1223 
1224 
1225 
1241  const OrthancPluginWorklistQuery* query,
1242  const char* issuerAet,
1243  const char* calledAet);
1244 
1245 
1246 
1266  typedef int32_t (*OrthancPluginIncomingHttpRequestFilter) (
1267  OrthancPluginHttpMethod method,
1268  const char* uri,
1269  const char* ip,
1270  uint32_t headersCount,
1271  const char* const* headersKeys,
1272  const char* const* headersValues);
1273 
1274 
1275 
1297  typedef int32_t (*OrthancPluginIncomingHttpRequestFilter2) (
1298  OrthancPluginHttpMethod method,
1299  const char* uri,
1300  const char* ip,
1301  uint32_t headersCount,
1302  const char* const* headersKeys,
1303  const char* const* headersValues,
1304  uint32_t getArgumentsCount,
1305  const char* const* getArgumentsKeys,
1306  const char* const* getArgumentsValues);
1307 
1308 
1309 
1325  OrthancPluginFindAnswers* answers,
1326  const OrthancPluginFindQuery* query,
1327  const char* issuerAet,
1328  const char* calledAet);
1329 
1330 
1331 
1367  typedef void* (*OrthancPluginMoveCallback) (
1368  OrthancPluginResourceType resourceType,
1369  const char* patientId,
1370  const char* accessionNumber,
1371  const char* studyInstanceUid,
1372  const char* seriesInstanceUid,
1373  const char* sopInstanceUid,
1374  const char* originatorAet,
1375  const char* sourceAet,
1376  const char* targetAet,
1377  uint16_t originatorId);
1378 
1379 
1392  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1393 
1394 
1407  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1408 
1409 
1421  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1422 
1423 
1434  typedef void (*OrthancPluginJobFinalize) (void* job);
1435 
1436 
1447  typedef float (*OrthancPluginJobGetProgress) (void* job);
1448 
1449 
1462  typedef const char* (*OrthancPluginJobGetContent) (void* job);
1463 
1464 
1480  typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1481 
1482 
1495  typedef OrthancPluginJobStepStatus (*OrthancPluginJobStep) (void* job);
1496 
1497 
1519  typedef OrthancPluginErrorCode (*OrthancPluginJobStop) (void* job,
1521 
1522 
1536  typedef OrthancPluginErrorCode (*OrthancPluginJobReset) (void* job);
1537 
1538 
1552  typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1553  const char* serialized);
1554 
1555 
1556 
1570  typedef void (*OrthancPluginRefreshMetricsCallback) ();
1571 
1572 
1573 
1598  typedef void (*OrthancPluginDicomWebBinaryCallback) (
1601  uint32_t levelDepth,
1602  const uint16_t* levelTagGroup,
1603  const uint16_t* levelTagElement,
1604  const uint32_t* levelIndex,
1605  uint16_t tagGroup,
1606  uint16_t tagElement,
1608 
1609 
1610 
1614  typedef struct _OrthancPluginContext_t
1615  {
1616  void* pluginsManager;
1617  const char* orthancVersion;
1618  OrthancPluginFree Free;
1619  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1620  _OrthancPluginService service,
1621  const void* params);
1623 
1624 
1625 
1629  typedef struct
1630  {
1631  uint16_t group;
1632  uint16_t element;
1634  uint32_t minMultiplicity;
1635  uint32_t maxMultiplicity;
1637 
1638 
1639 
1648  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1649  OrthancPluginContext* context,
1650  char* str)
1651  {
1652  if (str != NULL)
1653  {
1654  context->Free(str);
1655  }
1656  }
1657 
1658 
1678  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1679  OrthancPluginContext* context,
1680  int expectedMajor,
1681  int expectedMinor,
1682  int expectedRevision)
1683  {
1684  int major, minor, revision;
1685 
1686  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1687  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1688  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1689  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1690  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1691  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1692  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1693  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1694  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1695  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1696  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1697  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1698  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1699  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1700  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1701  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1702  sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1703  sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
1704  sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
1705  sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
1706  sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason))
1707  {
1708  /* Mismatch in the size of the enumerations */
1709  return 0;
1710  }
1711 
1712  /* Assume compatibility with the mainline */
1713  if (!strcmp(context->orthancVersion, "mainline"))
1714  {
1715  return 1;
1716  }
1717 
1718  /* Parse the version of the Orthanc core */
1719  if (
1720 #ifdef _MSC_VER
1721  sscanf_s
1722 #else
1723  sscanf
1724 #endif
1725  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1726  {
1727  return 0;
1728  }
1729 
1730  /* Check the major number of the version */
1731 
1732  if (major > expectedMajor)
1733  {
1734  return 1;
1735  }
1736 
1737  if (major < expectedMajor)
1738  {
1739  return 0;
1740  }
1741 
1742  /* Check the minor number of the version */
1743 
1744  if (minor > expectedMinor)
1745  {
1746  return 1;
1747  }
1748 
1749  if (minor < expectedMinor)
1750  {
1751  return 0;
1752  }
1753 
1754  /* Check the revision number of the version */
1755 
1756  if (revision >= expectedRevision)
1757  {
1758  return 1;
1759  }
1760  else
1761  {
1762  return 0;
1763  }
1764  }
1765 
1766 
1783  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1784  OrthancPluginContext* context)
1785  {
1787  context,
1788  ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1789  ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1790  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1791  }
1792 
1793 
1802  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1803  OrthancPluginContext* context,
1804  OrthancPluginMemoryBuffer* buffer)
1805  {
1806  context->Free(buffer->data);
1807  }
1808 
1809 
1818  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1819  OrthancPluginContext* context,
1820  const char* message)
1821  {
1822  context->InvokeService(context, _OrthancPluginService_LogError, message);
1823  }
1824 
1825 
1834  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
1835  OrthancPluginContext* context,
1836  const char* message)
1837  {
1838  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1839  }
1840 
1841 
1850  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
1851  OrthancPluginContext* context,
1852  const char* message)
1853  {
1854  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
1855  }
1856 
1857 
1858 
1859  typedef struct
1860  {
1861  const char* pathRegularExpression;
1862  OrthancPluginRestCallback callback;
1863  } _OrthancPluginRestCallback;
1864 
1886  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
1887  OrthancPluginContext* context,
1888  const char* pathRegularExpression,
1889  OrthancPluginRestCallback callback)
1890  {
1891  _OrthancPluginRestCallback params;
1892  params.pathRegularExpression = pathRegularExpression;
1893  params.callback = callback;
1894  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
1895  }
1896 
1897 
1898 
1926  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
1927  OrthancPluginContext* context,
1928  const char* pathRegularExpression,
1929  OrthancPluginRestCallback callback)
1930  {
1931  _OrthancPluginRestCallback params;
1932  params.pathRegularExpression = pathRegularExpression;
1933  params.callback = callback;
1934  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
1935  }
1936 
1937 
1938 
1939  typedef struct
1940  {
1942  } _OrthancPluginOnStoredInstanceCallback;
1943 
1954  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnStoredInstanceCallback(
1955  OrthancPluginContext* context,
1957  {
1958  _OrthancPluginOnStoredInstanceCallback params;
1959  params.callback = callback;
1960 
1961  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
1962  }
1963 
1964 
1965 
1966  typedef struct
1967  {
1968  OrthancPluginRestOutput* output;
1969  const void* answer;
1970  uint32_t answerSize;
1971  const char* mimeType;
1972  } _OrthancPluginAnswerBuffer;
1973 
1986  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
1987  OrthancPluginContext* context,
1988  OrthancPluginRestOutput* output,
1989  const void* answer,
1990  uint32_t answerSize,
1991  const char* mimeType)
1992  {
1993  _OrthancPluginAnswerBuffer params;
1994  params.output = output;
1995  params.answer = answer;
1996  params.answerSize = answerSize;
1997  params.mimeType = mimeType;
1998  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
1999  }
2000 
2001 
2002  typedef struct
2003  {
2004  OrthancPluginRestOutput* output;
2005  OrthancPluginPixelFormat format;
2006  uint32_t width;
2007  uint32_t height;
2008  uint32_t pitch;
2009  const void* buffer;
2010  } _OrthancPluginCompressAndAnswerPngImage;
2011 
2012  typedef struct
2013  {
2014  OrthancPluginRestOutput* output;
2015  OrthancPluginImageFormat imageFormat;
2016  OrthancPluginPixelFormat pixelFormat;
2017  uint32_t width;
2018  uint32_t height;
2019  uint32_t pitch;
2020  const void* buffer;
2021  uint8_t quality;
2022  } _OrthancPluginCompressAndAnswerImage;
2023 
2024 
2043  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2044  OrthancPluginContext* context,
2045  OrthancPluginRestOutput* output,
2046  OrthancPluginPixelFormat format,
2047  uint32_t width,
2048  uint32_t height,
2049  uint32_t pitch,
2050  const void* buffer)
2051  {
2052  _OrthancPluginCompressAndAnswerImage params;
2053  params.output = output;
2054  params.imageFormat = OrthancPluginImageFormat_Png;
2055  params.pixelFormat = format;
2056  params.width = width;
2057  params.height = height;
2058  params.pitch = pitch;
2059  params.buffer = buffer;
2060  params.quality = 0; /* No quality for PNG */
2061  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2062  }
2063 
2064 
2065 
2066  typedef struct
2067  {
2068  OrthancPluginMemoryBuffer* target;
2069  const char* instanceId;
2070  } _OrthancPluginGetDicomForInstance;
2071 
2085  OrthancPluginContext* context,
2086  OrthancPluginMemoryBuffer* target,
2087  const char* instanceId)
2088  {
2089  _OrthancPluginGetDicomForInstance params;
2090  params.target = target;
2091  params.instanceId = instanceId;
2092  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2093  }
2094 
2095 
2096 
2097  typedef struct
2098  {
2099  OrthancPluginMemoryBuffer* target;
2100  const char* uri;
2101  } _OrthancPluginRestApiGet;
2102 
2117  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiGet(
2118  OrthancPluginContext* context,
2119  OrthancPluginMemoryBuffer* target,
2120  const char* uri)
2121  {
2122  _OrthancPluginRestApiGet params;
2123  params.target = target;
2124  params.uri = uri;
2125  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2126  }
2127 
2128 
2129 
2148  OrthancPluginContext* context,
2149  OrthancPluginMemoryBuffer* target,
2150  const char* uri)
2151  {
2152  _OrthancPluginRestApiGet params;
2153  params.target = target;
2154  params.uri = uri;
2155  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2156  }
2157 
2158 
2159 
2160  typedef struct
2161  {
2162  OrthancPluginMemoryBuffer* target;
2163  const char* uri;
2164  const void* body;
2165  uint32_t bodySize;
2166  } _OrthancPluginRestApiPostPut;
2167 
2184  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiPost(
2185  OrthancPluginContext* context,
2186  OrthancPluginMemoryBuffer* target,
2187  const char* uri,
2188  const void* body,
2189  uint32_t bodySize)
2190  {
2191  _OrthancPluginRestApiPostPut params;
2192  params.target = target;
2193  params.uri = uri;
2194  params.body = body;
2195  params.bodySize = bodySize;
2196  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2197  }
2198 
2199 
2220  OrthancPluginContext* context,
2221  OrthancPluginMemoryBuffer* target,
2222  const char* uri,
2223  const void* body,
2224  uint32_t bodySize)
2225  {
2226  _OrthancPluginRestApiPostPut params;
2227  params.target = target;
2228  params.uri = uri;
2229  params.body = body;
2230  params.bodySize = bodySize;
2231  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2232  }
2233 
2234 
2235 
2248  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiDelete(
2249  OrthancPluginContext* context,
2250  const char* uri)
2251  {
2252  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2253  }
2254 
2255 
2272  OrthancPluginContext* context,
2273  const char* uri)
2274  {
2275  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2276  }
2277 
2278 
2279 
2296  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiPut(
2297  OrthancPluginContext* context,
2298  OrthancPluginMemoryBuffer* target,
2299  const char* uri,
2300  const void* body,
2301  uint32_t bodySize)
2302  {
2303  _OrthancPluginRestApiPostPut params;
2304  params.target = target;
2305  params.uri = uri;
2306  params.body = body;
2307  params.bodySize = bodySize;
2308  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2309  }
2310 
2311 
2312 
2333  OrthancPluginContext* context,
2334  OrthancPluginMemoryBuffer* target,
2335  const char* uri,
2336  const void* body,
2337  uint32_t bodySize)
2338  {
2339  _OrthancPluginRestApiPostPut params;
2340  params.target = target;
2341  params.uri = uri;
2342  params.body = body;
2343  params.bodySize = bodySize;
2344  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2345  }
2346 
2347 
2348 
2349  typedef struct
2350  {
2351  OrthancPluginRestOutput* output;
2352  const char* argument;
2353  } _OrthancPluginOutputPlusArgument;
2354 
2366  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2367  OrthancPluginContext* context,
2368  OrthancPluginRestOutput* output,
2369  const char* redirection)
2370  {
2371  _OrthancPluginOutputPlusArgument params;
2372  params.output = output;
2373  params.argument = redirection;
2374  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2375  }
2376 
2377 
2378 
2379  typedef struct
2380  {
2381  char** result;
2382  const char* argument;
2383  } _OrthancPluginRetrieveDynamicString;
2384 
2398  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2399  OrthancPluginContext* context,
2400  const char* patientID)
2401  {
2402  char* result;
2403 
2404  _OrthancPluginRetrieveDynamicString params;
2405  params.result = &result;
2406  params.argument = patientID;
2407 
2408  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2409  {
2410  /* Error */
2411  return NULL;
2412  }
2413  else
2414  {
2415  return result;
2416  }
2417  }
2418 
2419 
2433  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2434  OrthancPluginContext* context,
2435  const char* studyUID)
2436  {
2437  char* result;
2438 
2439  _OrthancPluginRetrieveDynamicString params;
2440  params.result = &result;
2441  params.argument = studyUID;
2442 
2443  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2444  {
2445  /* Error */
2446  return NULL;
2447  }
2448  else
2449  {
2450  return result;
2451  }
2452  }
2453 
2454 
2468  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
2469  OrthancPluginContext* context,
2470  const char* accessionNumber)
2471  {
2472  char* result;
2473 
2474  _OrthancPluginRetrieveDynamicString params;
2475  params.result = &result;
2476  params.argument = accessionNumber;
2477 
2478  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2479  {
2480  /* Error */
2481  return NULL;
2482  }
2483  else
2484  {
2485  return result;
2486  }
2487  }
2488 
2489 
2503  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2504  OrthancPluginContext* context,
2505  const char* seriesUID)
2506  {
2507  char* result;
2508 
2509  _OrthancPluginRetrieveDynamicString params;
2510  params.result = &result;
2511  params.argument = seriesUID;
2512 
2513  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2514  {
2515  /* Error */
2516  return NULL;
2517  }
2518  else
2519  {
2520  return result;
2521  }
2522  }
2523 
2524 
2538  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2539  OrthancPluginContext* context,
2540  const char* sopInstanceUID)
2541  {
2542  char* result;
2543 
2544  _OrthancPluginRetrieveDynamicString params;
2545  params.result = &result;
2546  params.argument = sopInstanceUID;
2547 
2548  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2549  {
2550  /* Error */
2551  return NULL;
2552  }
2553  else
2554  {
2555  return result;
2556  }
2557  }
2558 
2559 
2560 
2561  typedef struct
2562  {
2563  OrthancPluginRestOutput* output;
2564  uint16_t status;
2565  } _OrthancPluginSendHttpStatusCode;
2566 
2583  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2584  OrthancPluginContext* context,
2585  OrthancPluginRestOutput* output,
2586  uint16_t status)
2587  {
2588  _OrthancPluginSendHttpStatusCode params;
2589  params.output = output;
2590  params.status = status;
2591  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2592  }
2593 
2594 
2606  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2607  OrthancPluginContext* context,
2608  OrthancPluginRestOutput* output,
2609  const char* realm)
2610  {
2611  _OrthancPluginOutputPlusArgument params;
2612  params.output = output;
2613  params.argument = realm;
2614  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2615  }
2616 
2617 
2629  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2630  OrthancPluginContext* context,
2631  OrthancPluginRestOutput* output,
2632  const char* allowedMethods)
2633  {
2634  _OrthancPluginOutputPlusArgument params;
2635  params.output = output;
2636  params.argument = allowedMethods;
2637  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2638  }
2639 
2640 
2641  typedef struct
2642  {
2643  OrthancPluginRestOutput* output;
2644  const char* key;
2645  const char* value;
2646  } _OrthancPluginSetHttpHeader;
2647 
2659  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2660  OrthancPluginContext* context,
2661  OrthancPluginRestOutput* output,
2662  const char* cookie,
2663  const char* value)
2664  {
2665  _OrthancPluginSetHttpHeader params;
2666  params.output = output;
2667  params.key = cookie;
2668  params.value = value;
2669  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2670  }
2671 
2672 
2684  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2685  OrthancPluginContext* context,
2686  OrthancPluginRestOutput* output,
2687  const char* key,
2688  const char* value)
2689  {
2690  _OrthancPluginSetHttpHeader params;
2691  params.output = output;
2692  params.key = key;
2693  params.value = value;
2694  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2695  }
2696 
2697 
2698  typedef struct
2699  {
2700  char** resultStringToFree;
2701  const char** resultString;
2702  int64_t* resultInt64;
2703  const char* key;
2704  const OrthancPluginDicomInstance* instance;
2705  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2706  } _OrthancPluginAccessDicomInstance;
2707 
2708 
2720  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2721  OrthancPluginContext* context,
2722  const OrthancPluginDicomInstance* instance)
2723  {
2724  const char* result;
2725 
2726  _OrthancPluginAccessDicomInstance params;
2727  memset(&params, 0, sizeof(params));
2728  params.resultString = &result;
2729  params.instance = instance;
2730 
2731  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2732  {
2733  /* Error */
2734  return NULL;
2735  }
2736  else
2737  {
2738  return result;
2739  }
2740  }
2741 
2742 
2753  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2754  OrthancPluginContext* context,
2755  const OrthancPluginDicomInstance* instance)
2756  {
2757  int64_t size;
2758 
2759  _OrthancPluginAccessDicomInstance params;
2760  memset(&params, 0, sizeof(params));
2761  params.resultInt64 = &size;
2762  params.instance = instance;
2763 
2764  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2765  {
2766  /* Error */
2767  return -1;
2768  }
2769  else
2770  {
2771  return size;
2772  }
2773  }
2774 
2775 
2786  ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData(
2787  OrthancPluginContext* context,
2788  const OrthancPluginDicomInstance* instance)
2789  {
2790  const char* result;
2791 
2792  _OrthancPluginAccessDicomInstance params;
2793  memset(&params, 0, sizeof(params));
2794  params.resultString = &result;
2795  params.instance = instance;
2796 
2797  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2798  {
2799  /* Error */
2800  return NULL;
2801  }
2802  else
2803  {
2804  return result;
2805  }
2806  }
2807 
2808 
2822  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
2823  OrthancPluginContext* context,
2824  const OrthancPluginDicomInstance* instance)
2825  {
2826  char* result;
2827 
2828  _OrthancPluginAccessDicomInstance params;
2829  memset(&params, 0, sizeof(params));
2830  params.resultStringToFree = &result;
2831  params.instance = instance;
2832 
2833  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
2834  {
2835  /* Error */
2836  return NULL;
2837  }
2838  else
2839  {
2840  return result;
2841  }
2842  }
2843 
2844 
2860  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
2861  OrthancPluginContext* context,
2862  const OrthancPluginDicomInstance* instance)
2863  {
2864  char* result;
2865 
2866  _OrthancPluginAccessDicomInstance params;
2867  memset(&params, 0, sizeof(params));
2868  params.resultStringToFree = &result;
2869  params.instance = instance;
2870 
2871  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
2872  {
2873  /* Error */
2874  return NULL;
2875  }
2876  else
2877  {
2878  return result;
2879  }
2880  }
2881 
2882 
2899  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
2900  OrthancPluginContext* context,
2901  const OrthancPluginDicomInstance* instance,
2902  const char* metadata)
2903  {
2904  int64_t result;
2905 
2906  _OrthancPluginAccessDicomInstance params;
2907  memset(&params, 0, sizeof(params));
2908  params.resultInt64 = &result;
2909  params.instance = instance;
2910  params.key = metadata;
2911 
2912  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2913  {
2914  /* Error */
2915  return -1;
2916  }
2917  else
2918  {
2919  return (result != 0);
2920  }
2921  }
2922 
2923 
2940  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
2941  OrthancPluginContext* context,
2942  const OrthancPluginDicomInstance* instance,
2943  const char* metadata)
2944  {
2945  const char* result;
2946 
2947  _OrthancPluginAccessDicomInstance params;
2948  memset(&params, 0, sizeof(params));
2949  params.resultString = &result;
2950  params.instance = instance;
2951  params.key = metadata;
2952 
2953  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2954  {
2955  /* Error */
2956  return NULL;
2957  }
2958  else
2959  {
2960  return result;
2961  }
2962  }
2963 
2964 
2965 
2966  typedef struct
2967  {
2971  OrthancPluginFree free;
2972  } _OrthancPluginRegisterStorageArea;
2973 
2988  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
2989  OrthancPluginContext* context,
2993  {
2994  _OrthancPluginRegisterStorageArea params;
2995  params.create = create;
2996  params.read = read;
2997  params.remove = remove;
2998 
2999 #ifdef __cplusplus
3000  params.free = ::free;
3001 #else
3002  params.free = free;
3003 #endif
3004 
3005  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3006  }
3007 
3008 
3009 
3020  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3021  {
3022  char* result;
3023 
3024  _OrthancPluginRetrieveDynamicString params;
3025  params.result = &result;
3026  params.argument = NULL;
3027 
3028  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3029  {
3030  /* Error */
3031  return NULL;
3032  }
3033  else
3034  {
3035  return result;
3036  }
3037  }
3038 
3039 
3050  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3051  {
3052  char* result;
3053 
3054  _OrthancPluginRetrieveDynamicString params;
3055  params.result = &result;
3056  params.argument = NULL;
3057 
3058  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3059  {
3060  /* Error */
3061  return NULL;
3062  }
3063  else
3064  {
3065  return result;
3066  }
3067  }
3068 
3069 
3085  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3086  {
3087  char* result;
3088 
3089  _OrthancPluginRetrieveDynamicString params;
3090  params.result = &result;
3091  params.argument = NULL;
3092 
3093  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3094  {
3095  /* Error */
3096  return NULL;
3097  }
3098  else
3099  {
3100  return result;
3101  }
3102  }
3103 
3104 
3105 
3106  typedef struct
3107  {
3109  } _OrthancPluginOnChangeCallback;
3110 
3127  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3128  OrthancPluginContext* context,
3130  {
3131  _OrthancPluginOnChangeCallback params;
3132  params.callback = callback;
3133 
3134  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3135  }
3136 
3137 
3138 
3139  typedef struct
3140  {
3141  const char* plugin;
3142  _OrthancPluginProperty property;
3143  const char* value;
3144  } _OrthancPluginSetPluginProperty;
3145 
3146 
3158  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3159  OrthancPluginContext* context,
3160  const char* uri)
3161  {
3162  _OrthancPluginSetPluginProperty params;
3163  params.plugin = OrthancPluginGetName();
3164  params.property = _OrthancPluginProperty_RootUri;
3165  params.value = uri;
3166 
3167  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3168  }
3169 
3170 
3180  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3181  OrthancPluginContext* context,
3182  const char* description)
3183  {
3184  _OrthancPluginSetPluginProperty params;
3185  params.plugin = OrthancPluginGetName();
3186  params.property = _OrthancPluginProperty_Description;
3187  params.value = description;
3188 
3189  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3190  }
3191 
3192 
3202  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3203  OrthancPluginContext* context,
3204  const char* javascript)
3205  {
3206  _OrthancPluginSetPluginProperty params;
3207  params.plugin = OrthancPluginGetName();
3208  params.property = _OrthancPluginProperty_OrthancExplorer;
3209  params.value = javascript;
3210 
3211  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3212  }
3213 
3214 
3215  typedef struct
3216  {
3217  char** result;
3218  int32_t property;
3219  const char* value;
3220  } _OrthancPluginGlobalProperty;
3221 
3222 
3236  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3237  OrthancPluginContext* context,
3238  int32_t property,
3239  const char* defaultValue)
3240  {
3241  char* result;
3242 
3243  _OrthancPluginGlobalProperty params;
3244  params.result = &result;
3245  params.property = property;
3246  params.value = defaultValue;
3247 
3248  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3249  {
3250  /* Error */
3251  return NULL;
3252  }
3253  else
3254  {
3255  return result;
3256  }
3257  }
3258 
3259 
3276  OrthancPluginContext* context,
3277  int32_t property,
3278  const char* value)
3279  {
3280  _OrthancPluginGlobalProperty params;
3281  params.result = NULL;
3282  params.property = property;
3283  params.value = value;
3284 
3285  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3286  }
3287 
3288 
3289 
3290  typedef struct
3291  {
3292  int32_t *resultInt32;
3293  uint32_t *resultUint32;
3294  int64_t *resultInt64;
3295  uint64_t *resultUint64;
3296  } _OrthancPluginReturnSingleValue;
3297 
3306  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3307  OrthancPluginContext* context)
3308  {
3309  uint32_t count = 0;
3310 
3311  _OrthancPluginReturnSingleValue params;
3312  memset(&params, 0, sizeof(params));
3313  params.resultUint32 = &count;
3314 
3315  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3316  {
3317  /* Error */
3318  return 0;
3319  }
3320  else
3321  {
3322  return count;
3323  }
3324  }
3325 
3326 
3327 
3340  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3341  OrthancPluginContext* context,
3342  uint32_t argument)
3343  {
3344  char* result;
3345 
3346  _OrthancPluginGlobalProperty params;
3347  params.result = &result;
3348  params.property = (int32_t) argument;
3349  params.value = NULL;
3350 
3351  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3352  {
3353  /* Error */
3354  return NULL;
3355  }
3356  else
3357  {
3358  return result;
3359  }
3360  }
3361 
3362 
3372  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3373  OrthancPluginContext* context)
3374  {
3375  uint32_t count = 0;
3376 
3377  _OrthancPluginReturnSingleValue params;
3378  memset(&params, 0, sizeof(params));
3379  params.resultUint32 = &count;
3380 
3381  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3382  {
3383  /* Error */
3384  return 0;
3385  }
3386  else
3387  {
3388  return count;
3389  }
3390  }
3391 
3392 
3393 
3405  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3406  {
3407  char* result;
3408 
3409  _OrthancPluginRetrieveDynamicString params;
3410  params.result = &result;
3411  params.argument = NULL;
3412 
3413  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3414  {
3415  /* Error */
3416  return NULL;
3417  }
3418  else
3419  {
3420  return result;
3421  }
3422  }
3423 
3424 
3425 
3426  typedef struct
3427  {
3428  OrthancPluginRestOutput* output;
3429  const char* subType;
3430  const char* contentType;
3431  } _OrthancPluginStartMultipartAnswer;
3432 
3447  OrthancPluginContext* context,
3448  OrthancPluginRestOutput* output,
3449  const char* subType,
3450  const char* contentType)
3451  {
3452  _OrthancPluginStartMultipartAnswer params;
3453  params.output = output;
3454  params.subType = subType;
3455  params.contentType = contentType;
3456  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3457  }
3458 
3459 
3476  OrthancPluginContext* context,
3477  OrthancPluginRestOutput* output,
3478  const char* answer,
3479  uint32_t answerSize)
3480  {
3481  _OrthancPluginAnswerBuffer params;
3482  params.output = output;
3483  params.answer = answer;
3484  params.answerSize = answerSize;
3485  params.mimeType = NULL;
3486  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3487  }
3488 
3489 
3490 
3491  typedef struct
3492  {
3493  OrthancPluginMemoryBuffer* target;
3494  const void* source;
3495  uint32_t size;
3496  OrthancPluginCompressionType compression;
3497  uint8_t uncompress;
3498  } _OrthancPluginBufferCompression;
3499 
3500 
3518  OrthancPluginContext* context,
3519  OrthancPluginMemoryBuffer* target,
3520  const void* source,
3521  uint32_t size,
3522  OrthancPluginCompressionType compression,
3523  uint8_t uncompress)
3524  {
3525  _OrthancPluginBufferCompression params;
3526  params.target = target;
3527  params.source = source;
3528  params.size = size;
3529  params.compression = compression;
3530  params.uncompress = uncompress;
3531 
3532  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3533  }
3534 
3535 
3536 
3537  typedef struct
3538  {
3539  OrthancPluginMemoryBuffer* target;
3540  const char* path;
3541  } _OrthancPluginReadFile;
3542 
3554  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginReadFile(
3555  OrthancPluginContext* context,
3556  OrthancPluginMemoryBuffer* target,
3557  const char* path)
3558  {
3559  _OrthancPluginReadFile params;
3560  params.target = target;
3561  params.path = path;
3562  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3563  }
3564 
3565 
3566 
3567  typedef struct
3568  {
3569  const char* path;
3570  const void* data;
3571  uint32_t size;
3572  } _OrthancPluginWriteFile;
3573 
3585  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginWriteFile(
3586  OrthancPluginContext* context,
3587  const char* path,
3588  const void* data,
3589  uint32_t size)
3590  {
3591  _OrthancPluginWriteFile params;
3592  params.path = path;
3593  params.data = data;
3594  params.size = size;
3595  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3596  }
3597 
3598 
3599 
3600  typedef struct
3601  {
3602  const char** target;
3603  OrthancPluginErrorCode error;
3604  } _OrthancPluginGetErrorDescription;
3605 
3616  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3617  OrthancPluginContext* context,
3618  OrthancPluginErrorCode error)
3619  {
3620  const char* result = NULL;
3621 
3622  _OrthancPluginGetErrorDescription params;
3623  params.target = &result;
3624  params.error = error;
3625 
3626  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3627  result == NULL)
3628  {
3629  return "Unknown error code";
3630  }
3631  else
3632  {
3633  return result;
3634  }
3635  }
3636 
3637 
3638 
3639  typedef struct
3640  {
3641  OrthancPluginRestOutput* output;
3642  uint16_t status;
3643  const char* body;
3644  uint32_t bodySize;
3645  } _OrthancPluginSendHttpStatus;
3646 
3669  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3670  OrthancPluginContext* context,
3671  OrthancPluginRestOutput* output,
3672  uint16_t status,
3673  const char* body,
3674  uint32_t bodySize)
3675  {
3676  _OrthancPluginSendHttpStatus params;
3677  params.output = output;
3678  params.status = status;
3679  params.body = body;
3680  params.bodySize = bodySize;
3681  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3682  }
3683 
3684 
3685 
3686  typedef struct
3687  {
3688  const OrthancPluginImage* image;
3689  uint32_t* resultUint32;
3690  OrthancPluginPixelFormat* resultPixelFormat;
3691  void** resultBuffer;
3692  } _OrthancPluginGetImageInfo;
3693 
3694 
3706  OrthancPluginContext* context,
3707  const OrthancPluginImage* image)
3708  {
3709  OrthancPluginPixelFormat target;
3710 
3711  _OrthancPluginGetImageInfo params;
3712  memset(&params, 0, sizeof(params));
3713  params.image = image;
3714  params.resultPixelFormat = &target;
3715 
3716  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3717  {
3719  }
3720  else
3721  {
3722  return (OrthancPluginPixelFormat) target;
3723  }
3724  }
3725 
3726 
3727 
3738  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3739  OrthancPluginContext* context,
3740  const OrthancPluginImage* image)
3741  {
3742  uint32_t width;
3743 
3744  _OrthancPluginGetImageInfo params;
3745  memset(&params, 0, sizeof(params));
3746  params.image = image;
3747  params.resultUint32 = &width;
3748 
3749  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3750  {
3751  return 0;
3752  }
3753  else
3754  {
3755  return width;
3756  }
3757  }
3758 
3759 
3760 
3771  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3772  OrthancPluginContext* context,
3773  const OrthancPluginImage* image)
3774  {
3775  uint32_t height;
3776 
3777  _OrthancPluginGetImageInfo params;
3778  memset(&params, 0, sizeof(params));
3779  params.image = image;
3780  params.resultUint32 = &height;
3781 
3782  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3783  {
3784  return 0;
3785  }
3786  else
3787  {
3788  return height;
3789  }
3790  }
3791 
3792 
3793 
3806  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3807  OrthancPluginContext* context,
3808  const OrthancPluginImage* image)
3809  {
3810  uint32_t pitch;
3811 
3812  _OrthancPluginGetImageInfo params;
3813  memset(&params, 0, sizeof(params));
3814  params.image = image;
3815  params.resultUint32 = &pitch;
3816 
3817  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
3818  {
3819  return 0;
3820  }
3821  else
3822  {
3823  return pitch;
3824  }
3825  }
3826 
3827 
3828 
3840  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
3841  OrthancPluginContext* context,
3842  const OrthancPluginImage* image)
3843  {
3844  void* target = NULL;
3845 
3846  _OrthancPluginGetImageInfo params;
3847  memset(&params, 0, sizeof(params));
3848  params.resultBuffer = &target;
3849  params.image = image;
3850 
3851  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
3852  {
3853  return NULL;
3854  }
3855  else
3856  {
3857  return target;
3858  }
3859  }
3860 
3861 
3862  typedef struct
3863  {
3864  OrthancPluginImage** target;
3865  const void* data;
3866  uint32_t size;
3867  OrthancPluginImageFormat format;
3868  } _OrthancPluginUncompressImage;
3869 
3870 
3883  ORTHANC_PLUGIN_INLINE OrthancPluginImage *OrthancPluginUncompressImage(
3884  OrthancPluginContext* context,
3885  const void* data,
3886  uint32_t size,
3887  OrthancPluginImageFormat format)
3888  {
3889  OrthancPluginImage* target = NULL;
3890 
3891  _OrthancPluginUncompressImage params;
3892  memset(&params, 0, sizeof(params));
3893  params.target = &target;
3894  params.data = data;
3895  params.size = size;
3896  params.format = format;
3897 
3898  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
3899  {
3900  return NULL;
3901  }
3902  else
3903  {
3904  return target;
3905  }
3906  }
3907 
3908 
3909 
3910 
3911  typedef struct
3912  {
3913  OrthancPluginImage* image;
3914  } _OrthancPluginFreeImage;
3915 
3925  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
3926  OrthancPluginContext* context,
3927  OrthancPluginImage* image)
3928  {
3929  _OrthancPluginFreeImage params;
3930  params.image = image;
3931 
3932  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
3933  }
3934 
3935 
3936 
3937 
3938  typedef struct
3939  {
3940  OrthancPluginMemoryBuffer* target;
3941  OrthancPluginImageFormat imageFormat;
3942  OrthancPluginPixelFormat pixelFormat;
3943  uint32_t width;
3944  uint32_t height;
3945  uint32_t pitch;
3946  const void* buffer;
3947  uint8_t quality;
3948  } _OrthancPluginCompressImage;
3949 
3950 
3971  OrthancPluginContext* context,
3972  OrthancPluginMemoryBuffer* target,
3973  OrthancPluginPixelFormat format,
3974  uint32_t width,
3975  uint32_t height,
3976  uint32_t pitch,
3977  const void* buffer)
3978  {
3979  _OrthancPluginCompressImage params;
3980  memset(&params, 0, sizeof(params));
3981  params.target = target;
3982  params.imageFormat = OrthancPluginImageFormat_Png;
3983  params.pixelFormat = format;
3984  params.width = width;
3985  params.height = height;
3986  params.pitch = pitch;
3987  params.buffer = buffer;
3988  params.quality = 0; /* Unused for PNG */
3989 
3990  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3991  }
3992 
3993 
4016  OrthancPluginContext* context,
4017  OrthancPluginMemoryBuffer* target,
4018  OrthancPluginPixelFormat format,
4019  uint32_t width,
4020  uint32_t height,
4021  uint32_t pitch,
4022  const void* buffer,
4023  uint8_t quality)
4024  {
4025  _OrthancPluginCompressImage params;
4026  memset(&params, 0, sizeof(params));
4027  params.target = target;
4028  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4029  params.pixelFormat = format;
4030  params.width = width;
4031  params.height = height;
4032  params.pitch = pitch;
4033  params.buffer = buffer;
4034  params.quality = quality;
4035 
4036  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4037  }
4038 
4039 
4040 
4062  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
4063  OrthancPluginContext* context,
4064  OrthancPluginRestOutput* output,
4065  OrthancPluginPixelFormat format,
4066  uint32_t width,
4067  uint32_t height,
4068  uint32_t pitch,
4069  const void* buffer,
4070  uint8_t quality)
4071  {
4072  _OrthancPluginCompressAndAnswerImage params;
4073  params.output = output;
4074  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4075  params.pixelFormat = format;
4076  params.width = width;
4077  params.height = height;
4078  params.pitch = pitch;
4079  params.buffer = buffer;
4080  params.quality = quality;
4081  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4082  }
4083 
4084 
4085 
4086 
4087  typedef struct
4088  {
4089  OrthancPluginMemoryBuffer* target;
4090  OrthancPluginHttpMethod method;
4091  const char* url;
4092  const char* username;
4093  const char* password;
4094  const void* body;
4095  uint32_t bodySize;
4096  } _OrthancPluginCallHttpClient;
4097 
4098 
4115  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginHttpGet(
4116  OrthancPluginContext* context,
4117  OrthancPluginMemoryBuffer* target,
4118  const char* url,
4119  const char* username,
4120  const char* password)
4121  {
4122  _OrthancPluginCallHttpClient params;
4123  memset(&params, 0, sizeof(params));
4124 
4125  params.target = target;
4126  params.method = OrthancPluginHttpMethod_Get;
4127  params.url = url;
4128  params.username = username;
4129  params.password = password;
4130 
4131  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4132  }
4133 
4134 
4153  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginHttpPost(
4154  OrthancPluginContext* context,
4155  OrthancPluginMemoryBuffer* target,
4156  const char* url,
4157  const void* body,
4158  uint32_t bodySize,
4159  const char* username,
4160  const char* password)
4161  {
4162  _OrthancPluginCallHttpClient params;
4163  memset(&params, 0, sizeof(params));
4164 
4165  params.target = target;
4166  params.method = OrthancPluginHttpMethod_Post;
4167  params.url = url;
4168  params.body = body;
4169  params.bodySize = bodySize;
4170  params.username = username;
4171  params.password = password;
4172 
4173  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4174  }
4175 
4176 
4195  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginHttpPut(
4196  OrthancPluginContext* context,
4197  OrthancPluginMemoryBuffer* target,
4198  const char* url,
4199  const void* body,
4200  uint32_t bodySize,
4201  const char* username,
4202  const char* password)
4203  {
4204  _OrthancPluginCallHttpClient params;
4205  memset(&params, 0, sizeof(params));
4206 
4207  params.target = target;
4208  params.method = OrthancPluginHttpMethod_Put;
4209  params.url = url;
4210  params.body = body;
4211  params.bodySize = bodySize;
4212  params.username = username;
4213  params.password = password;
4214 
4215  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4216  }
4217 
4218 
4233  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginHttpDelete(
4234  OrthancPluginContext* context,
4235  const char* url,
4236  const char* username,
4237  const char* password)
4238  {
4239  _OrthancPluginCallHttpClient params;
4240  memset(&params, 0, sizeof(params));
4241 
4242  params.method = OrthancPluginHttpMethod_Delete;
4243  params.url = url;
4244  params.username = username;
4245  params.password = password;
4246 
4247  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4248  }
4249 
4250 
4251 
4252  typedef struct
4253  {
4254  OrthancPluginImage** target;
4255  const OrthancPluginImage* source;
4256  OrthancPluginPixelFormat targetFormat;
4257  } _OrthancPluginConvertPixelFormat;
4258 
4259 
4271  ORTHANC_PLUGIN_INLINE OrthancPluginImage *OrthancPluginConvertPixelFormat(
4272  OrthancPluginContext* context,
4273  const OrthancPluginImage* source,
4274  OrthancPluginPixelFormat targetFormat)
4275  {
4276  OrthancPluginImage* target = NULL;
4277 
4278  _OrthancPluginConvertPixelFormat params;
4279  params.target = &target;
4280  params.source = source;
4281  params.targetFormat = targetFormat;
4282 
4283  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4284  {
4285  return NULL;
4286  }
4287  else
4288  {
4289  return target;
4290  }
4291  }
4292 
4293 
4294 
4306  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4307  OrthancPluginContext* context)
4308  {
4309  uint32_t count = 0;
4310 
4311  _OrthancPluginReturnSingleValue params;
4312  memset(&params, 0, sizeof(params));
4313  params.resultUint32 = &count;
4314 
4315  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4316  {
4317  /* Error */
4318  return 0;
4319  }
4320  else
4321  {
4322  return count;
4323  }
4324  }
4325 
4326 
4327 
4328 
4329  typedef struct
4330  {
4331  uint32_t fontIndex; /* in */
4332  const char** name; /* out */
4333  uint32_t* size; /* out */
4334  } _OrthancPluginGetFontInfo;
4335 
4346  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4347  OrthancPluginContext* context,
4348  uint32_t fontIndex)
4349  {
4350  const char* result = NULL;
4351 
4352  _OrthancPluginGetFontInfo params;
4353  memset(&params, 0, sizeof(params));
4354  params.name = &result;
4355  params.fontIndex = fontIndex;
4356 
4357  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4358  {
4359  return NULL;
4360  }
4361  else
4362  {
4363  return result;
4364  }
4365  }
4366 
4367 
4378  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4379  OrthancPluginContext* context,
4380  uint32_t fontIndex)
4381  {
4382  uint32_t result;
4383 
4384  _OrthancPluginGetFontInfo params;
4385  memset(&params, 0, sizeof(params));
4386  params.size = &result;
4387  params.fontIndex = fontIndex;
4388 
4389  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4390  {
4391  return 0;
4392  }
4393  else
4394  {
4395  return result;
4396  }
4397  }
4398 
4399 
4400 
4401  typedef struct
4402  {
4403  OrthancPluginImage* image;
4404  uint32_t fontIndex;
4405  const char* utf8Text;
4406  int32_t x;
4407  int32_t y;
4408  uint8_t r;
4409  uint8_t g;
4410  uint8_t b;
4411  } _OrthancPluginDrawText;
4412 
4413 
4431  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginDrawText(
4432  OrthancPluginContext* context,
4433  OrthancPluginImage* image,
4434  uint32_t fontIndex,
4435  const char* utf8Text,
4436  int32_t x,
4437  int32_t y,
4438  uint8_t r,
4439  uint8_t g,
4440  uint8_t b)
4441  {
4442  _OrthancPluginDrawText params;
4443  memset(&params, 0, sizeof(params));
4444  params.image = image;
4445  params.fontIndex = fontIndex;
4446  params.utf8Text = utf8Text;
4447  params.x = x;
4448  params.y = y;
4449  params.r = r;
4450  params.g = g;
4451  params.b = b;
4452 
4453  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4454  }
4455 
4456 
4457 
4458  typedef struct
4459  {
4460  OrthancPluginStorageArea* storageArea;
4461  const char* uuid;
4462  const void* content;
4463  uint64_t size;
4465  } _OrthancPluginStorageAreaCreate;
4466 
4467 
4484  OrthancPluginContext* context,
4485  OrthancPluginStorageArea* storageArea,
4486  const char* uuid,
4487  const void* content,
4488  uint64_t size,
4490  {
4491  _OrthancPluginStorageAreaCreate params;
4492  params.storageArea = storageArea;
4493  params.uuid = uuid;
4494  params.content = content;
4495  params.size = size;
4496  params.type = type;
4497 
4498  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4499  }
4500 
4501 
4502  typedef struct
4503  {
4504  OrthancPluginMemoryBuffer* target;
4505  OrthancPluginStorageArea* storageArea;
4506  const char* uuid;
4508  } _OrthancPluginStorageAreaRead;
4509 
4510 
4526  OrthancPluginContext* context,
4527  OrthancPluginMemoryBuffer* target,
4528  OrthancPluginStorageArea* storageArea,
4529  const char* uuid,
4531  {
4532  _OrthancPluginStorageAreaRead params;
4533  params.target = target;
4534  params.storageArea = storageArea;
4535  params.uuid = uuid;
4536  params.type = type;
4537 
4538  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4539  }
4540 
4541 
4542  typedef struct
4543  {
4544  OrthancPluginStorageArea* storageArea;
4545  const char* uuid;
4547  } _OrthancPluginStorageAreaRemove;
4548 
4563  OrthancPluginContext* context,
4564  OrthancPluginStorageArea* storageArea,
4565  const char* uuid,
4567  {
4568  _OrthancPluginStorageAreaRemove params;
4569  params.storageArea = storageArea;
4570  params.uuid = uuid;
4571  params.type = type;
4572 
4573  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4574  }
4575 
4576 
4577 
4578  typedef struct
4579  {
4580  OrthancPluginErrorCode* target;
4581  int32_t code;
4582  uint16_t httpStatus;
4583  const char* message;
4584  } _OrthancPluginRegisterErrorCode;
4585 
4602  OrthancPluginContext* context,
4603  int32_t code,
4604  uint16_t httpStatus,
4605  const char* message)
4606  {
4607  OrthancPluginErrorCode target;
4608 
4609  _OrthancPluginRegisterErrorCode params;
4610  params.target = &target;
4611  params.code = code;
4612  params.httpStatus = httpStatus;
4613  params.message = message;
4614 
4615  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4616  {
4617  return target;
4618  }
4619  else
4620  {
4621  /* There was an error while assigned the error. Use a generic code. */
4623  }
4624  }
4625 
4626 
4627 
4628  typedef struct
4629  {
4630  uint16_t group;
4631  uint16_t element;
4633  const char* name;
4634  uint32_t minMultiplicity;
4635  uint32_t maxMultiplicity;
4636  } _OrthancPluginRegisterDictionaryTag;
4637 
4658  OrthancPluginContext* context,
4659  uint16_t group,
4660  uint16_t element,
4662  const char* name,
4663  uint32_t minMultiplicity,
4664  uint32_t maxMultiplicity)
4665  {
4666  _OrthancPluginRegisterDictionaryTag params;
4667  params.group = group;
4668  params.element = element;
4669  params.vr = vr;
4670  params.name = name;
4671  params.minMultiplicity = minMultiplicity;
4672  params.maxMultiplicity = maxMultiplicity;
4673 
4674  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4675  }
4676 
4677 
4678 
4679  typedef struct
4680  {
4681  uint16_t group;
4682  uint16_t element;
4684  const char* name;
4685  uint32_t minMultiplicity;
4686  uint32_t maxMultiplicity;
4687  const char* privateCreator;
4688  } _OrthancPluginRegisterPrivateDictionaryTag;
4689 
4711  OrthancPluginContext* context,
4712  uint16_t group,
4713  uint16_t element,
4715  const char* name,
4716  uint32_t minMultiplicity,
4717  uint32_t maxMultiplicity,
4718  const char* privateCreator)
4719  {
4720  _OrthancPluginRegisterPrivateDictionaryTag params;
4721  params.group = group;
4722  params.element = element;
4723  params.vr = vr;
4724  params.name = name;
4725  params.minMultiplicity = minMultiplicity;
4726  params.maxMultiplicity = maxMultiplicity;
4727  params.privateCreator = privateCreator;
4728 
4729  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4730  }
4731 
4732 
4733 
4734  typedef struct
4735  {
4736  OrthancPluginStorageArea* storageArea;
4738  } _OrthancPluginReconstructMainDicomTags;
4739 
4755  OrthancPluginContext* context,
4756  OrthancPluginStorageArea* storageArea,
4758  {
4759  _OrthancPluginReconstructMainDicomTags params;
4760  params.level = level;
4761  params.storageArea = storageArea;
4762 
4763  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
4764  }
4765 
4766 
4767  typedef struct
4768  {
4769  char** result;
4770  const char* instanceId;
4771  const void* buffer;
4772  uint32_t size;
4775  uint32_t maxStringLength;
4776  } _OrthancPluginDicomToJson;
4777 
4778 
4798  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4799  OrthancPluginContext* context,
4800  const void* buffer,
4801  uint32_t size,
4804  uint32_t maxStringLength)
4805  {
4806  char* result;
4807 
4808  _OrthancPluginDicomToJson params;
4809  memset(&params, 0, sizeof(params));
4810  params.result = &result;
4811  params.buffer = buffer;
4812  params.size = size;
4813  params.format = format;
4814  params.flags = flags;
4815  params.maxStringLength = maxStringLength;
4816 
4817  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
4818  {
4819  /* Error */
4820  return NULL;
4821  }
4822  else
4823  {
4824  return result;
4825  }
4826  }
4827 
4828 
4847  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
4848  OrthancPluginContext* context,
4849  const char* instanceId,
4852  uint32_t maxStringLength)
4853  {
4854  char* result;
4855 
4856  _OrthancPluginDicomToJson params;
4857  memset(&params, 0, sizeof(params));
4858  params.result = &result;
4859  params.instanceId = instanceId;
4860  params.format = format;
4861  params.flags = flags;
4862  params.maxStringLength = maxStringLength;
4863 
4864  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
4865  {
4866  /* Error */
4867  return NULL;
4868  }
4869  else
4870  {
4871  return result;
4872  }
4873  }
4874 
4875 
4876  typedef struct
4877  {
4878  OrthancPluginMemoryBuffer* target;
4879  const char* uri;
4880  uint32_t headersCount;
4881  const char* const* headersKeys;
4882  const char* const* headersValues;
4883  int32_t afterPlugins;
4884  } _OrthancPluginRestApiGet2;
4885 
4905  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRestApiGet2(
4906  OrthancPluginContext* context,
4907  OrthancPluginMemoryBuffer* target,
4908  const char* uri,
4909  uint32_t headersCount,
4910  const char* const* headersKeys,
4911  const char* const* headersValues,
4912  int32_t afterPlugins)
4913  {
4914  _OrthancPluginRestApiGet2 params;
4915  params.target = target;
4916  params.uri = uri;
4917  params.headersCount = headersCount;
4918  params.headersKeys = headersKeys;
4919  params.headersValues = headersValues;
4920  params.afterPlugins = afterPlugins;
4921 
4922  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
4923  }
4924 
4925 
4926 
4927  typedef struct
4928  {
4930  } _OrthancPluginWorklistCallback;
4931 
4944  OrthancPluginContext* context,
4946  {
4947  _OrthancPluginWorklistCallback params;
4948  params.callback = callback;
4949 
4950  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
4951  }
4952 
4953 
4954 
4955  typedef struct
4956  {
4958  const OrthancPluginWorklistQuery* query;
4959  const void* dicom;
4960  uint32_t size;
4961  } _OrthancPluginWorklistAnswersOperation;
4962 
4980  OrthancPluginContext* context,
4982  const OrthancPluginWorklistQuery* query,
4983  const void* dicom,
4984  uint32_t size)
4985  {
4986  _OrthancPluginWorklistAnswersOperation params;
4987  params.answers = answers;
4988  params.query = query;
4989  params.dicom = dicom;
4990  params.size = size;
4991 
4992  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
4993  }
4994 
4995 
5010  OrthancPluginContext* context,
5012  {
5013  _OrthancPluginWorklistAnswersOperation params;
5014  params.answers = answers;
5015  params.query = NULL;
5016  params.dicom = NULL;
5017  params.size = 0;
5018 
5019  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5020  }
5021 
5022 
5023  typedef struct
5024  {
5025  const OrthancPluginWorklistQuery* query;
5026  const void* dicom;
5027  uint32_t size;
5028  int32_t* isMatch;
5029  OrthancPluginMemoryBuffer* target;
5030  } _OrthancPluginWorklistQueryOperation;
5031 
5047  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5048  OrthancPluginContext* context,
5049  const OrthancPluginWorklistQuery* query,
5050  const void* dicom,
5051  uint32_t size)
5052  {
5053  int32_t isMatch = 0;
5054 
5055  _OrthancPluginWorklistQueryOperation params;
5056  params.query = query;
5057  params.dicom = dicom;
5058  params.size = size;
5059  params.isMatch = &isMatch;
5060  params.target = NULL;
5061 
5062  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5063  {
5064  return isMatch;
5065  }
5066  else
5067  {
5068  /* Error: Assume non-match */
5069  return 0;
5070  }
5071  }
5072 
5073 
5087  OrthancPluginContext* context,
5088  OrthancPluginMemoryBuffer* target,
5089  const OrthancPluginWorklistQuery* query)
5090  {
5091  _OrthancPluginWorklistQueryOperation params;
5092  params.query = query;
5093  params.dicom = NULL;
5094  params.size = 0;
5095  params.isMatch = NULL;
5096  params.target = target;
5097 
5098  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5099  }
5100 
5101 
5113  OrthancPluginContext* context,
5114  const OrthancPluginDicomInstance* instance)
5115  {
5117 
5118  _OrthancPluginAccessDicomInstance params;
5119  memset(&params, 0, sizeof(params));
5120  params.resultOrigin = &origin;
5121  params.instance = instance;
5122 
5123  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5124  {
5125  /* Error */
5127  }
5128  else
5129  {
5130  return origin;
5131  }
5132  }
5133 
5134 
5135  typedef struct
5136  {
5137  OrthancPluginMemoryBuffer* target;
5138  const char* json;
5139  const OrthancPluginImage* pixelData;
5141  } _OrthancPluginCreateDicom;
5142 
5161  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginCreateDicom(
5162  OrthancPluginContext* context,
5163  OrthancPluginMemoryBuffer* target,
5164  const char* json,
5165  const OrthancPluginImage* pixelData,
5167  {
5168  _OrthancPluginCreateDicom params;
5169  params.target = target;
5170  params.json = json;
5171  params.pixelData = pixelData;
5172  params.flags = flags;
5173 
5174  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5175  }
5176 
5177 
5178  typedef struct
5179  {
5181  } _OrthancPluginDecodeImageCallback;
5182 
5195  OrthancPluginContext* context,
5197  {
5198  _OrthancPluginDecodeImageCallback params;
5199  params.callback = callback;
5200 
5201  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5202  }
5203 
5204 
5205 
5206  typedef struct
5207  {
5208  OrthancPluginImage** target;
5209  OrthancPluginPixelFormat format;
5210  uint32_t width;
5211  uint32_t height;
5212  uint32_t pitch;
5213  void* buffer;
5214  const void* constBuffer;
5215  uint32_t bufferSize;
5216  uint32_t frameIndex;
5217  } _OrthancPluginCreateImage;
5218 
5219 
5232  ORTHANC_PLUGIN_INLINE OrthancPluginImage* OrthancPluginCreateImage(
5233  OrthancPluginContext* context,
5234  OrthancPluginPixelFormat format,
5235  uint32_t width,
5236  uint32_t height)
5237  {
5238  OrthancPluginImage* target = NULL;
5239 
5240  _OrthancPluginCreateImage params;
5241  memset(&params, 0, sizeof(params));
5242  params.target = &target;
5243  params.format = format;
5244  params.width = width;
5245  params.height = height;
5246 
5247  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5248  {
5249  return NULL;
5250  }
5251  else
5252  {
5253  return target;
5254  }
5255  }
5256 
5257 
5276  OrthancPluginContext* context,
5277  OrthancPluginPixelFormat format,
5278  uint32_t width,
5279  uint32_t height,
5280  uint32_t pitch,
5281  void* buffer)
5282  {
5283  OrthancPluginImage* target = NULL;
5284 
5285  _OrthancPluginCreateImage params;
5286  memset(&params, 0, sizeof(params));
5287  params.target = &target;
5288  params.format = format;
5289  params.width = width;
5290  params.height = height;
5291  params.pitch = pitch;
5292  params.buffer = buffer;
5293 
5294  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5295  {
5296  return NULL;
5297  }
5298  else
5299  {
5300  return target;
5301  }
5302  }
5303 
5304 
5305 
5320  ORTHANC_PLUGIN_INLINE OrthancPluginImage* OrthancPluginDecodeDicomImage(
5321  OrthancPluginContext* context,
5322  const void* buffer,
5323  uint32_t bufferSize,
5324  uint32_t frameIndex)
5325  {
5326  OrthancPluginImage* target = NULL;
5327 
5328  _OrthancPluginCreateImage params;
5329  memset(&params, 0, sizeof(params));
5330  params.target = &target;
5331  params.constBuffer = buffer;
5332  params.bufferSize = bufferSize;
5333  params.frameIndex = frameIndex;
5334 
5335  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5336  {
5337  return NULL;
5338  }
5339  else
5340  {
5341  return target;
5342  }
5343  }
5344 
5345 
5346 
5347  typedef struct
5348  {
5349  char** result;
5350  const void* buffer;
5351  uint32_t size;
5352  } _OrthancPluginComputeHash;
5353 
5366  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5367  OrthancPluginContext* context,
5368  const void* buffer,
5369  uint32_t size)
5370  {
5371  char* result;
5372 
5373  _OrthancPluginComputeHash params;
5374  params.result = &result;
5375  params.buffer = buffer;
5376  params.size = size;
5377 
5378  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5379  {
5380  /* Error */
5381  return NULL;
5382  }
5383  else
5384  {
5385  return result;
5386  }
5387  }
5388 
5389 
5402  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5403  OrthancPluginContext* context,
5404  const void* buffer,
5405  uint32_t size)
5406  {
5407  char* result;
5408 
5409  _OrthancPluginComputeHash params;
5410  params.result = &result;
5411  params.buffer = buffer;
5412  params.size = size;
5413 
5414  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5415  {
5416  /* Error */
5417  return NULL;
5418  }
5419  else
5420  {
5421  return result;
5422  }
5423  }
5424 
5425 
5426 
5427  typedef struct
5428  {
5430  const char* name;
5431  } _OrthancPluginLookupDictionary;
5432 
5449  OrthancPluginContext* context,
5451  const char* name)
5452  {
5453  _OrthancPluginLookupDictionary params;
5454  params.target = target;
5455  params.name = name;
5456  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5457  }
5458 
5459 
5460 
5461  typedef struct
5462  {
5463  OrthancPluginRestOutput* output;
5464  const char* answer;
5465  uint32_t answerSize;
5466  uint32_t headersCount;
5467  const char* const* headersKeys;
5468  const char* const* headersValues;
5469  } _OrthancPluginSendMultipartItem2;
5470 
5492  OrthancPluginContext* context,
5493  OrthancPluginRestOutput* output,
5494  const char* answer,
5495  uint32_t answerSize,
5496  uint32_t headersCount,
5497  const char* const* headersKeys,
5498  const char* const* headersValues)
5499  {
5500  _OrthancPluginSendMultipartItem2 params;
5501  params.output = output;
5502  params.answer = answer;
5503  params.answerSize = answerSize;
5504  params.headersCount = headersCount;
5505  params.headersKeys = headersKeys;
5506  params.headersValues = headersValues;
5507 
5508  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5509  }
5510 
5511 
5512  typedef struct
5513  {
5515  } _OrthancPluginIncomingHttpRequestFilter;
5516 
5530  OrthancPluginContext* context,
5532  {
5533  _OrthancPluginIncomingHttpRequestFilter params;
5534  params.callback = callback;
5535 
5536  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5537  }
5538 
5539 
5540 
5541  typedef struct
5542  {
5543  OrthancPluginMemoryBuffer* answerBody;
5544  OrthancPluginMemoryBuffer* answerHeaders;
5545  uint16_t* httpStatus;
5546  OrthancPluginHttpMethod method;
5547  const char* url;
5548  uint32_t headersCount;
5549  const char* const* headersKeys;
5550  const char* const* headersValues;
5551  const void* body;
5552  uint32_t bodySize;
5553  const char* username;
5554  const char* password;
5555  uint32_t timeout;
5556  const char* certificateFile;
5557  const char* certificateKeyFile;
5558  const char* certificateKeyPassword;
5559  uint8_t pkcs11;
5560  } _OrthancPluginCallHttpClient2;
5561 
5562 
5563 
5603  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginHttpClient(
5604  OrthancPluginContext* context,
5605  OrthancPluginMemoryBuffer* answerBody,
5606  OrthancPluginMemoryBuffer* answerHeaders,
5607  uint16_t* httpStatus,
5608  OrthancPluginHttpMethod method,
5609  const char* url,
5610  uint32_t headersCount,
5611  const char* const* headersKeys,
5612  const char* const* headersValues,
5613  const void* body,
5614  uint32_t bodySize,
5615  const char* username,
5616  const char* password,
5617  uint32_t timeout,
5618  const char* certificateFile,
5619  const char* certificateKeyFile,
5620  const char* certificateKeyPassword,
5621  uint8_t pkcs11)
5622  {
5623  _OrthancPluginCallHttpClient2 params;
5624  memset(&params, 0, sizeof(params));
5625 
5626  params.answerBody = answerBody;
5627  params.answerHeaders = answerHeaders;
5628  params.httpStatus = httpStatus;
5629  params.method = method;
5630  params.url = url;
5631  params.headersCount = headersCount;
5632  params.headersKeys = headersKeys;
5633  params.headersValues = headersValues;
5634  params.body = body;
5635  params.bodySize = bodySize;
5636  params.username = username;
5637  params.password = password;
5638  params.timeout = timeout;
5639  params.certificateFile = certificateFile;
5640  params.certificateKeyFile = certificateKeyFile;
5641  params.certificateKeyPassword = certificateKeyPassword;
5642  params.pkcs11 = pkcs11;
5643 
5644  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5645  }
5646 
5647 
5658  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5659  OrthancPluginContext* context)
5660  {
5661  char* result;
5662 
5663  _OrthancPluginRetrieveDynamicString params;
5664  params.result = &result;
5665  params.argument = NULL;
5666 
5667  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5668  {
5669  /* Error */
5670  return NULL;
5671  }
5672  else
5673  {
5674  return result;
5675  }
5676  }
5677 
5678 
5679 
5680 
5681  typedef struct
5682  {
5683  OrthancPluginFindCallback callback;
5684  } _OrthancPluginFindCallback;
5685 
5698  OrthancPluginContext* context,
5699  OrthancPluginFindCallback callback)
5700  {
5701  _OrthancPluginFindCallback params;
5702  params.callback = callback;
5703 
5704  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5705  }
5706 
5707 
5708  typedef struct
5709  {
5710  OrthancPluginFindAnswers *answers;
5711  const OrthancPluginFindQuery *query;
5712  const void *dicom;
5713  uint32_t size;
5714  uint32_t index;
5715  uint32_t *resultUint32;
5716  uint16_t *resultGroup;
5717  uint16_t *resultElement;
5718  char **resultString;
5719  } _OrthancPluginFindOperation;
5720 
5736  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginFindAddAnswer(
5737  OrthancPluginContext* context,
5738  OrthancPluginFindAnswers* answers,
5739  const void* dicom,
5740  uint32_t size)
5741  {
5742  _OrthancPluginFindOperation params;
5743  memset(&params, 0, sizeof(params));
5744  params.answers = answers;
5745  params.dicom = dicom;
5746  params.size = size;
5747 
5748  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
5749  }
5750 
5751 
5766  OrthancPluginContext* context,
5767  OrthancPluginFindAnswers* answers)
5768  {
5769  _OrthancPluginFindOperation params;
5770  memset(&params, 0, sizeof(params));
5771  params.answers = answers;
5772 
5773  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
5774  }
5775 
5776 
5777 
5789  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
5790  OrthancPluginContext* context,
5791  const OrthancPluginFindQuery* query)
5792  {
5793  uint32_t count = 0;
5794 
5795  _OrthancPluginFindOperation params;
5796  memset(&params, 0, sizeof(params));
5797  params.query = query;
5798  params.resultUint32 = &count;
5799 
5800  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
5801  {
5802  /* Error */
5803  return 0;
5804  }
5805  else
5806  {
5807  return count;
5808  }
5809  }
5810 
5811 
5827  OrthancPluginContext* context,
5828  uint16_t* group,
5829  uint16_t* element,
5830  const OrthancPluginFindQuery* query,
5831  uint32_t index)
5832  {
5833  _OrthancPluginFindOperation params;
5834  memset(&params, 0, sizeof(params));
5835  params.query = query;
5836  params.index = index;
5837  params.resultGroup = group;
5838  params.resultElement = element;
5839 
5840  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
5841  }
5842 
5843 
5857  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
5858  OrthancPluginContext* context,
5859  const OrthancPluginFindQuery* query,
5860  uint32_t index)
5861  {
5862  char* result;
5863 
5864  _OrthancPluginFindOperation params;
5865  memset(&params, 0, sizeof(params));
5866  params.query = query;
5867  params.index = index;
5868  params.resultString = &result;
5869 
5870  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
5871  {
5872  /* Error */
5873  return NULL;
5874  }
5875  else
5876  {
5877  return result;
5878  }
5879  }
5880 
5881 
5895  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
5896  OrthancPluginContext* context,
5897  const OrthancPluginFindQuery* query,
5898  uint32_t index)
5899  {
5900  char* result;
5901 
5902  _OrthancPluginFindOperation params;
5903  memset(&params, 0, sizeof(params));
5904  params.query = query;
5905  params.index = index;
5906  params.resultString = &result;
5907 
5908  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
5909  {
5910  /* Error */
5911  return NULL;
5912  }
5913  else
5914  {
5915  return result;
5916  }
5917  }
5918 
5919 
5920 
5921 
5922  typedef struct
5923  {
5924  OrthancPluginMoveCallback callback;
5925  OrthancPluginGetMoveSize getMoveSize;
5926  OrthancPluginApplyMove applyMove;
5927  OrthancPluginFreeMove freeMove;
5928  } _OrthancPluginMoveCallback;
5929 
5944  OrthancPluginContext* context,
5945  OrthancPluginMoveCallback callback,
5946  OrthancPluginGetMoveSize getMoveSize,
5947  OrthancPluginApplyMove applyMove,
5948  OrthancPluginFreeMove freeMove)
5949  {
5950  _OrthancPluginMoveCallback params;
5951  params.callback = callback;
5952  params.getMoveSize = getMoveSize;
5953  params.applyMove = applyMove;
5954  params.freeMove = freeMove;
5955 
5956  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
5957  }
5958 
5959 
5960 
5961  typedef struct
5962  {
5963  OrthancPluginFindMatcher** target;
5964  const void* query;
5965  uint32_t size;
5966  } _OrthancPluginCreateFindMatcher;
5967 
5968 
5983  OrthancPluginContext* context,
5984  const void* query,
5985  uint32_t size)
5986  {
5987  OrthancPluginFindMatcher* target = NULL;
5988 
5989  _OrthancPluginCreateFindMatcher params;
5990  memset(&params, 0, sizeof(params));
5991  params.target = &target;
5992  params.query = query;
5993  params.size = size;
5994 
5995  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
5996  {
5997  return NULL;
5998  }
5999  else
6000  {
6001  return target;
6002  }
6003  }
6004 
6005 
6006  typedef struct
6007  {
6008  OrthancPluginFindMatcher* matcher;
6009  } _OrthancPluginFreeFindMatcher;
6010 
6020  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6021  OrthancPluginContext* context,
6022  OrthancPluginFindMatcher* matcher)
6023  {
6024  _OrthancPluginFreeFindMatcher params;
6025  params.matcher = matcher;
6026 
6027  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6028  }
6029 
6030 
6031  typedef struct
6032  {
6033  const OrthancPluginFindMatcher* matcher;
6034  const void* dicom;
6035  uint32_t size;
6036  int32_t* isMatch;
6037  } _OrthancPluginFindMatcherIsMatch;
6038 
6053  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6054  OrthancPluginContext* context,
6055  const OrthancPluginFindMatcher* matcher,
6056  const void* dicom,
6057  uint32_t size)
6058  {
6059  int32_t isMatch = 0;
6060 
6061  _OrthancPluginFindMatcherIsMatch params;
6062  params.matcher = matcher;
6063  params.dicom = dicom;
6064  params.size = size;
6065  params.isMatch = &isMatch;
6066 
6067  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6068  {
6069  return isMatch;
6070  }
6071  else
6072  {
6073  /* Error: Assume non-match */
6074  return 0;
6075  }
6076  }
6077 
6078 
6079  typedef struct
6080  {
6082  } _OrthancPluginIncomingHttpRequestFilter2;
6083 
6096  OrthancPluginContext* context,
6098  {
6099  _OrthancPluginIncomingHttpRequestFilter2 params;
6100  params.callback = callback;
6101 
6102  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6103  }
6104 
6105 
6106 
6107  typedef struct
6108  {
6109  OrthancPluginPeers** peers;
6110  } _OrthancPluginGetPeers;
6111 
6123  ORTHANC_PLUGIN_INLINE OrthancPluginPeers* OrthancPluginGetPeers(
6124  OrthancPluginContext* context)
6125  {
6126  OrthancPluginPeers* peers = NULL;
6127 
6128  _OrthancPluginGetPeers params;
6129  memset(&params, 0, sizeof(params));
6130  params.peers = &peers;
6131 
6132  if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6133  {
6134  return NULL;
6135  }
6136  else
6137  {
6138  return peers;
6139  }
6140  }
6141 
6142 
6143  typedef struct
6144  {
6145  OrthancPluginPeers* peers;
6146  } _OrthancPluginFreePeers;
6147 
6157  ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6158  OrthancPluginContext* context,
6159  OrthancPluginPeers* peers)
6160  {
6161  _OrthancPluginFreePeers params;
6162  params.peers = peers;
6163 
6164  context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6165  }
6166 
6167 
6168  typedef struct
6169  {
6170  uint32_t* target;
6171  const OrthancPluginPeers* peers;
6172  } _OrthancPluginGetPeersCount;
6173 
6187  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6188  OrthancPluginContext* context,
6189  const OrthancPluginPeers* peers)
6190  {
6191  uint32_t target = 0;
6192 
6193  _OrthancPluginGetPeersCount params;
6194  memset(&params, 0, sizeof(params));
6195  params.target = &target;
6196  params.peers = peers;
6197 
6198  if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6199  {
6200  /* Error */
6201  return 0;
6202  }
6203  else
6204  {
6205  return target;
6206  }
6207  }
6208 
6209 
6210  typedef struct
6211  {
6212  const char** target;
6213  const OrthancPluginPeers* peers;
6214  uint32_t peerIndex;
6215  const char* userProperty;
6216  } _OrthancPluginGetPeerProperty;
6217 
6235  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6236  OrthancPluginContext* context,
6237  const OrthancPluginPeers* peers,
6238  uint32_t peerIndex)
6239  {
6240  const char* target = NULL;
6241 
6242  _OrthancPluginGetPeerProperty params;
6243  memset(&params, 0, sizeof(params));
6244  params.target = &target;
6245  params.peers = peers;
6246  params.peerIndex = peerIndex;
6247  params.userProperty = NULL;
6248 
6249  if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6250  {
6251  /* Error */
6252  return NULL;
6253  }
6254  else
6255  {
6256  return target;
6257  }
6258  }
6259 
6260 
6276  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6277  OrthancPluginContext* context,
6278  const OrthancPluginPeers* peers,
6279  uint32_t peerIndex)
6280  {
6281  const char* target = NULL;
6282 
6283  _OrthancPluginGetPeerProperty params;
6284  memset(&params, 0, sizeof(params));
6285  params.target = &target;
6286  params.peers = peers;
6287  params.peerIndex = peerIndex;
6288  params.userProperty = NULL;
6289 
6290  if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6291  {
6292  /* Error */
6293  return NULL;
6294  }
6295  else
6296  {
6297  return target;
6298  }
6299  }
6300 
6301 
6302 
6322  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6323  OrthancPluginContext* context,
6324  const OrthancPluginPeers* peers,
6325  uint32_t peerIndex,
6326  const char* userProperty)
6327  {
6328  const char* target = NULL;
6329 
6330  _OrthancPluginGetPeerProperty params;
6331  memset(&params, 0, sizeof(params));
6332  params.target = &target;
6333  params.peers = peers;
6334  params.peerIndex = peerIndex;
6335  params.userProperty = userProperty;
6336 
6337  if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6338  {
6339  /* No such user property */
6340  return NULL;
6341  }
6342  else
6343  {
6344  return target;
6345  }
6346  }
6347 
6348 
6349 
6350  typedef struct
6351  {
6352  OrthancPluginMemoryBuffer* answerBody;
6353  OrthancPluginMemoryBuffer* answerHeaders;
6354  uint16_t* httpStatus;
6355  const OrthancPluginPeers* peers;
6356  uint32_t peerIndex;
6357  OrthancPluginHttpMethod method;
6358  const char* uri;
6359  uint32_t additionalHeadersCount;
6360  const char* const* additionalHeadersKeys;
6361  const char* const* additionalHeadersValues;
6362  const void* body;
6363  uint32_t bodySize;
6364  uint32_t timeout;
6365  } _OrthancPluginCallPeerApi;
6366 
6402  ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginCallPeerApi(
6403  OrthancPluginContext* context,
6404  OrthancPluginMemoryBuffer* answerBody,
6405  OrthancPluginMemoryBuffer* answerHeaders,
6406  uint16_t* httpStatus,
6407  const OrthancPluginPeers* peers,
6408  uint32_t peerIndex,
6409  OrthancPluginHttpMethod method,
6410  const char* uri,
6411  uint32_t additionalHeadersCount,
6412  const char* const* additionalHeadersKeys,
6413  const char* const* additionalHeadersValues,
6414  const void* body,
6415  uint32_t bodySize,
6416  uint32_t timeout)
6417  {
6418  _OrthancPluginCallPeerApi params;
6419  memset(&params, 0, sizeof(params));
6420 
6421  params.answerBody = answerBody;
6422  params.answerHeaders = answerHeaders;
6423  params.httpStatus = httpStatus;
6424  params.peers = peers;
6425  params.peerIndex = peerIndex;
6426  params.method = method;
6427  params.uri = uri;
6428  params.additionalHeadersCount = additionalHeadersCount;
6429  params.additionalHeadersKeys = additionalHeadersKeys;
6430  params.additionalHeadersValues = additionalHeadersValues;
6431  params.body = body;
6432  params.bodySize = bodySize;
6433  params.timeout = timeout;
6434 
6435  return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6436  }
6437 
6438 
6439 
6440 
6441 
6442  typedef struct
6443  {
6444  OrthancPluginJob** target;
6445  void *job;
6446  OrthancPluginJobFinalize finalize;
6447  const char *type;
6448  OrthancPluginJobGetProgress getProgress;
6449  OrthancPluginJobGetContent getContent;
6450  OrthancPluginJobGetSerialized getSerialized;
6451  OrthancPluginJobStep step;
6452  OrthancPluginJobStop stop;
6453  OrthancPluginJobReset reset;
6454  } _OrthancPluginCreateJob;
6455 
6487  ORTHANC_PLUGIN_INLINE OrthancPluginJob *OrthancPluginCreateJob(
6488  OrthancPluginContext *context,
6489  void *job,
6490  OrthancPluginJobFinalize finalize,
6491  const char *type,
6492  OrthancPluginJobGetProgress getProgress,
6493  OrthancPluginJobGetContent getContent,
6494  OrthancPluginJobGetSerialized getSerialized,
6495  OrthancPluginJobStep step,
6496  OrthancPluginJobStop stop,
6497  OrthancPluginJobReset reset)
6498  {
6499  OrthancPluginJob* target = NULL;
6500 
6501  _OrthancPluginCreateJob params;
6502  memset(&params, 0, sizeof(params));
6503 
6504  params.target = &target;
6505  params.job = job;
6506  params.finalize = finalize;
6507  params.type = type;
6508  params.getProgress = getProgress;
6509  params.getContent = getContent;
6510  params.getSerialized = getSerialized;
6511  params.step = step;
6512  params.stop = stop;
6513  params.reset = reset;
6514 
6515  if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6516  target == NULL)
6517  {
6518  /* Error */
6519  return NULL;
6520  }
6521  else
6522  {
6523  return target;
6524  }
6525  }
6526 
6527 
6528  typedef struct
6529  {
6530  OrthancPluginJob* job;
6531  } _OrthancPluginFreeJob;
6532 
6542  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6543  OrthancPluginContext* context,
6544  OrthancPluginJob* job)
6545  {
6546  _OrthancPluginFreeJob params;
6547  params.job = job;
6548 
6549  context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6550  }
6551 
6552 
6553 
6554  typedef struct
6555  {
6556  char** resultId;
6557  OrthancPluginJob *job;
6558  int priority;
6559  } _OrthancPluginSubmitJob;
6560 
6574  ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6575  OrthancPluginContext *context,
6576  OrthancPluginJob *job,
6577  int priority)
6578  {
6579  char* resultId = NULL;
6580 
6581  _OrthancPluginSubmitJob params;
6582  memset(&params, 0, sizeof(params));
6583 
6584  params.resultId = &resultId;
6585  params.job = job;
6586  params.priority = priority;
6587 
6588  if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6589  resultId == NULL)
6590  {
6591  /* Error */
6592  return NULL;
6593  }
6594  else
6595  {
6596  return resultId;
6597  }
6598  }
6599 
6600 
6601 
6602  typedef struct
6603  {
6604  OrthancPluginJobsUnserializer unserializer;
6605  } _OrthancPluginJobsUnserializer;
6606 
6619  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6620  OrthancPluginContext* context,
6621  OrthancPluginJobsUnserializer unserializer)
6622  {
6623  _OrthancPluginJobsUnserializer params;
6624  params.unserializer = unserializer;
6625 
6626  context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6627  }
6628 
6629 
6630 
6631  typedef struct
6632  {
6633  OrthancPluginRestOutput* output;
6634  const char* details;
6635  uint8_t log;
6636  } _OrthancPluginSetHttpErrorDetails;
6637 
6655  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
6656  OrthancPluginContext* context,
6657  OrthancPluginRestOutput* output,
6658  const char* details,
6659  uint8_t log)
6660  {
6661  _OrthancPluginSetHttpErrorDetails params;
6662  params.output = output;
6663  params.details = details;
6664  params.log = log;
6665  context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
6666  }
6667 
6668 
6669 
6670  typedef struct
6671  {
6672  const char** result;
6673  const char* argument;
6674  } _OrthancPluginRetrieveStaticString;
6675 
6687  ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
6688  OrthancPluginContext* context,
6689  const char* path)
6690  {
6691  const char* result = NULL;
6692 
6693  _OrthancPluginRetrieveStaticString params;
6694  params.result = &result;
6695  params.argument = path;
6696 
6697  if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
6698  {
6699  /* Error */
6700  return NULL;
6701  }
6702  else
6703  {
6704  return result;
6705  }
6706  }
6707 
6708 
6709 
6710  typedef struct
6711  {
6712  const char* name;
6713  float value;
6715  } _OrthancPluginSetMetricsValue;
6716 
6731  ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
6732  OrthancPluginContext* context,
6733  const char* name,
6734  float value,
6736  {
6737  _OrthancPluginSetMetricsValue params;
6738  params.name = name;
6739  params.value = value;
6740  params.type = type;
6741  context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
6742  }
6743 
6744 
6745 
6746  typedef struct
6747  {
6749  } _OrthancPluginRegisterRefreshMetricsCallback;
6750 
6761  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRefreshMetricsCallback(
6762  OrthancPluginContext* context,
6764  {
6765  _OrthancPluginRegisterRefreshMetricsCallback params;
6766  params.callback = callback;
6767  context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
6768  }
6769 
6770 
6771 
6772 
6773  typedef struct
6774  {
6775  char** target;
6776  const void* dicom;
6777  uint32_t dicomSize;
6779  } _OrthancPluginEncodeDicomWeb;
6780 
6796  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
6797  OrthancPluginContext* context,
6798  const void* dicom,
6799  uint32_t dicomSize,
6801  {
6802  char* target = NULL;
6803 
6804  _OrthancPluginEncodeDicomWeb params;
6805  params.target = &target;
6806  params.dicom = dicom;
6807  params.dicomSize = dicomSize;
6808  params.callback = callback;
6809 
6810  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
6811  {
6812  /* Error */
6813  return NULL;
6814  }
6815  else
6816  {
6817  return target;
6818  }
6819  }
6820 
6821 
6837  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
6838  OrthancPluginContext* context,
6839  const void* dicom,
6840  uint32_t dicomSize,
6842  {
6843  char* target = NULL;
6844 
6845  _OrthancPluginEncodeDicomWeb params;
6846  params.target = &target;
6847  params.dicom = dicom;
6848  params.dicomSize = dicomSize;
6849  params.callback = callback;
6850 
6851  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
6852  {
6853  /* Error */
6854  return NULL;
6855  }
6856  else
6857  {
6858  return target;
6859  }
6860  }
6861 
6862 
6863 
6880  void* answer,
6881  const char* key,
6882  const char* value);
6883 
6884 
6901  void* answer,
6902  const void* data,
6903  uint32_t size);
6904 
6905 
6920  typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
6921 
6922 
6938 
6939 
6953  typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
6954 
6955 
6969  typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
6970 
6971 
6972  typedef struct
6973  {
6974  void* answer;
6977  uint16_t* httpStatus;
6978  OrthancPluginHttpMethod method;
6979  const char* url;
6980  uint32_t headersCount;
6981  const char* const* headersKeys;
6982  const char* const* headersValues;
6983  void* request;
6988  const char* username;
6989  const char* password;
6990  uint32_t timeout;
6991  const char* certificateFile;
6992  const char* certificateKeyFile;
6993  const char* certificateKeyPassword;
6994  uint8_t pkcs11;
6995  } _OrthancPluginChunkedHttpClient;
6996 
6997 
7049  OrthancPluginContext* context,
7050  void* answer,
7053  uint16_t* httpStatus,
7054  OrthancPluginHttpMethod method,
7055  const char* url,
7056  uint32_t headersCount,
7057  const char* const* headersKeys,
7058  const char* const* headersValues,
7059  void* request,
7064  const char* username,
7065  const char* password,
7066  uint32_t timeout,
7067  const char* certificateFile,
7068  const char* certificateKeyFile,
7069  const char* certificateKeyPassword,
7070  uint8_t pkcs11)
7071  {
7072  _OrthancPluginChunkedHttpClient params;
7073  memset(&params, 0, sizeof(params));
7074 
7075  /* In common with OrthancPluginHttpClient() */
7076  params.httpStatus = httpStatus;
7077  params.method = method;
7078  params.url = url;
7079  params.headersCount = headersCount;
7080  params.headersKeys = headersKeys;
7081  params.headersValues = headersValues;
7082  params.username = username;
7083  params.password = password;
7084  params.timeout = timeout;
7085  params.certificateFile = certificateFile;
7086  params.certificateKeyFile = certificateKeyFile;
7087  params.certificateKeyPassword = certificateKeyPassword;
7088  params.pkcs11 = pkcs11;
7089 
7090  /* For chunked body/answer */
7091  params.answer = answer;
7092  params.answerAddChunk = answerAddChunk;
7093  params.answerAddHeader = answerAddHeader;
7094  params.request = request;
7095  params.requestIsDone = requestIsDone;
7096  params.requestChunkData = requestChunkData;
7097  params.requestChunkSize = requestChunkSize;
7098  params.requestNext = requestNext;
7099 
7100  return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7101  }
7102 
7103 
7104 
7109  typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7110 
7111 
7112 
7130  const char* url,
7131  const OrthancPluginHttpRequest* request);
7132 
7133 
7149  const void* data,
7150  uint32_t size);
7151 
7152 
7169  OrthancPluginRestOutput* output);
7170 
7171 
7187 
7188  typedef struct
7189  {
7190  const char* pathRegularExpression;
7191  OrthancPluginRestCallback getHandler;
7193  OrthancPluginRestCallback deleteHandler;
7198  } _OrthancPluginChunkedRestCallback;
7199 
7200 
7230  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterChunkedRestCallback(
7231  OrthancPluginContext* context,
7232  const char* pathRegularExpression,
7233  OrthancPluginRestCallback getHandler,
7235  OrthancPluginRestCallback deleteHandler,
7240  {
7241  _OrthancPluginChunkedRestCallback params;
7242  params.pathRegularExpression = pathRegularExpression;
7243  params.getHandler = getHandler;
7244  params.postHandler = postHandler;
7245  params.deleteHandler = deleteHandler;
7246  params.putHandler = putHandler;
7247  params.addChunk = addChunk;
7248  params.execute = execute;
7249  params.finalize = finalize;
7250 
7251  context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
7252  }
7253 
7254 
7255 
7256 
7257 
7258  typedef struct
7259  {
7260  char** result;
7261  uint16_t group;
7262  uint16_t element;
7263  const char* privateCreator;
7264  } _OrthancPluginGetTagName;
7265 
7281  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
7282  OrthancPluginContext* context,
7283  uint16_t group,
7284  uint16_t element,
7285  const char* privateCreator)
7286  {
7287  char* result;
7288 
7289  _OrthancPluginGetTagName params;
7290  params.result = &result;
7291  params.group = group;
7292  params.element = element;
7293  params.privateCreator = privateCreator;
7294 
7295  if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
7296  {
7297  /* Error */
7298  return NULL;
7299  }
7300  else
7301  {
7302  return result;
7303  }
7304  }
7305 
7306 
7307 
7337  void** handler /* out */,
7338  const char* jobId,
7339  const char* transactionUid,
7340  const char* const* sopClassUids,
7341  const char* const* sopInstanceUids,
7342  uint32_t countInstances,
7343  const char* remoteAet,
7344  const char* calledAet);
7345 
7346 
7358  typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
7359 
7360 
7381  void* handler,
7382  const char* sopClassUid,
7383  const char* sopInstanceUid);
7384 
7385 
7386  typedef struct
7387  {
7391  } _OrthancPluginRegisterStorageCommitmentScpCallback;
7392 
7407  OrthancPluginContext* context,
7411  {
7412  _OrthancPluginRegisterStorageCommitmentScpCallback params;
7413  params.factory = factory;
7414  params.destructor = destructor;
7415  params.lookup = lookup;
7416  return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
7417  }
7418 
7419 
7420 
7436  typedef int32_t (*OrthancPluginIncomingDicomInstanceFilter) (
7437  const OrthancPluginDicomInstance* instance);
7438 
7439 
7440  typedef struct
7441  {
7443  } _OrthancPluginIncomingDicomInstanceFilter;
7444 
7458  OrthancPluginContext* context,
7460  {
7461  _OrthancPluginIncomingDicomInstanceFilter params;
7462  params.callback = callback;
7463 
7464  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, &params);
7465  }
7466 
7467 
7481  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceTransferSyntaxUid(
7482  OrthancPluginContext* context,
7483  const OrthancPluginDicomInstance* instance)
7484  {
7485  char* result;
7486 
7487  _OrthancPluginAccessDicomInstance params;
7488  memset(&params, 0, sizeof(params));
7489  params.resultStringToFree = &result;
7490  params.instance = instance;
7491 
7492  if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, &params) != OrthancPluginErrorCode_Success)
7493  {
7494  /* Error */
7495  return NULL;
7496  }
7497  else
7498  {
7499  return result;
7500  }
7501  }
7502 
7503 
7516  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData(
7517  OrthancPluginContext* context,
7518  const OrthancPluginDicomInstance* instance)
7519  {
7520  int64_t hasPixelData;
7521 
7522  _OrthancPluginAccessDicomInstance params;
7523  memset(&params, 0, sizeof(params));
7524  params.resultInt64 = &hasPixelData;
7525  params.instance = instance;
7526 
7527  if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, &params) != OrthancPluginErrorCode_Success ||
7528  hasPixelData < 0 ||
7529  hasPixelData > 1)
7530  {
7531  /* Error */
7532  return -1;
7533  }
7534  else
7535  {
7536  return hasPixelData;
7537  }
7538  }
7539 
7540 
7541 #ifdef __cplusplus
7542 }
7543 #endif
7544 
7545 
OrthancPluginJobGetProgress
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1444
OrthancPluginMetricsType_Default
Definition: OrthancCPlugin.h:917
OrthancPluginChangeType_NewPatient
Definition: OrthancCPlugin.h:706
OrthancPluginErrorCode_SQLiteStatementAlreadyUsed
Definition: OrthancCPlugin.h:254
OrthancPluginConvertPixelFormat
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4268
OrthancPluginGetMoveSize
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1389
OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
Definition: OrthancCPlugin.h:818
OrthancPluginErrorCode_CannotExecuteLua
Definition: OrthancCPlugin.h:298
OrthancPluginCheckVersion
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1780
OrthancPluginErrorCode_NoWorklistHandler
Definition: OrthancCPlugin.h:308
OrthancPluginGetInstanceSize
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2750
OrthancPluginCompressionType_Gzip
Definition: OrthancCPlugin.h:731
OrthancPluginExtendOrthancExplorer
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:3199
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:5600
OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii
Definition: OrthancCPlugin.h:817
OrthancPluginErrorCode_SQLiteBindOutOfRange
Definition: OrthancCPlugin.h:262
OrthancPluginRegisterOnStoredInstanceCallback
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:1951
OrthancPluginValueRepresentation_AS
Definition: OrthancCPlugin.h:759
OrthancPluginValueRepresentation_UT
Definition: OrthancCPlugin.h:784
OrthancPluginErrorCode_SystemCommand
Definition: OrthancCPlugin.h:221
OrthancPluginErrorCode_NotEnoughMemory
Definition: OrthancCPlugin.h:215
OrthancPluginChangeType_UpdatedAttachment
Definition: OrthancCPlugin.h:714
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:3666
OrthancPluginInstanceOrigin_Plugin
Definition: OrthancCPlugin.h:879
OrthancPluginFindAddAnswer
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5733
OrthancPluginGetOrthancDirectory
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:3047
OrthancPluginDicomToJsonFlags_IncludePrivateTags
Definition: OrthancCPlugin.h:814
OrthancPluginAnswerBuffer
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:1983
OrthancPluginPixelFormat_RGBA32
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:617
OrthancPluginChangeType_StableStudy
Definition: OrthancCPlugin.h:711
OrthancPluginRestApiDelete
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2245
OrthancPluginGetInstanceRemoteAet
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2717
OrthancPluginValueRepresentation_FD
Definition: OrthancCPlugin.h:765
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:2329
OrthancPluginErrorCode_Unauthorized
Definition: OrthancCPlugin.h:240
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:7125
OrthancPluginErrorCode_CreateDicomNoPayload
Definition: OrthancCPlugin.h:289
OrthancPluginHasInstancePixelData
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:7513
OrthancPluginErrorCode_InexistentTag
Definition: OrthancCPlugin.h:232
OrthancPluginComputeSha1
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5399
OrthancPluginErrorCode_CreateDicomUseContent
Definition: OrthancCPlugin.h:288
OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:651
OrthancPluginErrorCode_Timeout
Definition: OrthancCPlugin.h:227
OrthancPluginResourceType_Patient
Definition: OrthancCPlugin.h:685
OrthancPluginErrorCode_JsonToLuaTable
Definition: OrthancCPlugin.h:296
OrthancPluginErrorCode_LuaReturnsNoString
Definition: OrthancCPlugin.h:302
OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:643
OrthancPluginCreateDicomFlags_DecodeDataUriScheme
Definition: OrthancCPlugin.h:832
OrthancPluginCreateImage
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5229
OrthancPluginLookupSeries
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2500
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:7144
OrthancPluginJobGetSerialized
const typedef char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1477
OrthancPluginJobGetContent
const typedef char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1459
OrthancPluginIncomingDicomInstanceFilter
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition: OrthancCPlugin.h:7433
OrthancPluginChangeType_OrthancStopped
Definition: OrthancCPlugin.h:713
OrthancPluginErrorCode_LuaAlreadyExecuted
Definition: OrthancCPlugin.h:299
OrthancPluginDicomToJsonFlags
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:810
OrthancPluginErrorCode_SQLiteCannotStep
Definition: OrthancCPlugin.h:261
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:4059
OrthancPluginGetPeerUrl
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6273
OrthancPluginValueRepresentation_ST
Definition: OrthancCPlugin.h:778
OrthancPluginImageFormat
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:742
OrthancPluginConstraintType_Wildcard
Definition: OrthancCPlugin.h:864
OrthancPluginStorageAreaRead
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4522
OrthancPluginRegisterDecodeImageCallback
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5191
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:2216
OrthancPluginErrorCode_SQLiteCannotOpen
Definition: OrthancCPlugin.h:253
OrthancPluginChangeType_CompletedSeries
Definition: OrthancCPlugin.h:702
OrthancPluginErrorCode_SQLiteFlush
Definition: OrthancCPlugin.h:259
OrthancPluginErrorCode_SQLiteExecute
Definition: OrthancCPlugin.h:255
OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
Definition: OrthancCPlugin.h:953
OrthancPluginGetInstanceMetadata
const char * OrthancPluginGetInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Get the value of some metadata associated with a given DICOM instance.
Definition: OrthancCPlugin.h:2937
OrthancPluginHttpRequest
The parameters of a REST request.
Definition: OrthancCPlugin.h:336
OrthancPluginInstanceOrigin_Unknown
Definition: OrthancCPlugin.h:876
OrthancPluginValueRepresentation_DA
Definition: OrthancCPlugin.h:762
OrthancPluginIdentifierConstraint_SmallerOrEqual
Definition: OrthancCPlugin.h:847
OrthancPluginGetImageWidth
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3735
OrthancPluginConstraintType
OrthancPluginConstraintType
Definition: OrthancCPlugin.h:859
OrthancPluginGetPeerName
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6232
OrthancPluginErrorCode_InternalError
Definition: OrthancCPlugin.h:210
OrthancPluginChangeType_NewChildInstance
Definition: OrthancCPlugin.h:704
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:1236
OrthancPluginChangeType_UpdatedPeers
Definition: OrthancCPlugin.h:716
OrthancPluginGetImagePitch
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3803
OrthancPluginFindMatcher
struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher
Opaque structure to an object that can be used to check whether a DICOM instance matches a C-Find que...
Definition: OrthancCPlugin.h:1067
OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
Definition: OrthancCPlugin.h:961
OrthancPluginErrorCode_BadApplicationEntityTitle
Definition: OrthancCPlugin.h:276
OrthancPluginErrorCode_NoCMoveHandler
Definition: OrthancCPlugin.h:278
OrthancPluginErrorCode_SQLiteCannotRun
Definition: OrthancCPlugin.h:260
OrthancPluginDicomToJsonFlags_IncludeBinary
Definition: OrthancCPlugin.h:813
OrthancPluginRegisterStorageCommitmentScpCallback
OrthancPluginErrorCode OrthancPluginRegisterStorageCommitmentScpCallback(OrthancPluginContext *context, OrthancPluginStorageCommitmentFactory factory, OrthancPluginStorageCommitmentDestructor destructor, OrthancPluginStorageCommitmentLookup lookup)
Register a callback to handle incoming requests to the storage commitment SCP.
Definition: OrthancCPlugin.h:7403
OrthancPluginJobStopReason_Failure
Definition: OrthancCPlugin.h:907
OrthancPluginCreateDicomFlags_GenerateIdentifiers
Definition: OrthancCPlugin.h:833
OrthancPluginErrorCode_SQLitePrepareStatement
Definition: OrthancCPlugin.h:263
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:1100
OrthancPluginReconstructMainDicomTags
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4751
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:7278
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:5823
OrthancPluginLookupDictionary
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5445
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:4795
OrthancPluginGetConfigurationPath
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:3082
OrthancPluginHttpDelete
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4230
OrthancPluginCompressionType
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:727
OrthancPluginJobStep
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1492
OrthancPluginErrorCode_InexistentFile
Definition: OrthancCPlugin.h:224
OrthancPluginErrorCode_ParameterOutOfRange
Definition: OrthancCPlugin.h:214
OrthancPluginContentType_Dicom
Definition: OrthancCPlugin.h:672
OrthancPluginErrorCode_UnknownResource
Definition: OrthancCPlugin.h:228
OrthancPluginErrorCode_DirectoryExpected
Definition: OrthancCPlugin.h:269
OrthancPluginResourceType_Instance
Definition: OrthancCPlugin.h:688
OrthancPluginRegisterIncomingHttpRequestFilter
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5526
OrthancPluginErrorCode_Success
Definition: OrthancCPlugin.h:211
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:3967
OrthancPluginErrorCode_MakeDirectory
Definition: OrthancCPlugin.h:275
OrthancPluginErrorCode_UnsupportedMediaType
Definition: OrthancCPlugin.h:311
OrthancPluginChangeType_NewInstance
Definition: OrthancCPlugin.h:705
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:4428
OrthancPluginResourceType_None
Definition: OrthancCPlugin.h:689
OrthancPluginSetMetricsValue
void OrthancPluginSetMetricsValue(OrthancPluginContext *context, const char *name, float value, OrthancPluginMetricsType type)
Set the value of a metrics.
Definition: OrthancCPlugin.h:6728
OrthancPluginGetInstanceTransferSyntaxUid
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition: OrthancCPlugin.h:7478
OrthancPluginErrorCode_CannotStoreInstance
Definition: OrthancCPlugin.h:285
OrthancPluginHttpMethod_Get
Definition: OrthancCPlugin.h:323
OrthancPluginCreateDicomFlags
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:829
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:4976
OrthancPluginPixelFormat_Grayscale8
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:585
OrthancPluginStorageArea
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:1027
OrthancPluginSendHttpStatusCode
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2580
OrthancPluginIdentifierConstraint
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:844
OrthancPluginRestApiDeleteAfterPlugins
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2268
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:1075
OrthancPluginRefreshMetricsCallback
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1567
OrthancPluginDicomWebBinaryMode_BulkDataUri
Definition: OrthancCPlugin.h:936
OrthancPluginPixelFormat_Unknown
Definition: OrthancCPlugin.h:619
OrthancPluginValueRepresentation_LO
Definition: OrthancCPlugin.h:768
OrthancPluginRegisterIncomingHttpRequestFilter2
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6092
OrthancPluginValueRepresentation_AE
Definition: OrthancCPlugin.h:758
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:4902
OrthancPluginResourceType
OrthancPluginResourceType
Definition: OrthancCPlugin.h:683
OrthancPluginCreateFindMatcher
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:5979
OrthancPluginErrorCode_NoSopClassOrInstance
Definition: OrthancCPlugin.h:281
OrthancPluginJobStop
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1516
OrthancPluginValueRepresentation_AT
Definition: OrthancCPlugin.h:760
OrthancPluginReadFile
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3551
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:6399
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:1121
OrthancPluginInstanceOrigin_RestApi
Definition: OrthancCPlugin.h:878
OrthancPluginChunkedClientRequestIsDone
uint8_t(* OrthancPluginChunkedClientRequestIsDone)(void *request)
Callback to know whether the request body is entirely read during a chunked transfer.
Definition: OrthancCPlugin.h:6917
OrthancPluginErrorCode_NoApplicationEntityFilter
Definition: OrthancCPlugin.h:280
OrthancPluginLookupStudyWithAccessionNumber
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2465
OrthancPluginCompressionType_ZlibWithSize
Definition: OrthancCPlugin.h:730
OrthancPluginGetCommandLineArgumentsCount
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3303
OrthancPluginErrorCode_ReadOnly
Definition: OrthancCPlugin.h:233
OrthancPluginErrorCode_SQLiteTransactionAlreadyStarted
Definition: OrthancCPlugin.h:264
OrthancPluginValueRepresentation_TM
Definition: OrthancCPlugin.h:779
OrthancPluginErrorCode_StorageAreaPlugin
Definition: OrthancCPlugin.h:243
OrthancPluginWorklistQuery
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1035
OrthancPluginEncodeDicomWebXml
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:6834
OrthancPluginImageFormat_Jpeg
Definition: OrthancCPlugin.h:745
OrthancPluginErrorCode_BadRequest
Definition: OrthancCPlugin.h:219
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:1154
OrthancPluginOnStoredInstanceCallback
OrthancPluginErrorCode(* OrthancPluginOnStoredInstanceCallback)(const OrthancPluginDicomInstance *instance, const char *instanceId)
Signature of a callback function that is triggered when Orthanc stores a new DICOM instance.
Definition: OrthancCPlugin.h:1111
OrthancPluginRestApiGet
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2114
OrthancPluginConstraintType_SmallerOrEqual
Definition: OrthancCPlugin.h:862
OrthancPluginRestOutput
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:1004
OrthancPluginServerChunkedRequestReaderFinalize
void(* OrthancPluginServerChunkedRequestReaderFinalize)(OrthancPluginServerChunkedRequestReader *reader)
Callback invoked to release the resources associated with an incoming HTTP chunked transfer.
Definition: OrthancCPlugin.h:7182
OrthancPluginCompressionType_Zlib
Definition: OrthancCPlugin.h:729
OrthancPluginErrorCode_NoCStoreHandler
Definition: OrthancCPlugin.h:279
OrthancPluginErrorCode_CreateDicomParentEncoding
Definition: OrthancCPlugin.h:293
OrthancPluginDicomToJsonFormat_Short
Definition: OrthancCPlugin.h:798
OrthancPluginLogError
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:1815
OrthancPluginPixelFormat_RGB48
Color image in RGB48 format.
Definition: OrthancCPlugin.h:627
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:2040
OrthancPluginValueRepresentation_SL
Definition: OrthancCPlugin.h:775
OrthancPluginErrorCode_DicomFindUnavailable
Definition: OrthancCPlugin.h:283
OrthancPluginErrorCode_InexistentItem
Definition: OrthancCPlugin.h:218
OrthancPluginJobStopReason_Canceled
Definition: OrthancCPlugin.h:908
OrthancPluginErrorCode_SslInitialization
Definition: OrthancCPlugin.h:250
OrthancPluginDicomToJsonFormat
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:795
OrthancPluginErrorCode_IncompatibleDatabaseVersion
Definition: OrthancCPlugin.h:229
OrthancPluginErrorCode_AlreadyExistingTag
Definition: OrthancCPlugin.h:309
OrthancPluginErrorCode_CreateDicomNotString
Definition: OrthancCPlugin.h:286
OrthancPluginErrorCode_BadFont
Definition: OrthancCPlugin.h:241
OrthancPluginConstraintType_Equal
Definition: OrthancCPlugin.h:861
OrthancPluginErrorCode_IncompatibleImageSize
Definition: OrthancCPlugin.h:235
OrthancPluginErrorCode_SQLiteTransactionCommit
Definition: OrthancCPlugin.h:265
OrthancPluginHttpMethod_Post
Definition: OrthancCPlugin.h:324
OrthancPluginErrorCode_UnknownPluginService
Definition: OrthancCPlugin.h:237
OrthancPluginErrorCode_CorruptedFile
Definition: OrthancCPlugin.h:231
OrthancPluginDicomWebBinaryMode_InlineBinary
Definition: OrthancCPlugin.h:935
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:1263
OrthancPluginChangeType_StableSeries
Definition: OrthancCPlugin.h:710
OrthancPluginGetOrthancPath
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:3017
OrthancPluginStorageCreate
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1173
OrthancPluginContentType
OrthancPluginContentType
Definition: OrthancCPlugin.h:669
OrthancPluginGenerateUuid
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5655
OrthancPluginValueRepresentation_LT
Definition: OrthancCPlugin.h:769
OrthancPluginFreeMemoryBuffer
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1799
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:3472
OrthancPluginMetricsType_Timer
Definition: OrthancCPlugin.h:924
OrthancPluginChunkedClientRequestGetChunkData
const typedef void *(* OrthancPluginChunkedClientRequestGetChunkData)(void *request)
Callback to read the current chunk of the request body during a chunked transfer.
Definition: OrthancCPlugin.h:6950
OrthancPluginServerChunkedRequestReaderExecute
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderExecute)(OrthancPluginServerChunkedRequestReader *reader, OrthancPluginRestOutput *output)
Callback invoked whenever the request body is entirely received.
Definition: OrthancCPlugin.h:7164
OrthancPluginInstanceOrigin_Lua
Definition: OrthancCPlugin.h:880
OrthancPluginSetRootUri
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:3155
OrthancPluginCompressionType_GzipWithSize
Definition: OrthancCPlugin.h:732
OrthancPluginStartMultipartAnswer
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3443
OrthancPluginErrorCode_CannotOrderSlices
Definition: OrthancCPlugin.h:307
OrthancPluginGetInstanceSimplifiedJson
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:2857
OrthancPluginGetImageBuffer
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:3837
OrthancPluginStorageRemove
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1217
OrthancPluginErrorCode_SQLiteTransactionBegin
Definition: OrthancCPlugin.h:266
OrthancPluginErrorCode_BadJobOrdering
Definition: OrthancCPlugin.h:295
OrthancPluginValueRepresentation_DS
Definition: OrthancCPlugin.h:763
OrthancPluginInstanceOrigin
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:874
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:2293
OrthancPluginErrorCode_CreateDicomOverrideTag
Definition: OrthancCPlugin.h:287
OrthancPluginDicomWebBinaryMode_Ignore
Definition: OrthancCPlugin.h:934
OrthancPluginGetFontsCount
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4303
OrthancPluginRegisterIncomingDicomInstanceFilter
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instance.
Definition: OrthancCPlugin.h:7454
OrthancPluginChangeType_StablePatient
Definition: OrthancCPlugin.h:709
OrthancPluginGetInstanceJson
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2819
OrthancPluginGetExpectedDatabaseVersion
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3369
OrthancPluginRegisterOnChangeCallback
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3124
OrthancPluginChangeType_OrthancStarted
Definition: OrthancCPlugin.h:712
OrthancPluginFreeJob
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6539
OrthancPluginChangeType_NewSeries
Definition: OrthancCPlugin.h:707
OrthancPluginDicomToJsonFormat_Human
Definition: OrthancCPlugin.h:799
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:6897
OrthancPluginServerChunkedRequestReader
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition: OrthancCPlugin.h:7106
OrthancPluginIdentifierConstraint_GreaterOrEqual
Definition: OrthancCPlugin.h:848
OrthancPluginValueRepresentation
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:756
OrthancPluginErrorCode_CannotWriteFile
Definition: OrthancCPlugin.h:225
OrthancPluginIdentifierConstraint_Equal
Definition: OrthancCPlugin.h:846
OrthancPluginErrorCode_Database
Definition: OrthancCPlugin.h:222
OrthancPluginErrorCode_DirectoryOverFile
Definition: OrthancCPlugin.h:267
OrthancPluginRegisterWorklistCallback
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:4940
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:5158
OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered
Definition: OrthancCPlugin.h:304
OrthancPluginGetFontSize
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4375
OrthancPluginGetErrorDescription
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3613
OrthancPluginErrorCode_DatabaseUnavailable
Definition: OrthancCPlugin.h:247
OrthancPluginSetGlobalProperty
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3272
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:1132
OrthancPluginRegisterRestCallback
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:1883
OrthancPluginChangeType_Deleted
Definition: OrthancCPlugin.h:703
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:1364
OrthancPluginImageFormat_Dicom
Definition: OrthancCPlugin.h:746
OrthancPluginGetGlobalProperty
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3233
OrthancPluginValueRepresentation_SH
Definition: OrthancCPlugin.h:774
OrthancPluginGetImageHeight
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:3768
OrthancPluginValueRepresentation_OB
Definition: OrthancCPlugin.h:770
OrthancPluginValueRepresentation_DT
Definition: OrthancCPlugin.h:764
OrthancPluginValueRepresentation_UL
Definition: OrthancCPlugin.h:781
OrthancPluginPixelFormat_RGB24
Color image in RGB24 format.
Definition: OrthancCPlugin.h:609
OrthancPluginValueRepresentation_SQ
Definition: OrthancCPlugin.h:776
OrthancPluginFindAnswers
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1059
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:4598
OrthancPluginComputeMd5
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5363
OrthancPluginErrorCode_SQLiteRegisterFunction
Definition: OrthancCPlugin.h:258
OrthancPluginErrorCode_NoStorageCommitmentHandler
Definition: OrthancCPlugin.h:310
OrthancPluginValueRepresentation_CS
Definition: OrthancCPlugin.h:761
OrthancPluginMemoryBuffer::data
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:989
OrthancPluginPixelFormat_SignedGrayscale16
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:601
OrthancPluginFreeFindMatcher
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:6017
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:4012
OrthancPluginHttpMethod_Put
Definition: OrthancCPlugin.h:325
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:4480
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:7376
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:7227
OrthancPluginErrorCode_NotImplemented
Definition: OrthancCPlugin.h:213
OrthancPluginDicomToJsonFlags_IncludePixelData
Definition: OrthancCPlugin.h:816
OrthancPluginRegisterMoveCallback
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:5940
OrthancPluginRegisterJobsUnserializer
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6616
OrthancPluginErrorCode_UnknownModality
Definition: OrthancCPlugin.h:294
OrthancPluginErrorCode_CreateDicomBadParent
Definition: OrthancCPlugin.h:291
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:4150
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:4192
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:4844
OrthancPluginChangeType_UpdatedModalities
Definition: OrthancCPlugin.h:717
OrthancPluginValueRepresentation_UN
Definition: OrthancCPlugin.h:782
OrthancPluginSetDescription
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:3177
OrthancPluginDicomWebBinaryMode
OrthancPluginDicomWebBinaryMode
Definition: OrthancCPlugin.h:932
OrthancPluginIdentifierConstraint_Wildcard
Definition: OrthancCPlugin.h:849
OrthancPluginPixelFormat_Grayscale64
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:659
OrthancPluginConstraintType_GreaterOrEqual
Definition: OrthancCPlugin.h:863
OrthancPluginErrorCode_NoCFindHandler
Definition: OrthancCPlugin.h:277
OrthancPluginValueRepresentation_IS
Definition: OrthancCPlugin.h:767
OrthancPluginErrorCode_BadGeometry
Definition: OrthancCPlugin.h:249
OrthancPluginLogWarning
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:1831
OrthancPluginValueRepresentation_UI
Definition: OrthancCPlugin.h:780
OrthancPluginGetImagePixelFormat
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3702
OrthancPluginStorageCommitmentFailureReason_Success
Definition: OrthancCPlugin.h:947
OrthancPluginErrorCode_CreateDicomParentIsInstance
Definition: OrthancCPlugin.h:292
OrthancPluginFree
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1144
OrthancPluginRedirect
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2363
OrthancPluginValueRepresentation_SS
Definition: OrthancCPlugin.h:777
OrthancPluginJobReset
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1533
OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
Definition: OrthancCPlugin.h:965
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:5854
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:6484
OrthancPluginWorklistMarkIncomplete
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5006
OrthancPluginEncodeDicomWebJson
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:6793
OrthancPluginErrorCode_SQLiteCommitWithoutTransaction
Definition: OrthancCPlugin.h:257
OrthancPluginValueRepresentation_PN
Definition: OrthancCPlugin.h:773
OrthancPluginErrorCode
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:202
OrthancPluginErrorCode_Plugin
Definition: OrthancCPlugin.h:212
OrthancPluginErrorCode_UriSyntax
Definition: OrthancCPlugin.h:223
OrthancPluginStorageRead
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1199
OrthancPluginJobsUnserializer
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1549
OrthancPluginChangeType_UpdatedMetadata
Definition: OrthancCPlugin.h:715
OrthancPluginMemoryBuffer
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:984
OrthancPluginValueRepresentation_FL
Definition: OrthancCPlugin.h:766
OrthancPluginFreePeers
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6154
OrthancPluginWorklistAnswers
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1043
OrthancPluginRegisterFindCallback
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5694
OrthancPluginImage
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1019
OrthancPluginConstraintType_List
Definition: OrthancCPlugin.h:865
OrthancPluginJob
struct _OrthancPluginJob_t OrthancPluginJob
Opaque structure to a job to be executed by Orthanc.
Definition: OrthancCPlugin.h:1083
OrthancPluginGetInstanceOrigin
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5109
OrthancPluginErrorCode_BadSequenceOfCalls
Definition: OrthancCPlugin.h:217
OrthancPluginContentType_Unknown
Definition: OrthancCPlugin.h:671
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:1294
OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
Definition: OrthancCPlugin.h:970
OrthancPluginHttpMethod
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:321
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:1321
OrthancPluginFreeImage
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:3922
OrthancPluginDicomWebNode
struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode
Opaque structure that represents a node in a JSON or XML document used in DICOMweb.
Definition: OrthancCPlugin.h:1092
OrthancPluginAutodetectMimeType
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:6684
OrthancPluginErrorCode_DicomMoveUnavailable
Definition: OrthancCPlugin.h:284
OrthancPluginErrorCode_DicomPortInUse
Definition: OrthancCPlugin.h:271
OrthancPluginFreeMove
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1418
OrthancPluginGetFontName
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4343
OrthancPluginSetCookie
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2656
OrthancPluginJobFinalize
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1431
OrthancPluginApplyMove
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1404
OrthancPluginErrorCode_EmptyRequest
Definition: OrthancCPlugin.h:244
OrthancPluginErrorCode_CanceledJob
Definition: OrthancCPlugin.h:248
OrthancPluginJobStepStatus_Failure
Definition: OrthancCPlugin.h:892
OrthancPluginPixelFormat_Grayscale32
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:635
OrthancPluginGetPeers
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6120
OrthancPluginErrorCode_NoPresentationContext
Definition: OrthancCPlugin.h:282
OrthancPluginErrorCode_NetworkProtocol
Definition: OrthancCPlugin.h:220
OrthancPluginSubmitJob
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int priority)
Submit a new job to the jobs engine of Orthanc.
Definition: OrthancCPlugin.h:6571
OrthancPluginDicomToJsonFormat_Full
Definition: OrthancCPlugin.h:797
OrthancPluginRegisterRefreshMetricsCallback
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:6758
OrthancPluginHttpMethod_Delete
Definition: OrthancCPlugin.h:326
OrthancPluginErrorCode_UnknownDicomTag
Definition: OrthancCPlugin.h:238
OrthancPluginInstanceOrigin_DicomProtocol
Definition: OrthancCPlugin.h:877
OrthancPluginResourceType_Series
Definition: OrthancCPlugin.h:687
OrthancPluginErrorCode_IncompatibleImageFormat
Definition: OrthancCPlugin.h:234
OrthancPluginChangeType_NewStudy
Definition: OrthancCPlugin.h:708
OrthancPluginErrorCode_FullStorage
Definition: OrthancCPlugin.h:230
OrthancPluginDictionaryEntry
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1626
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:5272
OrthancPluginJobStopReason_Paused
Definition: OrthancCPlugin.h:906
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:6319
OrthancPluginLookupPatient
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2395
OrthancPluginJobStopReason_Success
Definition: OrthancCPlugin.h:905
OrthancPluginErrorCode_SQLiteAlreadyOpened
Definition: OrthancCPlugin.h:252
OrthancPluginFreeString
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1645
OrthancPluginWriteFile
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3582
OrthancPluginGetCommandLineArgument
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3337
OrthancPluginJobStepStatus_Continue
Definition: OrthancCPlugin.h:893
OrthancPluginErrorCode_RegularFileExpected
Definition: OrthancCPlugin.h:273
OrthancPluginLookupInstance
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2535
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:7045
OrthancPluginErrorCode_SslDisabled
Definition: OrthancCPlugin.h:306
OrthancPluginErrorCode_CreateDicomUseDataUriScheme
Definition: OrthancCPlugin.h:290
OrthancPluginContext
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginChangeType
OrthancPluginChangeType
Definition: OrthancCPlugin.h:700
OrthancPluginErrorCode_CannotCreateLua
Definition: OrthancCPlugin.h:297
OrthancPluginErrorCode_BadHttpStatusInRest
Definition: OrthancCPlugin.h:272
OrthancPluginErrorCode_StorageAreaAlreadyRegistered
Definition: OrthancCPlugin.h:303
OrthancPluginJobStepStatus
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:889
OrthancPluginUncompressImage
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:3880
OrthancPluginRegisterRestCallbackNoLock
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:1923
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:1675
OrthancPluginValueRepresentation_US
Definition: OrthancCPlugin.h:783
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:5044
OrthancPluginErrorCode_DatabaseNotInitialized
Definition: OrthancCPlugin.h:305
OrthancPluginDicomToJsonFlags_IncludeUnknownTags
Definition: OrthancCPlugin.h:815
OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
Definition: OrthancCPlugin.h:957
OrthancPluginMemoryBuffer::size
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:994
OrthancPluginJobStopReason
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:903
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:4707
OrthancPluginStorageAreaRemove
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4559
OrthancPluginGetPeersCount
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6184
OrthancPluginGetFindQuerySize
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5786
OrthancPluginLogInfo
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:1847
OrthancPluginErrorCode_SQLiteRollbackWithoutTransaction
Definition: OrthancCPlugin.h:256
OrthancPluginFindMarkIncomplete
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:5762
OrthancPluginFindQuery
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1051
OrthancPluginDicomInstance
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance received by Orthanc.
Definition: OrthancCPlugin.h:1011
OrthancPluginHttpGet
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:4112
OrthancPluginErrorCode_BadFileFormat
Definition: OrthancCPlugin.h:226
OrthancPluginErrorCode_BadJson
Definition: OrthancCPlugin.h:239
OrthancPluginChunkedClientRequestGetChunkSize
uint32_t(* OrthancPluginChunkedClientRequestGetChunkSize)(void *request)
Callback to read the size of the current request chunk during a chunked transfer.
Definition: OrthancCPlugin.h:6966
OrthancPluginResourceType_Study
Definition: OrthancCPlugin.h:686
OrthancPluginStorageCommitmentFailureReason
OrthancPluginStorageCommitmentFailureReason
Definition: OrthancCPlugin.h:945
OrthancPluginContentType_DicomAsJson
Definition: OrthancCPlugin.h:673
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:1595
OrthancPluginErrorCode_HttpPortInUse
Definition: OrthancCPlugin.h:270
OrthancPluginErrorCode_PathToExecutable
Definition: OrthancCPlugin.h:274
OrthancPluginMetricsType
OrthancPluginMetricsType
Definition: OrthancCPlugin.h:915
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:3514
OrthancPluginGetInstanceData
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2783
OrthancPluginGetDicomForInstance
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2081
OrthancPluginWorklistGetDicomQuery
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5083
OrthancPluginErrorCode_NullPointer
Definition: OrthancCPlugin.h:246
OrthancPluginSetHttpErrorDetails
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:6652
OrthancPluginErrorCode_SharedLibrary
Definition: OrthancCPlugin.h:236
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:6876
OrthancPluginErrorCode_FileStorageCannotWrite
Definition: OrthancCPlugin.h:268
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:6050
OrthancPluginValueRepresentation_OW
Definition: OrthancCPlugin.h:772
OrthancPluginValueRepresentation_OF
Definition: OrthancCPlugin.h:771
OrthancPluginChunkedClientRequestNext
OrthancPluginErrorCode(* OrthancPluginChunkedClientRequestNext)(void *request)
Callback to advance in the request body during a chunked transfer.
Definition: OrthancCPlugin.h:6934
OrthancPluginErrorCode_SQLiteNotOpened
Definition: OrthancCPlugin.h:251
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:2181
OrthancPluginRegisterStorageArea
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:2985
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:7333
OrthancPluginJobStepStatus_Success
Definition: OrthancCPlugin.h:891
OrthancPluginErrorCode_BadParameterType
Definition: OrthancCPlugin.h:216
OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
Definition: OrthancCPlugin.h:950
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:2144
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:5488
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:5892
OrthancPluginImageFormat_Png
Definition: OrthancCPlugin.h:744
OrthancPluginPixelFormat
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:577
OrthancPluginErrorCode_LuaBadOutput
Definition: OrthancCPlugin.h:300
OrthancPluginSendUnauthorized
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2603
OrthancPluginErrorCode_DatabasePlugin
Definition: OrthancCPlugin.h:242
OrthancPluginPixelFormat_Grayscale16
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:593
OrthancPluginSendMethodNotAllowed
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2626
OrthancPluginStorageCommitmentDestructor
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7355
OrthancPluginSetHttpHeader
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2681
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:4654
OrthancPluginErrorCode_NotLuaPredicate
Definition: OrthancCPlugin.h:301
OrthancPluginLookupStudy
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2430
OrthancPluginHasInstanceMetadata
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:2896
OrthancPluginErrorCode_NotAcceptable
Definition: OrthancCPlugin.h:245
OrthancPluginDecodeDicomImage
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5317
OrthancPluginGetConfiguration
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3402