Orthanc Plugin SDK  1.5.3
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 5
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  _OrthancPluginService_AutodetectMimeType = 30,
427 
428  /* Registration of callbacks */
429  _OrthancPluginService_RegisterRestCallback = 1000,
430  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
431  _OrthancPluginService_RegisterStorageArea = 1002,
432  _OrthancPluginService_RegisterOnChangeCallback = 1003,
433  _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
434  _OrthancPluginService_RegisterWorklistCallback = 1005,
435  _OrthancPluginService_RegisterDecodeImageCallback = 1006,
436  _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
437  _OrthancPluginService_RegisterFindCallback = 1008,
438  _OrthancPluginService_RegisterMoveCallback = 1009,
439  _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
440 
441  /* Sending answers to REST calls */
442  _OrthancPluginService_AnswerBuffer = 2000,
443  _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
444  _OrthancPluginService_Redirect = 2002,
445  _OrthancPluginService_SendHttpStatusCode = 2003,
446  _OrthancPluginService_SendUnauthorized = 2004,
447  _OrthancPluginService_SendMethodNotAllowed = 2005,
448  _OrthancPluginService_SetCookie = 2006,
449  _OrthancPluginService_SetHttpHeader = 2007,
450  _OrthancPluginService_StartMultipartAnswer = 2008,
451  _OrthancPluginService_SendMultipartItem = 2009,
452  _OrthancPluginService_SendHttpStatus = 2010,
453  _OrthancPluginService_CompressAndAnswerImage = 2011,
454  _OrthancPluginService_SendMultipartItem2 = 2012,
455  _OrthancPluginService_SetHttpErrorDetails = 2013,
456 
457  /* Access to the Orthanc database and API */
458  _OrthancPluginService_GetDicomForInstance = 3000,
459  _OrthancPluginService_RestApiGet = 3001,
460  _OrthancPluginService_RestApiPost = 3002,
461  _OrthancPluginService_RestApiDelete = 3003,
462  _OrthancPluginService_RestApiPut = 3004,
463  _OrthancPluginService_LookupPatient = 3005,
464  _OrthancPluginService_LookupStudy = 3006,
465  _OrthancPluginService_LookupSeries = 3007,
466  _OrthancPluginService_LookupInstance = 3008,
467  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
468  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
469  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
470  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
471  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
472  _OrthancPluginService_ReconstructMainDicomTags = 3014,
473  _OrthancPluginService_RestApiGet2 = 3015,
474 
475  /* Access to DICOM instances */
476  _OrthancPluginService_GetInstanceRemoteAet = 4000,
477  _OrthancPluginService_GetInstanceSize = 4001,
478  _OrthancPluginService_GetInstanceData = 4002,
479  _OrthancPluginService_GetInstanceJson = 4003,
480  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
481  _OrthancPluginService_HasInstanceMetadata = 4005,
482  _OrthancPluginService_GetInstanceMetadata = 4006,
483  _OrthancPluginService_GetInstanceOrigin = 4007,
484 
485  /* Services for plugins implementing a database back-end */
486  _OrthancPluginService_RegisterDatabaseBackend = 5000,
487  _OrthancPluginService_DatabaseAnswer = 5001,
488  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
489  _OrthancPluginService_StorageAreaCreate = 5003,
490  _OrthancPluginService_StorageAreaRead = 5004,
491  _OrthancPluginService_StorageAreaRemove = 5005,
492 
493  /* Primitives for handling images */
494  _OrthancPluginService_GetImagePixelFormat = 6000,
495  _OrthancPluginService_GetImageWidth = 6001,
496  _OrthancPluginService_GetImageHeight = 6002,
497  _OrthancPluginService_GetImagePitch = 6003,
498  _OrthancPluginService_GetImageBuffer = 6004,
499  _OrthancPluginService_UncompressImage = 6005,
500  _OrthancPluginService_FreeImage = 6006,
501  _OrthancPluginService_CompressImage = 6007,
502  _OrthancPluginService_ConvertPixelFormat = 6008,
503  _OrthancPluginService_GetFontsCount = 6009,
504  _OrthancPluginService_GetFontInfo = 6010,
505  _OrthancPluginService_DrawText = 6011,
506  _OrthancPluginService_CreateImage = 6012,
507  _OrthancPluginService_CreateImageAccessor = 6013,
508  _OrthancPluginService_DecodeDicomImage = 6014,
509 
510  /* Primitives for handling C-Find, C-Move and worklists */
511  _OrthancPluginService_WorklistAddAnswer = 7000,
512  _OrthancPluginService_WorklistMarkIncomplete = 7001,
513  _OrthancPluginService_WorklistIsMatch = 7002,
514  _OrthancPluginService_WorklistGetDicomQuery = 7003,
515  _OrthancPluginService_FindAddAnswer = 7004,
516  _OrthancPluginService_FindMarkIncomplete = 7005,
517  _OrthancPluginService_GetFindQuerySize = 7006,
518  _OrthancPluginService_GetFindQueryTag = 7007,
519  _OrthancPluginService_GetFindQueryTagName = 7008,
520  _OrthancPluginService_GetFindQueryValue = 7009,
521  _OrthancPluginService_CreateFindMatcher = 7010,
522  _OrthancPluginService_FreeFindMatcher = 7011,
523  _OrthancPluginService_FindMatcherIsMatch = 7012,
524 
525  /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
526  _OrthancPluginService_GetPeers = 8000,
527  _OrthancPluginService_FreePeers = 8001,
528  _OrthancPluginService_GetPeersCount = 8003,
529  _OrthancPluginService_GetPeerName = 8004,
530  _OrthancPluginService_GetPeerUrl = 8005,
531  _OrthancPluginService_CallPeerApi = 8006,
532  _OrthancPluginService_GetPeerUserProperty = 8007,
533 
534  /* Primitives for handling jobs (new in 1.4.2) */
535  _OrthancPluginService_CreateJob = 9000,
536  _OrthancPluginService_FreeJob = 9001,
537  _OrthancPluginService_SubmitJob = 9002,
538  _OrthancPluginService_RegisterJobsUnserializer = 9003,
539 
540  _OrthancPluginService_INTERNAL = 0x7fffffff
541  } _OrthancPluginService;
542 
543 
544  typedef enum
545  {
546  _OrthancPluginProperty_Description = 1,
547  _OrthancPluginProperty_RootUri = 2,
548  _OrthancPluginProperty_OrthancExplorer = 3,
549 
550  _OrthancPluginProperty_INTERNAL = 0x7fffffff
551  } _OrthancPluginProperty;
552 
553 
554 
559  typedef enum
560  {
568 
576 
584 
592 
600 
610 
618 
626 
634 
642 
643  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
645 
646 
647 
651  typedef enum
652  {
657  _OrthancPluginContentType_INTERNAL = 0x7fffffff
659 
660 
661 
665  typedef enum
666  {
673  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
675 
676 
677 
682  typedef enum
683  {
701  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
703 
704 
709  typedef enum
710  {
716  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
718 
719 
724  typedef enum
725  {
730  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
732 
733 
738  typedef enum
739  {
768  _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
770 
771 
777  typedef enum
778  {
783  _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
785 
786 
792  typedef enum
793  {
794  OrthancPluginDicomToJsonFlags_None = 0,
802  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
804 
805 
811  typedef enum
812  {
813  OrthancPluginCreateDicomFlags_None = 0,
817  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
819 
820 
826  typedef enum
827  {
833  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
835 
836 
841  typedef enum
842  {
849  _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
851 
852 
856  typedef enum
857  {
864  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
866 
867 
871  typedef enum
872  {
877 
878 
885  typedef enum
886  {
892 
893 
901  typedef struct
902  {
906  void* data;
907 
911  uint32_t size;
913 
914 
915 
916 
921  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
922 
923 
924 
928  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
929 
930 
931 
936  typedef struct _OrthancPluginImage_t OrthancPluginImage;
937 
938 
939 
944  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
945 
946 
947 
952  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
953 
954 
955 
960  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
961 
962 
963 
968  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
969 
970 
971 
976  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
977 
978 
979 
984  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindMatcher;
985 
986 
987 
992  typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
993 
994 
995 
1000  typedef struct _OrthancPluginJob_t OrthancPluginJob;
1001 
1002 
1003 
1009  OrthancPluginRestOutput* output,
1010  const char* url,
1011  const OrthancPluginHttpRequest* request);
1012 
1013 
1014 
1020  OrthancPluginDicomInstance* instance,
1021  const char* instanceId);
1022 
1023 
1024 
1030  OrthancPluginChangeType changeType,
1031  OrthancPluginResourceType resourceType,
1032  const char* resourceId);
1033 
1034 
1035 
1041  OrthancPluginImage** target,
1042  const void* dicom,
1043  const uint32_t size,
1044  uint32_t frameIndex);
1045 
1046 
1047 
1051  typedef void (*OrthancPluginFree) (void* buffer);
1052 
1053 
1054 
1068  const char* uuid,
1069  const void* content,
1070  int64_t size,
1072 
1073 
1074 
1088  void** content,
1089  int64_t* size,
1090  const char* uuid,
1092 
1093 
1094 
1106  const char* uuid,
1108 
1109 
1110 
1126  const OrthancPluginWorklistQuery* query,
1127  const char* issuerAet,
1128  const char* calledAet);
1129 
1130 
1131 
1152  OrthancPluginHttpMethod method,
1153  const char* uri,
1154  const char* ip,
1155  uint32_t headersCount,
1156  const char* const* headersKeys,
1157  const char* const* headersValues);
1158 
1159 
1160 
1183  OrthancPluginHttpMethod method,
1184  const char* uri,
1185  const char* ip,
1186  uint32_t headersCount,
1187  const char* const* headersKeys,
1188  const char* const* headersValues,
1189  uint32_t getArgumentsCount,
1190  const char* const* getArgumentsKeys,
1191  const char* const* getArgumentsValues);
1192 
1193 
1194 
1210  OrthancPluginFindAnswers* answers,
1211  const OrthancPluginFindQuery* query,
1212  const char* issuerAet,
1213  const char* calledAet);
1214 
1215 
1216 
1252  typedef void* (*OrthancPluginMoveCallback) (
1253  OrthancPluginResourceType resourceType,
1254  const char* patientId,
1255  const char* accessionNumber,
1256  const char* studyInstanceUid,
1257  const char* seriesInstanceUid,
1258  const char* sopInstanceUid,
1259  const char* originatorAet,
1260  const char* sourceAet,
1261  const char* targetAet,
1262  uint16_t originatorId);
1263 
1264 
1277  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1278 
1279 
1292  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1293 
1294 
1306  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1307 
1308 
1319  typedef void (*OrthancPluginJobFinalize) (void* job);
1320 
1321 
1332  typedef float (*OrthancPluginJobGetProgress) (void* job);
1333 
1334 
1347  typedef const char* (*OrthancPluginJobGetContent) (void* job);
1348 
1349 
1365  typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1366 
1367 
1381 
1382 
1406 
1407 
1422 
1423 
1437  typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1438  const char* serialized);
1439 
1440 
1441 
1445  typedef struct _OrthancPluginContext_t
1446  {
1447  void* pluginsManager;
1448  const char* orthancVersion;
1449  OrthancPluginFree Free;
1450  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1451  _OrthancPluginService service,
1452  const void* params);
1454 
1455 
1456 
1460  typedef struct
1461  {
1462  uint16_t group;
1463  uint16_t element;
1465  uint32_t minMultiplicity;
1466  uint32_t maxMultiplicity;
1468 
1469 
1470 
1479  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1480  OrthancPluginContext* context,
1481  char* str)
1482  {
1483  if (str != NULL)
1484  {
1485  context->Free(str);
1486  }
1487  }
1488 
1489 
1509  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1510  OrthancPluginContext* context,
1511  int expectedMajor,
1512  int expectedMinor,
1513  int expectedRevision)
1514  {
1515  int major, minor, revision;
1516 
1517  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1518  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1519  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1520  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1521  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1522  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1523  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1524  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1525  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1526  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1527  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1528  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1529  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1530  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1531  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1532  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1533  sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1534  sizeof(int32_t) != sizeof(OrthancPluginConstraintType))
1535  {
1536  /* Mismatch in the size of the enumerations */
1537  return 0;
1538  }
1539 
1540  /* Assume compatibility with the mainline */
1541  if (!strcmp(context->orthancVersion, "mainline"))
1542  {
1543  return 1;
1544  }
1545 
1546  /* Parse the version of the Orthanc core */
1547  if (
1548 #ifdef _MSC_VER
1549  sscanf_s
1550 #else
1551  sscanf
1552 #endif
1553  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1554  {
1555  return 0;
1556  }
1557 
1558  /* Check the major number of the version */
1559 
1560  if (major > expectedMajor)
1561  {
1562  return 1;
1563  }
1564 
1565  if (major < expectedMajor)
1566  {
1567  return 0;
1568  }
1569 
1570  /* Check the minor number of the version */
1571 
1572  if (minor > expectedMinor)
1573  {
1574  return 1;
1575  }
1576 
1577  if (minor < expectedMinor)
1578  {
1579  return 0;
1580  }
1581 
1582  /* Check the revision number of the version */
1583 
1584  if (revision >= expectedRevision)
1585  {
1586  return 1;
1587  }
1588  else
1589  {
1590  return 0;
1591  }
1592  }
1593 
1594 
1611  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1612  OrthancPluginContext* context)
1613  {
1615  context,
1616  ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1617  ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1618  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1619  }
1620 
1621 
1630  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1631  OrthancPluginContext* context,
1632  OrthancPluginMemoryBuffer* buffer)
1633  {
1634  context->Free(buffer->data);
1635  }
1636 
1637 
1646  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1647  OrthancPluginContext* context,
1648  const char* message)
1649  {
1650  context->InvokeService(context, _OrthancPluginService_LogError, message);
1651  }
1652 
1653 
1662  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
1663  OrthancPluginContext* context,
1664  const char* message)
1665  {
1666  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1667  }
1668 
1669 
1678  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
1679  OrthancPluginContext* context,
1680  const char* message)
1681  {
1682  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
1683  }
1684 
1685 
1686 
1687  typedef struct
1688  {
1689  const char* pathRegularExpression;
1690  OrthancPluginRestCallback callback;
1691  } _OrthancPluginRestCallback;
1692 
1714  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
1715  OrthancPluginContext* context,
1716  const char* pathRegularExpression,
1717  OrthancPluginRestCallback callback)
1718  {
1719  _OrthancPluginRestCallback params;
1720  params.pathRegularExpression = pathRegularExpression;
1721  params.callback = callback;
1722  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
1723  }
1724 
1725 
1726 
1754  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
1755  OrthancPluginContext* context,
1756  const char* pathRegularExpression,
1757  OrthancPluginRestCallback callback)
1758  {
1759  _OrthancPluginRestCallback params;
1760  params.pathRegularExpression = pathRegularExpression;
1761  params.callback = callback;
1762  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
1763  }
1764 
1765 
1766 
1767  typedef struct
1768  {
1770  } _OrthancPluginOnStoredInstanceCallback;
1771 
1783  OrthancPluginContext* context,
1785  {
1786  _OrthancPluginOnStoredInstanceCallback params;
1787  params.callback = callback;
1788 
1789  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
1790  }
1791 
1792 
1793 
1794  typedef struct
1795  {
1796  OrthancPluginRestOutput* output;
1797  const char* answer;
1798  uint32_t answerSize;
1799  const char* mimeType;
1800  } _OrthancPluginAnswerBuffer;
1801 
1814  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
1815  OrthancPluginContext* context,
1816  OrthancPluginRestOutput* output,
1817  const char* answer,
1818  uint32_t answerSize,
1819  const char* mimeType)
1820  {
1821  _OrthancPluginAnswerBuffer params;
1822  params.output = output;
1823  params.answer = answer;
1824  params.answerSize = answerSize;
1825  params.mimeType = mimeType;
1826  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
1827  }
1828 
1829 
1830  typedef struct
1831  {
1832  OrthancPluginRestOutput* output;
1833  OrthancPluginPixelFormat format;
1834  uint32_t width;
1835  uint32_t height;
1836  uint32_t pitch;
1837  const void* buffer;
1838  } _OrthancPluginCompressAndAnswerPngImage;
1839 
1840  typedef struct
1841  {
1842  OrthancPluginRestOutput* output;
1843  OrthancPluginImageFormat imageFormat;
1844  OrthancPluginPixelFormat pixelFormat;
1845  uint32_t width;
1846  uint32_t height;
1847  uint32_t pitch;
1848  const void* buffer;
1849  uint8_t quality;
1850  } _OrthancPluginCompressAndAnswerImage;
1851 
1852 
1871  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
1872  OrthancPluginContext* context,
1873  OrthancPluginRestOutput* output,
1874  OrthancPluginPixelFormat format,
1875  uint32_t width,
1876  uint32_t height,
1877  uint32_t pitch,
1878  const void* buffer)
1879  {
1880  _OrthancPluginCompressAndAnswerImage params;
1881  params.output = output;
1882  params.imageFormat = OrthancPluginImageFormat_Png;
1883  params.pixelFormat = format;
1884  params.width = width;
1885  params.height = height;
1886  params.pitch = pitch;
1887  params.buffer = buffer;
1888  params.quality = 0; /* No quality for PNG */
1889  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
1890  }
1891 
1892 
1893 
1894  typedef struct
1895  {
1896  OrthancPluginMemoryBuffer* target;
1897  const char* instanceId;
1898  } _OrthancPluginGetDicomForInstance;
1899 
1913  OrthancPluginContext* context,
1914  OrthancPluginMemoryBuffer* target,
1915  const char* instanceId)
1916  {
1917  _OrthancPluginGetDicomForInstance params;
1918  params.target = target;
1919  params.instanceId = instanceId;
1920  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
1921  }
1922 
1923 
1924 
1925  typedef struct
1926  {
1927  OrthancPluginMemoryBuffer* target;
1928  const char* uri;
1929  } _OrthancPluginRestApiGet;
1930 
1946  OrthancPluginContext* context,
1947  OrthancPluginMemoryBuffer* target,
1948  const char* uri)
1949  {
1950  _OrthancPluginRestApiGet params;
1951  params.target = target;
1952  params.uri = uri;
1953  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
1954  }
1955 
1956 
1957 
1976  OrthancPluginContext* context,
1977  OrthancPluginMemoryBuffer* target,
1978  const char* uri)
1979  {
1980  _OrthancPluginRestApiGet params;
1981  params.target = target;
1982  params.uri = uri;
1983  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
1984  }
1985 
1986 
1987 
1988  typedef struct
1989  {
1990  OrthancPluginMemoryBuffer* target;
1991  const char* uri;
1992  const char* body;
1993  uint32_t bodySize;
1994  } _OrthancPluginRestApiPostPut;
1995 
2013  OrthancPluginContext* context,
2014  OrthancPluginMemoryBuffer* target,
2015  const char* uri,
2016  const char* body,
2017  uint32_t bodySize)
2018  {
2019  _OrthancPluginRestApiPostPut params;
2020  params.target = target;
2021  params.uri = uri;
2022  params.body = body;
2023  params.bodySize = bodySize;
2024  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2025  }
2026 
2027 
2048  OrthancPluginContext* context,
2049  OrthancPluginMemoryBuffer* target,
2050  const char* uri,
2051  const char* body,
2052  uint32_t bodySize)
2053  {
2054  _OrthancPluginRestApiPostPut params;
2055  params.target = target;
2056  params.uri = uri;
2057  params.body = body;
2058  params.bodySize = bodySize;
2059  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2060  }
2061 
2062 
2063 
2077  OrthancPluginContext* context,
2078  const char* uri)
2079  {
2080  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2081  }
2082 
2083 
2100  OrthancPluginContext* context,
2101  const char* uri)
2102  {
2103  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2104  }
2105 
2106 
2107 
2125  OrthancPluginContext* context,
2126  OrthancPluginMemoryBuffer* target,
2127  const char* uri,
2128  const char* body,
2129  uint32_t bodySize)
2130  {
2131  _OrthancPluginRestApiPostPut params;
2132  params.target = target;
2133  params.uri = uri;
2134  params.body = body;
2135  params.bodySize = bodySize;
2136  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2137  }
2138 
2139 
2140 
2161  OrthancPluginContext* context,
2162  OrthancPluginMemoryBuffer* target,
2163  const char* uri,
2164  const char* body,
2165  uint32_t bodySize)
2166  {
2167  _OrthancPluginRestApiPostPut params;
2168  params.target = target;
2169  params.uri = uri;
2170  params.body = body;
2171  params.bodySize = bodySize;
2172  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2173  }
2174 
2175 
2176 
2177  typedef struct
2178  {
2179  OrthancPluginRestOutput* output;
2180  const char* argument;
2181  } _OrthancPluginOutputPlusArgument;
2182 
2194  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2195  OrthancPluginContext* context,
2196  OrthancPluginRestOutput* output,
2197  const char* redirection)
2198  {
2199  _OrthancPluginOutputPlusArgument params;
2200  params.output = output;
2201  params.argument = redirection;
2202  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2203  }
2204 
2205 
2206 
2207  typedef struct
2208  {
2209  char** result;
2210  const char* argument;
2211  } _OrthancPluginRetrieveDynamicString;
2212 
2226  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2227  OrthancPluginContext* context,
2228  const char* patientID)
2229  {
2230  char* result;
2231 
2232  _OrthancPluginRetrieveDynamicString params;
2233  params.result = &result;
2234  params.argument = patientID;
2235 
2236  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2237  {
2238  /* Error */
2239  return NULL;
2240  }
2241  else
2242  {
2243  return result;
2244  }
2245  }
2246 
2247 
2261  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2262  OrthancPluginContext* context,
2263  const char* studyUID)
2264  {
2265  char* result;
2266 
2267  _OrthancPluginRetrieveDynamicString params;
2268  params.result = &result;
2269  params.argument = studyUID;
2270 
2271  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2272  {
2273  /* Error */
2274  return NULL;
2275  }
2276  else
2277  {
2278  return result;
2279  }
2280  }
2281 
2282 
2296  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
2297  OrthancPluginContext* context,
2298  const char* accessionNumber)
2299  {
2300  char* result;
2301 
2302  _OrthancPluginRetrieveDynamicString params;
2303  params.result = &result;
2304  params.argument = accessionNumber;
2305 
2306  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2307  {
2308  /* Error */
2309  return NULL;
2310  }
2311  else
2312  {
2313  return result;
2314  }
2315  }
2316 
2317 
2331  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2332  OrthancPluginContext* context,
2333  const char* seriesUID)
2334  {
2335  char* result;
2336 
2337  _OrthancPluginRetrieveDynamicString params;
2338  params.result = &result;
2339  params.argument = seriesUID;
2340 
2341  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2342  {
2343  /* Error */
2344  return NULL;
2345  }
2346  else
2347  {
2348  return result;
2349  }
2350  }
2351 
2352 
2366  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2367  OrthancPluginContext* context,
2368  const char* sopInstanceUID)
2369  {
2370  char* result;
2371 
2372  _OrthancPluginRetrieveDynamicString params;
2373  params.result = &result;
2374  params.argument = sopInstanceUID;
2375 
2376  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2377  {
2378  /* Error */
2379  return NULL;
2380  }
2381  else
2382  {
2383  return result;
2384  }
2385  }
2386 
2387 
2388 
2389  typedef struct
2390  {
2391  OrthancPluginRestOutput* output;
2392  uint16_t status;
2393  } _OrthancPluginSendHttpStatusCode;
2394 
2411  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2412  OrthancPluginContext* context,
2413  OrthancPluginRestOutput* output,
2414  uint16_t status)
2415  {
2416  _OrthancPluginSendHttpStatusCode params;
2417  params.output = output;
2418  params.status = status;
2419  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2420  }
2421 
2422 
2434  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2435  OrthancPluginContext* context,
2436  OrthancPluginRestOutput* output,
2437  const char* realm)
2438  {
2439  _OrthancPluginOutputPlusArgument params;
2440  params.output = output;
2441  params.argument = realm;
2442  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2443  }
2444 
2445 
2457  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2458  OrthancPluginContext* context,
2459  OrthancPluginRestOutput* output,
2460  const char* allowedMethods)
2461  {
2462  _OrthancPluginOutputPlusArgument params;
2463  params.output = output;
2464  params.argument = allowedMethods;
2465  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2466  }
2467 
2468 
2469  typedef struct
2470  {
2471  OrthancPluginRestOutput* output;
2472  const char* key;
2473  const char* value;
2474  } _OrthancPluginSetHttpHeader;
2475 
2487  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2488  OrthancPluginContext* context,
2489  OrthancPluginRestOutput* output,
2490  const char* cookie,
2491  const char* value)
2492  {
2493  _OrthancPluginSetHttpHeader params;
2494  params.output = output;
2495  params.key = cookie;
2496  params.value = value;
2497  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2498  }
2499 
2500 
2512  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2513  OrthancPluginContext* context,
2514  OrthancPluginRestOutput* output,
2515  const char* key,
2516  const char* value)
2517  {
2518  _OrthancPluginSetHttpHeader params;
2519  params.output = output;
2520  params.key = key;
2521  params.value = value;
2522  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2523  }
2524 
2525 
2526  typedef struct
2527  {
2528  char** resultStringToFree;
2529  const char** resultString;
2530  int64_t* resultInt64;
2531  const char* key;
2532  OrthancPluginDicomInstance* instance;
2533  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2534  } _OrthancPluginAccessDicomInstance;
2535 
2536 
2548  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2549  OrthancPluginContext* context,
2550  OrthancPluginDicomInstance* instance)
2551  {
2552  const char* result;
2553 
2554  _OrthancPluginAccessDicomInstance params;
2555  memset(&params, 0, sizeof(params));
2556  params.resultString = &result;
2557  params.instance = instance;
2558 
2559  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2560  {
2561  /* Error */
2562  return NULL;
2563  }
2564  else
2565  {
2566  return result;
2567  }
2568  }
2569 
2570 
2581  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2582  OrthancPluginContext* context,
2583  OrthancPluginDicomInstance* instance)
2584  {
2585  int64_t size;
2586 
2587  _OrthancPluginAccessDicomInstance params;
2588  memset(&params, 0, sizeof(params));
2589  params.resultInt64 = &size;
2590  params.instance = instance;
2591 
2592  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2593  {
2594  /* Error */
2595  return -1;
2596  }
2597  else
2598  {
2599  return size;
2600  }
2601  }
2602 
2603 
2614  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceData(
2615  OrthancPluginContext* context,
2616  OrthancPluginDicomInstance* instance)
2617  {
2618  const char* result;
2619 
2620  _OrthancPluginAccessDicomInstance params;
2621  memset(&params, 0, sizeof(params));
2622  params.resultString = &result;
2623  params.instance = instance;
2624 
2625  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2626  {
2627  /* Error */
2628  return NULL;
2629  }
2630  else
2631  {
2632  return result;
2633  }
2634  }
2635 
2636 
2650  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
2651  OrthancPluginContext* context,
2652  OrthancPluginDicomInstance* instance)
2653  {
2654  char* result;
2655 
2656  _OrthancPluginAccessDicomInstance params;
2657  memset(&params, 0, sizeof(params));
2658  params.resultStringToFree = &result;
2659  params.instance = instance;
2660 
2661  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
2662  {
2663  /* Error */
2664  return NULL;
2665  }
2666  else
2667  {
2668  return result;
2669  }
2670  }
2671 
2672 
2688  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
2689  OrthancPluginContext* context,
2690  OrthancPluginDicomInstance* instance)
2691  {
2692  char* result;
2693 
2694  _OrthancPluginAccessDicomInstance params;
2695  memset(&params, 0, sizeof(params));
2696  params.resultStringToFree = &result;
2697  params.instance = instance;
2698 
2699  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
2700  {
2701  /* Error */
2702  return NULL;
2703  }
2704  else
2705  {
2706  return result;
2707  }
2708  }
2709 
2710 
2727  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
2728  OrthancPluginContext* context,
2729  OrthancPluginDicomInstance* instance,
2730  const char* metadata)
2731  {
2732  int64_t result;
2733 
2734  _OrthancPluginAccessDicomInstance params;
2735  memset(&params, 0, sizeof(params));
2736  params.resultInt64 = &result;
2737  params.instance = instance;
2738  params.key = metadata;
2739 
2740  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2741  {
2742  /* Error */
2743  return -1;
2744  }
2745  else
2746  {
2747  return (result != 0);
2748  }
2749  }
2750 
2751 
2765  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
2766  OrthancPluginContext* context,
2767  OrthancPluginDicomInstance* instance,
2768  const char* metadata)
2769  {
2770  const char* result;
2771 
2772  _OrthancPluginAccessDicomInstance params;
2773  memset(&params, 0, sizeof(params));
2774  params.resultString = &result;
2775  params.instance = instance;
2776  params.key = metadata;
2777 
2778  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2779  {
2780  /* Error */
2781  return NULL;
2782  }
2783  else
2784  {
2785  return result;
2786  }
2787  }
2788 
2789 
2790 
2791  typedef struct
2792  {
2796  OrthancPluginFree free;
2797  } _OrthancPluginRegisterStorageArea;
2798 
2813  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
2814  OrthancPluginContext* context,
2818  {
2819  _OrthancPluginRegisterStorageArea params;
2820  params.create = create;
2821  params.read = read;
2822  params.remove = remove;
2823 
2824 #ifdef __cplusplus
2825  params.free = ::free;
2826 #else
2827  params.free = free;
2828 #endif
2829 
2830  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
2831  }
2832 
2833 
2834 
2845  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
2846  {
2847  char* result;
2848 
2849  _OrthancPluginRetrieveDynamicString params;
2850  params.result = &result;
2851  params.argument = NULL;
2852 
2853  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
2854  {
2855  /* Error */
2856  return NULL;
2857  }
2858  else
2859  {
2860  return result;
2861  }
2862  }
2863 
2864 
2875  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
2876  {
2877  char* result;
2878 
2879  _OrthancPluginRetrieveDynamicString params;
2880  params.result = &result;
2881  params.argument = NULL;
2882 
2883  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
2884  {
2885  /* Error */
2886  return NULL;
2887  }
2888  else
2889  {
2890  return result;
2891  }
2892  }
2893 
2894 
2910  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
2911  {
2912  char* result;
2913 
2914  _OrthancPluginRetrieveDynamicString params;
2915  params.result = &result;
2916  params.argument = NULL;
2917 
2918  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
2919  {
2920  /* Error */
2921  return NULL;
2922  }
2923  else
2924  {
2925  return result;
2926  }
2927  }
2928 
2929 
2930 
2931  typedef struct
2932  {
2934  } _OrthancPluginOnChangeCallback;
2935 
2952  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
2953  OrthancPluginContext* context,
2955  {
2956  _OrthancPluginOnChangeCallback params;
2957  params.callback = callback;
2958 
2959  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
2960  }
2961 
2962 
2963 
2964  typedef struct
2965  {
2966  const char* plugin;
2967  _OrthancPluginProperty property;
2968  const char* value;
2969  } _OrthancPluginSetPluginProperty;
2970 
2971 
2983  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
2984  OrthancPluginContext* context,
2985  const char* uri)
2986  {
2987  _OrthancPluginSetPluginProperty params;
2988  params.plugin = OrthancPluginGetName();
2989  params.property = _OrthancPluginProperty_RootUri;
2990  params.value = uri;
2991 
2992  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2993  }
2994 
2995 
3005  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3006  OrthancPluginContext* context,
3007  const char* description)
3008  {
3009  _OrthancPluginSetPluginProperty params;
3010  params.plugin = OrthancPluginGetName();
3011  params.property = _OrthancPluginProperty_Description;
3012  params.value = description;
3013 
3014  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3015  }
3016 
3017 
3027  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3028  OrthancPluginContext* context,
3029  const char* javascript)
3030  {
3031  _OrthancPluginSetPluginProperty params;
3032  params.plugin = OrthancPluginGetName();
3033  params.property = _OrthancPluginProperty_OrthancExplorer;
3034  params.value = javascript;
3035 
3036  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3037  }
3038 
3039 
3040  typedef struct
3041  {
3042  char** result;
3043  int32_t property;
3044  const char* value;
3045  } _OrthancPluginGlobalProperty;
3046 
3047 
3061  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3062  OrthancPluginContext* context,
3063  int32_t property,
3064  const char* defaultValue)
3065  {
3066  char* result;
3067 
3068  _OrthancPluginGlobalProperty params;
3069  params.result = &result;
3070  params.property = property;
3071  params.value = defaultValue;
3072 
3073  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3074  {
3075  /* Error */
3076  return NULL;
3077  }
3078  else
3079  {
3080  return result;
3081  }
3082  }
3083 
3084 
3101  OrthancPluginContext* context,
3102  int32_t property,
3103  const char* value)
3104  {
3105  _OrthancPluginGlobalProperty params;
3106  params.result = NULL;
3107  params.property = property;
3108  params.value = value;
3109 
3110  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3111  }
3112 
3113 
3114 
3115  typedef struct
3116  {
3117  int32_t *resultInt32;
3118  uint32_t *resultUint32;
3119  int64_t *resultInt64;
3120  uint64_t *resultUint64;
3121  } _OrthancPluginReturnSingleValue;
3122 
3131  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3132  OrthancPluginContext* context)
3133  {
3134  uint32_t count = 0;
3135 
3136  _OrthancPluginReturnSingleValue params;
3137  memset(&params, 0, sizeof(params));
3138  params.resultUint32 = &count;
3139 
3140  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3141  {
3142  /* Error */
3143  return 0;
3144  }
3145  else
3146  {
3147  return count;
3148  }
3149  }
3150 
3151 
3152 
3165  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3166  OrthancPluginContext* context,
3167  uint32_t argument)
3168  {
3169  char* result;
3170 
3171  _OrthancPluginGlobalProperty params;
3172  params.result = &result;
3173  params.property = (int32_t) argument;
3174  params.value = NULL;
3175 
3176  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3177  {
3178  /* Error */
3179  return NULL;
3180  }
3181  else
3182  {
3183  return result;
3184  }
3185  }
3186 
3187 
3197  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3198  OrthancPluginContext* context)
3199  {
3200  uint32_t count = 0;
3201 
3202  _OrthancPluginReturnSingleValue params;
3203  memset(&params, 0, sizeof(params));
3204  params.resultUint32 = &count;
3205 
3206  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3207  {
3208  /* Error */
3209  return 0;
3210  }
3211  else
3212  {
3213  return count;
3214  }
3215  }
3216 
3217 
3218 
3230  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3231  {
3232  char* result;
3233 
3234  _OrthancPluginRetrieveDynamicString params;
3235  params.result = &result;
3236  params.argument = NULL;
3237 
3238  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3239  {
3240  /* Error */
3241  return NULL;
3242  }
3243  else
3244  {
3245  return result;
3246  }
3247  }
3248 
3249 
3250 
3251  typedef struct
3252  {
3253  OrthancPluginRestOutput* output;
3254  const char* subType;
3255  const char* contentType;
3256  } _OrthancPluginStartMultipartAnswer;
3257 
3272  OrthancPluginContext* context,
3273  OrthancPluginRestOutput* output,
3274  const char* subType,
3275  const char* contentType)
3276  {
3277  _OrthancPluginStartMultipartAnswer params;
3278  params.output = output;
3279  params.subType = subType;
3280  params.contentType = contentType;
3281  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3282  }
3283 
3284 
3301  OrthancPluginContext* context,
3302  OrthancPluginRestOutput* output,
3303  const char* answer,
3304  uint32_t answerSize)
3305  {
3306  _OrthancPluginAnswerBuffer params;
3307  params.output = output;
3308  params.answer = answer;
3309  params.answerSize = answerSize;
3310  params.mimeType = NULL;
3311  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3312  }
3313 
3314 
3315 
3316  typedef struct
3317  {
3318  OrthancPluginMemoryBuffer* target;
3319  const void* source;
3320  uint32_t size;
3321  OrthancPluginCompressionType compression;
3322  uint8_t uncompress;
3323  } _OrthancPluginBufferCompression;
3324 
3325 
3343  OrthancPluginContext* context,
3344  OrthancPluginMemoryBuffer* target,
3345  const void* source,
3346  uint32_t size,
3347  OrthancPluginCompressionType compression,
3348  uint8_t uncompress)
3349  {
3350  _OrthancPluginBufferCompression params;
3351  params.target = target;
3352  params.source = source;
3353  params.size = size;
3354  params.compression = compression;
3355  params.uncompress = uncompress;
3356 
3357  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3358  }
3359 
3360 
3361 
3362  typedef struct
3363  {
3364  OrthancPluginMemoryBuffer* target;
3365  const char* path;
3366  } _OrthancPluginReadFile;
3367 
3380  OrthancPluginContext* context,
3381  OrthancPluginMemoryBuffer* target,
3382  const char* path)
3383  {
3384  _OrthancPluginReadFile params;
3385  params.target = target;
3386  params.path = path;
3387  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3388  }
3389 
3390 
3391 
3392  typedef struct
3393  {
3394  const char* path;
3395  const void* data;
3396  uint32_t size;
3397  } _OrthancPluginWriteFile;
3398 
3411  OrthancPluginContext* context,
3412  const char* path,
3413  const void* data,
3414  uint32_t size)
3415  {
3416  _OrthancPluginWriteFile params;
3417  params.path = path;
3418  params.data = data;
3419  params.size = size;
3420  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3421  }
3422 
3423 
3424 
3425  typedef struct
3426  {
3427  const char** target;
3428  OrthancPluginErrorCode error;
3429  } _OrthancPluginGetErrorDescription;
3430 
3441  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3442  OrthancPluginContext* context,
3443  OrthancPluginErrorCode error)
3444  {
3445  const char* result = NULL;
3446 
3447  _OrthancPluginGetErrorDescription params;
3448  params.target = &result;
3449  params.error = error;
3450 
3451  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3452  result == NULL)
3453  {
3454  return "Unknown error code";
3455  }
3456  else
3457  {
3458  return result;
3459  }
3460  }
3461 
3462 
3463 
3464  typedef struct
3465  {
3466  OrthancPluginRestOutput* output;
3467  uint16_t status;
3468  const char* body;
3469  uint32_t bodySize;
3470  } _OrthancPluginSendHttpStatus;
3471 
3494  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3495  OrthancPluginContext* context,
3496  OrthancPluginRestOutput* output,
3497  uint16_t status,
3498  const char* body,
3499  uint32_t bodySize)
3500  {
3501  _OrthancPluginSendHttpStatus params;
3502  params.output = output;
3503  params.status = status;
3504  params.body = body;
3505  params.bodySize = bodySize;
3506  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3507  }
3508 
3509 
3510 
3511  typedef struct
3512  {
3513  const OrthancPluginImage* image;
3514  uint32_t* resultUint32;
3515  OrthancPluginPixelFormat* resultPixelFormat;
3516  void** resultBuffer;
3517  } _OrthancPluginGetImageInfo;
3518 
3519 
3531  OrthancPluginContext* context,
3532  const OrthancPluginImage* image)
3533  {
3534  OrthancPluginPixelFormat target;
3535 
3536  _OrthancPluginGetImageInfo params;
3537  memset(&params, 0, sizeof(params));
3538  params.image = image;
3539  params.resultPixelFormat = &target;
3540 
3541  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3542  {
3544  }
3545  else
3546  {
3547  return (OrthancPluginPixelFormat) target;
3548  }
3549  }
3550 
3551 
3552 
3563  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3564  OrthancPluginContext* context,
3565  const OrthancPluginImage* image)
3566  {
3567  uint32_t width;
3568 
3569  _OrthancPluginGetImageInfo params;
3570  memset(&params, 0, sizeof(params));
3571  params.image = image;
3572  params.resultUint32 = &width;
3573 
3574  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3575  {
3576  return 0;
3577  }
3578  else
3579  {
3580  return width;
3581  }
3582  }
3583 
3584 
3585 
3596  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3597  OrthancPluginContext* context,
3598  const OrthancPluginImage* image)
3599  {
3600  uint32_t height;
3601 
3602  _OrthancPluginGetImageInfo params;
3603  memset(&params, 0, sizeof(params));
3604  params.image = image;
3605  params.resultUint32 = &height;
3606 
3607  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3608  {
3609  return 0;
3610  }
3611  else
3612  {
3613  return height;
3614  }
3615  }
3616 
3617 
3618 
3631  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3632  OrthancPluginContext* context,
3633  const OrthancPluginImage* image)
3634  {
3635  uint32_t pitch;
3636 
3637  _OrthancPluginGetImageInfo params;
3638  memset(&params, 0, sizeof(params));
3639  params.image = image;
3640  params.resultUint32 = &pitch;
3641 
3642  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
3643  {
3644  return 0;
3645  }
3646  else
3647  {
3648  return pitch;
3649  }
3650  }
3651 
3652 
3653 
3665  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
3666  OrthancPluginContext* context,
3667  const OrthancPluginImage* image)
3668  {
3669  void* target = NULL;
3670 
3671  _OrthancPluginGetImageInfo params;
3672  memset(&params, 0, sizeof(params));
3673  params.resultBuffer = &target;
3674  params.image = image;
3675 
3676  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
3677  {
3678  return NULL;
3679  }
3680  else
3681  {
3682  return target;
3683  }
3684  }
3685 
3686 
3687  typedef struct
3688  {
3689  OrthancPluginImage** target;
3690  const void* data;
3691  uint32_t size;
3692  OrthancPluginImageFormat format;
3693  } _OrthancPluginUncompressImage;
3694 
3695 
3709  OrthancPluginContext* context,
3710  const void* data,
3711  uint32_t size,
3712  OrthancPluginImageFormat format)
3713  {
3714  OrthancPluginImage* target = NULL;
3715 
3716  _OrthancPluginUncompressImage params;
3717  memset(&params, 0, sizeof(params));
3718  params.target = &target;
3719  params.data = data;
3720  params.size = size;
3721  params.format = format;
3722 
3723  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
3724  {
3725  return NULL;
3726  }
3727  else
3728  {
3729  return target;
3730  }
3731  }
3732 
3733 
3734 
3735 
3736  typedef struct
3737  {
3738  OrthancPluginImage* image;
3739  } _OrthancPluginFreeImage;
3740 
3750  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
3751  OrthancPluginContext* context,
3752  OrthancPluginImage* image)
3753  {
3754  _OrthancPluginFreeImage params;
3755  params.image = image;
3756 
3757  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
3758  }
3759 
3760 
3761 
3762 
3763  typedef struct
3764  {
3765  OrthancPluginMemoryBuffer* target;
3766  OrthancPluginImageFormat imageFormat;
3767  OrthancPluginPixelFormat pixelFormat;
3768  uint32_t width;
3769  uint32_t height;
3770  uint32_t pitch;
3771  const void* buffer;
3772  uint8_t quality;
3773  } _OrthancPluginCompressImage;
3774 
3775 
3796  OrthancPluginContext* context,
3797  OrthancPluginMemoryBuffer* target,
3798  OrthancPluginPixelFormat format,
3799  uint32_t width,
3800  uint32_t height,
3801  uint32_t pitch,
3802  const void* buffer)
3803  {
3804  _OrthancPluginCompressImage params;
3805  memset(&params, 0, sizeof(params));
3806  params.target = target;
3807  params.imageFormat = OrthancPluginImageFormat_Png;
3808  params.pixelFormat = format;
3809  params.width = width;
3810  params.height = height;
3811  params.pitch = pitch;
3812  params.buffer = buffer;
3813  params.quality = 0; /* Unused for PNG */
3814 
3815  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3816  }
3817 
3818 
3841  OrthancPluginContext* context,
3842  OrthancPluginMemoryBuffer* target,
3843  OrthancPluginPixelFormat format,
3844  uint32_t width,
3845  uint32_t height,
3846  uint32_t pitch,
3847  const void* buffer,
3848  uint8_t quality)
3849  {
3850  _OrthancPluginCompressImage params;
3851  memset(&params, 0, sizeof(params));
3852  params.target = target;
3853  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3854  params.pixelFormat = format;
3855  params.width = width;
3856  params.height = height;
3857  params.pitch = pitch;
3858  params.buffer = buffer;
3859  params.quality = quality;
3860 
3861  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3862  }
3863 
3864 
3865 
3887  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
3888  OrthancPluginContext* context,
3889  OrthancPluginRestOutput* output,
3890  OrthancPluginPixelFormat format,
3891  uint32_t width,
3892  uint32_t height,
3893  uint32_t pitch,
3894  const void* buffer,
3895  uint8_t quality)
3896  {
3897  _OrthancPluginCompressAndAnswerImage params;
3898  params.output = output;
3899  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3900  params.pixelFormat = format;
3901  params.width = width;
3902  params.height = height;
3903  params.pitch = pitch;
3904  params.buffer = buffer;
3905  params.quality = quality;
3906  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
3907  }
3908 
3909 
3910 
3911 
3912  typedef struct
3913  {
3914  OrthancPluginMemoryBuffer* target;
3915  OrthancPluginHttpMethod method;
3916  const char* url;
3917  const char* username;
3918  const char* password;
3919  const char* body;
3920  uint32_t bodySize;
3921  } _OrthancPluginCallHttpClient;
3922 
3923 
3940  OrthancPluginContext* context,
3941  OrthancPluginMemoryBuffer* target,
3942  const char* url,
3943  const char* username,
3944  const char* password)
3945  {
3946  _OrthancPluginCallHttpClient params;
3947  memset(&params, 0, sizeof(params));
3948 
3949  params.target = target;
3950  params.method = OrthancPluginHttpMethod_Get;
3951  params.url = url;
3952  params.username = username;
3953  params.password = password;
3954 
3955  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3956  }
3957 
3958 
3977  OrthancPluginContext* context,
3978  OrthancPluginMemoryBuffer* target,
3979  const char* url,
3980  const char* body,
3981  uint32_t bodySize,
3982  const char* username,
3983  const char* password)
3984  {
3985  _OrthancPluginCallHttpClient params;
3986  memset(&params, 0, sizeof(params));
3987 
3988  params.target = target;
3989  params.method = OrthancPluginHttpMethod_Post;
3990  params.url = url;
3991  params.body = body;
3992  params.bodySize = bodySize;
3993  params.username = username;
3994  params.password = password;
3995 
3996  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3997  }
3998 
3999 
4018  OrthancPluginContext* context,
4019  OrthancPluginMemoryBuffer* target,
4020  const char* url,
4021  const char* body,
4022  uint32_t bodySize,
4023  const char* username,
4024  const char* password)
4025  {
4026  _OrthancPluginCallHttpClient params;
4027  memset(&params, 0, sizeof(params));
4028 
4029  params.target = target;
4030  params.method = OrthancPluginHttpMethod_Put;
4031  params.url = url;
4032  params.body = body;
4033  params.bodySize = bodySize;
4034  params.username = username;
4035  params.password = password;
4036 
4037  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4038  }
4039 
4040 
4055  OrthancPluginContext* context,
4056  const char* url,
4057  const char* username,
4058  const char* password)
4059  {
4060  _OrthancPluginCallHttpClient params;
4061  memset(&params, 0, sizeof(params));
4062 
4063  params.method = OrthancPluginHttpMethod_Delete;
4064  params.url = url;
4065  params.username = username;
4066  params.password = password;
4067 
4068  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4069  }
4070 
4071 
4072 
4073  typedef struct
4074  {
4075  OrthancPluginImage** target;
4076  const OrthancPluginImage* source;
4077  OrthancPluginPixelFormat targetFormat;
4078  } _OrthancPluginConvertPixelFormat;
4079 
4080 
4093  OrthancPluginContext* context,
4094  const OrthancPluginImage* source,
4095  OrthancPluginPixelFormat targetFormat)
4096  {
4097  OrthancPluginImage* target = NULL;
4098 
4099  _OrthancPluginConvertPixelFormat params;
4100  params.target = &target;
4101  params.source = source;
4102  params.targetFormat = targetFormat;
4103 
4104  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4105  {
4106  return NULL;
4107  }
4108  else
4109  {
4110  return target;
4111  }
4112  }
4113 
4114 
4115 
4127  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4128  OrthancPluginContext* context)
4129  {
4130  uint32_t count = 0;
4131 
4132  _OrthancPluginReturnSingleValue params;
4133  memset(&params, 0, sizeof(params));
4134  params.resultUint32 = &count;
4135 
4136  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4137  {
4138  /* Error */
4139  return 0;
4140  }
4141  else
4142  {
4143  return count;
4144  }
4145  }
4146 
4147 
4148 
4149 
4150  typedef struct
4151  {
4152  uint32_t fontIndex; /* in */
4153  const char** name; /* out */
4154  uint32_t* size; /* out */
4155  } _OrthancPluginGetFontInfo;
4156 
4167  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4168  OrthancPluginContext* context,
4169  uint32_t fontIndex)
4170  {
4171  const char* result = NULL;
4172 
4173  _OrthancPluginGetFontInfo params;
4174  memset(&params, 0, sizeof(params));
4175  params.name = &result;
4176  params.fontIndex = fontIndex;
4177 
4178  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4179  {
4180  return NULL;
4181  }
4182  else
4183  {
4184  return result;
4185  }
4186  }
4187 
4188 
4199  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4200  OrthancPluginContext* context,
4201  uint32_t fontIndex)
4202  {
4203  uint32_t result;
4204 
4205  _OrthancPluginGetFontInfo params;
4206  memset(&params, 0, sizeof(params));
4207  params.size = &result;
4208  params.fontIndex = fontIndex;
4209 
4210  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4211  {
4212  return 0;
4213  }
4214  else
4215  {
4216  return result;
4217  }
4218  }
4219 
4220 
4221 
4222  typedef struct
4223  {
4224  OrthancPluginImage* image;
4225  uint32_t fontIndex;
4226  const char* utf8Text;
4227  int32_t x;
4228  int32_t y;
4229  uint8_t r;
4230  uint8_t g;
4231  uint8_t b;
4232  } _OrthancPluginDrawText;
4233 
4234 
4253  OrthancPluginContext* context,
4254  OrthancPluginImage* image,
4255  uint32_t fontIndex,
4256  const char* utf8Text,
4257  int32_t x,
4258  int32_t y,
4259  uint8_t r,
4260  uint8_t g,
4261  uint8_t b)
4262  {
4263  _OrthancPluginDrawText params;
4264  memset(&params, 0, sizeof(params));
4265  params.image = image;
4266  params.fontIndex = fontIndex;
4267  params.utf8Text = utf8Text;
4268  params.x = x;
4269  params.y = y;
4270  params.r = r;
4271  params.g = g;
4272  params.b = b;
4273 
4274  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4275  }
4276 
4277 
4278 
4279  typedef struct
4280  {
4281  OrthancPluginStorageArea* storageArea;
4282  const char* uuid;
4283  const void* content;
4284  uint64_t size;
4286  } _OrthancPluginStorageAreaCreate;
4287 
4288 
4305  OrthancPluginContext* context,
4306  OrthancPluginStorageArea* storageArea,
4307  const char* uuid,
4308  const void* content,
4309  uint64_t size,
4311  {
4312  _OrthancPluginStorageAreaCreate params;
4313  params.storageArea = storageArea;
4314  params.uuid = uuid;
4315  params.content = content;
4316  params.size = size;
4317  params.type = type;
4318 
4319  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4320  }
4321 
4322 
4323  typedef struct
4324  {
4325  OrthancPluginMemoryBuffer* target;
4326  OrthancPluginStorageArea* storageArea;
4327  const char* uuid;
4329  } _OrthancPluginStorageAreaRead;
4330 
4331 
4347  OrthancPluginContext* context,
4348  OrthancPluginMemoryBuffer* target,
4349  OrthancPluginStorageArea* storageArea,
4350  const char* uuid,
4352  {
4353  _OrthancPluginStorageAreaRead params;
4354  params.target = target;
4355  params.storageArea = storageArea;
4356  params.uuid = uuid;
4357  params.type = type;
4358 
4359  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4360  }
4361 
4362 
4363  typedef struct
4364  {
4365  OrthancPluginStorageArea* storageArea;
4366  const char* uuid;
4368  } _OrthancPluginStorageAreaRemove;
4369 
4384  OrthancPluginContext* context,
4385  OrthancPluginStorageArea* storageArea,
4386  const char* uuid,
4388  {
4389  _OrthancPluginStorageAreaRemove params;
4390  params.storageArea = storageArea;
4391  params.uuid = uuid;
4392  params.type = type;
4393 
4394  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4395  }
4396 
4397 
4398 
4399  typedef struct
4400  {
4401  OrthancPluginErrorCode* target;
4402  int32_t code;
4403  uint16_t httpStatus;
4404  const char* message;
4405  } _OrthancPluginRegisterErrorCode;
4406 
4423  OrthancPluginContext* context,
4424  int32_t code,
4425  uint16_t httpStatus,
4426  const char* message)
4427  {
4428  OrthancPluginErrorCode target;
4429 
4430  _OrthancPluginRegisterErrorCode params;
4431  params.target = &target;
4432  params.code = code;
4433  params.httpStatus = httpStatus;
4434  params.message = message;
4435 
4436  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4437  {
4438  return target;
4439  }
4440  else
4441  {
4442  /* There was an error while assigned the error. Use a generic code. */
4444  }
4445  }
4446 
4447 
4448 
4449  typedef struct
4450  {
4451  uint16_t group;
4452  uint16_t element;
4454  const char* name;
4455  uint32_t minMultiplicity;
4456  uint32_t maxMultiplicity;
4457  } _OrthancPluginRegisterDictionaryTag;
4458 
4479  OrthancPluginContext* context,
4480  uint16_t group,
4481  uint16_t element,
4483  const char* name,
4484  uint32_t minMultiplicity,
4485  uint32_t maxMultiplicity)
4486  {
4487  _OrthancPluginRegisterDictionaryTag params;
4488  params.group = group;
4489  params.element = element;
4490  params.vr = vr;
4491  params.name = name;
4492  params.minMultiplicity = minMultiplicity;
4493  params.maxMultiplicity = maxMultiplicity;
4494 
4495  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4496  }
4497 
4498 
4499 
4500  typedef struct
4501  {
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  } _OrthancPluginRegisterPrivateDictionaryTag;
4510 
4532  OrthancPluginContext* context,
4533  uint16_t group,
4534  uint16_t element,
4536  const char* name,
4537  uint32_t minMultiplicity,
4538  uint32_t maxMultiplicity,
4539  const char* privateCreator)
4540  {
4541  _OrthancPluginRegisterPrivateDictionaryTag params;
4542  params.group = group;
4543  params.element = element;
4544  params.vr = vr;
4545  params.name = name;
4546  params.minMultiplicity = minMultiplicity;
4547  params.maxMultiplicity = maxMultiplicity;
4548  params.privateCreator = privateCreator;
4549 
4550  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4551  }
4552 
4553 
4554 
4555  typedef struct
4556  {
4557  OrthancPluginStorageArea* storageArea;
4559  } _OrthancPluginReconstructMainDicomTags;
4560 
4576  OrthancPluginContext* context,
4577  OrthancPluginStorageArea* storageArea,
4579  {
4580  _OrthancPluginReconstructMainDicomTags params;
4581  params.level = level;
4582  params.storageArea = storageArea;
4583 
4584  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
4585  }
4586 
4587 
4588  typedef struct
4589  {
4590  char** result;
4591  const char* instanceId;
4592  const void* buffer;
4593  uint32_t size;
4596  uint32_t maxStringLength;
4597  } _OrthancPluginDicomToJson;
4598 
4599 
4619  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4620  OrthancPluginContext* context,
4621  const void* buffer,
4622  uint32_t size,
4625  uint32_t maxStringLength)
4626  {
4627  char* result;
4628 
4629  _OrthancPluginDicomToJson params;
4630  memset(&params, 0, sizeof(params));
4631  params.result = &result;
4632  params.buffer = buffer;
4633  params.size = size;
4634  params.format = format;
4635  params.flags = flags;
4636  params.maxStringLength = maxStringLength;
4637 
4638  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
4639  {
4640  /* Error */
4641  return NULL;
4642  }
4643  else
4644  {
4645  return result;
4646  }
4647  }
4648 
4649 
4668  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
4669  OrthancPluginContext* context,
4670  const char* instanceId,
4673  uint32_t maxStringLength)
4674  {
4675  char* result;
4676 
4677  _OrthancPluginDicomToJson params;
4678  memset(&params, 0, sizeof(params));
4679  params.result = &result;
4680  params.instanceId = instanceId;
4681  params.format = format;
4682  params.flags = flags;
4683  params.maxStringLength = maxStringLength;
4684 
4685  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
4686  {
4687  /* Error */
4688  return NULL;
4689  }
4690  else
4691  {
4692  return result;
4693  }
4694  }
4695 
4696 
4697  typedef struct
4698  {
4699  OrthancPluginMemoryBuffer* target;
4700  const char* uri;
4701  uint32_t headersCount;
4702  const char* const* headersKeys;
4703  const char* const* headersValues;
4704  int32_t afterPlugins;
4705  } _OrthancPluginRestApiGet2;
4706 
4727  OrthancPluginContext* context,
4728  OrthancPluginMemoryBuffer* target,
4729  const char* uri,
4730  uint32_t headersCount,
4731  const char* const* headersKeys,
4732  const char* const* headersValues,
4733  int32_t afterPlugins)
4734  {
4735  _OrthancPluginRestApiGet2 params;
4736  params.target = target;
4737  params.uri = uri;
4738  params.headersCount = headersCount;
4739  params.headersKeys = headersKeys;
4740  params.headersValues = headersValues;
4741  params.afterPlugins = afterPlugins;
4742 
4743  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
4744  }
4745 
4746 
4747 
4748  typedef struct
4749  {
4751  } _OrthancPluginWorklistCallback;
4752 
4765  OrthancPluginContext* context,
4767  {
4768  _OrthancPluginWorklistCallback params;
4769  params.callback = callback;
4770 
4771  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
4772  }
4773 
4774 
4775 
4776  typedef struct
4777  {
4779  const OrthancPluginWorklistQuery* query;
4780  const void* dicom;
4781  uint32_t size;
4782  } _OrthancPluginWorklistAnswersOperation;
4783 
4801  OrthancPluginContext* context,
4803  const OrthancPluginWorklistQuery* query,
4804  const void* dicom,
4805  uint32_t size)
4806  {
4807  _OrthancPluginWorklistAnswersOperation params;
4808  params.answers = answers;
4809  params.query = query;
4810  params.dicom = dicom;
4811  params.size = size;
4812 
4813  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
4814  }
4815 
4816 
4831  OrthancPluginContext* context,
4833  {
4834  _OrthancPluginWorklistAnswersOperation params;
4835  params.answers = answers;
4836  params.query = NULL;
4837  params.dicom = NULL;
4838  params.size = 0;
4839 
4840  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
4841  }
4842 
4843 
4844  typedef struct
4845  {
4846  const OrthancPluginWorklistQuery* query;
4847  const void* dicom;
4848  uint32_t size;
4849  int32_t* isMatch;
4850  OrthancPluginMemoryBuffer* target;
4851  } _OrthancPluginWorklistQueryOperation;
4852 
4868  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
4869  OrthancPluginContext* context,
4870  const OrthancPluginWorklistQuery* query,
4871  const void* dicom,
4872  uint32_t size)
4873  {
4874  int32_t isMatch = 0;
4875 
4876  _OrthancPluginWorklistQueryOperation params;
4877  params.query = query;
4878  params.dicom = dicom;
4879  params.size = size;
4880  params.isMatch = &isMatch;
4881  params.target = NULL;
4882 
4883  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
4884  {
4885  return isMatch;
4886  }
4887  else
4888  {
4889  /* Error: Assume non-match */
4890  return 0;
4891  }
4892  }
4893 
4894 
4908  OrthancPluginContext* context,
4909  OrthancPluginMemoryBuffer* target,
4910  const OrthancPluginWorklistQuery* query)
4911  {
4912  _OrthancPluginWorklistQueryOperation params;
4913  params.query = query;
4914  params.dicom = NULL;
4915  params.size = 0;
4916  params.isMatch = NULL;
4917  params.target = target;
4918 
4919  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
4920  }
4921 
4922 
4934  OrthancPluginContext* context,
4935  OrthancPluginDicomInstance* instance)
4936  {
4938 
4939  _OrthancPluginAccessDicomInstance params;
4940  memset(&params, 0, sizeof(params));
4941  params.resultOrigin = &origin;
4942  params.instance = instance;
4943 
4944  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
4945  {
4946  /* Error */
4948  }
4949  else
4950  {
4951  return origin;
4952  }
4953  }
4954 
4955 
4956  typedef struct
4957  {
4958  OrthancPluginMemoryBuffer* target;
4959  const char* json;
4960  const OrthancPluginImage* pixelData;
4962  } _OrthancPluginCreateDicom;
4963 
4983  OrthancPluginContext* context,
4984  OrthancPluginMemoryBuffer* target,
4985  const char* json,
4986  const OrthancPluginImage* pixelData,
4988  {
4989  _OrthancPluginCreateDicom params;
4990  params.target = target;
4991  params.json = json;
4992  params.pixelData = pixelData;
4993  params.flags = flags;
4994 
4995  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
4996  }
4997 
4998 
4999  typedef struct
5000  {
5002  } _OrthancPluginDecodeImageCallback;
5003 
5016  OrthancPluginContext* context,
5018  {
5019  _OrthancPluginDecodeImageCallback params;
5020  params.callback = callback;
5021 
5022  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5023  }
5024 
5025 
5026 
5027  typedef struct
5028  {
5029  OrthancPluginImage** target;
5030  OrthancPluginPixelFormat format;
5031  uint32_t width;
5032  uint32_t height;
5033  uint32_t pitch;
5034  void* buffer;
5035  const void* constBuffer;
5036  uint32_t bufferSize;
5037  uint32_t frameIndex;
5038  } _OrthancPluginCreateImage;
5039 
5040 
5054  OrthancPluginContext* context,
5055  OrthancPluginPixelFormat format,
5056  uint32_t width,
5057  uint32_t height)
5058  {
5059  OrthancPluginImage* target = NULL;
5060 
5061  _OrthancPluginCreateImage params;
5062  memset(&params, 0, sizeof(params));
5063  params.target = &target;
5064  params.format = format;
5065  params.width = width;
5066  params.height = height;
5067 
5068  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5069  {
5070  return NULL;
5071  }
5072  else
5073  {
5074  return target;
5075  }
5076  }
5077 
5078 
5097  OrthancPluginContext* context,
5098  OrthancPluginPixelFormat format,
5099  uint32_t width,
5100  uint32_t height,
5101  uint32_t pitch,
5102  void* buffer)
5103  {
5104  OrthancPluginImage* target = NULL;
5105 
5106  _OrthancPluginCreateImage params;
5107  memset(&params, 0, sizeof(params));
5108  params.target = &target;
5109  params.format = format;
5110  params.width = width;
5111  params.height = height;
5112  params.pitch = pitch;
5113  params.buffer = buffer;
5114 
5115  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5116  {
5117  return NULL;
5118  }
5119  else
5120  {
5121  return target;
5122  }
5123  }
5124 
5125 
5126 
5142  OrthancPluginContext* context,
5143  const void* buffer,
5144  uint32_t bufferSize,
5145  uint32_t frameIndex)
5146  {
5147  OrthancPluginImage* target = NULL;
5148 
5149  _OrthancPluginCreateImage params;
5150  memset(&params, 0, sizeof(params));
5151  params.target = &target;
5152  params.constBuffer = buffer;
5153  params.bufferSize = bufferSize;
5154  params.frameIndex = frameIndex;
5155 
5156  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5157  {
5158  return NULL;
5159  }
5160  else
5161  {
5162  return target;
5163  }
5164  }
5165 
5166 
5167 
5168  typedef struct
5169  {
5170  char** result;
5171  const void* buffer;
5172  uint32_t size;
5173  } _OrthancPluginComputeHash;
5174 
5187  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5188  OrthancPluginContext* context,
5189  const void* buffer,
5190  uint32_t size)
5191  {
5192  char* result;
5193 
5194  _OrthancPluginComputeHash params;
5195  params.result = &result;
5196  params.buffer = buffer;
5197  params.size = size;
5198 
5199  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5200  {
5201  /* Error */
5202  return NULL;
5203  }
5204  else
5205  {
5206  return result;
5207  }
5208  }
5209 
5210 
5223  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5224  OrthancPluginContext* context,
5225  const void* buffer,
5226  uint32_t size)
5227  {
5228  char* result;
5229 
5230  _OrthancPluginComputeHash params;
5231  params.result = &result;
5232  params.buffer = buffer;
5233  params.size = size;
5234 
5235  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5236  {
5237  /* Error */
5238  return NULL;
5239  }
5240  else
5241  {
5242  return result;
5243  }
5244  }
5245 
5246 
5247 
5248  typedef struct
5249  {
5251  const char* name;
5252  } _OrthancPluginLookupDictionary;
5253 
5270  OrthancPluginContext* context,
5272  const char* name)
5273  {
5274  _OrthancPluginLookupDictionary params;
5275  params.target = target;
5276  params.name = name;
5277  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5278  }
5279 
5280 
5281 
5282  typedef struct
5283  {
5284  OrthancPluginRestOutput* output;
5285  const char* answer;
5286  uint32_t answerSize;
5287  uint32_t headersCount;
5288  const char* const* headersKeys;
5289  const char* const* headersValues;
5290  } _OrthancPluginSendMultipartItem2;
5291 
5313  OrthancPluginContext* context,
5314  OrthancPluginRestOutput* output,
5315  const char* answer,
5316  uint32_t answerSize,
5317  uint32_t headersCount,
5318  const char* const* headersKeys,
5319  const char* const* headersValues)
5320  {
5321  _OrthancPluginSendMultipartItem2 params;
5322  params.output = output;
5323  params.answer = answer;
5324  params.answerSize = answerSize;
5325  params.headersCount = headersCount;
5326  params.headersKeys = headersKeys;
5327  params.headersValues = headersValues;
5328 
5329  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5330  }
5331 
5332 
5333  typedef struct
5334  {
5336  } _OrthancPluginIncomingHttpRequestFilter;
5337 
5351  OrthancPluginContext* context,
5353  {
5354  _OrthancPluginIncomingHttpRequestFilter params;
5355  params.callback = callback;
5356 
5357  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5358  }
5359 
5360 
5361 
5362  typedef struct
5363  {
5364  OrthancPluginMemoryBuffer* answerBody;
5365  OrthancPluginMemoryBuffer* answerHeaders;
5366  uint16_t* httpStatus;
5367  OrthancPluginHttpMethod method;
5368  const char* url;
5369  uint32_t headersCount;
5370  const char* const* headersKeys;
5371  const char* const* headersValues;
5372  const char* body;
5373  uint32_t bodySize;
5374  const char* username;
5375  const char* password;
5376  uint32_t timeout;
5377  const char* certificateFile;
5378  const char* certificateKeyFile;
5379  const char* certificateKeyPassword;
5380  uint8_t pkcs11;
5381  } _OrthancPluginCallHttpClient2;
5382 
5383 
5384 
5424  OrthancPluginContext* context,
5425  OrthancPluginMemoryBuffer* answerBody,
5426  OrthancPluginMemoryBuffer* answerHeaders,
5427  uint16_t* httpStatus,
5428  OrthancPluginHttpMethod method,
5429  const char* url,
5430  uint32_t headersCount,
5431  const char* const* headersKeys,
5432  const char* const* headersValues,
5433  const char* body,
5434  uint32_t bodySize,
5435  const char* username,
5436  const char* password,
5437  uint32_t timeout,
5438  const char* certificateFile,
5439  const char* certificateKeyFile,
5440  const char* certificateKeyPassword,
5441  uint8_t pkcs11)
5442  {
5443  _OrthancPluginCallHttpClient2 params;
5444  memset(&params, 0, sizeof(params));
5445 
5446  params.answerBody = answerBody;
5447  params.answerHeaders = answerHeaders;
5448  params.httpStatus = httpStatus;
5449  params.method = method;
5450  params.url = url;
5451  params.headersCount = headersCount;
5452  params.headersKeys = headersKeys;
5453  params.headersValues = headersValues;
5454  params.body = body;
5455  params.bodySize = bodySize;
5456  params.username = username;
5457  params.password = password;
5458  params.timeout = timeout;
5459  params.certificateFile = certificateFile;
5460  params.certificateKeyFile = certificateKeyFile;
5461  params.certificateKeyPassword = certificateKeyPassword;
5462  params.pkcs11 = pkcs11;
5463 
5464  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5465  }
5466 
5467 
5478  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5479  OrthancPluginContext* context)
5480  {
5481  char* result;
5482 
5483  _OrthancPluginRetrieveDynamicString params;
5484  params.result = &result;
5485  params.argument = NULL;
5486 
5487  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5488  {
5489  /* Error */
5490  return NULL;
5491  }
5492  else
5493  {
5494  return result;
5495  }
5496  }
5497 
5498 
5499 
5500 
5501  typedef struct
5502  {
5503  OrthancPluginFindCallback callback;
5504  } _OrthancPluginFindCallback;
5505 
5518  OrthancPluginContext* context,
5519  OrthancPluginFindCallback callback)
5520  {
5521  _OrthancPluginFindCallback params;
5522  params.callback = callback;
5523 
5524  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5525  }
5526 
5527 
5528  typedef struct
5529  {
5530  OrthancPluginFindAnswers *answers;
5531  const OrthancPluginFindQuery *query;
5532  const void *dicom;
5533  uint32_t size;
5534  uint32_t index;
5535  uint32_t *resultUint32;
5536  uint16_t *resultGroup;
5537  uint16_t *resultElement;
5538  char **resultString;
5539  } _OrthancPluginFindOperation;
5540 
5557  OrthancPluginContext* context,
5558  OrthancPluginFindAnswers* answers,
5559  const void* dicom,
5560  uint32_t size)
5561  {
5562  _OrthancPluginFindOperation params;
5563  memset(&params, 0, sizeof(params));
5564  params.answers = answers;
5565  params.dicom = dicom;
5566  params.size = size;
5567 
5568  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
5569  }
5570 
5571 
5586  OrthancPluginContext* context,
5587  OrthancPluginFindAnswers* answers)
5588  {
5589  _OrthancPluginFindOperation params;
5590  memset(&params, 0, sizeof(params));
5591  params.answers = answers;
5592 
5593  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
5594  }
5595 
5596 
5597 
5609  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
5610  OrthancPluginContext* context,
5611  const OrthancPluginFindQuery* query)
5612  {
5613  uint32_t count = 0;
5614 
5615  _OrthancPluginFindOperation params;
5616  memset(&params, 0, sizeof(params));
5617  params.query = query;
5618  params.resultUint32 = &count;
5619 
5620  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
5621  {
5622  /* Error */
5623  return 0;
5624  }
5625  else
5626  {
5627  return count;
5628  }
5629  }
5630 
5631 
5647  OrthancPluginContext* context,
5648  uint16_t* group,
5649  uint16_t* element,
5650  const OrthancPluginFindQuery* query,
5651  uint32_t index)
5652  {
5653  _OrthancPluginFindOperation params;
5654  memset(&params, 0, sizeof(params));
5655  params.query = query;
5656  params.index = index;
5657  params.resultGroup = group;
5658  params.resultElement = element;
5659 
5660  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
5661  }
5662 
5663 
5677  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
5678  OrthancPluginContext* context,
5679  const OrthancPluginFindQuery* query,
5680  uint32_t index)
5681  {
5682  char* result;
5683 
5684  _OrthancPluginFindOperation params;
5685  memset(&params, 0, sizeof(params));
5686  params.query = query;
5687  params.index = index;
5688  params.resultString = &result;
5689 
5690  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
5691  {
5692  /* Error */
5693  return NULL;
5694  }
5695  else
5696  {
5697  return result;
5698  }
5699  }
5700 
5701 
5715  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
5716  OrthancPluginContext* context,
5717  const OrthancPluginFindQuery* query,
5718  uint32_t index)
5719  {
5720  char* result;
5721 
5722  _OrthancPluginFindOperation params;
5723  memset(&params, 0, sizeof(params));
5724  params.query = query;
5725  params.index = index;
5726  params.resultString = &result;
5727 
5728  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
5729  {
5730  /* Error */
5731  return NULL;
5732  }
5733  else
5734  {
5735  return result;
5736  }
5737  }
5738 
5739 
5740 
5741 
5742  typedef struct
5743  {
5744  OrthancPluginMoveCallback callback;
5745  OrthancPluginGetMoveSize getMoveSize;
5746  OrthancPluginApplyMove applyMove;
5747  OrthancPluginFreeMove freeMove;
5748  } _OrthancPluginMoveCallback;
5749 
5764  OrthancPluginContext* context,
5765  OrthancPluginMoveCallback callback,
5766  OrthancPluginGetMoveSize getMoveSize,
5767  OrthancPluginApplyMove applyMove,
5768  OrthancPluginFreeMove freeMove)
5769  {
5770  _OrthancPluginMoveCallback params;
5771  params.callback = callback;
5772  params.getMoveSize = getMoveSize;
5773  params.applyMove = applyMove;
5774  params.freeMove = freeMove;
5775 
5776  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
5777  }
5778 
5779 
5780 
5781  typedef struct
5782  {
5783  OrthancPluginFindMatcher** target;
5784  const void* query;
5785  uint32_t size;
5786  } _OrthancPluginCreateFindMatcher;
5787 
5788 
5803  OrthancPluginContext* context,
5804  const void* query,
5805  uint32_t size)
5806  {
5807  OrthancPluginFindMatcher* target = NULL;
5808 
5809  _OrthancPluginCreateFindMatcher params;
5810  memset(&params, 0, sizeof(params));
5811  params.target = &target;
5812  params.query = query;
5813  params.size = size;
5814 
5815  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
5816  {
5817  return NULL;
5818  }
5819  else
5820  {
5821  return target;
5822  }
5823  }
5824 
5825 
5826  typedef struct
5827  {
5828  OrthancPluginFindMatcher* matcher;
5829  } _OrthancPluginFreeFindMatcher;
5830 
5840  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
5841  OrthancPluginContext* context,
5842  OrthancPluginFindMatcher* matcher)
5843  {
5844  _OrthancPluginFreeFindMatcher params;
5845  params.matcher = matcher;
5846 
5847  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
5848  }
5849 
5850 
5851  typedef struct
5852  {
5853  const OrthancPluginFindMatcher* matcher;
5854  const void* dicom;
5855  uint32_t size;
5856  int32_t* isMatch;
5857  } _OrthancPluginFindMatcherIsMatch;
5858 
5873  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
5874  OrthancPluginContext* context,
5875  const OrthancPluginFindMatcher* matcher,
5876  const void* dicom,
5877  uint32_t size)
5878  {
5879  int32_t isMatch = 0;
5880 
5881  _OrthancPluginFindMatcherIsMatch params;
5882  params.matcher = matcher;
5883  params.dicom = dicom;
5884  params.size = size;
5885  params.isMatch = &isMatch;
5886 
5887  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
5888  {
5889  return isMatch;
5890  }
5891  else
5892  {
5893  /* Error: Assume non-match */
5894  return 0;
5895  }
5896  }
5897 
5898 
5899  typedef struct
5900  {
5902  } _OrthancPluginIncomingHttpRequestFilter2;
5903 
5916  OrthancPluginContext* context,
5918  {
5919  _OrthancPluginIncomingHttpRequestFilter2 params;
5920  params.callback = callback;
5921 
5922  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
5923  }
5924 
5925 
5926 
5927  typedef struct
5928  {
5929  OrthancPluginPeers** peers;
5930  } _OrthancPluginGetPeers;
5931 
5944  OrthancPluginContext* context)
5945  {
5946  OrthancPluginPeers* peers = NULL;
5947 
5948  _OrthancPluginGetPeers params;
5949  memset(&params, 0, sizeof(params));
5950  params.peers = &peers;
5951 
5952  if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
5953  {
5954  return NULL;
5955  }
5956  else
5957  {
5958  return peers;
5959  }
5960  }
5961 
5962 
5963  typedef struct
5964  {
5965  OrthancPluginPeers* peers;
5966  } _OrthancPluginFreePeers;
5967 
5977  ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
5978  OrthancPluginContext* context,
5979  OrthancPluginPeers* peers)
5980  {
5981  _OrthancPluginFreePeers params;
5982  params.peers = peers;
5983 
5984  context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
5985  }
5986 
5987 
5988  typedef struct
5989  {
5990  uint32_t* target;
5991  const OrthancPluginPeers* peers;
5992  } _OrthancPluginGetPeersCount;
5993 
6007  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6008  OrthancPluginContext* context,
6009  const OrthancPluginPeers* peers)
6010  {
6011  uint32_t target = 0;
6012 
6013  _OrthancPluginGetPeersCount params;
6014  memset(&params, 0, sizeof(params));
6015  params.target = &target;
6016  params.peers = peers;
6017 
6018  if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6019  {
6020  /* Error */
6021  return 0;
6022  }
6023  else
6024  {
6025  return target;
6026  }
6027  }
6028 
6029 
6030  typedef struct
6031  {
6032  const char** target;
6033  const OrthancPluginPeers* peers;
6034  uint32_t peerIndex;
6035  const char* userProperty;
6036  } _OrthancPluginGetPeerProperty;
6037 
6055  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6056  OrthancPluginContext* context,
6057  const OrthancPluginPeers* peers,
6058  uint32_t peerIndex)
6059  {
6060  const char* target = NULL;
6061 
6062  _OrthancPluginGetPeerProperty params;
6063  memset(&params, 0, sizeof(params));
6064  params.target = &target;
6065  params.peers = peers;
6066  params.peerIndex = peerIndex;
6067  params.userProperty = NULL;
6068 
6069  if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6070  {
6071  /* Error */
6072  return NULL;
6073  }
6074  else
6075  {
6076  return target;
6077  }
6078  }
6079 
6080 
6096  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6097  OrthancPluginContext* context,
6098  const OrthancPluginPeers* peers,
6099  uint32_t peerIndex)
6100  {
6101  const char* target = NULL;
6102 
6103  _OrthancPluginGetPeerProperty params;
6104  memset(&params, 0, sizeof(params));
6105  params.target = &target;
6106  params.peers = peers;
6107  params.peerIndex = peerIndex;
6108  params.userProperty = NULL;
6109 
6110  if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6111  {
6112  /* Error */
6113  return NULL;
6114  }
6115  else
6116  {
6117  return target;
6118  }
6119  }
6120 
6121 
6122 
6142  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6143  OrthancPluginContext* context,
6144  const OrthancPluginPeers* peers,
6145  uint32_t peerIndex,
6146  const char* userProperty)
6147  {
6148  const char* target = NULL;
6149 
6150  _OrthancPluginGetPeerProperty params;
6151  memset(&params, 0, sizeof(params));
6152  params.target = &target;
6153  params.peers = peers;
6154  params.peerIndex = peerIndex;
6155  params.userProperty = userProperty;
6156 
6157  if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6158  {
6159  /* No such user property */
6160  return NULL;
6161  }
6162  else
6163  {
6164  return target;
6165  }
6166  }
6167 
6168 
6169 
6170  typedef struct
6171  {
6172  OrthancPluginMemoryBuffer* answerBody;
6173  OrthancPluginMemoryBuffer* answerHeaders;
6174  uint16_t* httpStatus;
6175  const OrthancPluginPeers* peers;
6176  uint32_t peerIndex;
6177  OrthancPluginHttpMethod method;
6178  const char* uri;
6179  uint32_t additionalHeadersCount;
6180  const char* const* additionalHeadersKeys;
6181  const char* const* additionalHeadersValues;
6182  const char* body;
6183  uint32_t bodySize;
6184  uint32_t timeout;
6185  } _OrthancPluginCallPeerApi;
6186 
6223  OrthancPluginContext* context,
6224  OrthancPluginMemoryBuffer* answerBody,
6225  OrthancPluginMemoryBuffer* answerHeaders,
6226  uint16_t* httpStatus,
6227  const OrthancPluginPeers* peers,
6228  uint32_t peerIndex,
6229  OrthancPluginHttpMethod method,
6230  const char* uri,
6231  uint32_t additionalHeadersCount,
6232  const char* const* additionalHeadersKeys,
6233  const char* const* additionalHeadersValues,
6234  const char* body,
6235  uint32_t bodySize,
6236  uint32_t timeout)
6237  {
6238  _OrthancPluginCallPeerApi params;
6239  memset(&params, 0, sizeof(params));
6240 
6241  params.answerBody = answerBody;
6242  params.answerHeaders = answerHeaders;
6243  params.httpStatus = httpStatus;
6244  params.peers = peers;
6245  params.peerIndex = peerIndex;
6246  params.method = method;
6247  params.uri = uri;
6248  params.additionalHeadersCount = additionalHeadersCount;
6249  params.additionalHeadersKeys = additionalHeadersKeys;
6250  params.additionalHeadersValues = additionalHeadersValues;
6251  params.body = body;
6252  params.bodySize = bodySize;
6253  params.timeout = timeout;
6254 
6255  return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6256  }
6257 
6258 
6259 
6260 
6261 
6262  typedef struct
6263  {
6264  OrthancPluginJob** target;
6265  void *job;
6266  OrthancPluginJobFinalize finalize;
6267  const char *type;
6268  OrthancPluginJobGetProgress getProgress;
6269  OrthancPluginJobGetContent getContent;
6270  OrthancPluginJobGetSerialized getSerialized;
6271  OrthancPluginJobStep step;
6272  OrthancPluginJobStop stop;
6273  OrthancPluginJobReset reset;
6274  } _OrthancPluginCreateJob;
6275 
6308  OrthancPluginContext *context,
6309  void *job,
6310  OrthancPluginJobFinalize finalize,
6311  const char *type,
6312  OrthancPluginJobGetProgress getProgress,
6313  OrthancPluginJobGetContent getContent,
6314  OrthancPluginJobGetSerialized getSerialized,
6315  OrthancPluginJobStep step,
6316  OrthancPluginJobStop stop,
6317  OrthancPluginJobReset reset)
6318  {
6319  OrthancPluginJob* target = NULL;
6320 
6321  _OrthancPluginCreateJob params;
6322  memset(&params, 0, sizeof(params));
6323 
6324  params.target = &target;
6325  params.job = job;
6326  params.finalize = finalize;
6327  params.type = type;
6328  params.getProgress = getProgress;
6329  params.getContent = getContent;
6330  params.getSerialized = getSerialized;
6331  params.step = step;
6332  params.stop = stop;
6333  params.reset = reset;
6334 
6335  if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6336  target == NULL)
6337  {
6338  /* Error */
6339  return NULL;
6340  }
6341  else
6342  {
6343  return target;
6344  }
6345  }
6346 
6347 
6348  typedef struct
6349  {
6350  OrthancPluginJob* job;
6351  } _OrthancPluginFreeJob;
6352 
6362  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6363  OrthancPluginContext* context,
6364  OrthancPluginJob* job)
6365  {
6366  _OrthancPluginFreeJob params;
6367  params.job = job;
6368 
6369  context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6370  }
6371 
6372 
6373 
6374  typedef struct
6375  {
6376  char** resultId;
6377  OrthancPluginJob *job;
6378  int priority;
6379  } _OrthancPluginSubmitJob;
6380 
6394  ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6395  OrthancPluginContext *context,
6396  OrthancPluginJob *job,
6397  int priority)
6398  {
6399  char* resultId = NULL;
6400 
6401  _OrthancPluginSubmitJob params;
6402  memset(&params, 0, sizeof(params));
6403 
6404  params.resultId = &resultId;
6405  params.job = job;
6406  params.priority = priority;
6407 
6408  if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6409  resultId == NULL)
6410  {
6411  /* Error */
6412  return NULL;
6413  }
6414  else
6415  {
6416  return resultId;
6417  }
6418  }
6419 
6420 
6421 
6422  typedef struct
6423  {
6424  OrthancPluginJobsUnserializer unserializer;
6425  } _OrthancPluginJobsUnserializer;
6426 
6439  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6440  OrthancPluginContext* context,
6441  OrthancPluginJobsUnserializer unserializer)
6442  {
6443  _OrthancPluginJobsUnserializer params;
6444  params.unserializer = unserializer;
6445 
6446  context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6447  }
6448 
6449 
6450 
6451  typedef struct
6452  {
6453  OrthancPluginRestOutput* output;
6454  const char* details;
6455  uint8_t log;
6456  } _OrthancPluginSetHttpErrorDetails;
6457 
6475  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
6476  OrthancPluginContext* context,
6477  OrthancPluginRestOutput* output,
6478  const char* details,
6479  uint8_t log)
6480  {
6481  _OrthancPluginSetHttpErrorDetails params;
6482  params.output = output;
6483  params.details = details;
6484  params.log = log;
6485  context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
6486  }
6487 
6488 
6489 
6490  typedef struct
6491  {
6492  const char** result;
6493  const char* argument;
6494  } _OrthancPluginRetrieveStaticString;
6495 
6507  ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
6508  OrthancPluginContext* context,
6509  const char* path)
6510  {
6511  const char* result = NULL;
6512 
6513  _OrthancPluginRetrieveStaticString params;
6514  params.result = &result;
6515  params.argument = path;
6516 
6517  if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
6518  {
6519  /* Error */
6520  return NULL;
6521  }
6522  else
6523  {
6524  return result;
6525  }
6526  }
6527 
6528 
6529 #ifdef __cplusplus
6530 }
6531 #endif
6532 
6533 
Definition: OrthancCPlugin.h:727
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2548
Definition: OrthancCPlugin.h:829
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:2727
OrthancPluginChangeType
Definition: OrthancCPlugin.h:682
Definition: OrthancCPlugin.h:235
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2411
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:5977
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:921
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5556
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2512
Definition: OrthancCPlugin.h:750
Definition: OrthancCPlugin.h:270
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:1678
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5015
Definition: OrthancCPlugin.h:830
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:2194
OrthancPluginContentType
Definition: OrthancCPlugin.h:651
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2099
Definition: OrthancCPlugin.h:668
Definition: OrthancCPlugin.h:749
Definition: OrthancCPlugin.h:861
const char * OrthancPluginGetInstanceData(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2614
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:3795
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:3887
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:871
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:1182
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1611
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:6475
Definition: OrthancCPlugin.h:262
Definition: OrthancCPlugin.h:205
Definition: OrthancCPlugin.h:260
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:856
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1347
Definition: OrthancCPlugin.h:747
Definition: OrthancCPlugin.h:889
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2581
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:4531
Definition: OrthancCPlugin.h:285
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:575
Definition: OrthancCPlugin.h:697
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:811
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5223
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:6307
Definition: OrthancCPlugin.h:276
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:559
Definition: OrthancCPlugin.h:862
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:6394
Definition: OrthancCPlugin.h:601
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:2813
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:6507
Definition: OrthancCPlugin.h:845
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:1912
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:6222
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:724
Definition: OrthancCPlugin.h:213
Definition: OrthancCPlugin.h:298
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1479
Definition: OrthancCPlugin.h:282
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4167
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:1051
Definition: OrthancCPlugin.h:224
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5187
Definition: OrthancCPlugin.h:873
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:1000
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4092
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:1124
Definition: OrthancCPlugin.h:691
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4346
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4127
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:2910
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:5646
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:5423
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:2952
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:599
Definition: OrthancCPlugin.h:795
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:792
Definition: OrthancCPlugin.h:890
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:2457
Definition: OrthancCPlugin.h:711
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5478
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1332
Definition: OrthancCPlugin.h:699
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:1814
Definition: OrthancCPlugin.h:888
Definition: OrthancCPlugin.h:685
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:5141
Definition: OrthancCPlugin.h:259
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:777
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5269
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1404
Definition: OrthancCPlugin.h:779
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4422
Definition: OrthancCPlugin.h:240
uint16_t group
Definition: OrthancCPlugin.h:1462
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:3665
Definition: OrthancCPlugin.h:740
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1465
Definition: OrthancCPlugin.h:781
Definition: OrthancCPlugin.h:752
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:4800
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:2765
Definition: OrthancCPlugin.h:887
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:885
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:952
Definition: OrthancCPlugin.h:726
Definition: OrthancCPlugin.h:252
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:944
Definition: OrthancCPlugin.h:244
Definition: OrthancCPlugin.h:653
Definition: OrthancCPlugin.h:689
Color image in RGB48 format.
Definition: OrthancCPlugin.h:609
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:2160
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3197
Definition: OrthancCPlugin.h:275
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:567
Definition: OrthancCPlugin.h:273
Definition: OrthancCPlugin.h:216
OrthancPluginConstraintType
Definition: OrthancCPlugin.h:841
OrthancPluginResourceType
Definition: OrthancCPlugin.h:665
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:3596
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:738
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3230
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:3494
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:3708
Definition: OrthancCPlugin.h:278
Definition: OrthancCPlugin.h:742
Definition: OrthancCPlugin.h:219
Definition: OrthancCPlugin.h:670
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1008
Definition: OrthancCPlugin.h:269
Definition: OrthancCPlugin.h:712
Definition: OrthancCPlugin.h:745
Definition: OrthancCPlugin.h:286
Definition: OrthancCPlugin.h:875
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:2875
Definition: OrthancCPlugin.h:237
Definition: OrthancCPlugin.h:714
Definition: OrthancCPlugin.h:764
Definition: OrthancCPlugin.h:261
Color image in RGB24 format.
Definition: OrthancCPlugin.h:591
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5915
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:583
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1460
Definition: OrthancCPlugin.h:271
Definition: OrthancCPlugin.h:209
Definition: OrthancCPlugin.h:684
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:709
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:4017
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:4726
Definition: OrthancCPlugin.h:798
struct _OrthancPluginPeers_t OrthancPluginPeers
Opaque structure to the set of remote Orthanc Peers that are known to the local Orthanc server...
Definition: OrthancCPlugin.h:992
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3530
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:4252
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3631
Definition: OrthancCPlugin.h:654
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:1871
Definition: OrthancCPlugin.h:291
Definition: OrthancCPlugin.h:297
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1380
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1466
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:1040
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:4619
Definition: OrthancCPlugin.h:846
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3131
Definition: OrthancCPlugin.h:242
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2434
Definition: OrthancCPlugin.h:211
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:641
Definition: OrthancCPlugin.h:267
Definition: OrthancCPlugin.h:255
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:5840
Definition: OrthancCPlugin.h:287
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:1646
Definition: OrthancCPlugin.h:230
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:5802
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:906
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4199
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:3027
Definition: OrthancCPlugin.h:860
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1945
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3441
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:1151
Definition: OrthancCPlugin.h:690
Definition: OrthancCPlugin.h:797
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1630
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:4764
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1067
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:1252
Definition: OrthancCPlugin.h:758
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2076
Definition: OrthancCPlugin.h:762
Definition: OrthancCPlugin.h:669
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3379
Definition: OrthancCPlugin.h:751
Definition: OrthancCPlugin.h:831
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:976
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:5763
Definition: OrthancCPlugin.h:318
Definition: OrthancCPlugin.h:698
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5053
Definition: OrthancCPlugin.h:753
Definition: OrthancCPlugin.h:247
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:2845
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3061
Definition: OrthancCPlugin.h:847
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:5312
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1105
Definition: OrthancCPlugin.h:780
Definition: OrthancCPlugin.h:256
Definition: OrthancCPlugin.h:294
Definition: OrthancCPlugin.h:316
Definition: OrthancCPlugin.h:692
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4575
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:5677
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6439
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3165
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:3939
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:5096
Definition: OrthancCPlugin.h:264
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5350
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:4668
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:6142
Definition: OrthancCPlugin.h:765
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:1029
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:5943
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:2688
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:3342
Definition: OrthancCPlugin.h:257
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:4830
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:4982
Definition: OrthancCPlugin.h:250
Definition: OrthancCPlugin.h:728
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:1754
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1209
Definition: OrthancCPlugin.h:695
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5517
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:936
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:2124
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3271
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:960
Definition: OrthancCPlugin.h:202
Definition: OrthancCPlugin.h:228
Definition: OrthancCPlugin.h:221
Definition: OrthancCPlugin.h:828
Definition: OrthancCPlugin.h:295
Definition: OrthancCPlugin.h:266
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1306
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:2983
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1365
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4383
Definition: OrthancCPlugin.h:874
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6362
Definition: OrthancCPlugin.h:757
Definition: OrthancCPlugin.h:696
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:354
Definition: OrthancCPlugin.h:760
Definition: OrthancCPlugin.h:687
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2226
Definition: OrthancCPlugin.h:844
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:4933
Definition: OrthancCPlugin.h:761
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:3750
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1464
uint16_t element
Definition: OrthancCPlugin.h:1463
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2366
Definition: OrthancCPlugin.h:694
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3100
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1292
Definition: OrthancCPlugin.h:234
Definition: OrthancCPlugin.h:655
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:3300
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:3410
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:1087
Definition: OrthancCPlugin.h:268
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2261
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:911
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:625
Definition: OrthancCPlugin.h:858
Definition: OrthancCPlugin.h:248
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1421
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance received by Orthanc.
Definition: OrthancCPlugin.h:928
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:339
Definition: OrthancCPlugin.h:249
Definition: OrthancCPlugin.h:671
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:1662
Definition: OrthancCPlugin.h:746
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:4868
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:1509
Definition: OrthancCPlugin.h:766
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:826
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:5585
Definition: OrthancCPlugin.h:319
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialized a custom job.
Definition: OrthancCPlugin.h:1437
Definition: OrthancCPlugin.h:239
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2487
Definition: OrthancCPlugin.h:686
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6007
Definition: OrthancCPlugin.h:756
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2650
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6096
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5609
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:3005
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:2012
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:1782
Definition: OrthancCPlugin.h:688
Definition: OrthancCPlugin.h:759
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:4478
Definition: OrthancCPlugin.h:251
Definition: OrthancCPlugin.h:214
Definition: OrthancCPlugin.h:763
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:3976
Definition: OrthancCPlugin.h:743
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:617
Definition: OrthancCPlugin.h:843
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:1714
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2296
Definition: OrthancCPlugin.h:755
Definition: OrthancCPlugin.h:741
Definition: OrthancCPlugin.h:206
Definition: OrthancCPlugin.h:667
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:4907
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:1975
Definition: OrthancCPlugin.h:859
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:1019
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:968
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:2047
Definition: OrthancCPlugin.h:204
Definition: OrthancCPlugin.h:229
Definition: OrthancCPlugin.h:693
Definition: OrthancCPlugin.h:713
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:4304
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4054
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:901
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6055
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:633
Definition: OrthancCPlugin.h:748
Definition: OrthancCPlugin.h:796
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:5873
Definition: OrthancCPlugin.h:754
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1319
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2331
Definition: OrthancCPlugin.h:208
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1277
Definition: OrthancCPlugin.h:744
Definition: OrthancCPlugin.h:277
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3563
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:3840
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:984
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:5715
Definition: OrthancCPlugin.h:238
Definition: OrthancCPlugin.h:231