Orthanc Plugin SDK  1.4.2
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1 
108 #pragma once
109 
110 
111 #include <stdio.h>
112 #include <string.h>
113 
114 #ifdef WIN32
115 #define ORTHANC_PLUGINS_API __declspec(dllexport)
116 #else
117 #define ORTHANC_PLUGINS_API
118 #endif
119 
120 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
121 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 4
122 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 2
123 
124 
125 #if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
126 #define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
127  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
128  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
129  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
130  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
131  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
132 #endif
133 
134 
135 
136 /********************************************************************
137  ** Check that function inlining is properly supported. The use of
138  ** inlining is required, to avoid the duplication of object code
139  ** between two compilation modules that would use the Orthanc Plugin
140  ** API.
141  ********************************************************************/
142 
143 /* If the auto-detection of the "inline" keyword below does not work
144  automatically and that your compiler is known to properly support
145  inlining, uncomment the following #define and adapt the definition
146  of "static inline". */
147 
148 /* #define ORTHANC_PLUGIN_INLINE static inline */
149 
150 #ifndef ORTHANC_PLUGIN_INLINE
151 # if __STDC_VERSION__ >= 199901L
152 /* This is C99 or above: http://predef.sourceforge.net/prestd.html */
153 # define ORTHANC_PLUGIN_INLINE static inline
154 # elif defined(__cplusplus)
155 /* This is C++ */
156 # define ORTHANC_PLUGIN_INLINE static inline
157 # elif defined(__GNUC__)
158 /* This is GCC running in C89 mode */
159 # define ORTHANC_PLUGIN_INLINE static __inline
160 # elif defined(_MSC_VER)
161 /* This is Visual Studio running in C89 mode */
162 # define ORTHANC_PLUGIN_INLINE static __inline
163 # else
164 # error Your compiler is not known to support the "inline" keyword
165 # endif
166 #endif
167 
168 
169 
170 /********************************************************************
171  ** Inclusion of standard libraries.
172  ********************************************************************/
173 
179 #include <stdint.h>
180 
181 #include <stdlib.h>
182 
183 
184 
185 /********************************************************************
186  ** Definition of the Orthanc Plugin API.
187  ********************************************************************/
188 
191 #ifdef __cplusplus
192 extern "C"
193 {
194 #endif
195 
199  typedef enum
200  {
299 
300  _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
302 
303 
308  ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
309 
310 
314  typedef enum
315  {
321  _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
323 
324 
329  typedef struct
330  {
335 
339  uint32_t groupsCount;
340 
344  const char* const* groups;
345 
349  uint32_t getCount;
350 
354  const char* const* getKeys;
355 
359  const char* const* getValues;
360 
364  const char* body;
365 
369  uint32_t bodySize;
370 
371 
372  /* --------------------------------------------------
373  New in version 0.8.1
374  -------------------------------------------------- */
375 
379  uint32_t headersCount;
380 
384  const char* const* headersKeys;
385 
389  const char* const* headersValues;
390 
392 
393 
394  typedef enum
395  {
396  /* Generic services */
397  _OrthancPluginService_LogInfo = 1,
398  _OrthancPluginService_LogWarning = 2,
399  _OrthancPluginService_LogError = 3,
400  _OrthancPluginService_GetOrthancPath = 4,
401  _OrthancPluginService_GetOrthancDirectory = 5,
402  _OrthancPluginService_GetConfigurationPath = 6,
403  _OrthancPluginService_SetPluginProperty = 7,
404  _OrthancPluginService_GetGlobalProperty = 8,
405  _OrthancPluginService_SetGlobalProperty = 9,
406  _OrthancPluginService_GetCommandLineArgumentsCount = 10,
407  _OrthancPluginService_GetCommandLineArgument = 11,
408  _OrthancPluginService_GetExpectedDatabaseVersion = 12,
409  _OrthancPluginService_GetConfiguration = 13,
410  _OrthancPluginService_BufferCompression = 14,
411  _OrthancPluginService_ReadFile = 15,
412  _OrthancPluginService_WriteFile = 16,
413  _OrthancPluginService_GetErrorDescription = 17,
414  _OrthancPluginService_CallHttpClient = 18,
415  _OrthancPluginService_RegisterErrorCode = 19,
416  _OrthancPluginService_RegisterDictionaryTag = 20,
417  _OrthancPluginService_DicomBufferToJson = 21,
418  _OrthancPluginService_DicomInstanceToJson = 22,
419  _OrthancPluginService_CreateDicom = 23,
420  _OrthancPluginService_ComputeMd5 = 24,
421  _OrthancPluginService_ComputeSha1 = 25,
422  _OrthancPluginService_LookupDictionary = 26,
423  _OrthancPluginService_CallHttpClient2 = 27,
424  _OrthancPluginService_GenerateUuid = 28,
425  _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
426 
427  /* Registration of callbacks */
428  _OrthancPluginService_RegisterRestCallback = 1000,
429  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
430  _OrthancPluginService_RegisterStorageArea = 1002,
431  _OrthancPluginService_RegisterOnChangeCallback = 1003,
432  _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
433  _OrthancPluginService_RegisterWorklistCallback = 1005,
434  _OrthancPluginService_RegisterDecodeImageCallback = 1006,
435  _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
436  _OrthancPluginService_RegisterFindCallback = 1008,
437  _OrthancPluginService_RegisterMoveCallback = 1009,
438  _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
439 
440  /* Sending answers to REST calls */
441  _OrthancPluginService_AnswerBuffer = 2000,
442  _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
443  _OrthancPluginService_Redirect = 2002,
444  _OrthancPluginService_SendHttpStatusCode = 2003,
445  _OrthancPluginService_SendUnauthorized = 2004,
446  _OrthancPluginService_SendMethodNotAllowed = 2005,
447  _OrthancPluginService_SetCookie = 2006,
448  _OrthancPluginService_SetHttpHeader = 2007,
449  _OrthancPluginService_StartMultipartAnswer = 2008,
450  _OrthancPluginService_SendMultipartItem = 2009,
451  _OrthancPluginService_SendHttpStatus = 2010,
452  _OrthancPluginService_CompressAndAnswerImage = 2011,
453  _OrthancPluginService_SendMultipartItem2 = 2012,
454 
455  /* Access to the Orthanc database and API */
456  _OrthancPluginService_GetDicomForInstance = 3000,
457  _OrthancPluginService_RestApiGet = 3001,
458  _OrthancPluginService_RestApiPost = 3002,
459  _OrthancPluginService_RestApiDelete = 3003,
460  _OrthancPluginService_RestApiPut = 3004,
461  _OrthancPluginService_LookupPatient = 3005,
462  _OrthancPluginService_LookupStudy = 3006,
463  _OrthancPluginService_LookupSeries = 3007,
464  _OrthancPluginService_LookupInstance = 3008,
465  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
466  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
467  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
468  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
469  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
470  _OrthancPluginService_ReconstructMainDicomTags = 3014,
471  _OrthancPluginService_RestApiGet2 = 3015,
472 
473  /* Access to DICOM instances */
474  _OrthancPluginService_GetInstanceRemoteAet = 4000,
475  _OrthancPluginService_GetInstanceSize = 4001,
476  _OrthancPluginService_GetInstanceData = 4002,
477  _OrthancPluginService_GetInstanceJson = 4003,
478  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
479  _OrthancPluginService_HasInstanceMetadata = 4005,
480  _OrthancPluginService_GetInstanceMetadata = 4006,
481  _OrthancPluginService_GetInstanceOrigin = 4007,
482 
483  /* Services for plugins implementing a database back-end */
484  _OrthancPluginService_RegisterDatabaseBackend = 5000,
485  _OrthancPluginService_DatabaseAnswer = 5001,
486  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
487  _OrthancPluginService_StorageAreaCreate = 5003,
488  _OrthancPluginService_StorageAreaRead = 5004,
489  _OrthancPluginService_StorageAreaRemove = 5005,
490 
491  /* Primitives for handling images */
492  _OrthancPluginService_GetImagePixelFormat = 6000,
493  _OrthancPluginService_GetImageWidth = 6001,
494  _OrthancPluginService_GetImageHeight = 6002,
495  _OrthancPluginService_GetImagePitch = 6003,
496  _OrthancPluginService_GetImageBuffer = 6004,
497  _OrthancPluginService_UncompressImage = 6005,
498  _OrthancPluginService_FreeImage = 6006,
499  _OrthancPluginService_CompressImage = 6007,
500  _OrthancPluginService_ConvertPixelFormat = 6008,
501  _OrthancPluginService_GetFontsCount = 6009,
502  _OrthancPluginService_GetFontInfo = 6010,
503  _OrthancPluginService_DrawText = 6011,
504  _OrthancPluginService_CreateImage = 6012,
505  _OrthancPluginService_CreateImageAccessor = 6013,
506  _OrthancPluginService_DecodeDicomImage = 6014,
507 
508  /* Primitives for handling C-Find, C-Move and worklists */
509  _OrthancPluginService_WorklistAddAnswer = 7000,
510  _OrthancPluginService_WorklistMarkIncomplete = 7001,
511  _OrthancPluginService_WorklistIsMatch = 7002,
512  _OrthancPluginService_WorklistGetDicomQuery = 7003,
513  _OrthancPluginService_FindAddAnswer = 7004,
514  _OrthancPluginService_FindMarkIncomplete = 7005,
515  _OrthancPluginService_GetFindQuerySize = 7006,
516  _OrthancPluginService_GetFindQueryTag = 7007,
517  _OrthancPluginService_GetFindQueryTagName = 7008,
518  _OrthancPluginService_GetFindQueryValue = 7009,
519  _OrthancPluginService_CreateFindMatcher = 7010,
520  _OrthancPluginService_FreeFindMatcher = 7011,
521  _OrthancPluginService_FindMatcherIsMatch = 7012,
522 
523  /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
524  _OrthancPluginService_GetPeers = 8000,
525  _OrthancPluginService_FreePeers = 8001,
526  _OrthancPluginService_GetPeersCount = 8003,
527  _OrthancPluginService_GetPeerName = 8004,
528  _OrthancPluginService_GetPeerUrl = 8005,
529  _OrthancPluginService_CallPeerApi = 8006,
530  _OrthancPluginService_GetPeerUserProperty = 8007,
531 
532  /* Primitives for handling jobs (new in 1.4.2) */
533  _OrthancPluginService_CreateJob = 9000,
534  _OrthancPluginService_FreeJob = 9001,
535  _OrthancPluginService_SubmitJob = 9002,
536  _OrthancPluginService_RegisterJobsUnserializer = 9003,
537 
538  _OrthancPluginService_INTERNAL = 0x7fffffff
539  } _OrthancPluginService;
540 
541 
542  typedef enum
543  {
544  _OrthancPluginProperty_Description = 1,
545  _OrthancPluginProperty_RootUri = 2,
546  _OrthancPluginProperty_OrthancExplorer = 3,
547 
548  _OrthancPluginProperty_INTERNAL = 0x7fffffff
549  } _OrthancPluginProperty;
550 
551 
552 
557  typedef enum
558  {
566 
574 
582 
590 
598 
608 
616 
624 
632 
640 
641  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
643 
644 
645 
649  typedef enum
650  {
655  _OrthancPluginContentType_INTERNAL = 0x7fffffff
657 
658 
659 
663  typedef enum
664  {
671  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
673 
674 
675 
680  typedef enum
681  {
699  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
701 
702 
707  typedef enum
708  {
714  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
716 
717 
722  typedef enum
723  {
728  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
730 
731 
736  typedef enum
737  {
766  _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
768 
769 
775  typedef enum
776  {
781  _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
783 
784 
790  typedef enum
791  {
792  OrthancPluginDicomToJsonFlags_None = 0,
800  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
802 
803 
809  typedef enum
810  {
811  OrthancPluginCreateDicomFlags_None = 0,
815  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
817 
818 
823  typedef enum
824  {
830  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
832 
833 
837  typedef enum
838  {
845  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
847 
848 
852  typedef enum
853  {
858 
859 
866  typedef enum
867  {
873 
874 
882  typedef struct
883  {
887  void* data;
888 
892  uint32_t size;
894 
895 
896 
897 
902  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
903 
904 
905 
909  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
910 
911 
912 
917  typedef struct _OrthancPluginImage_t OrthancPluginImage;
918 
919 
920 
925  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
926 
927 
928 
933  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
934 
935 
936 
941  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
942 
943 
944 
949  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
950 
951 
952 
957  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
958 
959 
960 
965  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindMatcher;
966 
967 
968 
973  typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
974 
975 
976 
981  typedef struct _OrthancPluginJob_t OrthancPluginJob;
982 
983 
984 
990  OrthancPluginRestOutput* output,
991  const char* url,
992  const OrthancPluginHttpRequest* request);
993 
994 
995 
1001  OrthancPluginDicomInstance* instance,
1002  const char* instanceId);
1003 
1004 
1005 
1011  OrthancPluginChangeType changeType,
1012  OrthancPluginResourceType resourceType,
1013  const char* resourceId);
1014 
1015 
1016 
1022  OrthancPluginImage** target,
1023  const void* dicom,
1024  const uint32_t size,
1025  uint32_t frameIndex);
1026 
1027 
1028 
1032  typedef void (*OrthancPluginFree) (void* buffer);
1033 
1034 
1035 
1049  const char* uuid,
1050  const void* content,
1051  int64_t size,
1053 
1054 
1055 
1069  void** content,
1070  int64_t* size,
1071  const char* uuid,
1073 
1074 
1075 
1087  const char* uuid,
1089 
1090 
1091 
1107  const OrthancPluginWorklistQuery* query,
1108  const char* issuerAet,
1109  const char* calledAet);
1110 
1111 
1112 
1133  OrthancPluginHttpMethod method,
1134  const char* uri,
1135  const char* ip,
1136  uint32_t headersCount,
1137  const char* const* headersKeys,
1138  const char* const* headersValues);
1139 
1140 
1141 
1164  OrthancPluginHttpMethod method,
1165  const char* uri,
1166  const char* ip,
1167  uint32_t headersCount,
1168  const char* const* headersKeys,
1169  const char* const* headersValues,
1170  uint32_t getArgumentsCount,
1171  const char* const* getArgumentsKeys,
1172  const char* const* getArgumentsValues);
1173 
1174 
1175 
1191  OrthancPluginFindAnswers* answers,
1192  const OrthancPluginFindQuery* query,
1193  const char* issuerAet,
1194  const char* calledAet);
1195 
1196 
1197 
1233  typedef void* (*OrthancPluginMoveCallback) (
1234  OrthancPluginResourceType resourceType,
1235  const char* patientId,
1236  const char* accessionNumber,
1237  const char* studyInstanceUid,
1238  const char* seriesInstanceUid,
1239  const char* sopInstanceUid,
1240  const char* originatorAet,
1241  const char* sourceAet,
1242  const char* targetAet,
1243  uint16_t originatorId);
1244 
1245 
1258  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1259 
1260 
1273  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1274 
1275 
1287  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1288 
1289 
1300  typedef void (*OrthancPluginJobFinalize) (void* job);
1301 
1302 
1313  typedef float (*OrthancPluginJobGetProgress) (void* job);
1314 
1315 
1328  typedef const char* (*OrthancPluginJobGetContent) (void* job);
1329 
1330 
1346  typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1347 
1348 
1362 
1363 
1387 
1388 
1403 
1404 
1418  typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1419  const char* serialized);
1420 
1421 
1422 
1426  typedef struct _OrthancPluginContext_t
1427  {
1428  void* pluginsManager;
1429  const char* orthancVersion;
1430  OrthancPluginFree Free;
1431  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1432  _OrthancPluginService service,
1433  const void* params);
1435 
1436 
1437 
1441  typedef struct
1442  {
1443  uint16_t group;
1444  uint16_t element;
1446  uint32_t minMultiplicity;
1447  uint32_t maxMultiplicity;
1449 
1450 
1451 
1460  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1461  OrthancPluginContext* context,
1462  char* str)
1463  {
1464  if (str != NULL)
1465  {
1466  context->Free(str);
1467  }
1468  }
1469 
1470 
1490  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1491  OrthancPluginContext* context,
1492  int expectedMajor,
1493  int expectedMinor,
1494  int expectedRevision)
1495  {
1496  int major, minor, revision;
1497 
1498  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1499  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1500  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1501  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1502  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1503  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1504  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1505  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1506  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1507  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1508  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1509  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1510  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1511  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1512  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1513  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1514  sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus))
1515  {
1516  /* Mismatch in the size of the enumerations */
1517  return 0;
1518  }
1519 
1520  /* Assume compatibility with the mainline */
1521  if (!strcmp(context->orthancVersion, "mainline"))
1522  {
1523  return 1;
1524  }
1525 
1526  /* Parse the version of the Orthanc core */
1527  if (
1528 #ifdef _MSC_VER
1529  sscanf_s
1530 #else
1531  sscanf
1532 #endif
1533  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1534  {
1535  return 0;
1536  }
1537 
1538  /* Check the major number of the version */
1539 
1540  if (major > expectedMajor)
1541  {
1542  return 1;
1543  }
1544 
1545  if (major < expectedMajor)
1546  {
1547  return 0;
1548  }
1549 
1550  /* Check the minor number of the version */
1551 
1552  if (minor > expectedMinor)
1553  {
1554  return 1;
1555  }
1556 
1557  if (minor < expectedMinor)
1558  {
1559  return 0;
1560  }
1561 
1562  /* Check the revision number of the version */
1563 
1564  if (revision >= expectedRevision)
1565  {
1566  return 1;
1567  }
1568  else
1569  {
1570  return 0;
1571  }
1572  }
1573 
1574 
1591  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1592  OrthancPluginContext* context)
1593  {
1595  context,
1596  ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1597  ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1598  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1599  }
1600 
1601 
1610  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1611  OrthancPluginContext* context,
1612  OrthancPluginMemoryBuffer* buffer)
1613  {
1614  context->Free(buffer->data);
1615  }
1616 
1617 
1626  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1627  OrthancPluginContext* context,
1628  const char* message)
1629  {
1630  context->InvokeService(context, _OrthancPluginService_LogError, message);
1631  }
1632 
1633 
1642  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
1643  OrthancPluginContext* context,
1644  const char* message)
1645  {
1646  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1647  }
1648 
1649 
1658  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
1659  OrthancPluginContext* context,
1660  const char* message)
1661  {
1662  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
1663  }
1664 
1665 
1666 
1667  typedef struct
1668  {
1669  const char* pathRegularExpression;
1670  OrthancPluginRestCallback callback;
1671  } _OrthancPluginRestCallback;
1672 
1689  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
1690  OrthancPluginContext* context,
1691  const char* pathRegularExpression,
1692  OrthancPluginRestCallback callback)
1693  {
1694  _OrthancPluginRestCallback params;
1695  params.pathRegularExpression = pathRegularExpression;
1696  params.callback = callback;
1697  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
1698  }
1699 
1700 
1701 
1723  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
1724  OrthancPluginContext* context,
1725  const char* pathRegularExpression,
1726  OrthancPluginRestCallback callback)
1727  {
1728  _OrthancPluginRestCallback params;
1729  params.pathRegularExpression = pathRegularExpression;
1730  params.callback = callback;
1731  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
1732  }
1733 
1734 
1735 
1736  typedef struct
1737  {
1739  } _OrthancPluginOnStoredInstanceCallback;
1740 
1752  OrthancPluginContext* context,
1754  {
1755  _OrthancPluginOnStoredInstanceCallback params;
1756  params.callback = callback;
1757 
1758  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
1759  }
1760 
1761 
1762 
1763  typedef struct
1764  {
1765  OrthancPluginRestOutput* output;
1766  const char* answer;
1767  uint32_t answerSize;
1768  const char* mimeType;
1769  } _OrthancPluginAnswerBuffer;
1770 
1783  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
1784  OrthancPluginContext* context,
1785  OrthancPluginRestOutput* output,
1786  const char* answer,
1787  uint32_t answerSize,
1788  const char* mimeType)
1789  {
1790  _OrthancPluginAnswerBuffer params;
1791  params.output = output;
1792  params.answer = answer;
1793  params.answerSize = answerSize;
1794  params.mimeType = mimeType;
1795  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
1796  }
1797 
1798 
1799  typedef struct
1800  {
1801  OrthancPluginRestOutput* output;
1802  OrthancPluginPixelFormat format;
1803  uint32_t width;
1804  uint32_t height;
1805  uint32_t pitch;
1806  const void* buffer;
1807  } _OrthancPluginCompressAndAnswerPngImage;
1808 
1809  typedef struct
1810  {
1811  OrthancPluginRestOutput* output;
1812  OrthancPluginImageFormat imageFormat;
1813  OrthancPluginPixelFormat pixelFormat;
1814  uint32_t width;
1815  uint32_t height;
1816  uint32_t pitch;
1817  const void* buffer;
1818  uint8_t quality;
1819  } _OrthancPluginCompressAndAnswerImage;
1820 
1821 
1840  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
1841  OrthancPluginContext* context,
1842  OrthancPluginRestOutput* output,
1843  OrthancPluginPixelFormat format,
1844  uint32_t width,
1845  uint32_t height,
1846  uint32_t pitch,
1847  const void* buffer)
1848  {
1849  _OrthancPluginCompressAndAnswerImage params;
1850  params.output = output;
1851  params.imageFormat = OrthancPluginImageFormat_Png;
1852  params.pixelFormat = format;
1853  params.width = width;
1854  params.height = height;
1855  params.pitch = pitch;
1856  params.buffer = buffer;
1857  params.quality = 0; /* No quality for PNG */
1858  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
1859  }
1860 
1861 
1862 
1863  typedef struct
1864  {
1865  OrthancPluginMemoryBuffer* target;
1866  const char* instanceId;
1867  } _OrthancPluginGetDicomForInstance;
1868 
1882  OrthancPluginContext* context,
1883  OrthancPluginMemoryBuffer* target,
1884  const char* instanceId)
1885  {
1886  _OrthancPluginGetDicomForInstance params;
1887  params.target = target;
1888  params.instanceId = instanceId;
1889  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
1890  }
1891 
1892 
1893 
1894  typedef struct
1895  {
1896  OrthancPluginMemoryBuffer* target;
1897  const char* uri;
1898  } _OrthancPluginRestApiGet;
1899 
1915  OrthancPluginContext* context,
1916  OrthancPluginMemoryBuffer* target,
1917  const char* uri)
1918  {
1919  _OrthancPluginRestApiGet params;
1920  params.target = target;
1921  params.uri = uri;
1922  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
1923  }
1924 
1925 
1926 
1945  OrthancPluginContext* context,
1946  OrthancPluginMemoryBuffer* target,
1947  const char* uri)
1948  {
1949  _OrthancPluginRestApiGet params;
1950  params.target = target;
1951  params.uri = uri;
1952  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
1953  }
1954 
1955 
1956 
1957  typedef struct
1958  {
1959  OrthancPluginMemoryBuffer* target;
1960  const char* uri;
1961  const char* body;
1962  uint32_t bodySize;
1963  } _OrthancPluginRestApiPostPut;
1964 
1982  OrthancPluginContext* context,
1983  OrthancPluginMemoryBuffer* target,
1984  const char* uri,
1985  const char* body,
1986  uint32_t bodySize)
1987  {
1988  _OrthancPluginRestApiPostPut params;
1989  params.target = target;
1990  params.uri = uri;
1991  params.body = body;
1992  params.bodySize = bodySize;
1993  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
1994  }
1995 
1996 
2017  OrthancPluginContext* context,
2018  OrthancPluginMemoryBuffer* target,
2019  const char* uri,
2020  const char* body,
2021  uint32_t bodySize)
2022  {
2023  _OrthancPluginRestApiPostPut params;
2024  params.target = target;
2025  params.uri = uri;
2026  params.body = body;
2027  params.bodySize = bodySize;
2028  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2029  }
2030 
2031 
2032 
2046  OrthancPluginContext* context,
2047  const char* uri)
2048  {
2049  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2050  }
2051 
2052 
2069  OrthancPluginContext* context,
2070  const char* uri)
2071  {
2072  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2073  }
2074 
2075 
2076 
2094  OrthancPluginContext* context,
2095  OrthancPluginMemoryBuffer* target,
2096  const char* uri,
2097  const char* body,
2098  uint32_t bodySize)
2099  {
2100  _OrthancPluginRestApiPostPut params;
2101  params.target = target;
2102  params.uri = uri;
2103  params.body = body;
2104  params.bodySize = bodySize;
2105  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2106  }
2107 
2108 
2109 
2130  OrthancPluginContext* context,
2131  OrthancPluginMemoryBuffer* target,
2132  const char* uri,
2133  const char* body,
2134  uint32_t bodySize)
2135  {
2136  _OrthancPluginRestApiPostPut params;
2137  params.target = target;
2138  params.uri = uri;
2139  params.body = body;
2140  params.bodySize = bodySize;
2141  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2142  }
2143 
2144 
2145 
2146  typedef struct
2147  {
2148  OrthancPluginRestOutput* output;
2149  const char* argument;
2150  } _OrthancPluginOutputPlusArgument;
2151 
2163  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2164  OrthancPluginContext* context,
2165  OrthancPluginRestOutput* output,
2166  const char* redirection)
2167  {
2168  _OrthancPluginOutputPlusArgument params;
2169  params.output = output;
2170  params.argument = redirection;
2171  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2172  }
2173 
2174 
2175 
2176  typedef struct
2177  {
2178  char** result;
2179  const char* argument;
2180  } _OrthancPluginRetrieveDynamicString;
2181 
2195  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2196  OrthancPluginContext* context,
2197  const char* patientID)
2198  {
2199  char* result;
2200 
2201  _OrthancPluginRetrieveDynamicString params;
2202  params.result = &result;
2203  params.argument = patientID;
2204 
2205  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2206  {
2207  /* Error */
2208  return NULL;
2209  }
2210  else
2211  {
2212  return result;
2213  }
2214  }
2215 
2216 
2230  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2231  OrthancPluginContext* context,
2232  const char* studyUID)
2233  {
2234  char* result;
2235 
2236  _OrthancPluginRetrieveDynamicString params;
2237  params.result = &result;
2238  params.argument = studyUID;
2239 
2240  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2241  {
2242  /* Error */
2243  return NULL;
2244  }
2245  else
2246  {
2247  return result;
2248  }
2249  }
2250 
2251 
2265  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
2266  OrthancPluginContext* context,
2267  const char* accessionNumber)
2268  {
2269  char* result;
2270 
2271  _OrthancPluginRetrieveDynamicString params;
2272  params.result = &result;
2273  params.argument = accessionNumber;
2274 
2275  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2276  {
2277  /* Error */
2278  return NULL;
2279  }
2280  else
2281  {
2282  return result;
2283  }
2284  }
2285 
2286 
2300  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2301  OrthancPluginContext* context,
2302  const char* seriesUID)
2303  {
2304  char* result;
2305 
2306  _OrthancPluginRetrieveDynamicString params;
2307  params.result = &result;
2308  params.argument = seriesUID;
2309 
2310  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2311  {
2312  /* Error */
2313  return NULL;
2314  }
2315  else
2316  {
2317  return result;
2318  }
2319  }
2320 
2321 
2335  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2336  OrthancPluginContext* context,
2337  const char* sopInstanceUID)
2338  {
2339  char* result;
2340 
2341  _OrthancPluginRetrieveDynamicString params;
2342  params.result = &result;
2343  params.argument = sopInstanceUID;
2344 
2345  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2346  {
2347  /* Error */
2348  return NULL;
2349  }
2350  else
2351  {
2352  return result;
2353  }
2354  }
2355 
2356 
2357 
2358  typedef struct
2359  {
2360  OrthancPluginRestOutput* output;
2361  uint16_t status;
2362  } _OrthancPluginSendHttpStatusCode;
2363 
2380  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2381  OrthancPluginContext* context,
2382  OrthancPluginRestOutput* output,
2383  uint16_t status)
2384  {
2385  _OrthancPluginSendHttpStatusCode params;
2386  params.output = output;
2387  params.status = status;
2388  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2389  }
2390 
2391 
2403  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2404  OrthancPluginContext* context,
2405  OrthancPluginRestOutput* output,
2406  const char* realm)
2407  {
2408  _OrthancPluginOutputPlusArgument params;
2409  params.output = output;
2410  params.argument = realm;
2411  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2412  }
2413 
2414 
2426  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2427  OrthancPluginContext* context,
2428  OrthancPluginRestOutput* output,
2429  const char* allowedMethods)
2430  {
2431  _OrthancPluginOutputPlusArgument params;
2432  params.output = output;
2433  params.argument = allowedMethods;
2434  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2435  }
2436 
2437 
2438  typedef struct
2439  {
2440  OrthancPluginRestOutput* output;
2441  const char* key;
2442  const char* value;
2443  } _OrthancPluginSetHttpHeader;
2444 
2456  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2457  OrthancPluginContext* context,
2458  OrthancPluginRestOutput* output,
2459  const char* cookie,
2460  const char* value)
2461  {
2462  _OrthancPluginSetHttpHeader params;
2463  params.output = output;
2464  params.key = cookie;
2465  params.value = value;
2466  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2467  }
2468 
2469 
2481  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2482  OrthancPluginContext* context,
2483  OrthancPluginRestOutput* output,
2484  const char* key,
2485  const char* value)
2486  {
2487  _OrthancPluginSetHttpHeader params;
2488  params.output = output;
2489  params.key = key;
2490  params.value = value;
2491  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2492  }
2493 
2494 
2495  typedef struct
2496  {
2497  char** resultStringToFree;
2498  const char** resultString;
2499  int64_t* resultInt64;
2500  const char* key;
2501  OrthancPluginDicomInstance* instance;
2502  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2503  } _OrthancPluginAccessDicomInstance;
2504 
2505 
2517  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2518  OrthancPluginContext* context,
2519  OrthancPluginDicomInstance* instance)
2520  {
2521  const char* result;
2522 
2523  _OrthancPluginAccessDicomInstance params;
2524  memset(&params, 0, sizeof(params));
2525  params.resultString = &result;
2526  params.instance = instance;
2527 
2528  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2529  {
2530  /* Error */
2531  return NULL;
2532  }
2533  else
2534  {
2535  return result;
2536  }
2537  }
2538 
2539 
2550  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2551  OrthancPluginContext* context,
2552  OrthancPluginDicomInstance* instance)
2553  {
2554  int64_t size;
2555 
2556  _OrthancPluginAccessDicomInstance params;
2557  memset(&params, 0, sizeof(params));
2558  params.resultInt64 = &size;
2559  params.instance = instance;
2560 
2561  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2562  {
2563  /* Error */
2564  return -1;
2565  }
2566  else
2567  {
2568  return size;
2569  }
2570  }
2571 
2572 
2583  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceData(
2584  OrthancPluginContext* context,
2585  OrthancPluginDicomInstance* instance)
2586  {
2587  const char* result;
2588 
2589  _OrthancPluginAccessDicomInstance params;
2590  memset(&params, 0, sizeof(params));
2591  params.resultString = &result;
2592  params.instance = instance;
2593 
2594  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2595  {
2596  /* Error */
2597  return NULL;
2598  }
2599  else
2600  {
2601  return result;
2602  }
2603  }
2604 
2605 
2619  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
2620  OrthancPluginContext* context,
2621  OrthancPluginDicomInstance* instance)
2622  {
2623  char* result;
2624 
2625  _OrthancPluginAccessDicomInstance params;
2626  memset(&params, 0, sizeof(params));
2627  params.resultStringToFree = &result;
2628  params.instance = instance;
2629 
2630  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
2631  {
2632  /* Error */
2633  return NULL;
2634  }
2635  else
2636  {
2637  return result;
2638  }
2639  }
2640 
2641 
2657  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
2658  OrthancPluginContext* context,
2659  OrthancPluginDicomInstance* instance)
2660  {
2661  char* result;
2662 
2663  _OrthancPluginAccessDicomInstance params;
2664  memset(&params, 0, sizeof(params));
2665  params.resultStringToFree = &result;
2666  params.instance = instance;
2667 
2668  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
2669  {
2670  /* Error */
2671  return NULL;
2672  }
2673  else
2674  {
2675  return result;
2676  }
2677  }
2678 
2679 
2696  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
2697  OrthancPluginContext* context,
2698  OrthancPluginDicomInstance* instance,
2699  const char* metadata)
2700  {
2701  int64_t result;
2702 
2703  _OrthancPluginAccessDicomInstance params;
2704  memset(&params, 0, sizeof(params));
2705  params.resultInt64 = &result;
2706  params.instance = instance;
2707  params.key = metadata;
2708 
2709  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2710  {
2711  /* Error */
2712  return -1;
2713  }
2714  else
2715  {
2716  return (result != 0);
2717  }
2718  }
2719 
2720 
2734  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
2735  OrthancPluginContext* context,
2736  OrthancPluginDicomInstance* instance,
2737  const char* metadata)
2738  {
2739  const char* result;
2740 
2741  _OrthancPluginAccessDicomInstance params;
2742  memset(&params, 0, sizeof(params));
2743  params.resultString = &result;
2744  params.instance = instance;
2745  params.key = metadata;
2746 
2747  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2748  {
2749  /* Error */
2750  return NULL;
2751  }
2752  else
2753  {
2754  return result;
2755  }
2756  }
2757 
2758 
2759 
2760  typedef struct
2761  {
2765  OrthancPluginFree free;
2766  } _OrthancPluginRegisterStorageArea;
2767 
2782  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
2783  OrthancPluginContext* context,
2787  {
2788  _OrthancPluginRegisterStorageArea params;
2789  params.create = create;
2790  params.read = read;
2791  params.remove = remove;
2792 
2793 #ifdef __cplusplus
2794  params.free = ::free;
2795 #else
2796  params.free = free;
2797 #endif
2798 
2799  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
2800  }
2801 
2802 
2803 
2814  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
2815  {
2816  char* result;
2817 
2818  _OrthancPluginRetrieveDynamicString params;
2819  params.result = &result;
2820  params.argument = NULL;
2821 
2822  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
2823  {
2824  /* Error */
2825  return NULL;
2826  }
2827  else
2828  {
2829  return result;
2830  }
2831  }
2832 
2833 
2844  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
2845  {
2846  char* result;
2847 
2848  _OrthancPluginRetrieveDynamicString params;
2849  params.result = &result;
2850  params.argument = NULL;
2851 
2852  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
2853  {
2854  /* Error */
2855  return NULL;
2856  }
2857  else
2858  {
2859  return result;
2860  }
2861  }
2862 
2863 
2879  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
2880  {
2881  char* result;
2882 
2883  _OrthancPluginRetrieveDynamicString params;
2884  params.result = &result;
2885  params.argument = NULL;
2886 
2887  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
2888  {
2889  /* Error */
2890  return NULL;
2891  }
2892  else
2893  {
2894  return result;
2895  }
2896  }
2897 
2898 
2899 
2900  typedef struct
2901  {
2903  } _OrthancPluginOnChangeCallback;
2904 
2921  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
2922  OrthancPluginContext* context,
2924  {
2925  _OrthancPluginOnChangeCallback params;
2926  params.callback = callback;
2927 
2928  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
2929  }
2930 
2931 
2932 
2933  typedef struct
2934  {
2935  const char* plugin;
2936  _OrthancPluginProperty property;
2937  const char* value;
2938  } _OrthancPluginSetPluginProperty;
2939 
2940 
2952  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
2953  OrthancPluginContext* context,
2954  const char* uri)
2955  {
2956  _OrthancPluginSetPluginProperty params;
2957  params.plugin = OrthancPluginGetName();
2958  params.property = _OrthancPluginProperty_RootUri;
2959  params.value = uri;
2960 
2961  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2962  }
2963 
2964 
2974  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
2975  OrthancPluginContext* context,
2976  const char* description)
2977  {
2978  _OrthancPluginSetPluginProperty params;
2979  params.plugin = OrthancPluginGetName();
2980  params.property = _OrthancPluginProperty_Description;
2981  params.value = description;
2982 
2983  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2984  }
2985 
2986 
2996  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
2997  OrthancPluginContext* context,
2998  const char* javascript)
2999  {
3000  _OrthancPluginSetPluginProperty params;
3001  params.plugin = OrthancPluginGetName();
3002  params.property = _OrthancPluginProperty_OrthancExplorer;
3003  params.value = javascript;
3004 
3005  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3006  }
3007 
3008 
3009  typedef struct
3010  {
3011  char** result;
3012  int32_t property;
3013  const char* value;
3014  } _OrthancPluginGlobalProperty;
3015 
3016 
3030  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3031  OrthancPluginContext* context,
3032  int32_t property,
3033  const char* defaultValue)
3034  {
3035  char* result;
3036 
3037  _OrthancPluginGlobalProperty params;
3038  params.result = &result;
3039  params.property = property;
3040  params.value = defaultValue;
3041 
3042  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3043  {
3044  /* Error */
3045  return NULL;
3046  }
3047  else
3048  {
3049  return result;
3050  }
3051  }
3052 
3053 
3070  OrthancPluginContext* context,
3071  int32_t property,
3072  const char* value)
3073  {
3074  _OrthancPluginGlobalProperty params;
3075  params.result = NULL;
3076  params.property = property;
3077  params.value = value;
3078 
3079  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3080  }
3081 
3082 
3083 
3084  typedef struct
3085  {
3086  int32_t *resultInt32;
3087  uint32_t *resultUint32;
3088  int64_t *resultInt64;
3089  uint64_t *resultUint64;
3090  } _OrthancPluginReturnSingleValue;
3091 
3100  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3101  OrthancPluginContext* context)
3102  {
3103  uint32_t count = 0;
3104 
3105  _OrthancPluginReturnSingleValue params;
3106  memset(&params, 0, sizeof(params));
3107  params.resultUint32 = &count;
3108 
3109  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3110  {
3111  /* Error */
3112  return 0;
3113  }
3114  else
3115  {
3116  return count;
3117  }
3118  }
3119 
3120 
3121 
3134  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3135  OrthancPluginContext* context,
3136  uint32_t argument)
3137  {
3138  char* result;
3139 
3140  _OrthancPluginGlobalProperty params;
3141  params.result = &result;
3142  params.property = (int32_t) argument;
3143  params.value = NULL;
3144 
3145  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3146  {
3147  /* Error */
3148  return NULL;
3149  }
3150  else
3151  {
3152  return result;
3153  }
3154  }
3155 
3156 
3166  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3167  OrthancPluginContext* context)
3168  {
3169  uint32_t count = 0;
3170 
3171  _OrthancPluginReturnSingleValue params;
3172  memset(&params, 0, sizeof(params));
3173  params.resultUint32 = &count;
3174 
3175  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3176  {
3177  /* Error */
3178  return 0;
3179  }
3180  else
3181  {
3182  return count;
3183  }
3184  }
3185 
3186 
3187 
3199  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3200  {
3201  char* result;
3202 
3203  _OrthancPluginRetrieveDynamicString params;
3204  params.result = &result;
3205  params.argument = NULL;
3206 
3207  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3208  {
3209  /* Error */
3210  return NULL;
3211  }
3212  else
3213  {
3214  return result;
3215  }
3216  }
3217 
3218 
3219 
3220  typedef struct
3221  {
3222  OrthancPluginRestOutput* output;
3223  const char* subType;
3224  const char* contentType;
3225  } _OrthancPluginStartMultipartAnswer;
3226 
3241  OrthancPluginContext* context,
3242  OrthancPluginRestOutput* output,
3243  const char* subType,
3244  const char* contentType)
3245  {
3246  _OrthancPluginStartMultipartAnswer params;
3247  params.output = output;
3248  params.subType = subType;
3249  params.contentType = contentType;
3250  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3251  }
3252 
3253 
3270  OrthancPluginContext* context,
3271  OrthancPluginRestOutput* output,
3272  const char* answer,
3273  uint32_t answerSize)
3274  {
3275  _OrthancPluginAnswerBuffer params;
3276  params.output = output;
3277  params.answer = answer;
3278  params.answerSize = answerSize;
3279  params.mimeType = NULL;
3280  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3281  }
3282 
3283 
3284 
3285  typedef struct
3286  {
3287  OrthancPluginMemoryBuffer* target;
3288  const void* source;
3289  uint32_t size;
3290  OrthancPluginCompressionType compression;
3291  uint8_t uncompress;
3292  } _OrthancPluginBufferCompression;
3293 
3294 
3312  OrthancPluginContext* context,
3313  OrthancPluginMemoryBuffer* target,
3314  const void* source,
3315  uint32_t size,
3316  OrthancPluginCompressionType compression,
3317  uint8_t uncompress)
3318  {
3319  _OrthancPluginBufferCompression params;
3320  params.target = target;
3321  params.source = source;
3322  params.size = size;
3323  params.compression = compression;
3324  params.uncompress = uncompress;
3325 
3326  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3327  }
3328 
3329 
3330 
3331  typedef struct
3332  {
3333  OrthancPluginMemoryBuffer* target;
3334  const char* path;
3335  } _OrthancPluginReadFile;
3336 
3349  OrthancPluginContext* context,
3350  OrthancPluginMemoryBuffer* target,
3351  const char* path)
3352  {
3353  _OrthancPluginReadFile params;
3354  params.target = target;
3355  params.path = path;
3356  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3357  }
3358 
3359 
3360 
3361  typedef struct
3362  {
3363  const char* path;
3364  const void* data;
3365  uint32_t size;
3366  } _OrthancPluginWriteFile;
3367 
3380  OrthancPluginContext* context,
3381  const char* path,
3382  const void* data,
3383  uint32_t size)
3384  {
3385  _OrthancPluginWriteFile params;
3386  params.path = path;
3387  params.data = data;
3388  params.size = size;
3389  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3390  }
3391 
3392 
3393 
3394  typedef struct
3395  {
3396  const char** target;
3397  OrthancPluginErrorCode error;
3398  } _OrthancPluginGetErrorDescription;
3399 
3410  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3411  OrthancPluginContext* context,
3412  OrthancPluginErrorCode error)
3413  {
3414  const char* result = NULL;
3415 
3416  _OrthancPluginGetErrorDescription params;
3417  params.target = &result;
3418  params.error = error;
3419 
3420  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3421  result == NULL)
3422  {
3423  return "Unknown error code";
3424  }
3425  else
3426  {
3427  return result;
3428  }
3429  }
3430 
3431 
3432 
3433  typedef struct
3434  {
3435  OrthancPluginRestOutput* output;
3436  uint16_t status;
3437  const char* body;
3438  uint32_t bodySize;
3439  } _OrthancPluginSendHttpStatus;
3440 
3463  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3464  OrthancPluginContext* context,
3465  OrthancPluginRestOutput* output,
3466  uint16_t status,
3467  const char* body,
3468  uint32_t bodySize)
3469  {
3470  _OrthancPluginSendHttpStatus params;
3471  params.output = output;
3472  params.status = status;
3473  params.body = body;
3474  params.bodySize = bodySize;
3475  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3476  }
3477 
3478 
3479 
3480  typedef struct
3481  {
3482  const OrthancPluginImage* image;
3483  uint32_t* resultUint32;
3484  OrthancPluginPixelFormat* resultPixelFormat;
3485  void** resultBuffer;
3486  } _OrthancPluginGetImageInfo;
3487 
3488 
3500  OrthancPluginContext* context,
3501  const OrthancPluginImage* image)
3502  {
3503  OrthancPluginPixelFormat target;
3504 
3505  _OrthancPluginGetImageInfo params;
3506  memset(&params, 0, sizeof(params));
3507  params.image = image;
3508  params.resultPixelFormat = &target;
3509 
3510  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3511  {
3513  }
3514  else
3515  {
3516  return (OrthancPluginPixelFormat) target;
3517  }
3518  }
3519 
3520 
3521 
3532  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3533  OrthancPluginContext* context,
3534  const OrthancPluginImage* image)
3535  {
3536  uint32_t width;
3537 
3538  _OrthancPluginGetImageInfo params;
3539  memset(&params, 0, sizeof(params));
3540  params.image = image;
3541  params.resultUint32 = &width;
3542 
3543  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3544  {
3545  return 0;
3546  }
3547  else
3548  {
3549  return width;
3550  }
3551  }
3552 
3553 
3554 
3565  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3566  OrthancPluginContext* context,
3567  const OrthancPluginImage* image)
3568  {
3569  uint32_t height;
3570 
3571  _OrthancPluginGetImageInfo params;
3572  memset(&params, 0, sizeof(params));
3573  params.image = image;
3574  params.resultUint32 = &height;
3575 
3576  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3577  {
3578  return 0;
3579  }
3580  else
3581  {
3582  return height;
3583  }
3584  }
3585 
3586 
3587 
3600  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3601  OrthancPluginContext* context,
3602  const OrthancPluginImage* image)
3603  {
3604  uint32_t pitch;
3605 
3606  _OrthancPluginGetImageInfo params;
3607  memset(&params, 0, sizeof(params));
3608  params.image = image;
3609  params.resultUint32 = &pitch;
3610 
3611  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
3612  {
3613  return 0;
3614  }
3615  else
3616  {
3617  return pitch;
3618  }
3619  }
3620 
3621 
3622 
3634  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
3635  OrthancPluginContext* context,
3636  const OrthancPluginImage* image)
3637  {
3638  void* target = NULL;
3639 
3640  _OrthancPluginGetImageInfo params;
3641  memset(&params, 0, sizeof(params));
3642  params.resultBuffer = &target;
3643  params.image = image;
3644 
3645  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
3646  {
3647  return NULL;
3648  }
3649  else
3650  {
3651  return target;
3652  }
3653  }
3654 
3655 
3656  typedef struct
3657  {
3658  OrthancPluginImage** target;
3659  const void* data;
3660  uint32_t size;
3661  OrthancPluginImageFormat format;
3662  } _OrthancPluginUncompressImage;
3663 
3664 
3678  OrthancPluginContext* context,
3679  const void* data,
3680  uint32_t size,
3681  OrthancPluginImageFormat format)
3682  {
3683  OrthancPluginImage* target = NULL;
3684 
3685  _OrthancPluginUncompressImage params;
3686  memset(&params, 0, sizeof(params));
3687  params.target = &target;
3688  params.data = data;
3689  params.size = size;
3690  params.format = format;
3691 
3692  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
3693  {
3694  return NULL;
3695  }
3696  else
3697  {
3698  return target;
3699  }
3700  }
3701 
3702 
3703 
3704 
3705  typedef struct
3706  {
3707  OrthancPluginImage* image;
3708  } _OrthancPluginFreeImage;
3709 
3719  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
3720  OrthancPluginContext* context,
3721  OrthancPluginImage* image)
3722  {
3723  _OrthancPluginFreeImage params;
3724  params.image = image;
3725 
3726  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
3727  }
3728 
3729 
3730 
3731 
3732  typedef struct
3733  {
3734  OrthancPluginMemoryBuffer* target;
3735  OrthancPluginImageFormat imageFormat;
3736  OrthancPluginPixelFormat pixelFormat;
3737  uint32_t width;
3738  uint32_t height;
3739  uint32_t pitch;
3740  const void* buffer;
3741  uint8_t quality;
3742  } _OrthancPluginCompressImage;
3743 
3744 
3765  OrthancPluginContext* context,
3766  OrthancPluginMemoryBuffer* target,
3767  OrthancPluginPixelFormat format,
3768  uint32_t width,
3769  uint32_t height,
3770  uint32_t pitch,
3771  const void* buffer)
3772  {
3773  _OrthancPluginCompressImage params;
3774  memset(&params, 0, sizeof(params));
3775  params.target = target;
3776  params.imageFormat = OrthancPluginImageFormat_Png;
3777  params.pixelFormat = format;
3778  params.width = width;
3779  params.height = height;
3780  params.pitch = pitch;
3781  params.buffer = buffer;
3782  params.quality = 0; /* Unused for PNG */
3783 
3784  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3785  }
3786 
3787 
3810  OrthancPluginContext* context,
3811  OrthancPluginMemoryBuffer* target,
3812  OrthancPluginPixelFormat format,
3813  uint32_t width,
3814  uint32_t height,
3815  uint32_t pitch,
3816  const void* buffer,
3817  uint8_t quality)
3818  {
3819  _OrthancPluginCompressImage params;
3820  memset(&params, 0, sizeof(params));
3821  params.target = target;
3822  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3823  params.pixelFormat = format;
3824  params.width = width;
3825  params.height = height;
3826  params.pitch = pitch;
3827  params.buffer = buffer;
3828  params.quality = quality;
3829 
3830  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3831  }
3832 
3833 
3834 
3856  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
3857  OrthancPluginContext* context,
3858  OrthancPluginRestOutput* output,
3859  OrthancPluginPixelFormat format,
3860  uint32_t width,
3861  uint32_t height,
3862  uint32_t pitch,
3863  const void* buffer,
3864  uint8_t quality)
3865  {
3866  _OrthancPluginCompressAndAnswerImage params;
3867  params.output = output;
3868  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3869  params.pixelFormat = format;
3870  params.width = width;
3871  params.height = height;
3872  params.pitch = pitch;
3873  params.buffer = buffer;
3874  params.quality = quality;
3875  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
3876  }
3877 
3878 
3879 
3880 
3881  typedef struct
3882  {
3883  OrthancPluginMemoryBuffer* target;
3884  OrthancPluginHttpMethod method;
3885  const char* url;
3886  const char* username;
3887  const char* password;
3888  const char* body;
3889  uint32_t bodySize;
3890  } _OrthancPluginCallHttpClient;
3891 
3892 
3909  OrthancPluginContext* context,
3910  OrthancPluginMemoryBuffer* target,
3911  const char* url,
3912  const char* username,
3913  const char* password)
3914  {
3915  _OrthancPluginCallHttpClient params;
3916  memset(&params, 0, sizeof(params));
3917 
3918  params.target = target;
3919  params.method = OrthancPluginHttpMethod_Get;
3920  params.url = url;
3921  params.username = username;
3922  params.password = password;
3923 
3924  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3925  }
3926 
3927 
3946  OrthancPluginContext* context,
3947  OrthancPluginMemoryBuffer* target,
3948  const char* url,
3949  const char* body,
3950  uint32_t bodySize,
3951  const char* username,
3952  const char* password)
3953  {
3954  _OrthancPluginCallHttpClient params;
3955  memset(&params, 0, sizeof(params));
3956 
3957  params.target = target;
3958  params.method = OrthancPluginHttpMethod_Post;
3959  params.url = url;
3960  params.body = body;
3961  params.bodySize = bodySize;
3962  params.username = username;
3963  params.password = password;
3964 
3965  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3966  }
3967 
3968 
3987  OrthancPluginContext* context,
3988  OrthancPluginMemoryBuffer* target,
3989  const char* url,
3990  const char* body,
3991  uint32_t bodySize,
3992  const char* username,
3993  const char* password)
3994  {
3995  _OrthancPluginCallHttpClient params;
3996  memset(&params, 0, sizeof(params));
3997 
3998  params.target = target;
3999  params.method = OrthancPluginHttpMethod_Put;
4000  params.url = url;
4001  params.body = body;
4002  params.bodySize = bodySize;
4003  params.username = username;
4004  params.password = password;
4005 
4006  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4007  }
4008 
4009 
4024  OrthancPluginContext* context,
4025  const char* url,
4026  const char* username,
4027  const char* password)
4028  {
4029  _OrthancPluginCallHttpClient params;
4030  memset(&params, 0, sizeof(params));
4031 
4032  params.method = OrthancPluginHttpMethod_Delete;
4033  params.url = url;
4034  params.username = username;
4035  params.password = password;
4036 
4037  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4038  }
4039 
4040 
4041 
4042  typedef struct
4043  {
4044  OrthancPluginImage** target;
4045  const OrthancPluginImage* source;
4046  OrthancPluginPixelFormat targetFormat;
4047  } _OrthancPluginConvertPixelFormat;
4048 
4049 
4062  OrthancPluginContext* context,
4063  const OrthancPluginImage* source,
4064  OrthancPluginPixelFormat targetFormat)
4065  {
4066  OrthancPluginImage* target = NULL;
4067 
4068  _OrthancPluginConvertPixelFormat params;
4069  params.target = &target;
4070  params.source = source;
4071  params.targetFormat = targetFormat;
4072 
4073  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4074  {
4075  return NULL;
4076  }
4077  else
4078  {
4079  return target;
4080  }
4081  }
4082 
4083 
4084 
4096  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4097  OrthancPluginContext* context)
4098  {
4099  uint32_t count = 0;
4100 
4101  _OrthancPluginReturnSingleValue params;
4102  memset(&params, 0, sizeof(params));
4103  params.resultUint32 = &count;
4104 
4105  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4106  {
4107  /* Error */
4108  return 0;
4109  }
4110  else
4111  {
4112  return count;
4113  }
4114  }
4115 
4116 
4117 
4118 
4119  typedef struct
4120  {
4121  uint32_t fontIndex; /* in */
4122  const char** name; /* out */
4123  uint32_t* size; /* out */
4124  } _OrthancPluginGetFontInfo;
4125 
4136  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4137  OrthancPluginContext* context,
4138  uint32_t fontIndex)
4139  {
4140  const char* result = NULL;
4141 
4142  _OrthancPluginGetFontInfo params;
4143  memset(&params, 0, sizeof(params));
4144  params.name = &result;
4145  params.fontIndex = fontIndex;
4146 
4147  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4148  {
4149  return NULL;
4150  }
4151  else
4152  {
4153  return result;
4154  }
4155  }
4156 
4157 
4168  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4169  OrthancPluginContext* context,
4170  uint32_t fontIndex)
4171  {
4172  uint32_t result;
4173 
4174  _OrthancPluginGetFontInfo params;
4175  memset(&params, 0, sizeof(params));
4176  params.size = &result;
4177  params.fontIndex = fontIndex;
4178 
4179  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4180  {
4181  return 0;
4182  }
4183  else
4184  {
4185  return result;
4186  }
4187  }
4188 
4189 
4190 
4191  typedef struct
4192  {
4193  OrthancPluginImage* image;
4194  uint32_t fontIndex;
4195  const char* utf8Text;
4196  int32_t x;
4197  int32_t y;
4198  uint8_t r;
4199  uint8_t g;
4200  uint8_t b;
4201  } _OrthancPluginDrawText;
4202 
4203 
4222  OrthancPluginContext* context,
4223  OrthancPluginImage* image,
4224  uint32_t fontIndex,
4225  const char* utf8Text,
4226  int32_t x,
4227  int32_t y,
4228  uint8_t r,
4229  uint8_t g,
4230  uint8_t b)
4231  {
4232  _OrthancPluginDrawText params;
4233  memset(&params, 0, sizeof(params));
4234  params.image = image;
4235  params.fontIndex = fontIndex;
4236  params.utf8Text = utf8Text;
4237  params.x = x;
4238  params.y = y;
4239  params.r = r;
4240  params.g = g;
4241  params.b = b;
4242 
4243  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4244  }
4245 
4246 
4247 
4248  typedef struct
4249  {
4250  OrthancPluginStorageArea* storageArea;
4251  const char* uuid;
4252  const void* content;
4253  uint64_t size;
4255  } _OrthancPluginStorageAreaCreate;
4256 
4257 
4274  OrthancPluginContext* context,
4275  OrthancPluginStorageArea* storageArea,
4276  const char* uuid,
4277  const void* content,
4278  uint64_t size,
4280  {
4281  _OrthancPluginStorageAreaCreate params;
4282  params.storageArea = storageArea;
4283  params.uuid = uuid;
4284  params.content = content;
4285  params.size = size;
4286  params.type = type;
4287 
4288  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4289  }
4290 
4291 
4292  typedef struct
4293  {
4294  OrthancPluginMemoryBuffer* target;
4295  OrthancPluginStorageArea* storageArea;
4296  const char* uuid;
4298  } _OrthancPluginStorageAreaRead;
4299 
4300 
4316  OrthancPluginContext* context,
4317  OrthancPluginMemoryBuffer* target,
4318  OrthancPluginStorageArea* storageArea,
4319  const char* uuid,
4321  {
4322  _OrthancPluginStorageAreaRead params;
4323  params.target = target;
4324  params.storageArea = storageArea;
4325  params.uuid = uuid;
4326  params.type = type;
4327 
4328  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4329  }
4330 
4331 
4332  typedef struct
4333  {
4334  OrthancPluginStorageArea* storageArea;
4335  const char* uuid;
4337  } _OrthancPluginStorageAreaRemove;
4338 
4353  OrthancPluginContext* context,
4354  OrthancPluginStorageArea* storageArea,
4355  const char* uuid,
4357  {
4358  _OrthancPluginStorageAreaRemove params;
4359  params.storageArea = storageArea;
4360  params.uuid = uuid;
4361  params.type = type;
4362 
4363  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4364  }
4365 
4366 
4367 
4368  typedef struct
4369  {
4370  OrthancPluginErrorCode* target;
4371  int32_t code;
4372  uint16_t httpStatus;
4373  const char* message;
4374  } _OrthancPluginRegisterErrorCode;
4375 
4392  OrthancPluginContext* context,
4393  int32_t code,
4394  uint16_t httpStatus,
4395  const char* message)
4396  {
4397  OrthancPluginErrorCode target;
4398 
4399  _OrthancPluginRegisterErrorCode params;
4400  params.target = &target;
4401  params.code = code;
4402  params.httpStatus = httpStatus;
4403  params.message = message;
4404 
4405  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4406  {
4407  return target;
4408  }
4409  else
4410  {
4411  /* There was an error while assigned the error. Use a generic code. */
4413  }
4414  }
4415 
4416 
4417 
4418  typedef struct
4419  {
4420  uint16_t group;
4421  uint16_t element;
4423  const char* name;
4424  uint32_t minMultiplicity;
4425  uint32_t maxMultiplicity;
4426  } _OrthancPluginRegisterDictionaryTag;
4427 
4448  OrthancPluginContext* context,
4449  uint16_t group,
4450  uint16_t element,
4452  const char* name,
4453  uint32_t minMultiplicity,
4454  uint32_t maxMultiplicity)
4455  {
4456  _OrthancPluginRegisterDictionaryTag params;
4457  params.group = group;
4458  params.element = element;
4459  params.vr = vr;
4460  params.name = name;
4461  params.minMultiplicity = minMultiplicity;
4462  params.maxMultiplicity = maxMultiplicity;
4463 
4464  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4465  }
4466 
4467 
4468 
4469  typedef struct
4470  {
4471  uint16_t group;
4472  uint16_t element;
4474  const char* name;
4475  uint32_t minMultiplicity;
4476  uint32_t maxMultiplicity;
4477  const char* privateCreator;
4478  } _OrthancPluginRegisterPrivateDictionaryTag;
4479 
4501  OrthancPluginContext* context,
4502  uint16_t group,
4503  uint16_t element,
4505  const char* name,
4506  uint32_t minMultiplicity,
4507  uint32_t maxMultiplicity,
4508  const char* privateCreator)
4509  {
4510  _OrthancPluginRegisterPrivateDictionaryTag params;
4511  params.group = group;
4512  params.element = element;
4513  params.vr = vr;
4514  params.name = name;
4515  params.minMultiplicity = minMultiplicity;
4516  params.maxMultiplicity = maxMultiplicity;
4517  params.privateCreator = privateCreator;
4518 
4519  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4520  }
4521 
4522 
4523 
4524  typedef struct
4525  {
4526  OrthancPluginStorageArea* storageArea;
4528  } _OrthancPluginReconstructMainDicomTags;
4529 
4545  OrthancPluginContext* context,
4546  OrthancPluginStorageArea* storageArea,
4548  {
4549  _OrthancPluginReconstructMainDicomTags params;
4550  params.level = level;
4551  params.storageArea = storageArea;
4552 
4553  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
4554  }
4555 
4556 
4557  typedef struct
4558  {
4559  char** result;
4560  const char* instanceId;
4561  const void* buffer;
4562  uint32_t size;
4565  uint32_t maxStringLength;
4566  } _OrthancPluginDicomToJson;
4567 
4568 
4588  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4589  OrthancPluginContext* context,
4590  const void* buffer,
4591  uint32_t size,
4594  uint32_t maxStringLength)
4595  {
4596  char* result;
4597 
4598  _OrthancPluginDicomToJson params;
4599  memset(&params, 0, sizeof(params));
4600  params.result = &result;
4601  params.buffer = buffer;
4602  params.size = size;
4603  params.format = format;
4604  params.flags = flags;
4605  params.maxStringLength = maxStringLength;
4606 
4607  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
4608  {
4609  /* Error */
4610  return NULL;
4611  }
4612  else
4613  {
4614  return result;
4615  }
4616  }
4617 
4618 
4637  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
4638  OrthancPluginContext* context,
4639  const char* instanceId,
4642  uint32_t maxStringLength)
4643  {
4644  char* result;
4645 
4646  _OrthancPluginDicomToJson params;
4647  memset(&params, 0, sizeof(params));
4648  params.result = &result;
4649  params.instanceId = instanceId;
4650  params.format = format;
4651  params.flags = flags;
4652  params.maxStringLength = maxStringLength;
4653 
4654  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
4655  {
4656  /* Error */
4657  return NULL;
4658  }
4659  else
4660  {
4661  return result;
4662  }
4663  }
4664 
4665 
4666  typedef struct
4667  {
4668  OrthancPluginMemoryBuffer* target;
4669  const char* uri;
4670  uint32_t headersCount;
4671  const char* const* headersKeys;
4672  const char* const* headersValues;
4673  int32_t afterPlugins;
4674  } _OrthancPluginRestApiGet2;
4675 
4696  OrthancPluginContext* context,
4697  OrthancPluginMemoryBuffer* target,
4698  const char* uri,
4699  uint32_t headersCount,
4700  const char* const* headersKeys,
4701  const char* const* headersValues,
4702  int32_t afterPlugins)
4703  {
4704  _OrthancPluginRestApiGet2 params;
4705  params.target = target;
4706  params.uri = uri;
4707  params.headersCount = headersCount;
4708  params.headersKeys = headersKeys;
4709  params.headersValues = headersValues;
4710  params.afterPlugins = afterPlugins;
4711 
4712  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
4713  }
4714 
4715 
4716 
4717  typedef struct
4718  {
4720  } _OrthancPluginWorklistCallback;
4721 
4734  OrthancPluginContext* context,
4736  {
4737  _OrthancPluginWorklistCallback params;
4738  params.callback = callback;
4739 
4740  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
4741  }
4742 
4743 
4744 
4745  typedef struct
4746  {
4748  const OrthancPluginWorklistQuery* query;
4749  const void* dicom;
4750  uint32_t size;
4751  } _OrthancPluginWorklistAnswersOperation;
4752 
4770  OrthancPluginContext* context,
4772  const OrthancPluginWorklistQuery* query,
4773  const void* dicom,
4774  uint32_t size)
4775  {
4776  _OrthancPluginWorklistAnswersOperation params;
4777  params.answers = answers;
4778  params.query = query;
4779  params.dicom = dicom;
4780  params.size = size;
4781 
4782  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
4783  }
4784 
4785 
4800  OrthancPluginContext* context,
4802  {
4803  _OrthancPluginWorklistAnswersOperation params;
4804  params.answers = answers;
4805  params.query = NULL;
4806  params.dicom = NULL;
4807  params.size = 0;
4808 
4809  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
4810  }
4811 
4812 
4813  typedef struct
4814  {
4815  const OrthancPluginWorklistQuery* query;
4816  const void* dicom;
4817  uint32_t size;
4818  int32_t* isMatch;
4819  OrthancPluginMemoryBuffer* target;
4820  } _OrthancPluginWorklistQueryOperation;
4821 
4837  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
4838  OrthancPluginContext* context,
4839  const OrthancPluginWorklistQuery* query,
4840  const void* dicom,
4841  uint32_t size)
4842  {
4843  int32_t isMatch = 0;
4844 
4845  _OrthancPluginWorklistQueryOperation params;
4846  params.query = query;
4847  params.dicom = dicom;
4848  params.size = size;
4849  params.isMatch = &isMatch;
4850  params.target = NULL;
4851 
4852  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
4853  {
4854  return isMatch;
4855  }
4856  else
4857  {
4858  /* Error: Assume non-match */
4859  return 0;
4860  }
4861  }
4862 
4863 
4877  OrthancPluginContext* context,
4878  OrthancPluginMemoryBuffer* target,
4879  const OrthancPluginWorklistQuery* query)
4880  {
4881  _OrthancPluginWorklistQueryOperation params;
4882  params.query = query;
4883  params.dicom = NULL;
4884  params.size = 0;
4885  params.isMatch = NULL;
4886  params.target = target;
4887 
4888  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
4889  }
4890 
4891 
4903  OrthancPluginContext* context,
4904  OrthancPluginDicomInstance* instance)
4905  {
4907 
4908  _OrthancPluginAccessDicomInstance params;
4909  memset(&params, 0, sizeof(params));
4910  params.resultOrigin = &origin;
4911  params.instance = instance;
4912 
4913  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
4914  {
4915  /* Error */
4917  }
4918  else
4919  {
4920  return origin;
4921  }
4922  }
4923 
4924 
4925  typedef struct
4926  {
4927  OrthancPluginMemoryBuffer* target;
4928  const char* json;
4929  const OrthancPluginImage* pixelData;
4931  } _OrthancPluginCreateDicom;
4932 
4952  OrthancPluginContext* context,
4953  OrthancPluginMemoryBuffer* target,
4954  const char* json,
4955  const OrthancPluginImage* pixelData,
4957  {
4958  _OrthancPluginCreateDicom params;
4959  params.target = target;
4960  params.json = json;
4961  params.pixelData = pixelData;
4962  params.flags = flags;
4963 
4964  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
4965  }
4966 
4967 
4968  typedef struct
4969  {
4971  } _OrthancPluginDecodeImageCallback;
4972 
4985  OrthancPluginContext* context,
4987  {
4988  _OrthancPluginDecodeImageCallback params;
4989  params.callback = callback;
4990 
4991  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
4992  }
4993 
4994 
4995 
4996  typedef struct
4997  {
4998  OrthancPluginImage** target;
4999  OrthancPluginPixelFormat format;
5000  uint32_t width;
5001  uint32_t height;
5002  uint32_t pitch;
5003  void* buffer;
5004  const void* constBuffer;
5005  uint32_t bufferSize;
5006  uint32_t frameIndex;
5007  } _OrthancPluginCreateImage;
5008 
5009 
5023  OrthancPluginContext* context,
5024  OrthancPluginPixelFormat format,
5025  uint32_t width,
5026  uint32_t height)
5027  {
5028  OrthancPluginImage* target = NULL;
5029 
5030  _OrthancPluginCreateImage params;
5031  memset(&params, 0, sizeof(params));
5032  params.target = &target;
5033  params.format = format;
5034  params.width = width;
5035  params.height = height;
5036 
5037  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5038  {
5039  return NULL;
5040  }
5041  else
5042  {
5043  return target;
5044  }
5045  }
5046 
5047 
5066  OrthancPluginContext* context,
5067  OrthancPluginPixelFormat format,
5068  uint32_t width,
5069  uint32_t height,
5070  uint32_t pitch,
5071  void* buffer)
5072  {
5073  OrthancPluginImage* target = NULL;
5074 
5075  _OrthancPluginCreateImage params;
5076  memset(&params, 0, sizeof(params));
5077  params.target = &target;
5078  params.format = format;
5079  params.width = width;
5080  params.height = height;
5081  params.pitch = pitch;
5082  params.buffer = buffer;
5083 
5084  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5085  {
5086  return NULL;
5087  }
5088  else
5089  {
5090  return target;
5091  }
5092  }
5093 
5094 
5095 
5111  OrthancPluginContext* context,
5112  const void* buffer,
5113  uint32_t bufferSize,
5114  uint32_t frameIndex)
5115  {
5116  OrthancPluginImage* target = NULL;
5117 
5118  _OrthancPluginCreateImage params;
5119  memset(&params, 0, sizeof(params));
5120  params.target = &target;
5121  params.constBuffer = buffer;
5122  params.bufferSize = bufferSize;
5123  params.frameIndex = frameIndex;
5124 
5125  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5126  {
5127  return NULL;
5128  }
5129  else
5130  {
5131  return target;
5132  }
5133  }
5134 
5135 
5136 
5137  typedef struct
5138  {
5139  char** result;
5140  const void* buffer;
5141  uint32_t size;
5142  } _OrthancPluginComputeHash;
5143 
5156  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5157  OrthancPluginContext* context,
5158  const void* buffer,
5159  uint32_t size)
5160  {
5161  char* result;
5162 
5163  _OrthancPluginComputeHash params;
5164  params.result = &result;
5165  params.buffer = buffer;
5166  params.size = size;
5167 
5168  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5169  {
5170  /* Error */
5171  return NULL;
5172  }
5173  else
5174  {
5175  return result;
5176  }
5177  }
5178 
5179 
5192  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5193  OrthancPluginContext* context,
5194  const void* buffer,
5195  uint32_t size)
5196  {
5197  char* result;
5198 
5199  _OrthancPluginComputeHash params;
5200  params.result = &result;
5201  params.buffer = buffer;
5202  params.size = size;
5203 
5204  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5205  {
5206  /* Error */
5207  return NULL;
5208  }
5209  else
5210  {
5211  return result;
5212  }
5213  }
5214 
5215 
5216 
5217  typedef struct
5218  {
5220  const char* name;
5221  } _OrthancPluginLookupDictionary;
5222 
5239  OrthancPluginContext* context,
5241  const char* name)
5242  {
5243  _OrthancPluginLookupDictionary params;
5244  params.target = target;
5245  params.name = name;
5246  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5247  }
5248 
5249 
5250 
5251  typedef struct
5252  {
5253  OrthancPluginRestOutput* output;
5254  const char* answer;
5255  uint32_t answerSize;
5256  uint32_t headersCount;
5257  const char* const* headersKeys;
5258  const char* const* headersValues;
5259  } _OrthancPluginSendMultipartItem2;
5260 
5282  OrthancPluginContext* context,
5283  OrthancPluginRestOutput* output,
5284  const char* answer,
5285  uint32_t answerSize,
5286  uint32_t headersCount,
5287  const char* const* headersKeys,
5288  const char* const* headersValues)
5289  {
5290  _OrthancPluginSendMultipartItem2 params;
5291  params.output = output;
5292  params.answer = answer;
5293  params.answerSize = answerSize;
5294  params.headersCount = headersCount;
5295  params.headersKeys = headersKeys;
5296  params.headersValues = headersValues;
5297 
5298  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5299  }
5300 
5301 
5302  typedef struct
5303  {
5305  } _OrthancPluginIncomingHttpRequestFilter;
5306 
5320  OrthancPluginContext* context,
5322  {
5323  _OrthancPluginIncomingHttpRequestFilter params;
5324  params.callback = callback;
5325 
5326  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5327  }
5328 
5329 
5330 
5331  typedef struct
5332  {
5333  OrthancPluginMemoryBuffer* answerBody;
5334  OrthancPluginMemoryBuffer* answerHeaders;
5335  uint16_t* httpStatus;
5336  OrthancPluginHttpMethod method;
5337  const char* url;
5338  uint32_t headersCount;
5339  const char* const* headersKeys;
5340  const char* const* headersValues;
5341  const char* body;
5342  uint32_t bodySize;
5343  const char* username;
5344  const char* password;
5345  uint32_t timeout;
5346  const char* certificateFile;
5347  const char* certificateKeyFile;
5348  const char* certificateKeyPassword;
5349  uint8_t pkcs11;
5350  } _OrthancPluginCallHttpClient2;
5351 
5352 
5353 
5393  OrthancPluginContext* context,
5394  OrthancPluginMemoryBuffer* answerBody,
5395  OrthancPluginMemoryBuffer* answerHeaders,
5396  uint16_t* httpStatus,
5397  OrthancPluginHttpMethod method,
5398  const char* url,
5399  uint32_t headersCount,
5400  const char* const* headersKeys,
5401  const char* const* headersValues,
5402  const char* body,
5403  uint32_t bodySize,
5404  const char* username,
5405  const char* password,
5406  uint32_t timeout,
5407  const char* certificateFile,
5408  const char* certificateKeyFile,
5409  const char* certificateKeyPassword,
5410  uint8_t pkcs11)
5411  {
5412  _OrthancPluginCallHttpClient2 params;
5413  memset(&params, 0, sizeof(params));
5414 
5415  params.answerBody = answerBody;
5416  params.answerHeaders = answerHeaders;
5417  params.httpStatus = httpStatus;
5418  params.method = method;
5419  params.url = url;
5420  params.headersCount = headersCount;
5421  params.headersKeys = headersKeys;
5422  params.headersValues = headersValues;
5423  params.body = body;
5424  params.bodySize = bodySize;
5425  params.username = username;
5426  params.password = password;
5427  params.timeout = timeout;
5428  params.certificateFile = certificateFile;
5429  params.certificateKeyFile = certificateKeyFile;
5430  params.certificateKeyPassword = certificateKeyPassword;
5431  params.pkcs11 = pkcs11;
5432 
5433  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5434  }
5435 
5436 
5447  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5448  OrthancPluginContext* context)
5449  {
5450  char* result;
5451 
5452  _OrthancPluginRetrieveDynamicString params;
5453  params.result = &result;
5454  params.argument = NULL;
5455 
5456  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5457  {
5458  /* Error */
5459  return NULL;
5460  }
5461  else
5462  {
5463  return result;
5464  }
5465  }
5466 
5467 
5468 
5469 
5470  typedef struct
5471  {
5472  OrthancPluginFindCallback callback;
5473  } _OrthancPluginFindCallback;
5474 
5487  OrthancPluginContext* context,
5488  OrthancPluginFindCallback callback)
5489  {
5490  _OrthancPluginFindCallback params;
5491  params.callback = callback;
5492 
5493  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5494  }
5495 
5496 
5497  typedef struct
5498  {
5499  OrthancPluginFindAnswers *answers;
5500  const OrthancPluginFindQuery *query;
5501  const void *dicom;
5502  uint32_t size;
5503  uint32_t index;
5504  uint32_t *resultUint32;
5505  uint16_t *resultGroup;
5506  uint16_t *resultElement;
5507  char **resultString;
5508  } _OrthancPluginFindOperation;
5509 
5526  OrthancPluginContext* context,
5527  OrthancPluginFindAnswers* answers,
5528  const void* dicom,
5529  uint32_t size)
5530  {
5531  _OrthancPluginFindOperation params;
5532  memset(&params, 0, sizeof(params));
5533  params.answers = answers;
5534  params.dicom = dicom;
5535  params.size = size;
5536 
5537  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
5538  }
5539 
5540 
5555  OrthancPluginContext* context,
5556  OrthancPluginFindAnswers* answers)
5557  {
5558  _OrthancPluginFindOperation params;
5559  memset(&params, 0, sizeof(params));
5560  params.answers = answers;
5561 
5562  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
5563  }
5564 
5565 
5566 
5578  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
5579  OrthancPluginContext* context,
5580  const OrthancPluginFindQuery* query)
5581  {
5582  uint32_t count = 0;
5583 
5584  _OrthancPluginFindOperation params;
5585  memset(&params, 0, sizeof(params));
5586  params.query = query;
5587  params.resultUint32 = &count;
5588 
5589  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
5590  {
5591  /* Error */
5592  return 0;
5593  }
5594  else
5595  {
5596  return count;
5597  }
5598  }
5599 
5600 
5616  OrthancPluginContext* context,
5617  uint16_t* group,
5618  uint16_t* element,
5619  const OrthancPluginFindQuery* query,
5620  uint32_t index)
5621  {
5622  _OrthancPluginFindOperation params;
5623  memset(&params, 0, sizeof(params));
5624  params.query = query;
5625  params.index = index;
5626  params.resultGroup = group;
5627  params.resultElement = element;
5628 
5629  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
5630  }
5631 
5632 
5646  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
5647  OrthancPluginContext* context,
5648  const OrthancPluginFindQuery* query,
5649  uint32_t index)
5650  {
5651  char* result;
5652 
5653  _OrthancPluginFindOperation params;
5654  memset(&params, 0, sizeof(params));
5655  params.query = query;
5656  params.index = index;
5657  params.resultString = &result;
5658 
5659  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
5660  {
5661  /* Error */
5662  return NULL;
5663  }
5664  else
5665  {
5666  return result;
5667  }
5668  }
5669 
5670 
5684  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
5685  OrthancPluginContext* context,
5686  const OrthancPluginFindQuery* query,
5687  uint32_t index)
5688  {
5689  char* result;
5690 
5691  _OrthancPluginFindOperation params;
5692  memset(&params, 0, sizeof(params));
5693  params.query = query;
5694  params.index = index;
5695  params.resultString = &result;
5696 
5697  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
5698  {
5699  /* Error */
5700  return NULL;
5701  }
5702  else
5703  {
5704  return result;
5705  }
5706  }
5707 
5708 
5709 
5710 
5711  typedef struct
5712  {
5713  OrthancPluginMoveCallback callback;
5714  OrthancPluginGetMoveSize getMoveSize;
5715  OrthancPluginApplyMove applyMove;
5716  OrthancPluginFreeMove freeMove;
5717  } _OrthancPluginMoveCallback;
5718 
5733  OrthancPluginContext* context,
5734  OrthancPluginMoveCallback callback,
5735  OrthancPluginGetMoveSize getMoveSize,
5736  OrthancPluginApplyMove applyMove,
5737  OrthancPluginFreeMove freeMove)
5738  {
5739  _OrthancPluginMoveCallback params;
5740  params.callback = callback;
5741  params.getMoveSize = getMoveSize;
5742  params.applyMove = applyMove;
5743  params.freeMove = freeMove;
5744 
5745  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
5746  }
5747 
5748 
5749 
5750  typedef struct
5751  {
5752  OrthancPluginFindMatcher** target;
5753  const void* query;
5754  uint32_t size;
5755  } _OrthancPluginCreateFindMatcher;
5756 
5757 
5772  OrthancPluginContext* context,
5773  const void* query,
5774  uint32_t size)
5775  {
5776  OrthancPluginFindMatcher* target = NULL;
5777 
5778  _OrthancPluginCreateFindMatcher params;
5779  memset(&params, 0, sizeof(params));
5780  params.target = &target;
5781  params.query = query;
5782  params.size = size;
5783 
5784  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
5785  {
5786  return NULL;
5787  }
5788  else
5789  {
5790  return target;
5791  }
5792  }
5793 
5794 
5795  typedef struct
5796  {
5797  OrthancPluginFindMatcher* matcher;
5798  } _OrthancPluginFreeFindMatcher;
5799 
5809  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
5810  OrthancPluginContext* context,
5811  OrthancPluginFindMatcher* matcher)
5812  {
5813  _OrthancPluginFreeFindMatcher params;
5814  params.matcher = matcher;
5815 
5816  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
5817  }
5818 
5819 
5820  typedef struct
5821  {
5822  const OrthancPluginFindMatcher* matcher;
5823  const void* dicom;
5824  uint32_t size;
5825  int32_t* isMatch;
5826  } _OrthancPluginFindMatcherIsMatch;
5827 
5842  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
5843  OrthancPluginContext* context,
5844  const OrthancPluginFindMatcher* matcher,
5845  const void* dicom,
5846  uint32_t size)
5847  {
5848  int32_t isMatch = 0;
5849 
5850  _OrthancPluginFindMatcherIsMatch params;
5851  params.matcher = matcher;
5852  params.dicom = dicom;
5853  params.size = size;
5854  params.isMatch = &isMatch;
5855 
5856  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
5857  {
5858  return isMatch;
5859  }
5860  else
5861  {
5862  /* Error: Assume non-match */
5863  return 0;
5864  }
5865  }
5866 
5867 
5868  typedef struct
5869  {
5871  } _OrthancPluginIncomingHttpRequestFilter2;
5872 
5885  OrthancPluginContext* context,
5887  {
5888  _OrthancPluginIncomingHttpRequestFilter2 params;
5889  params.callback = callback;
5890 
5891  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
5892  }
5893 
5894 
5895 
5896  typedef struct
5897  {
5898  OrthancPluginPeers** peers;
5899  } _OrthancPluginGetPeers;
5900 
5913  OrthancPluginContext* context)
5914  {
5915  OrthancPluginPeers* peers = NULL;
5916 
5917  _OrthancPluginGetPeers params;
5918  memset(&params, 0, sizeof(params));
5919  params.peers = &peers;
5920 
5921  if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
5922  {
5923  return NULL;
5924  }
5925  else
5926  {
5927  return peers;
5928  }
5929  }
5930 
5931 
5932  typedef struct
5933  {
5934  OrthancPluginPeers* peers;
5935  } _OrthancPluginFreePeers;
5936 
5946  ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
5947  OrthancPluginContext* context,
5948  OrthancPluginPeers* peers)
5949  {
5950  _OrthancPluginFreePeers params;
5951  params.peers = peers;
5952 
5953  context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
5954  }
5955 
5956 
5957  typedef struct
5958  {
5959  uint32_t* target;
5960  const OrthancPluginPeers* peers;
5961  } _OrthancPluginGetPeersCount;
5962 
5976  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
5977  OrthancPluginContext* context,
5978  const OrthancPluginPeers* peers)
5979  {
5980  uint32_t target = 0;
5981 
5982  _OrthancPluginGetPeersCount params;
5983  memset(&params, 0, sizeof(params));
5984  params.target = &target;
5985  params.peers = peers;
5986 
5987  if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
5988  {
5989  /* Error */
5990  return 0;
5991  }
5992  else
5993  {
5994  return target;
5995  }
5996  }
5997 
5998 
5999  typedef struct
6000  {
6001  const char** target;
6002  const OrthancPluginPeers* peers;
6003  uint32_t peerIndex;
6004  const char* userProperty;
6005  } _OrthancPluginGetPeerProperty;
6006 
6024  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6025  OrthancPluginContext* context,
6026  const OrthancPluginPeers* peers,
6027  uint32_t peerIndex)
6028  {
6029  const char* target = NULL;
6030 
6031  _OrthancPluginGetPeerProperty params;
6032  memset(&params, 0, sizeof(params));
6033  params.target = &target;
6034  params.peers = peers;
6035  params.peerIndex = peerIndex;
6036  params.userProperty = NULL;
6037 
6038  if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6039  {
6040  /* Error */
6041  return NULL;
6042  }
6043  else
6044  {
6045  return target;
6046  }
6047  }
6048 
6049 
6065  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6066  OrthancPluginContext* context,
6067  const OrthancPluginPeers* peers,
6068  uint32_t peerIndex)
6069  {
6070  const char* target = NULL;
6071 
6072  _OrthancPluginGetPeerProperty params;
6073  memset(&params, 0, sizeof(params));
6074  params.target = &target;
6075  params.peers = peers;
6076  params.peerIndex = peerIndex;
6077  params.userProperty = NULL;
6078 
6079  if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6080  {
6081  /* Error */
6082  return NULL;
6083  }
6084  else
6085  {
6086  return target;
6087  }
6088  }
6089 
6090 
6091 
6111  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6112  OrthancPluginContext* context,
6113  const OrthancPluginPeers* peers,
6114  uint32_t peerIndex,
6115  const char* userProperty)
6116  {
6117  const char* target = NULL;
6118 
6119  _OrthancPluginGetPeerProperty params;
6120  memset(&params, 0, sizeof(params));
6121  params.target = &target;
6122  params.peers = peers;
6123  params.peerIndex = peerIndex;
6124  params.userProperty = userProperty;
6125 
6126  if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6127  {
6128  /* No such user property */
6129  return NULL;
6130  }
6131  else
6132  {
6133  return target;
6134  }
6135  }
6136 
6137 
6138 
6139  typedef struct
6140  {
6141  OrthancPluginMemoryBuffer* answerBody;
6142  OrthancPluginMemoryBuffer* answerHeaders;
6143  uint16_t* httpStatus;
6144  const OrthancPluginPeers* peers;
6145  uint32_t peerIndex;
6146  OrthancPluginHttpMethod method;
6147  const char* uri;
6148  uint32_t additionalHeadersCount;
6149  const char* const* additionalHeadersKeys;
6150  const char* const* additionalHeadersValues;
6151  const char* body;
6152  uint32_t bodySize;
6153  uint32_t timeout;
6154  } _OrthancPluginCallPeerApi;
6155 
6192  OrthancPluginContext* context,
6193  OrthancPluginMemoryBuffer* answerBody,
6194  OrthancPluginMemoryBuffer* answerHeaders,
6195  uint16_t* httpStatus,
6196  const OrthancPluginPeers* peers,
6197  uint32_t peerIndex,
6198  OrthancPluginHttpMethod method,
6199  const char* uri,
6200  uint32_t additionalHeadersCount,
6201  const char* const* additionalHeadersKeys,
6202  const char* const* additionalHeadersValues,
6203  const char* body,
6204  uint32_t bodySize,
6205  uint32_t timeout)
6206  {
6207  _OrthancPluginCallPeerApi params;
6208  memset(&params, 0, sizeof(params));
6209 
6210  params.answerBody = answerBody;
6211  params.answerHeaders = answerHeaders;
6212  params.httpStatus = httpStatus;
6213  params.peers = peers;
6214  params.peerIndex = peerIndex;
6215  params.method = method;
6216  params.uri = uri;
6217  params.additionalHeadersCount = additionalHeadersCount;
6218  params.additionalHeadersKeys = additionalHeadersKeys;
6219  params.additionalHeadersValues = additionalHeadersValues;
6220  params.body = body;
6221  params.bodySize = bodySize;
6222  params.timeout = timeout;
6223 
6224  return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6225  }
6226 
6227 
6228 
6229 
6230 
6231  typedef struct
6232  {
6233  OrthancPluginJob** target;
6234  void *job;
6235  OrthancPluginJobFinalize finalize;
6236  const char *type;
6237  OrthancPluginJobGetProgress getProgress;
6238  OrthancPluginJobGetContent getContent;
6239  OrthancPluginJobGetSerialized getSerialized;
6240  OrthancPluginJobStep step;
6241  OrthancPluginJobStop stop;
6242  OrthancPluginJobReset reset;
6243  } _OrthancPluginCreateJob;
6244 
6277  OrthancPluginContext *context,
6278  void *job,
6279  OrthancPluginJobFinalize finalize,
6280  const char *type,
6281  OrthancPluginJobGetProgress getProgress,
6282  OrthancPluginJobGetContent getContent,
6283  OrthancPluginJobGetSerialized getSerialized,
6284  OrthancPluginJobStep step,
6285  OrthancPluginJobStop stop,
6286  OrthancPluginJobReset reset)
6287  {
6288  OrthancPluginJob* target = NULL;
6289 
6290  _OrthancPluginCreateJob params;
6291  memset(&params, 0, sizeof(params));
6292 
6293  params.target = &target;
6294  params.job = job;
6295  params.finalize = finalize;
6296  params.type = type;
6297  params.getProgress = getProgress;
6298  params.getContent = getContent;
6299  params.getSerialized = getSerialized;
6300  params.step = step;
6301  params.stop = stop;
6302  params.reset = reset;
6303 
6304  if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6305  target == NULL)
6306  {
6307  /* Error */
6308  return NULL;
6309  }
6310  else
6311  {
6312  return target;
6313  }
6314  }
6315 
6316 
6317  typedef struct
6318  {
6319  OrthancPluginJob* job;
6320  } _OrthancPluginFreeJob;
6321 
6331  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6332  OrthancPluginContext* context,
6333  OrthancPluginJob* job)
6334  {
6335  _OrthancPluginFreeJob params;
6336  params.job = job;
6337 
6338  context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6339  }
6340 
6341 
6342 
6343  typedef struct
6344  {
6345  char** resultId;
6346  OrthancPluginJob *job;
6347  int priority;
6348  } _OrthancPluginSubmitJob;
6349 
6363  ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6364  OrthancPluginContext *context,
6365  OrthancPluginJob *job,
6366  int priority)
6367  {
6368  char* resultId = NULL;
6369 
6370  _OrthancPluginSubmitJob params;
6371  memset(&params, 0, sizeof(params));
6372 
6373  params.resultId = &resultId;
6374  params.job = job;
6375  params.priority = priority;
6376 
6377  if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6378  resultId == NULL)
6379  {
6380  /* Error */
6381  return NULL;
6382  }
6383  else
6384  {
6385  return resultId;
6386  }
6387  }
6388 
6389 
6390 
6391  typedef struct
6392  {
6393  OrthancPluginJobsUnserializer unserializer;
6394  } _OrthancPluginJobsUnserializer;
6395 
6408  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6409  OrthancPluginContext* context,
6410  OrthancPluginJobsUnserializer unserializer)
6411  {
6412  _OrthancPluginJobsUnserializer params;
6413  params.unserializer = unserializer;
6414 
6415  context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6416  }
6417 
6418 
6419 #ifdef __cplusplus
6420 }
6421 #endif
6422 
6423 
Definition: OrthancCPlugin.h:725
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2517
Definition: OrthancCPlugin.h:826
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:2696
OrthancPluginChangeType
Definition: OrthancCPlugin.h:680
Definition: OrthancCPlugin.h:235
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2380
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:5946
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:902
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5525
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2481
Definition: OrthancCPlugin.h:748
Definition: OrthancCPlugin.h:270
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:1658
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:4984
Definition: OrthancCPlugin.h:827
The parameters of a REST request.
Definition: OrthancCPlugin.h:329
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2163
OrthancPluginContentType
Definition: OrthancCPlugin.h:649
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2068
Definition: OrthancCPlugin.h:666
Definition: OrthancCPlugin.h:747
Definition: OrthancCPlugin.h:842
const char * OrthancPluginGetInstanceData(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2583
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:3764
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:3856
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:852
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:1163
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1591
Definition: OrthancCPlugin.h:262
Definition: OrthancCPlugin.h:205
Definition: OrthancCPlugin.h:260
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:837
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1328
Definition: OrthancCPlugin.h:745
Definition: OrthancCPlugin.h:870
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2550
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:4500
Definition: OrthancCPlugin.h:285
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:573
Definition: OrthancCPlugin.h:695
Definition: OrthancCPlugin.h:227
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:389
Definition: OrthancCPlugin.h:272
Definition: OrthancCPlugin.h:274
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:384
Definition: OrthancCPlugin.h:258
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:809
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5192
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:6276
Definition: OrthancCPlugin.h:276
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:557
Definition: OrthancCPlugin.h:843
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:349
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int priority)
Submit a new job to the jobs engine of Orthanc.
Definition: OrthancCPlugin.h:6363
Definition: OrthancCPlugin.h:599
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:2782
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:1881
OrthancPluginErrorCode OrthancPluginCallPeerApi(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, const OrthancPluginPeers *peers, uint32_t peerIndex, OrthancPluginHttpMethod method, const char *uri, uint32_t additionalHeadersCount, const char *const *additionalHeadersKeys, const char *const *additionalHeadersValues, const char *body, uint32_t bodySize, uint32_t timeout)
Call the REST API of an Orthanc peer.
Definition: OrthancCPlugin.h:6191
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:722
Definition: OrthancCPlugin.h:213
Definition: OrthancCPlugin.h:298
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1460
Definition: OrthancCPlugin.h:282
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4136
Definition: OrthancCPlugin.h:233
Definition: OrthancCPlugin.h:288
Definition: OrthancCPlugin.h:280
Definition: OrthancCPlugin.h:317
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1032
Definition: OrthancCPlugin.h:224
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5156
Definition: OrthancCPlugin.h:854
Definition: OrthancCPlugin.h:226
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:199
struct _OrthancPluginJob_t OrthancPluginJob
Opaque structure to a job to be executed by Orthanc.
Definition: OrthancCPlugin.h:981
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4061
Definition: OrthancCPlugin.h:283
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:1105
Definition: OrthancCPlugin.h:689
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4315
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4096
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:2879
Definition: OrthancCPlugin.h:222
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:5615
OrthancPluginErrorCode OrthancPluginHttpClient(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, OrthancPluginHttpMethod method, const char *url, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, const char *body, uint32_t bodySize, const char *username, const char *password, uint32_t timeout, const char *certificateFile, const char *certificateKeyFile, const char *certificateKeyPassword, uint8_t pkcs11)
Issue a HTTP call with full flexibility.
Definition: OrthancCPlugin.h:5392
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:2921
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:597
Definition: OrthancCPlugin.h:793
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:790
Definition: OrthancCPlugin.h:871
Definition: OrthancCPlugin.h:215
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2426
Definition: OrthancCPlugin.h:709
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5447
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1313
Definition: OrthancCPlugin.h:697
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:1783
Definition: OrthancCPlugin.h:869
Definition: OrthancCPlugin.h:683
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5110
Definition: OrthancCPlugin.h:259
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:775
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5238
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1385
Definition: OrthancCPlugin.h:777
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4391
Definition: OrthancCPlugin.h:240
uint16_t group
Definition: OrthancCPlugin.h:1443
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:3634
Definition: OrthancCPlugin.h:738
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1446
Definition: OrthancCPlugin.h:779
Definition: OrthancCPlugin.h:750
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:4769
const char * OrthancPluginGetInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Get the value of some metadata associated with a given DICOM instance.
Definition: OrthancCPlugin.h:2734
Definition: OrthancCPlugin.h:868
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:866
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:933
Definition: OrthancCPlugin.h:724
Definition: OrthancCPlugin.h:252
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:925
Definition: OrthancCPlugin.h:244
Definition: OrthancCPlugin.h:651
Definition: OrthancCPlugin.h:687
Color image in RGB48 format.
Definition: OrthancCPlugin.h:607
OrthancPluginErrorCode OrthancPluginRestApiPutAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const char *body, uint32_t bodySize)
Make a PUT call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2129
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3166
Definition: OrthancCPlugin.h:275
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:565
Definition: OrthancCPlugin.h:273
Definition: OrthancCPlugin.h:216
OrthancPluginResourceType
Definition: OrthancCPlugin.h:663
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:314
Definition: OrthancCPlugin.h:232
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:3565
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:736
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3199
Definition: OrthancCPlugin.h:203
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:3463
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:3677
Definition: OrthancCPlugin.h:278
Definition: OrthancCPlugin.h:740
Definition: OrthancCPlugin.h:219
Definition: OrthancCPlugin.h:668
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:989
Definition: OrthancCPlugin.h:269
Definition: OrthancCPlugin.h:710
Definition: OrthancCPlugin.h:743
Definition: OrthancCPlugin.h:286
Definition: OrthancCPlugin.h:856
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:2844
Definition: OrthancCPlugin.h:237
Definition: OrthancCPlugin.h:712
Definition: OrthancCPlugin.h:762
Definition: OrthancCPlugin.h:261
Color image in RGB24 format.
Definition: OrthancCPlugin.h:589
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5884
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:581
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1441
Definition: OrthancCPlugin.h:271
Definition: OrthancCPlugin.h:209
Definition: OrthancCPlugin.h:682
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:707
OrthancPluginErrorCode OrthancPluginHttpPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *body, uint32_t bodySize, const char *username, const char *password)
Issue a HTTP PUT call.
Definition: OrthancCPlugin.h:3986
Definition: OrthancCPlugin.h:201
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:4695
Definition: OrthancCPlugin.h:796
struct _OrthancPluginPeers_t OrthancPluginPeers
Opaque structure to the set of remote Orthanc Peers that are known to the local Orthanc server...
Definition: OrthancCPlugin.h:973
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3499
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:4221
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3600
Definition: OrthancCPlugin.h:652
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:1840
Definition: OrthancCPlugin.h:291
Definition: OrthancCPlugin.h:297
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1361
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1447
Definition: OrthancCPlugin.h:290
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:1021
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:4588
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3100
Definition: OrthancCPlugin.h:242
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2403
Definition: OrthancCPlugin.h:211
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:639
Definition: OrthancCPlugin.h:267
Definition: OrthancCPlugin.h:255
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:5809
Definition: OrthancCPlugin.h:287
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:1626
Definition: OrthancCPlugin.h:230
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:5771
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:887
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4168
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:2996
Definition: OrthancCPlugin.h:841
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1914
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3410
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:379
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:1132
Definition: OrthancCPlugin.h:688
Definition: OrthancCPlugin.h:795
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1610
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:4733
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1048
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:1233
Definition: OrthancCPlugin.h:756
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2045
Definition: OrthancCPlugin.h:760
Definition: OrthancCPlugin.h:667
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3348
Definition: OrthancCPlugin.h:749
Definition: OrthancCPlugin.h:828
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:957
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:5732
Definition: OrthancCPlugin.h:318
Definition: OrthancCPlugin.h:696
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5022
Definition: OrthancCPlugin.h:751
Definition: OrthancCPlugin.h:247
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:2814
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3030
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:5281
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1086
Definition: OrthancCPlugin.h:778
Definition: OrthancCPlugin.h:256
Definition: OrthancCPlugin.h:294
Definition: OrthancCPlugin.h:316
Definition: OrthancCPlugin.h:690
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4544
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:5646
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6408
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3134
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:3908
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:5065
Definition: OrthancCPlugin.h:264
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5319
Definition: OrthancCPlugin.h:223
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:4637
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:359
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:6111
Definition: OrthancCPlugin.h:763
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:1010
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:5912
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:2657
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:3311
Definition: OrthancCPlugin.h:257
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:4799
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:4951
Definition: OrthancCPlugin.h:250
Definition: OrthancCPlugin.h:726
Definition: OrthancCPlugin.h:210
const char * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:364
Definition: OrthancCPlugin.h:263
Definition: OrthancCPlugin.h:217
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:1723
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1190
Definition: OrthancCPlugin.h:693
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5486
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:917
OrthancPluginErrorCode OrthancPluginRestApiPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const char *body, uint32_t bodySize)
Make a PUT call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2093
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3240
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:941
Definition: OrthancCPlugin.h:202
Definition: OrthancCPlugin.h:228
Definition: OrthancCPlugin.h:221
Definition: OrthancCPlugin.h:825
Definition: OrthancCPlugin.h:295
Definition: OrthancCPlugin.h:266
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1287
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:2952
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1346
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4352
Definition: OrthancCPlugin.h:855
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6331
Definition: OrthancCPlugin.h:755
Definition: OrthancCPlugin.h:694
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:354
Definition: OrthancCPlugin.h:758
Definition: OrthancCPlugin.h:685
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2195
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:4902
Definition: OrthancCPlugin.h:759
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:3719
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1445
uint16_t element
Definition: OrthancCPlugin.h:1444
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2335
Definition: OrthancCPlugin.h:692
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3069
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1273
Definition: OrthancCPlugin.h:234
Definition: OrthancCPlugin.h:653
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:3269
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:344
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3379
Definition: OrthancCPlugin.h:265
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1068
Definition: OrthancCPlugin.h:268
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2230
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:892
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:623
Definition: OrthancCPlugin.h:839
Definition: OrthancCPlugin.h:248
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1402
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance received by Orthanc.
Definition: OrthancCPlugin.h:909
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:339
Definition: OrthancCPlugin.h:249
Definition: OrthancCPlugin.h:669
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:1642
Definition: OrthancCPlugin.h:744
Definition: OrthancCPlugin.h:254
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:4837
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:1490
Definition: OrthancCPlugin.h:764
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:823
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:369
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:5554
Definition: OrthancCPlugin.h:319
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialized a custom job.
Definition: OrthancCPlugin.h:1418
Definition: OrthancCPlugin.h:239
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2456
Definition: OrthancCPlugin.h:684
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:5976
Definition: OrthancCPlugin.h:754
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2619
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6065
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5578
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:2974
Definition: OrthancCPlugin.h:296
Definition: OrthancCPlugin.h:236
OrthancPluginErrorCode OrthancPluginRestApiPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const char *body, uint32_t bodySize)
Make a POST call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1981
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:1751
Definition: OrthancCPlugin.h:686
Definition: OrthancCPlugin.h:757
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:4447
Definition: OrthancCPlugin.h:251
Definition: OrthancCPlugin.h:214
Definition: OrthancCPlugin.h:761
OrthancPluginErrorCode OrthancPluginHttpPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *body, uint32_t bodySize, const char *username, const char *password)
Issue a HTTP POST call.
Definition: OrthancCPlugin.h:3945
Definition: OrthancCPlugin.h:741
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:615
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:1689
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2265
Definition: OrthancCPlugin.h:753
Definition: OrthancCPlugin.h:739
Definition: OrthancCPlugin.h:206
Definition: OrthancCPlugin.h:665
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:4876
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:1944
Definition: OrthancCPlugin.h:840
Definition: OrthancCPlugin.h:225
OrthancPluginErrorCode(* OrthancPluginOnStoredInstanceCallback)(OrthancPluginDicomInstance *instance, const char *instanceId)
Signature of a callback function that is triggered when Orthanc receives a DICOM instance.
Definition: OrthancCPlugin.h:1000
Definition: OrthancCPlugin.h:289
Definition: OrthancCPlugin.h:207
Definition: OrthancCPlugin.h:212
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:949
OrthancPluginErrorCode OrthancPluginRestApiPostAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const char *body, uint32_t bodySize)
Make a POST call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2016
Definition: OrthancCPlugin.h:204
Definition: OrthancCPlugin.h:229
Definition: OrthancCPlugin.h:691
Definition: OrthancCPlugin.h:711
Definition: OrthancCPlugin.h:241
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:334
Definition: OrthancCPlugin.h:284
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:4273
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4023
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:882
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6024
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:631
Definition: OrthancCPlugin.h:746
Definition: OrthancCPlugin.h:794
Definition: OrthancCPlugin.h:218
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:5842
Definition: OrthancCPlugin.h:752
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1300
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2300
Definition: OrthancCPlugin.h:208
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1258
Definition: OrthancCPlugin.h:742
Definition: OrthancCPlugin.h:277
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3532
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:3809
struct _OrthancPluginFindAnswers_t OrthancPluginFindMatcher
Opaque structure to an object that can be used to check whether a DICOM instance matches a C-Find que...
Definition: OrthancCPlugin.h:965
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:5684
Definition: OrthancCPlugin.h:238
Definition: OrthancCPlugin.h:231