Orthanc Plugin SDK  1.5.0
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 0
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 
825  typedef enum
826  {
832  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
834 
835 
839  typedef enum
840  {
847  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
849 
850 
854  typedef enum
855  {
860 
861 
868  typedef enum
869  {
875 
876 
884  typedef struct
885  {
889  void* data;
890 
894  uint32_t size;
896 
897 
898 
899 
904  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
905 
906 
907 
911  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
912 
913 
914 
919  typedef struct _OrthancPluginImage_t OrthancPluginImage;
920 
921 
922 
927  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
928 
929 
930 
935  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
936 
937 
938 
943  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
944 
945 
946 
951  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
952 
953 
954 
959  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
960 
961 
962 
967  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindMatcher;
968 
969 
970 
975  typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
976 
977 
978 
983  typedef struct _OrthancPluginJob_t OrthancPluginJob;
984 
985 
986 
992  OrthancPluginRestOutput* output,
993  const char* url,
994  const OrthancPluginHttpRequest* request);
995 
996 
997 
1003  OrthancPluginDicomInstance* instance,
1004  const char* instanceId);
1005 
1006 
1007 
1013  OrthancPluginChangeType changeType,
1014  OrthancPluginResourceType resourceType,
1015  const char* resourceId);
1016 
1017 
1018 
1024  OrthancPluginImage** target,
1025  const void* dicom,
1026  const uint32_t size,
1027  uint32_t frameIndex);
1028 
1029 
1030 
1034  typedef void (*OrthancPluginFree) (void* buffer);
1035 
1036 
1037 
1051  const char* uuid,
1052  const void* content,
1053  int64_t size,
1055 
1056 
1057 
1071  void** content,
1072  int64_t* size,
1073  const char* uuid,
1075 
1076 
1077 
1089  const char* uuid,
1091 
1092 
1093 
1109  const OrthancPluginWorklistQuery* query,
1110  const char* issuerAet,
1111  const char* calledAet);
1112 
1113 
1114 
1135  OrthancPluginHttpMethod method,
1136  const char* uri,
1137  const char* ip,
1138  uint32_t headersCount,
1139  const char* const* headersKeys,
1140  const char* const* headersValues);
1141 
1142 
1143 
1166  OrthancPluginHttpMethod method,
1167  const char* uri,
1168  const char* ip,
1169  uint32_t headersCount,
1170  const char* const* headersKeys,
1171  const char* const* headersValues,
1172  uint32_t getArgumentsCount,
1173  const char* const* getArgumentsKeys,
1174  const char* const* getArgumentsValues);
1175 
1176 
1177 
1193  OrthancPluginFindAnswers* answers,
1194  const OrthancPluginFindQuery* query,
1195  const char* issuerAet,
1196  const char* calledAet);
1197 
1198 
1199 
1235  typedef void* (*OrthancPluginMoveCallback) (
1236  OrthancPluginResourceType resourceType,
1237  const char* patientId,
1238  const char* accessionNumber,
1239  const char* studyInstanceUid,
1240  const char* seriesInstanceUid,
1241  const char* sopInstanceUid,
1242  const char* originatorAet,
1243  const char* sourceAet,
1244  const char* targetAet,
1245  uint16_t originatorId);
1246 
1247 
1260  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1261 
1262 
1275  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1276 
1277 
1289  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1290 
1291 
1302  typedef void (*OrthancPluginJobFinalize) (void* job);
1303 
1304 
1315  typedef float (*OrthancPluginJobGetProgress) (void* job);
1316 
1317 
1330  typedef const char* (*OrthancPluginJobGetContent) (void* job);
1331 
1332 
1348  typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1349 
1350 
1364 
1365 
1389 
1390 
1405 
1406 
1420  typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1421  const char* serialized);
1422 
1423 
1424 
1428  typedef struct _OrthancPluginContext_t
1429  {
1430  void* pluginsManager;
1431  const char* orthancVersion;
1432  OrthancPluginFree Free;
1433  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1434  _OrthancPluginService service,
1435  const void* params);
1437 
1438 
1439 
1443  typedef struct
1444  {
1445  uint16_t group;
1446  uint16_t element;
1448  uint32_t minMultiplicity;
1449  uint32_t maxMultiplicity;
1451 
1452 
1453 
1462  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1463  OrthancPluginContext* context,
1464  char* str)
1465  {
1466  if (str != NULL)
1467  {
1468  context->Free(str);
1469  }
1470  }
1471 
1472 
1492  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1493  OrthancPluginContext* context,
1494  int expectedMajor,
1495  int expectedMinor,
1496  int expectedRevision)
1497  {
1498  int major, minor, revision;
1499 
1500  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1501  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1502  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1503  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1504  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1505  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1506  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1507  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1508  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1509  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1510  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1511  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1512  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1513  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1514  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1515  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1516  sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus))
1517  {
1518  /* Mismatch in the size of the enumerations */
1519  return 0;
1520  }
1521 
1522  /* Assume compatibility with the mainline */
1523  if (!strcmp(context->orthancVersion, "mainline"))
1524  {
1525  return 1;
1526  }
1527 
1528  /* Parse the version of the Orthanc core */
1529  if (
1530 #ifdef _MSC_VER
1531  sscanf_s
1532 #else
1533  sscanf
1534 #endif
1535  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1536  {
1537  return 0;
1538  }
1539 
1540  /* Check the major number of the version */
1541 
1542  if (major > expectedMajor)
1543  {
1544  return 1;
1545  }
1546 
1547  if (major < expectedMajor)
1548  {
1549  return 0;
1550  }
1551 
1552  /* Check the minor number of the version */
1553 
1554  if (minor > expectedMinor)
1555  {
1556  return 1;
1557  }
1558 
1559  if (minor < expectedMinor)
1560  {
1561  return 0;
1562  }
1563 
1564  /* Check the revision number of the version */
1565 
1566  if (revision >= expectedRevision)
1567  {
1568  return 1;
1569  }
1570  else
1571  {
1572  return 0;
1573  }
1574  }
1575 
1576 
1593  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1594  OrthancPluginContext* context)
1595  {
1597  context,
1598  ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1599  ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1600  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1601  }
1602 
1603 
1612  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1613  OrthancPluginContext* context,
1614  OrthancPluginMemoryBuffer* buffer)
1615  {
1616  context->Free(buffer->data);
1617  }
1618 
1619 
1628  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1629  OrthancPluginContext* context,
1630  const char* message)
1631  {
1632  context->InvokeService(context, _OrthancPluginService_LogError, message);
1633  }
1634 
1635 
1644  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
1645  OrthancPluginContext* context,
1646  const char* message)
1647  {
1648  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1649  }
1650 
1651 
1660  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
1661  OrthancPluginContext* context,
1662  const char* message)
1663  {
1664  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
1665  }
1666 
1667 
1668 
1669  typedef struct
1670  {
1671  const char* pathRegularExpression;
1672  OrthancPluginRestCallback callback;
1673  } _OrthancPluginRestCallback;
1674 
1696  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
1697  OrthancPluginContext* context,
1698  const char* pathRegularExpression,
1699  OrthancPluginRestCallback callback)
1700  {
1701  _OrthancPluginRestCallback params;
1702  params.pathRegularExpression = pathRegularExpression;
1703  params.callback = callback;
1704  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
1705  }
1706 
1707 
1708 
1736  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
1737  OrthancPluginContext* context,
1738  const char* pathRegularExpression,
1739  OrthancPluginRestCallback callback)
1740  {
1741  _OrthancPluginRestCallback params;
1742  params.pathRegularExpression = pathRegularExpression;
1743  params.callback = callback;
1744  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
1745  }
1746 
1747 
1748 
1749  typedef struct
1750  {
1752  } _OrthancPluginOnStoredInstanceCallback;
1753 
1765  OrthancPluginContext* context,
1767  {
1768  _OrthancPluginOnStoredInstanceCallback params;
1769  params.callback = callback;
1770 
1771  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
1772  }
1773 
1774 
1775 
1776  typedef struct
1777  {
1778  OrthancPluginRestOutput* output;
1779  const char* answer;
1780  uint32_t answerSize;
1781  const char* mimeType;
1782  } _OrthancPluginAnswerBuffer;
1783 
1796  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
1797  OrthancPluginContext* context,
1798  OrthancPluginRestOutput* output,
1799  const char* answer,
1800  uint32_t answerSize,
1801  const char* mimeType)
1802  {
1803  _OrthancPluginAnswerBuffer params;
1804  params.output = output;
1805  params.answer = answer;
1806  params.answerSize = answerSize;
1807  params.mimeType = mimeType;
1808  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
1809  }
1810 
1811 
1812  typedef struct
1813  {
1814  OrthancPluginRestOutput* output;
1815  OrthancPluginPixelFormat format;
1816  uint32_t width;
1817  uint32_t height;
1818  uint32_t pitch;
1819  const void* buffer;
1820  } _OrthancPluginCompressAndAnswerPngImage;
1821 
1822  typedef struct
1823  {
1824  OrthancPluginRestOutput* output;
1825  OrthancPluginImageFormat imageFormat;
1826  OrthancPluginPixelFormat pixelFormat;
1827  uint32_t width;
1828  uint32_t height;
1829  uint32_t pitch;
1830  const void* buffer;
1831  uint8_t quality;
1832  } _OrthancPluginCompressAndAnswerImage;
1833 
1834 
1853  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
1854  OrthancPluginContext* context,
1855  OrthancPluginRestOutput* output,
1856  OrthancPluginPixelFormat format,
1857  uint32_t width,
1858  uint32_t height,
1859  uint32_t pitch,
1860  const void* buffer)
1861  {
1862  _OrthancPluginCompressAndAnswerImage params;
1863  params.output = output;
1864  params.imageFormat = OrthancPluginImageFormat_Png;
1865  params.pixelFormat = format;
1866  params.width = width;
1867  params.height = height;
1868  params.pitch = pitch;
1869  params.buffer = buffer;
1870  params.quality = 0; /* No quality for PNG */
1871  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
1872  }
1873 
1874 
1875 
1876  typedef struct
1877  {
1878  OrthancPluginMemoryBuffer* target;
1879  const char* instanceId;
1880  } _OrthancPluginGetDicomForInstance;
1881 
1895  OrthancPluginContext* context,
1896  OrthancPluginMemoryBuffer* target,
1897  const char* instanceId)
1898  {
1899  _OrthancPluginGetDicomForInstance params;
1900  params.target = target;
1901  params.instanceId = instanceId;
1902  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
1903  }
1904 
1905 
1906 
1907  typedef struct
1908  {
1909  OrthancPluginMemoryBuffer* target;
1910  const char* uri;
1911  } _OrthancPluginRestApiGet;
1912 
1928  OrthancPluginContext* context,
1929  OrthancPluginMemoryBuffer* target,
1930  const char* uri)
1931  {
1932  _OrthancPluginRestApiGet params;
1933  params.target = target;
1934  params.uri = uri;
1935  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
1936  }
1937 
1938 
1939 
1958  OrthancPluginContext* context,
1959  OrthancPluginMemoryBuffer* target,
1960  const char* uri)
1961  {
1962  _OrthancPluginRestApiGet params;
1963  params.target = target;
1964  params.uri = uri;
1965  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
1966  }
1967 
1968 
1969 
1970  typedef struct
1971  {
1972  OrthancPluginMemoryBuffer* target;
1973  const char* uri;
1974  const char* body;
1975  uint32_t bodySize;
1976  } _OrthancPluginRestApiPostPut;
1977 
1995  OrthancPluginContext* context,
1996  OrthancPluginMemoryBuffer* target,
1997  const char* uri,
1998  const char* body,
1999  uint32_t bodySize)
2000  {
2001  _OrthancPluginRestApiPostPut params;
2002  params.target = target;
2003  params.uri = uri;
2004  params.body = body;
2005  params.bodySize = bodySize;
2006  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2007  }
2008 
2009 
2030  OrthancPluginContext* context,
2031  OrthancPluginMemoryBuffer* target,
2032  const char* uri,
2033  const char* body,
2034  uint32_t bodySize)
2035  {
2036  _OrthancPluginRestApiPostPut params;
2037  params.target = target;
2038  params.uri = uri;
2039  params.body = body;
2040  params.bodySize = bodySize;
2041  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2042  }
2043 
2044 
2045 
2059  OrthancPluginContext* context,
2060  const char* uri)
2061  {
2062  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2063  }
2064 
2065 
2082  OrthancPluginContext* context,
2083  const char* uri)
2084  {
2085  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2086  }
2087 
2088 
2089 
2107  OrthancPluginContext* context,
2108  OrthancPluginMemoryBuffer* target,
2109  const char* uri,
2110  const char* body,
2111  uint32_t bodySize)
2112  {
2113  _OrthancPluginRestApiPostPut params;
2114  params.target = target;
2115  params.uri = uri;
2116  params.body = body;
2117  params.bodySize = bodySize;
2118  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2119  }
2120 
2121 
2122 
2143  OrthancPluginContext* context,
2144  OrthancPluginMemoryBuffer* target,
2145  const char* uri,
2146  const char* body,
2147  uint32_t bodySize)
2148  {
2149  _OrthancPluginRestApiPostPut params;
2150  params.target = target;
2151  params.uri = uri;
2152  params.body = body;
2153  params.bodySize = bodySize;
2154  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2155  }
2156 
2157 
2158 
2159  typedef struct
2160  {
2161  OrthancPluginRestOutput* output;
2162  const char* argument;
2163  } _OrthancPluginOutputPlusArgument;
2164 
2176  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2177  OrthancPluginContext* context,
2178  OrthancPluginRestOutput* output,
2179  const char* redirection)
2180  {
2181  _OrthancPluginOutputPlusArgument params;
2182  params.output = output;
2183  params.argument = redirection;
2184  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2185  }
2186 
2187 
2188 
2189  typedef struct
2190  {
2191  char** result;
2192  const char* argument;
2193  } _OrthancPluginRetrieveDynamicString;
2194 
2208  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2209  OrthancPluginContext* context,
2210  const char* patientID)
2211  {
2212  char* result;
2213 
2214  _OrthancPluginRetrieveDynamicString params;
2215  params.result = &result;
2216  params.argument = patientID;
2217 
2218  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2219  {
2220  /* Error */
2221  return NULL;
2222  }
2223  else
2224  {
2225  return result;
2226  }
2227  }
2228 
2229 
2243  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2244  OrthancPluginContext* context,
2245  const char* studyUID)
2246  {
2247  char* result;
2248 
2249  _OrthancPluginRetrieveDynamicString params;
2250  params.result = &result;
2251  params.argument = studyUID;
2252 
2253  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2254  {
2255  /* Error */
2256  return NULL;
2257  }
2258  else
2259  {
2260  return result;
2261  }
2262  }
2263 
2264 
2278  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
2279  OrthancPluginContext* context,
2280  const char* accessionNumber)
2281  {
2282  char* result;
2283 
2284  _OrthancPluginRetrieveDynamicString params;
2285  params.result = &result;
2286  params.argument = accessionNumber;
2287 
2288  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2289  {
2290  /* Error */
2291  return NULL;
2292  }
2293  else
2294  {
2295  return result;
2296  }
2297  }
2298 
2299 
2313  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2314  OrthancPluginContext* context,
2315  const char* seriesUID)
2316  {
2317  char* result;
2318 
2319  _OrthancPluginRetrieveDynamicString params;
2320  params.result = &result;
2321  params.argument = seriesUID;
2322 
2323  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2324  {
2325  /* Error */
2326  return NULL;
2327  }
2328  else
2329  {
2330  return result;
2331  }
2332  }
2333 
2334 
2348  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2349  OrthancPluginContext* context,
2350  const char* sopInstanceUID)
2351  {
2352  char* result;
2353 
2354  _OrthancPluginRetrieveDynamicString params;
2355  params.result = &result;
2356  params.argument = sopInstanceUID;
2357 
2358  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2359  {
2360  /* Error */
2361  return NULL;
2362  }
2363  else
2364  {
2365  return result;
2366  }
2367  }
2368 
2369 
2370 
2371  typedef struct
2372  {
2373  OrthancPluginRestOutput* output;
2374  uint16_t status;
2375  } _OrthancPluginSendHttpStatusCode;
2376 
2393  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2394  OrthancPluginContext* context,
2395  OrthancPluginRestOutput* output,
2396  uint16_t status)
2397  {
2398  _OrthancPluginSendHttpStatusCode params;
2399  params.output = output;
2400  params.status = status;
2401  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2402  }
2403 
2404 
2416  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2417  OrthancPluginContext* context,
2418  OrthancPluginRestOutput* output,
2419  const char* realm)
2420  {
2421  _OrthancPluginOutputPlusArgument params;
2422  params.output = output;
2423  params.argument = realm;
2424  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2425  }
2426 
2427 
2439  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2440  OrthancPluginContext* context,
2441  OrthancPluginRestOutput* output,
2442  const char* allowedMethods)
2443  {
2444  _OrthancPluginOutputPlusArgument params;
2445  params.output = output;
2446  params.argument = allowedMethods;
2447  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2448  }
2449 
2450 
2451  typedef struct
2452  {
2453  OrthancPluginRestOutput* output;
2454  const char* key;
2455  const char* value;
2456  } _OrthancPluginSetHttpHeader;
2457 
2469  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2470  OrthancPluginContext* context,
2471  OrthancPluginRestOutput* output,
2472  const char* cookie,
2473  const char* value)
2474  {
2475  _OrthancPluginSetHttpHeader params;
2476  params.output = output;
2477  params.key = cookie;
2478  params.value = value;
2479  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2480  }
2481 
2482 
2494  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2495  OrthancPluginContext* context,
2496  OrthancPluginRestOutput* output,
2497  const char* key,
2498  const char* value)
2499  {
2500  _OrthancPluginSetHttpHeader params;
2501  params.output = output;
2502  params.key = key;
2503  params.value = value;
2504  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2505  }
2506 
2507 
2508  typedef struct
2509  {
2510  char** resultStringToFree;
2511  const char** resultString;
2512  int64_t* resultInt64;
2513  const char* key;
2514  OrthancPluginDicomInstance* instance;
2515  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2516  } _OrthancPluginAccessDicomInstance;
2517 
2518 
2530  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2531  OrthancPluginContext* context,
2532  OrthancPluginDicomInstance* instance)
2533  {
2534  const char* result;
2535 
2536  _OrthancPluginAccessDicomInstance params;
2537  memset(&params, 0, sizeof(params));
2538  params.resultString = &result;
2539  params.instance = instance;
2540 
2541  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2542  {
2543  /* Error */
2544  return NULL;
2545  }
2546  else
2547  {
2548  return result;
2549  }
2550  }
2551 
2552 
2563  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2564  OrthancPluginContext* context,
2565  OrthancPluginDicomInstance* instance)
2566  {
2567  int64_t size;
2568 
2569  _OrthancPluginAccessDicomInstance params;
2570  memset(&params, 0, sizeof(params));
2571  params.resultInt64 = &size;
2572  params.instance = instance;
2573 
2574  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2575  {
2576  /* Error */
2577  return -1;
2578  }
2579  else
2580  {
2581  return size;
2582  }
2583  }
2584 
2585 
2596  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceData(
2597  OrthancPluginContext* context,
2598  OrthancPluginDicomInstance* instance)
2599  {
2600  const char* result;
2601 
2602  _OrthancPluginAccessDicomInstance params;
2603  memset(&params, 0, sizeof(params));
2604  params.resultString = &result;
2605  params.instance = instance;
2606 
2607  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2608  {
2609  /* Error */
2610  return NULL;
2611  }
2612  else
2613  {
2614  return result;
2615  }
2616  }
2617 
2618 
2632  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
2633  OrthancPluginContext* context,
2634  OrthancPluginDicomInstance* instance)
2635  {
2636  char* result;
2637 
2638  _OrthancPluginAccessDicomInstance params;
2639  memset(&params, 0, sizeof(params));
2640  params.resultStringToFree = &result;
2641  params.instance = instance;
2642 
2643  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
2644  {
2645  /* Error */
2646  return NULL;
2647  }
2648  else
2649  {
2650  return result;
2651  }
2652  }
2653 
2654 
2670  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
2671  OrthancPluginContext* context,
2672  OrthancPluginDicomInstance* instance)
2673  {
2674  char* result;
2675 
2676  _OrthancPluginAccessDicomInstance params;
2677  memset(&params, 0, sizeof(params));
2678  params.resultStringToFree = &result;
2679  params.instance = instance;
2680 
2681  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
2682  {
2683  /* Error */
2684  return NULL;
2685  }
2686  else
2687  {
2688  return result;
2689  }
2690  }
2691 
2692 
2709  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
2710  OrthancPluginContext* context,
2711  OrthancPluginDicomInstance* instance,
2712  const char* metadata)
2713  {
2714  int64_t result;
2715 
2716  _OrthancPluginAccessDicomInstance params;
2717  memset(&params, 0, sizeof(params));
2718  params.resultInt64 = &result;
2719  params.instance = instance;
2720  params.key = metadata;
2721 
2722  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2723  {
2724  /* Error */
2725  return -1;
2726  }
2727  else
2728  {
2729  return (result != 0);
2730  }
2731  }
2732 
2733 
2747  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
2748  OrthancPluginContext* context,
2749  OrthancPluginDicomInstance* instance,
2750  const char* metadata)
2751  {
2752  const char* result;
2753 
2754  _OrthancPluginAccessDicomInstance params;
2755  memset(&params, 0, sizeof(params));
2756  params.resultString = &result;
2757  params.instance = instance;
2758  params.key = metadata;
2759 
2760  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2761  {
2762  /* Error */
2763  return NULL;
2764  }
2765  else
2766  {
2767  return result;
2768  }
2769  }
2770 
2771 
2772 
2773  typedef struct
2774  {
2778  OrthancPluginFree free;
2779  } _OrthancPluginRegisterStorageArea;
2780 
2795  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
2796  OrthancPluginContext* context,
2800  {
2801  _OrthancPluginRegisterStorageArea params;
2802  params.create = create;
2803  params.read = read;
2804  params.remove = remove;
2805 
2806 #ifdef __cplusplus
2807  params.free = ::free;
2808 #else
2809  params.free = free;
2810 #endif
2811 
2812  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
2813  }
2814 
2815 
2816 
2827  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
2828  {
2829  char* result;
2830 
2831  _OrthancPluginRetrieveDynamicString params;
2832  params.result = &result;
2833  params.argument = NULL;
2834 
2835  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
2836  {
2837  /* Error */
2838  return NULL;
2839  }
2840  else
2841  {
2842  return result;
2843  }
2844  }
2845 
2846 
2857  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
2858  {
2859  char* result;
2860 
2861  _OrthancPluginRetrieveDynamicString params;
2862  params.result = &result;
2863  params.argument = NULL;
2864 
2865  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
2866  {
2867  /* Error */
2868  return NULL;
2869  }
2870  else
2871  {
2872  return result;
2873  }
2874  }
2875 
2876 
2892  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
2893  {
2894  char* result;
2895 
2896  _OrthancPluginRetrieveDynamicString params;
2897  params.result = &result;
2898  params.argument = NULL;
2899 
2900  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
2901  {
2902  /* Error */
2903  return NULL;
2904  }
2905  else
2906  {
2907  return result;
2908  }
2909  }
2910 
2911 
2912 
2913  typedef struct
2914  {
2916  } _OrthancPluginOnChangeCallback;
2917 
2934  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
2935  OrthancPluginContext* context,
2937  {
2938  _OrthancPluginOnChangeCallback params;
2939  params.callback = callback;
2940 
2941  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
2942  }
2943 
2944 
2945 
2946  typedef struct
2947  {
2948  const char* plugin;
2949  _OrthancPluginProperty property;
2950  const char* value;
2951  } _OrthancPluginSetPluginProperty;
2952 
2953 
2965  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
2966  OrthancPluginContext* context,
2967  const char* uri)
2968  {
2969  _OrthancPluginSetPluginProperty params;
2970  params.plugin = OrthancPluginGetName();
2971  params.property = _OrthancPluginProperty_RootUri;
2972  params.value = uri;
2973 
2974  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2975  }
2976 
2977 
2987  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
2988  OrthancPluginContext* context,
2989  const char* description)
2990  {
2991  _OrthancPluginSetPluginProperty params;
2992  params.plugin = OrthancPluginGetName();
2993  params.property = _OrthancPluginProperty_Description;
2994  params.value = description;
2995 
2996  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2997  }
2998 
2999 
3009  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3010  OrthancPluginContext* context,
3011  const char* javascript)
3012  {
3013  _OrthancPluginSetPluginProperty params;
3014  params.plugin = OrthancPluginGetName();
3015  params.property = _OrthancPluginProperty_OrthancExplorer;
3016  params.value = javascript;
3017 
3018  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3019  }
3020 
3021 
3022  typedef struct
3023  {
3024  char** result;
3025  int32_t property;
3026  const char* value;
3027  } _OrthancPluginGlobalProperty;
3028 
3029 
3043  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3044  OrthancPluginContext* context,
3045  int32_t property,
3046  const char* defaultValue)
3047  {
3048  char* result;
3049 
3050  _OrthancPluginGlobalProperty params;
3051  params.result = &result;
3052  params.property = property;
3053  params.value = defaultValue;
3054 
3055  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3056  {
3057  /* Error */
3058  return NULL;
3059  }
3060  else
3061  {
3062  return result;
3063  }
3064  }
3065 
3066 
3083  OrthancPluginContext* context,
3084  int32_t property,
3085  const char* value)
3086  {
3087  _OrthancPluginGlobalProperty params;
3088  params.result = NULL;
3089  params.property = property;
3090  params.value = value;
3091 
3092  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3093  }
3094 
3095 
3096 
3097  typedef struct
3098  {
3099  int32_t *resultInt32;
3100  uint32_t *resultUint32;
3101  int64_t *resultInt64;
3102  uint64_t *resultUint64;
3103  } _OrthancPluginReturnSingleValue;
3104 
3113  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3114  OrthancPluginContext* context)
3115  {
3116  uint32_t count = 0;
3117 
3118  _OrthancPluginReturnSingleValue params;
3119  memset(&params, 0, sizeof(params));
3120  params.resultUint32 = &count;
3121 
3122  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3123  {
3124  /* Error */
3125  return 0;
3126  }
3127  else
3128  {
3129  return count;
3130  }
3131  }
3132 
3133 
3134 
3147  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3148  OrthancPluginContext* context,
3149  uint32_t argument)
3150  {
3151  char* result;
3152 
3153  _OrthancPluginGlobalProperty params;
3154  params.result = &result;
3155  params.property = (int32_t) argument;
3156  params.value = NULL;
3157 
3158  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3159  {
3160  /* Error */
3161  return NULL;
3162  }
3163  else
3164  {
3165  return result;
3166  }
3167  }
3168 
3169 
3179  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3180  OrthancPluginContext* context)
3181  {
3182  uint32_t count = 0;
3183 
3184  _OrthancPluginReturnSingleValue params;
3185  memset(&params, 0, sizeof(params));
3186  params.resultUint32 = &count;
3187 
3188  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3189  {
3190  /* Error */
3191  return 0;
3192  }
3193  else
3194  {
3195  return count;
3196  }
3197  }
3198 
3199 
3200 
3212  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3213  {
3214  char* result;
3215 
3216  _OrthancPluginRetrieveDynamicString params;
3217  params.result = &result;
3218  params.argument = NULL;
3219 
3220  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3221  {
3222  /* Error */
3223  return NULL;
3224  }
3225  else
3226  {
3227  return result;
3228  }
3229  }
3230 
3231 
3232 
3233  typedef struct
3234  {
3235  OrthancPluginRestOutput* output;
3236  const char* subType;
3237  const char* contentType;
3238  } _OrthancPluginStartMultipartAnswer;
3239 
3254  OrthancPluginContext* context,
3255  OrthancPluginRestOutput* output,
3256  const char* subType,
3257  const char* contentType)
3258  {
3259  _OrthancPluginStartMultipartAnswer params;
3260  params.output = output;
3261  params.subType = subType;
3262  params.contentType = contentType;
3263  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3264  }
3265 
3266 
3283  OrthancPluginContext* context,
3284  OrthancPluginRestOutput* output,
3285  const char* answer,
3286  uint32_t answerSize)
3287  {
3288  _OrthancPluginAnswerBuffer params;
3289  params.output = output;
3290  params.answer = answer;
3291  params.answerSize = answerSize;
3292  params.mimeType = NULL;
3293  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3294  }
3295 
3296 
3297 
3298  typedef struct
3299  {
3300  OrthancPluginMemoryBuffer* target;
3301  const void* source;
3302  uint32_t size;
3303  OrthancPluginCompressionType compression;
3304  uint8_t uncompress;
3305  } _OrthancPluginBufferCompression;
3306 
3307 
3325  OrthancPluginContext* context,
3326  OrthancPluginMemoryBuffer* target,
3327  const void* source,
3328  uint32_t size,
3329  OrthancPluginCompressionType compression,
3330  uint8_t uncompress)
3331  {
3332  _OrthancPluginBufferCompression params;
3333  params.target = target;
3334  params.source = source;
3335  params.size = size;
3336  params.compression = compression;
3337  params.uncompress = uncompress;
3338 
3339  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3340  }
3341 
3342 
3343 
3344  typedef struct
3345  {
3346  OrthancPluginMemoryBuffer* target;
3347  const char* path;
3348  } _OrthancPluginReadFile;
3349 
3362  OrthancPluginContext* context,
3363  OrthancPluginMemoryBuffer* target,
3364  const char* path)
3365  {
3366  _OrthancPluginReadFile params;
3367  params.target = target;
3368  params.path = path;
3369  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3370  }
3371 
3372 
3373 
3374  typedef struct
3375  {
3376  const char* path;
3377  const void* data;
3378  uint32_t size;
3379  } _OrthancPluginWriteFile;
3380 
3393  OrthancPluginContext* context,
3394  const char* path,
3395  const void* data,
3396  uint32_t size)
3397  {
3398  _OrthancPluginWriteFile params;
3399  params.path = path;
3400  params.data = data;
3401  params.size = size;
3402  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3403  }
3404 
3405 
3406 
3407  typedef struct
3408  {
3409  const char** target;
3410  OrthancPluginErrorCode error;
3411  } _OrthancPluginGetErrorDescription;
3412 
3423  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3424  OrthancPluginContext* context,
3425  OrthancPluginErrorCode error)
3426  {
3427  const char* result = NULL;
3428 
3429  _OrthancPluginGetErrorDescription params;
3430  params.target = &result;
3431  params.error = error;
3432 
3433  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3434  result == NULL)
3435  {
3436  return "Unknown error code";
3437  }
3438  else
3439  {
3440  return result;
3441  }
3442  }
3443 
3444 
3445 
3446  typedef struct
3447  {
3448  OrthancPluginRestOutput* output;
3449  uint16_t status;
3450  const char* body;
3451  uint32_t bodySize;
3452  } _OrthancPluginSendHttpStatus;
3453 
3476  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3477  OrthancPluginContext* context,
3478  OrthancPluginRestOutput* output,
3479  uint16_t status,
3480  const char* body,
3481  uint32_t bodySize)
3482  {
3483  _OrthancPluginSendHttpStatus params;
3484  params.output = output;
3485  params.status = status;
3486  params.body = body;
3487  params.bodySize = bodySize;
3488  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3489  }
3490 
3491 
3492 
3493  typedef struct
3494  {
3495  const OrthancPluginImage* image;
3496  uint32_t* resultUint32;
3497  OrthancPluginPixelFormat* resultPixelFormat;
3498  void** resultBuffer;
3499  } _OrthancPluginGetImageInfo;
3500 
3501 
3513  OrthancPluginContext* context,
3514  const OrthancPluginImage* image)
3515  {
3516  OrthancPluginPixelFormat target;
3517 
3518  _OrthancPluginGetImageInfo params;
3519  memset(&params, 0, sizeof(params));
3520  params.image = image;
3521  params.resultPixelFormat = &target;
3522 
3523  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3524  {
3526  }
3527  else
3528  {
3529  return (OrthancPluginPixelFormat) target;
3530  }
3531  }
3532 
3533 
3534 
3545  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3546  OrthancPluginContext* context,
3547  const OrthancPluginImage* image)
3548  {
3549  uint32_t width;
3550 
3551  _OrthancPluginGetImageInfo params;
3552  memset(&params, 0, sizeof(params));
3553  params.image = image;
3554  params.resultUint32 = &width;
3555 
3556  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3557  {
3558  return 0;
3559  }
3560  else
3561  {
3562  return width;
3563  }
3564  }
3565 
3566 
3567 
3578  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3579  OrthancPluginContext* context,
3580  const OrthancPluginImage* image)
3581  {
3582  uint32_t height;
3583 
3584  _OrthancPluginGetImageInfo params;
3585  memset(&params, 0, sizeof(params));
3586  params.image = image;
3587  params.resultUint32 = &height;
3588 
3589  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3590  {
3591  return 0;
3592  }
3593  else
3594  {
3595  return height;
3596  }
3597  }
3598 
3599 
3600 
3613  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3614  OrthancPluginContext* context,
3615  const OrthancPluginImage* image)
3616  {
3617  uint32_t pitch;
3618 
3619  _OrthancPluginGetImageInfo params;
3620  memset(&params, 0, sizeof(params));
3621  params.image = image;
3622  params.resultUint32 = &pitch;
3623 
3624  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
3625  {
3626  return 0;
3627  }
3628  else
3629  {
3630  return pitch;
3631  }
3632  }
3633 
3634 
3635 
3647  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
3648  OrthancPluginContext* context,
3649  const OrthancPluginImage* image)
3650  {
3651  void* target = NULL;
3652 
3653  _OrthancPluginGetImageInfo params;
3654  memset(&params, 0, sizeof(params));
3655  params.resultBuffer = &target;
3656  params.image = image;
3657 
3658  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
3659  {
3660  return NULL;
3661  }
3662  else
3663  {
3664  return target;
3665  }
3666  }
3667 
3668 
3669  typedef struct
3670  {
3671  OrthancPluginImage** target;
3672  const void* data;
3673  uint32_t size;
3674  OrthancPluginImageFormat format;
3675  } _OrthancPluginUncompressImage;
3676 
3677 
3691  OrthancPluginContext* context,
3692  const void* data,
3693  uint32_t size,
3694  OrthancPluginImageFormat format)
3695  {
3696  OrthancPluginImage* target = NULL;
3697 
3698  _OrthancPluginUncompressImage params;
3699  memset(&params, 0, sizeof(params));
3700  params.target = &target;
3701  params.data = data;
3702  params.size = size;
3703  params.format = format;
3704 
3705  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
3706  {
3707  return NULL;
3708  }
3709  else
3710  {
3711  return target;
3712  }
3713  }
3714 
3715 
3716 
3717 
3718  typedef struct
3719  {
3720  OrthancPluginImage* image;
3721  } _OrthancPluginFreeImage;
3722 
3732  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
3733  OrthancPluginContext* context,
3734  OrthancPluginImage* image)
3735  {
3736  _OrthancPluginFreeImage params;
3737  params.image = image;
3738 
3739  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
3740  }
3741 
3742 
3743 
3744 
3745  typedef struct
3746  {
3747  OrthancPluginMemoryBuffer* target;
3748  OrthancPluginImageFormat imageFormat;
3749  OrthancPluginPixelFormat pixelFormat;
3750  uint32_t width;
3751  uint32_t height;
3752  uint32_t pitch;
3753  const void* buffer;
3754  uint8_t quality;
3755  } _OrthancPluginCompressImage;
3756 
3757 
3778  OrthancPluginContext* context,
3779  OrthancPluginMemoryBuffer* target,
3780  OrthancPluginPixelFormat format,
3781  uint32_t width,
3782  uint32_t height,
3783  uint32_t pitch,
3784  const void* buffer)
3785  {
3786  _OrthancPluginCompressImage params;
3787  memset(&params, 0, sizeof(params));
3788  params.target = target;
3789  params.imageFormat = OrthancPluginImageFormat_Png;
3790  params.pixelFormat = format;
3791  params.width = width;
3792  params.height = height;
3793  params.pitch = pitch;
3794  params.buffer = buffer;
3795  params.quality = 0; /* Unused for PNG */
3796 
3797  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3798  }
3799 
3800 
3823  OrthancPluginContext* context,
3824  OrthancPluginMemoryBuffer* target,
3825  OrthancPluginPixelFormat format,
3826  uint32_t width,
3827  uint32_t height,
3828  uint32_t pitch,
3829  const void* buffer,
3830  uint8_t quality)
3831  {
3832  _OrthancPluginCompressImage params;
3833  memset(&params, 0, sizeof(params));
3834  params.target = target;
3835  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3836  params.pixelFormat = format;
3837  params.width = width;
3838  params.height = height;
3839  params.pitch = pitch;
3840  params.buffer = buffer;
3841  params.quality = quality;
3842 
3843  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3844  }
3845 
3846 
3847 
3869  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
3870  OrthancPluginContext* context,
3871  OrthancPluginRestOutput* output,
3872  OrthancPluginPixelFormat format,
3873  uint32_t width,
3874  uint32_t height,
3875  uint32_t pitch,
3876  const void* buffer,
3877  uint8_t quality)
3878  {
3879  _OrthancPluginCompressAndAnswerImage params;
3880  params.output = output;
3881  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3882  params.pixelFormat = format;
3883  params.width = width;
3884  params.height = height;
3885  params.pitch = pitch;
3886  params.buffer = buffer;
3887  params.quality = quality;
3888  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
3889  }
3890 
3891 
3892 
3893 
3894  typedef struct
3895  {
3896  OrthancPluginMemoryBuffer* target;
3897  OrthancPluginHttpMethod method;
3898  const char* url;
3899  const char* username;
3900  const char* password;
3901  const char* body;
3902  uint32_t bodySize;
3903  } _OrthancPluginCallHttpClient;
3904 
3905 
3922  OrthancPluginContext* context,
3923  OrthancPluginMemoryBuffer* target,
3924  const char* url,
3925  const char* username,
3926  const char* password)
3927  {
3928  _OrthancPluginCallHttpClient params;
3929  memset(&params, 0, sizeof(params));
3930 
3931  params.target = target;
3932  params.method = OrthancPluginHttpMethod_Get;
3933  params.url = url;
3934  params.username = username;
3935  params.password = password;
3936 
3937  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3938  }
3939 
3940 
3959  OrthancPluginContext* context,
3960  OrthancPluginMemoryBuffer* target,
3961  const char* url,
3962  const char* body,
3963  uint32_t bodySize,
3964  const char* username,
3965  const char* password)
3966  {
3967  _OrthancPluginCallHttpClient params;
3968  memset(&params, 0, sizeof(params));
3969 
3970  params.target = target;
3971  params.method = OrthancPluginHttpMethod_Post;
3972  params.url = url;
3973  params.body = body;
3974  params.bodySize = bodySize;
3975  params.username = username;
3976  params.password = password;
3977 
3978  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3979  }
3980 
3981 
4000  OrthancPluginContext* context,
4001  OrthancPluginMemoryBuffer* target,
4002  const char* url,
4003  const char* body,
4004  uint32_t bodySize,
4005  const char* username,
4006  const char* password)
4007  {
4008  _OrthancPluginCallHttpClient params;
4009  memset(&params, 0, sizeof(params));
4010 
4011  params.target = target;
4012  params.method = OrthancPluginHttpMethod_Put;
4013  params.url = url;
4014  params.body = body;
4015  params.bodySize = bodySize;
4016  params.username = username;
4017  params.password = password;
4018 
4019  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4020  }
4021 
4022 
4037  OrthancPluginContext* context,
4038  const char* url,
4039  const char* username,
4040  const char* password)
4041  {
4042  _OrthancPluginCallHttpClient params;
4043  memset(&params, 0, sizeof(params));
4044 
4045  params.method = OrthancPluginHttpMethod_Delete;
4046  params.url = url;
4047  params.username = username;
4048  params.password = password;
4049 
4050  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4051  }
4052 
4053 
4054 
4055  typedef struct
4056  {
4057  OrthancPluginImage** target;
4058  const OrthancPluginImage* source;
4059  OrthancPluginPixelFormat targetFormat;
4060  } _OrthancPluginConvertPixelFormat;
4061 
4062 
4075  OrthancPluginContext* context,
4076  const OrthancPluginImage* source,
4077  OrthancPluginPixelFormat targetFormat)
4078  {
4079  OrthancPluginImage* target = NULL;
4080 
4081  _OrthancPluginConvertPixelFormat params;
4082  params.target = &target;
4083  params.source = source;
4084  params.targetFormat = targetFormat;
4085 
4086  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4087  {
4088  return NULL;
4089  }
4090  else
4091  {
4092  return target;
4093  }
4094  }
4095 
4096 
4097 
4109  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4110  OrthancPluginContext* context)
4111  {
4112  uint32_t count = 0;
4113 
4114  _OrthancPluginReturnSingleValue params;
4115  memset(&params, 0, sizeof(params));
4116  params.resultUint32 = &count;
4117 
4118  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4119  {
4120  /* Error */
4121  return 0;
4122  }
4123  else
4124  {
4125  return count;
4126  }
4127  }
4128 
4129 
4130 
4131 
4132  typedef struct
4133  {
4134  uint32_t fontIndex; /* in */
4135  const char** name; /* out */
4136  uint32_t* size; /* out */
4137  } _OrthancPluginGetFontInfo;
4138 
4149  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4150  OrthancPluginContext* context,
4151  uint32_t fontIndex)
4152  {
4153  const char* result = NULL;
4154 
4155  _OrthancPluginGetFontInfo params;
4156  memset(&params, 0, sizeof(params));
4157  params.name = &result;
4158  params.fontIndex = fontIndex;
4159 
4160  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4161  {
4162  return NULL;
4163  }
4164  else
4165  {
4166  return result;
4167  }
4168  }
4169 
4170 
4181  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4182  OrthancPluginContext* context,
4183  uint32_t fontIndex)
4184  {
4185  uint32_t result;
4186 
4187  _OrthancPluginGetFontInfo params;
4188  memset(&params, 0, sizeof(params));
4189  params.size = &result;
4190  params.fontIndex = fontIndex;
4191 
4192  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4193  {
4194  return 0;
4195  }
4196  else
4197  {
4198  return result;
4199  }
4200  }
4201 
4202 
4203 
4204  typedef struct
4205  {
4206  OrthancPluginImage* image;
4207  uint32_t fontIndex;
4208  const char* utf8Text;
4209  int32_t x;
4210  int32_t y;
4211  uint8_t r;
4212  uint8_t g;
4213  uint8_t b;
4214  } _OrthancPluginDrawText;
4215 
4216 
4235  OrthancPluginContext* context,
4236  OrthancPluginImage* image,
4237  uint32_t fontIndex,
4238  const char* utf8Text,
4239  int32_t x,
4240  int32_t y,
4241  uint8_t r,
4242  uint8_t g,
4243  uint8_t b)
4244  {
4245  _OrthancPluginDrawText params;
4246  memset(&params, 0, sizeof(params));
4247  params.image = image;
4248  params.fontIndex = fontIndex;
4249  params.utf8Text = utf8Text;
4250  params.x = x;
4251  params.y = y;
4252  params.r = r;
4253  params.g = g;
4254  params.b = b;
4255 
4256  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4257  }
4258 
4259 
4260 
4261  typedef struct
4262  {
4263  OrthancPluginStorageArea* storageArea;
4264  const char* uuid;
4265  const void* content;
4266  uint64_t size;
4268  } _OrthancPluginStorageAreaCreate;
4269 
4270 
4287  OrthancPluginContext* context,
4288  OrthancPluginStorageArea* storageArea,
4289  const char* uuid,
4290  const void* content,
4291  uint64_t size,
4293  {
4294  _OrthancPluginStorageAreaCreate params;
4295  params.storageArea = storageArea;
4296  params.uuid = uuid;
4297  params.content = content;
4298  params.size = size;
4299  params.type = type;
4300 
4301  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4302  }
4303 
4304 
4305  typedef struct
4306  {
4307  OrthancPluginMemoryBuffer* target;
4308  OrthancPluginStorageArea* storageArea;
4309  const char* uuid;
4311  } _OrthancPluginStorageAreaRead;
4312 
4313 
4329  OrthancPluginContext* context,
4330  OrthancPluginMemoryBuffer* target,
4331  OrthancPluginStorageArea* storageArea,
4332  const char* uuid,
4334  {
4335  _OrthancPluginStorageAreaRead params;
4336  params.target = target;
4337  params.storageArea = storageArea;
4338  params.uuid = uuid;
4339  params.type = type;
4340 
4341  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4342  }
4343 
4344 
4345  typedef struct
4346  {
4347  OrthancPluginStorageArea* storageArea;
4348  const char* uuid;
4350  } _OrthancPluginStorageAreaRemove;
4351 
4366  OrthancPluginContext* context,
4367  OrthancPluginStorageArea* storageArea,
4368  const char* uuid,
4370  {
4371  _OrthancPluginStorageAreaRemove params;
4372  params.storageArea = storageArea;
4373  params.uuid = uuid;
4374  params.type = type;
4375 
4376  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4377  }
4378 
4379 
4380 
4381  typedef struct
4382  {
4383  OrthancPluginErrorCode* target;
4384  int32_t code;
4385  uint16_t httpStatus;
4386  const char* message;
4387  } _OrthancPluginRegisterErrorCode;
4388 
4405  OrthancPluginContext* context,
4406  int32_t code,
4407  uint16_t httpStatus,
4408  const char* message)
4409  {
4410  OrthancPluginErrorCode target;
4411 
4412  _OrthancPluginRegisterErrorCode params;
4413  params.target = &target;
4414  params.code = code;
4415  params.httpStatus = httpStatus;
4416  params.message = message;
4417 
4418  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4419  {
4420  return target;
4421  }
4422  else
4423  {
4424  /* There was an error while assigned the error. Use a generic code. */
4426  }
4427  }
4428 
4429 
4430 
4431  typedef struct
4432  {
4433  uint16_t group;
4434  uint16_t element;
4436  const char* name;
4437  uint32_t minMultiplicity;
4438  uint32_t maxMultiplicity;
4439  } _OrthancPluginRegisterDictionaryTag;
4440 
4461  OrthancPluginContext* context,
4462  uint16_t group,
4463  uint16_t element,
4465  const char* name,
4466  uint32_t minMultiplicity,
4467  uint32_t maxMultiplicity)
4468  {
4469  _OrthancPluginRegisterDictionaryTag params;
4470  params.group = group;
4471  params.element = element;
4472  params.vr = vr;
4473  params.name = name;
4474  params.minMultiplicity = minMultiplicity;
4475  params.maxMultiplicity = maxMultiplicity;
4476 
4477  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4478  }
4479 
4480 
4481 
4482  typedef struct
4483  {
4484  uint16_t group;
4485  uint16_t element;
4487  const char* name;
4488  uint32_t minMultiplicity;
4489  uint32_t maxMultiplicity;
4490  const char* privateCreator;
4491  } _OrthancPluginRegisterPrivateDictionaryTag;
4492 
4514  OrthancPluginContext* context,
4515  uint16_t group,
4516  uint16_t element,
4518  const char* name,
4519  uint32_t minMultiplicity,
4520  uint32_t maxMultiplicity,
4521  const char* privateCreator)
4522  {
4523  _OrthancPluginRegisterPrivateDictionaryTag params;
4524  params.group = group;
4525  params.element = element;
4526  params.vr = vr;
4527  params.name = name;
4528  params.minMultiplicity = minMultiplicity;
4529  params.maxMultiplicity = maxMultiplicity;
4530  params.privateCreator = privateCreator;
4531 
4532  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4533  }
4534 
4535 
4536 
4537  typedef struct
4538  {
4539  OrthancPluginStorageArea* storageArea;
4541  } _OrthancPluginReconstructMainDicomTags;
4542 
4558  OrthancPluginContext* context,
4559  OrthancPluginStorageArea* storageArea,
4561  {
4562  _OrthancPluginReconstructMainDicomTags params;
4563  params.level = level;
4564  params.storageArea = storageArea;
4565 
4566  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
4567  }
4568 
4569 
4570  typedef struct
4571  {
4572  char** result;
4573  const char* instanceId;
4574  const void* buffer;
4575  uint32_t size;
4578  uint32_t maxStringLength;
4579  } _OrthancPluginDicomToJson;
4580 
4581 
4601  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4602  OrthancPluginContext* context,
4603  const void* buffer,
4604  uint32_t size,
4607  uint32_t maxStringLength)
4608  {
4609  char* result;
4610 
4611  _OrthancPluginDicomToJson params;
4612  memset(&params, 0, sizeof(params));
4613  params.result = &result;
4614  params.buffer = buffer;
4615  params.size = size;
4616  params.format = format;
4617  params.flags = flags;
4618  params.maxStringLength = maxStringLength;
4619 
4620  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
4621  {
4622  /* Error */
4623  return NULL;
4624  }
4625  else
4626  {
4627  return result;
4628  }
4629  }
4630 
4631 
4650  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
4651  OrthancPluginContext* context,
4652  const char* instanceId,
4655  uint32_t maxStringLength)
4656  {
4657  char* result;
4658 
4659  _OrthancPluginDicomToJson params;
4660  memset(&params, 0, sizeof(params));
4661  params.result = &result;
4662  params.instanceId = instanceId;
4663  params.format = format;
4664  params.flags = flags;
4665  params.maxStringLength = maxStringLength;
4666 
4667  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
4668  {
4669  /* Error */
4670  return NULL;
4671  }
4672  else
4673  {
4674  return result;
4675  }
4676  }
4677 
4678 
4679  typedef struct
4680  {
4681  OrthancPluginMemoryBuffer* target;
4682  const char* uri;
4683  uint32_t headersCount;
4684  const char* const* headersKeys;
4685  const char* const* headersValues;
4686  int32_t afterPlugins;
4687  } _OrthancPluginRestApiGet2;
4688 
4709  OrthancPluginContext* context,
4710  OrthancPluginMemoryBuffer* target,
4711  const char* uri,
4712  uint32_t headersCount,
4713  const char* const* headersKeys,
4714  const char* const* headersValues,
4715  int32_t afterPlugins)
4716  {
4717  _OrthancPluginRestApiGet2 params;
4718  params.target = target;
4719  params.uri = uri;
4720  params.headersCount = headersCount;
4721  params.headersKeys = headersKeys;
4722  params.headersValues = headersValues;
4723  params.afterPlugins = afterPlugins;
4724 
4725  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
4726  }
4727 
4728 
4729 
4730  typedef struct
4731  {
4733  } _OrthancPluginWorklistCallback;
4734 
4747  OrthancPluginContext* context,
4749  {
4750  _OrthancPluginWorklistCallback params;
4751  params.callback = callback;
4752 
4753  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
4754  }
4755 
4756 
4757 
4758  typedef struct
4759  {
4761  const OrthancPluginWorklistQuery* query;
4762  const void* dicom;
4763  uint32_t size;
4764  } _OrthancPluginWorklistAnswersOperation;
4765 
4783  OrthancPluginContext* context,
4785  const OrthancPluginWorklistQuery* query,
4786  const void* dicom,
4787  uint32_t size)
4788  {
4789  _OrthancPluginWorklistAnswersOperation params;
4790  params.answers = answers;
4791  params.query = query;
4792  params.dicom = dicom;
4793  params.size = size;
4794 
4795  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
4796  }
4797 
4798 
4813  OrthancPluginContext* context,
4815  {
4816  _OrthancPluginWorklistAnswersOperation params;
4817  params.answers = answers;
4818  params.query = NULL;
4819  params.dicom = NULL;
4820  params.size = 0;
4821 
4822  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
4823  }
4824 
4825 
4826  typedef struct
4827  {
4828  const OrthancPluginWorklistQuery* query;
4829  const void* dicom;
4830  uint32_t size;
4831  int32_t* isMatch;
4832  OrthancPluginMemoryBuffer* target;
4833  } _OrthancPluginWorklistQueryOperation;
4834 
4850  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
4851  OrthancPluginContext* context,
4852  const OrthancPluginWorklistQuery* query,
4853  const void* dicom,
4854  uint32_t size)
4855  {
4856  int32_t isMatch = 0;
4857 
4858  _OrthancPluginWorklistQueryOperation params;
4859  params.query = query;
4860  params.dicom = dicom;
4861  params.size = size;
4862  params.isMatch = &isMatch;
4863  params.target = NULL;
4864 
4865  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
4866  {
4867  return isMatch;
4868  }
4869  else
4870  {
4871  /* Error: Assume non-match */
4872  return 0;
4873  }
4874  }
4875 
4876 
4890  OrthancPluginContext* context,
4891  OrthancPluginMemoryBuffer* target,
4892  const OrthancPluginWorklistQuery* query)
4893  {
4894  _OrthancPluginWorklistQueryOperation params;
4895  params.query = query;
4896  params.dicom = NULL;
4897  params.size = 0;
4898  params.isMatch = NULL;
4899  params.target = target;
4900 
4901  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
4902  }
4903 
4904 
4916  OrthancPluginContext* context,
4917  OrthancPluginDicomInstance* instance)
4918  {
4920 
4921  _OrthancPluginAccessDicomInstance params;
4922  memset(&params, 0, sizeof(params));
4923  params.resultOrigin = &origin;
4924  params.instance = instance;
4925 
4926  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
4927  {
4928  /* Error */
4930  }
4931  else
4932  {
4933  return origin;
4934  }
4935  }
4936 
4937 
4938  typedef struct
4939  {
4940  OrthancPluginMemoryBuffer* target;
4941  const char* json;
4942  const OrthancPluginImage* pixelData;
4944  } _OrthancPluginCreateDicom;
4945 
4965  OrthancPluginContext* context,
4966  OrthancPluginMemoryBuffer* target,
4967  const char* json,
4968  const OrthancPluginImage* pixelData,
4970  {
4971  _OrthancPluginCreateDicom params;
4972  params.target = target;
4973  params.json = json;
4974  params.pixelData = pixelData;
4975  params.flags = flags;
4976 
4977  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
4978  }
4979 
4980 
4981  typedef struct
4982  {
4984  } _OrthancPluginDecodeImageCallback;
4985 
4998  OrthancPluginContext* context,
5000  {
5001  _OrthancPluginDecodeImageCallback params;
5002  params.callback = callback;
5003 
5004  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5005  }
5006 
5007 
5008 
5009  typedef struct
5010  {
5011  OrthancPluginImage** target;
5012  OrthancPluginPixelFormat format;
5013  uint32_t width;
5014  uint32_t height;
5015  uint32_t pitch;
5016  void* buffer;
5017  const void* constBuffer;
5018  uint32_t bufferSize;
5019  uint32_t frameIndex;
5020  } _OrthancPluginCreateImage;
5021 
5022 
5036  OrthancPluginContext* context,
5037  OrthancPluginPixelFormat format,
5038  uint32_t width,
5039  uint32_t height)
5040  {
5041  OrthancPluginImage* target = NULL;
5042 
5043  _OrthancPluginCreateImage params;
5044  memset(&params, 0, sizeof(params));
5045  params.target = &target;
5046  params.format = format;
5047  params.width = width;
5048  params.height = height;
5049 
5050  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5051  {
5052  return NULL;
5053  }
5054  else
5055  {
5056  return target;
5057  }
5058  }
5059 
5060 
5079  OrthancPluginContext* context,
5080  OrthancPluginPixelFormat format,
5081  uint32_t width,
5082  uint32_t height,
5083  uint32_t pitch,
5084  void* buffer)
5085  {
5086  OrthancPluginImage* target = NULL;
5087 
5088  _OrthancPluginCreateImage params;
5089  memset(&params, 0, sizeof(params));
5090  params.target = &target;
5091  params.format = format;
5092  params.width = width;
5093  params.height = height;
5094  params.pitch = pitch;
5095  params.buffer = buffer;
5096 
5097  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5098  {
5099  return NULL;
5100  }
5101  else
5102  {
5103  return target;
5104  }
5105  }
5106 
5107 
5108 
5124  OrthancPluginContext* context,
5125  const void* buffer,
5126  uint32_t bufferSize,
5127  uint32_t frameIndex)
5128  {
5129  OrthancPluginImage* target = NULL;
5130 
5131  _OrthancPluginCreateImage params;
5132  memset(&params, 0, sizeof(params));
5133  params.target = &target;
5134  params.constBuffer = buffer;
5135  params.bufferSize = bufferSize;
5136  params.frameIndex = frameIndex;
5137 
5138  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5139  {
5140  return NULL;
5141  }
5142  else
5143  {
5144  return target;
5145  }
5146  }
5147 
5148 
5149 
5150  typedef struct
5151  {
5152  char** result;
5153  const void* buffer;
5154  uint32_t size;
5155  } _OrthancPluginComputeHash;
5156 
5169  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5170  OrthancPluginContext* context,
5171  const void* buffer,
5172  uint32_t size)
5173  {
5174  char* result;
5175 
5176  _OrthancPluginComputeHash params;
5177  params.result = &result;
5178  params.buffer = buffer;
5179  params.size = size;
5180 
5181  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5182  {
5183  /* Error */
5184  return NULL;
5185  }
5186  else
5187  {
5188  return result;
5189  }
5190  }
5191 
5192 
5205  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5206  OrthancPluginContext* context,
5207  const void* buffer,
5208  uint32_t size)
5209  {
5210  char* result;
5211 
5212  _OrthancPluginComputeHash params;
5213  params.result = &result;
5214  params.buffer = buffer;
5215  params.size = size;
5216 
5217  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5218  {
5219  /* Error */
5220  return NULL;
5221  }
5222  else
5223  {
5224  return result;
5225  }
5226  }
5227 
5228 
5229 
5230  typedef struct
5231  {
5233  const char* name;
5234  } _OrthancPluginLookupDictionary;
5235 
5252  OrthancPluginContext* context,
5254  const char* name)
5255  {
5256  _OrthancPluginLookupDictionary params;
5257  params.target = target;
5258  params.name = name;
5259  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5260  }
5261 
5262 
5263 
5264  typedef struct
5265  {
5266  OrthancPluginRestOutput* output;
5267  const char* answer;
5268  uint32_t answerSize;
5269  uint32_t headersCount;
5270  const char* const* headersKeys;
5271  const char* const* headersValues;
5272  } _OrthancPluginSendMultipartItem2;
5273 
5295  OrthancPluginContext* context,
5296  OrthancPluginRestOutput* output,
5297  const char* answer,
5298  uint32_t answerSize,
5299  uint32_t headersCount,
5300  const char* const* headersKeys,
5301  const char* const* headersValues)
5302  {
5303  _OrthancPluginSendMultipartItem2 params;
5304  params.output = output;
5305  params.answer = answer;
5306  params.answerSize = answerSize;
5307  params.headersCount = headersCount;
5308  params.headersKeys = headersKeys;
5309  params.headersValues = headersValues;
5310 
5311  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5312  }
5313 
5314 
5315  typedef struct
5316  {
5318  } _OrthancPluginIncomingHttpRequestFilter;
5319 
5333  OrthancPluginContext* context,
5335  {
5336  _OrthancPluginIncomingHttpRequestFilter params;
5337  params.callback = callback;
5338 
5339  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5340  }
5341 
5342 
5343 
5344  typedef struct
5345  {
5346  OrthancPluginMemoryBuffer* answerBody;
5347  OrthancPluginMemoryBuffer* answerHeaders;
5348  uint16_t* httpStatus;
5349  OrthancPluginHttpMethod method;
5350  const char* url;
5351  uint32_t headersCount;
5352  const char* const* headersKeys;
5353  const char* const* headersValues;
5354  const char* body;
5355  uint32_t bodySize;
5356  const char* username;
5357  const char* password;
5358  uint32_t timeout;
5359  const char* certificateFile;
5360  const char* certificateKeyFile;
5361  const char* certificateKeyPassword;
5362  uint8_t pkcs11;
5363  } _OrthancPluginCallHttpClient2;
5364 
5365 
5366 
5406  OrthancPluginContext* context,
5407  OrthancPluginMemoryBuffer* answerBody,
5408  OrthancPluginMemoryBuffer* answerHeaders,
5409  uint16_t* httpStatus,
5410  OrthancPluginHttpMethod method,
5411  const char* url,
5412  uint32_t headersCount,
5413  const char* const* headersKeys,
5414  const char* const* headersValues,
5415  const char* body,
5416  uint32_t bodySize,
5417  const char* username,
5418  const char* password,
5419  uint32_t timeout,
5420  const char* certificateFile,
5421  const char* certificateKeyFile,
5422  const char* certificateKeyPassword,
5423  uint8_t pkcs11)
5424  {
5425  _OrthancPluginCallHttpClient2 params;
5426  memset(&params, 0, sizeof(params));
5427 
5428  params.answerBody = answerBody;
5429  params.answerHeaders = answerHeaders;
5430  params.httpStatus = httpStatus;
5431  params.method = method;
5432  params.url = url;
5433  params.headersCount = headersCount;
5434  params.headersKeys = headersKeys;
5435  params.headersValues = headersValues;
5436  params.body = body;
5437  params.bodySize = bodySize;
5438  params.username = username;
5439  params.password = password;
5440  params.timeout = timeout;
5441  params.certificateFile = certificateFile;
5442  params.certificateKeyFile = certificateKeyFile;
5443  params.certificateKeyPassword = certificateKeyPassword;
5444  params.pkcs11 = pkcs11;
5445 
5446  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5447  }
5448 
5449 
5460  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5461  OrthancPluginContext* context)
5462  {
5463  char* result;
5464 
5465  _OrthancPluginRetrieveDynamicString params;
5466  params.result = &result;
5467  params.argument = NULL;
5468 
5469  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5470  {
5471  /* Error */
5472  return NULL;
5473  }
5474  else
5475  {
5476  return result;
5477  }
5478  }
5479 
5480 
5481 
5482 
5483  typedef struct
5484  {
5485  OrthancPluginFindCallback callback;
5486  } _OrthancPluginFindCallback;
5487 
5500  OrthancPluginContext* context,
5501  OrthancPluginFindCallback callback)
5502  {
5503  _OrthancPluginFindCallback params;
5504  params.callback = callback;
5505 
5506  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5507  }
5508 
5509 
5510  typedef struct
5511  {
5512  OrthancPluginFindAnswers *answers;
5513  const OrthancPluginFindQuery *query;
5514  const void *dicom;
5515  uint32_t size;
5516  uint32_t index;
5517  uint32_t *resultUint32;
5518  uint16_t *resultGroup;
5519  uint16_t *resultElement;
5520  char **resultString;
5521  } _OrthancPluginFindOperation;
5522 
5539  OrthancPluginContext* context,
5540  OrthancPluginFindAnswers* answers,
5541  const void* dicom,
5542  uint32_t size)
5543  {
5544  _OrthancPluginFindOperation params;
5545  memset(&params, 0, sizeof(params));
5546  params.answers = answers;
5547  params.dicom = dicom;
5548  params.size = size;
5549 
5550  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
5551  }
5552 
5553 
5568  OrthancPluginContext* context,
5569  OrthancPluginFindAnswers* answers)
5570  {
5571  _OrthancPluginFindOperation params;
5572  memset(&params, 0, sizeof(params));
5573  params.answers = answers;
5574 
5575  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
5576  }
5577 
5578 
5579 
5591  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
5592  OrthancPluginContext* context,
5593  const OrthancPluginFindQuery* query)
5594  {
5595  uint32_t count = 0;
5596 
5597  _OrthancPluginFindOperation params;
5598  memset(&params, 0, sizeof(params));
5599  params.query = query;
5600  params.resultUint32 = &count;
5601 
5602  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
5603  {
5604  /* Error */
5605  return 0;
5606  }
5607  else
5608  {
5609  return count;
5610  }
5611  }
5612 
5613 
5629  OrthancPluginContext* context,
5630  uint16_t* group,
5631  uint16_t* element,
5632  const OrthancPluginFindQuery* query,
5633  uint32_t index)
5634  {
5635  _OrthancPluginFindOperation params;
5636  memset(&params, 0, sizeof(params));
5637  params.query = query;
5638  params.index = index;
5639  params.resultGroup = group;
5640  params.resultElement = element;
5641 
5642  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
5643  }
5644 
5645 
5659  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
5660  OrthancPluginContext* context,
5661  const OrthancPluginFindQuery* query,
5662  uint32_t index)
5663  {
5664  char* result;
5665 
5666  _OrthancPluginFindOperation params;
5667  memset(&params, 0, sizeof(params));
5668  params.query = query;
5669  params.index = index;
5670  params.resultString = &result;
5671 
5672  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
5673  {
5674  /* Error */
5675  return NULL;
5676  }
5677  else
5678  {
5679  return result;
5680  }
5681  }
5682 
5683 
5697  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
5698  OrthancPluginContext* context,
5699  const OrthancPluginFindQuery* query,
5700  uint32_t index)
5701  {
5702  char* result;
5703 
5704  _OrthancPluginFindOperation params;
5705  memset(&params, 0, sizeof(params));
5706  params.query = query;
5707  params.index = index;
5708  params.resultString = &result;
5709 
5710  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
5711  {
5712  /* Error */
5713  return NULL;
5714  }
5715  else
5716  {
5717  return result;
5718  }
5719  }
5720 
5721 
5722 
5723 
5724  typedef struct
5725  {
5726  OrthancPluginMoveCallback callback;
5727  OrthancPluginGetMoveSize getMoveSize;
5728  OrthancPluginApplyMove applyMove;
5729  OrthancPluginFreeMove freeMove;
5730  } _OrthancPluginMoveCallback;
5731 
5746  OrthancPluginContext* context,
5747  OrthancPluginMoveCallback callback,
5748  OrthancPluginGetMoveSize getMoveSize,
5749  OrthancPluginApplyMove applyMove,
5750  OrthancPluginFreeMove freeMove)
5751  {
5752  _OrthancPluginMoveCallback params;
5753  params.callback = callback;
5754  params.getMoveSize = getMoveSize;
5755  params.applyMove = applyMove;
5756  params.freeMove = freeMove;
5757 
5758  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
5759  }
5760 
5761 
5762 
5763  typedef struct
5764  {
5765  OrthancPluginFindMatcher** target;
5766  const void* query;
5767  uint32_t size;
5768  } _OrthancPluginCreateFindMatcher;
5769 
5770 
5785  OrthancPluginContext* context,
5786  const void* query,
5787  uint32_t size)
5788  {
5789  OrthancPluginFindMatcher* target = NULL;
5790 
5791  _OrthancPluginCreateFindMatcher params;
5792  memset(&params, 0, sizeof(params));
5793  params.target = &target;
5794  params.query = query;
5795  params.size = size;
5796 
5797  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
5798  {
5799  return NULL;
5800  }
5801  else
5802  {
5803  return target;
5804  }
5805  }
5806 
5807 
5808  typedef struct
5809  {
5810  OrthancPluginFindMatcher* matcher;
5811  } _OrthancPluginFreeFindMatcher;
5812 
5822  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
5823  OrthancPluginContext* context,
5824  OrthancPluginFindMatcher* matcher)
5825  {
5826  _OrthancPluginFreeFindMatcher params;
5827  params.matcher = matcher;
5828 
5829  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
5830  }
5831 
5832 
5833  typedef struct
5834  {
5835  const OrthancPluginFindMatcher* matcher;
5836  const void* dicom;
5837  uint32_t size;
5838  int32_t* isMatch;
5839  } _OrthancPluginFindMatcherIsMatch;
5840 
5855  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
5856  OrthancPluginContext* context,
5857  const OrthancPluginFindMatcher* matcher,
5858  const void* dicom,
5859  uint32_t size)
5860  {
5861  int32_t isMatch = 0;
5862 
5863  _OrthancPluginFindMatcherIsMatch params;
5864  params.matcher = matcher;
5865  params.dicom = dicom;
5866  params.size = size;
5867  params.isMatch = &isMatch;
5868 
5869  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
5870  {
5871  return isMatch;
5872  }
5873  else
5874  {
5875  /* Error: Assume non-match */
5876  return 0;
5877  }
5878  }
5879 
5880 
5881  typedef struct
5882  {
5884  } _OrthancPluginIncomingHttpRequestFilter2;
5885 
5898  OrthancPluginContext* context,
5900  {
5901  _OrthancPluginIncomingHttpRequestFilter2 params;
5902  params.callback = callback;
5903 
5904  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
5905  }
5906 
5907 
5908 
5909  typedef struct
5910  {
5911  OrthancPluginPeers** peers;
5912  } _OrthancPluginGetPeers;
5913 
5926  OrthancPluginContext* context)
5927  {
5928  OrthancPluginPeers* peers = NULL;
5929 
5930  _OrthancPluginGetPeers params;
5931  memset(&params, 0, sizeof(params));
5932  params.peers = &peers;
5933 
5934  if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
5935  {
5936  return NULL;
5937  }
5938  else
5939  {
5940  return peers;
5941  }
5942  }
5943 
5944 
5945  typedef struct
5946  {
5947  OrthancPluginPeers* peers;
5948  } _OrthancPluginFreePeers;
5949 
5959  ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
5960  OrthancPluginContext* context,
5961  OrthancPluginPeers* peers)
5962  {
5963  _OrthancPluginFreePeers params;
5964  params.peers = peers;
5965 
5966  context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
5967  }
5968 
5969 
5970  typedef struct
5971  {
5972  uint32_t* target;
5973  const OrthancPluginPeers* peers;
5974  } _OrthancPluginGetPeersCount;
5975 
5989  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
5990  OrthancPluginContext* context,
5991  const OrthancPluginPeers* peers)
5992  {
5993  uint32_t target = 0;
5994 
5995  _OrthancPluginGetPeersCount params;
5996  memset(&params, 0, sizeof(params));
5997  params.target = &target;
5998  params.peers = peers;
5999 
6000  if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6001  {
6002  /* Error */
6003  return 0;
6004  }
6005  else
6006  {
6007  return target;
6008  }
6009  }
6010 
6011 
6012  typedef struct
6013  {
6014  const char** target;
6015  const OrthancPluginPeers* peers;
6016  uint32_t peerIndex;
6017  const char* userProperty;
6018  } _OrthancPluginGetPeerProperty;
6019 
6037  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6038  OrthancPluginContext* context,
6039  const OrthancPluginPeers* peers,
6040  uint32_t peerIndex)
6041  {
6042  const char* target = NULL;
6043 
6044  _OrthancPluginGetPeerProperty params;
6045  memset(&params, 0, sizeof(params));
6046  params.target = &target;
6047  params.peers = peers;
6048  params.peerIndex = peerIndex;
6049  params.userProperty = NULL;
6050 
6051  if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6052  {
6053  /* Error */
6054  return NULL;
6055  }
6056  else
6057  {
6058  return target;
6059  }
6060  }
6061 
6062 
6078  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6079  OrthancPluginContext* context,
6080  const OrthancPluginPeers* peers,
6081  uint32_t peerIndex)
6082  {
6083  const char* target = NULL;
6084 
6085  _OrthancPluginGetPeerProperty params;
6086  memset(&params, 0, sizeof(params));
6087  params.target = &target;
6088  params.peers = peers;
6089  params.peerIndex = peerIndex;
6090  params.userProperty = NULL;
6091 
6092  if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6093  {
6094  /* Error */
6095  return NULL;
6096  }
6097  else
6098  {
6099  return target;
6100  }
6101  }
6102 
6103 
6104 
6124  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6125  OrthancPluginContext* context,
6126  const OrthancPluginPeers* peers,
6127  uint32_t peerIndex,
6128  const char* userProperty)
6129  {
6130  const char* target = NULL;
6131 
6132  _OrthancPluginGetPeerProperty params;
6133  memset(&params, 0, sizeof(params));
6134  params.target = &target;
6135  params.peers = peers;
6136  params.peerIndex = peerIndex;
6137  params.userProperty = userProperty;
6138 
6139  if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6140  {
6141  /* No such user property */
6142  return NULL;
6143  }
6144  else
6145  {
6146  return target;
6147  }
6148  }
6149 
6150 
6151 
6152  typedef struct
6153  {
6154  OrthancPluginMemoryBuffer* answerBody;
6155  OrthancPluginMemoryBuffer* answerHeaders;
6156  uint16_t* httpStatus;
6157  const OrthancPluginPeers* peers;
6158  uint32_t peerIndex;
6159  OrthancPluginHttpMethod method;
6160  const char* uri;
6161  uint32_t additionalHeadersCount;
6162  const char* const* additionalHeadersKeys;
6163  const char* const* additionalHeadersValues;
6164  const char* body;
6165  uint32_t bodySize;
6166  uint32_t timeout;
6167  } _OrthancPluginCallPeerApi;
6168 
6205  OrthancPluginContext* context,
6206  OrthancPluginMemoryBuffer* answerBody,
6207  OrthancPluginMemoryBuffer* answerHeaders,
6208  uint16_t* httpStatus,
6209  const OrthancPluginPeers* peers,
6210  uint32_t peerIndex,
6211  OrthancPluginHttpMethod method,
6212  const char* uri,
6213  uint32_t additionalHeadersCount,
6214  const char* const* additionalHeadersKeys,
6215  const char* const* additionalHeadersValues,
6216  const char* body,
6217  uint32_t bodySize,
6218  uint32_t timeout)
6219  {
6220  _OrthancPluginCallPeerApi params;
6221  memset(&params, 0, sizeof(params));
6222 
6223  params.answerBody = answerBody;
6224  params.answerHeaders = answerHeaders;
6225  params.httpStatus = httpStatus;
6226  params.peers = peers;
6227  params.peerIndex = peerIndex;
6228  params.method = method;
6229  params.uri = uri;
6230  params.additionalHeadersCount = additionalHeadersCount;
6231  params.additionalHeadersKeys = additionalHeadersKeys;
6232  params.additionalHeadersValues = additionalHeadersValues;
6233  params.body = body;
6234  params.bodySize = bodySize;
6235  params.timeout = timeout;
6236 
6237  return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6238  }
6239 
6240 
6241 
6242 
6243 
6244  typedef struct
6245  {
6246  OrthancPluginJob** target;
6247  void *job;
6248  OrthancPluginJobFinalize finalize;
6249  const char *type;
6250  OrthancPluginJobGetProgress getProgress;
6251  OrthancPluginJobGetContent getContent;
6252  OrthancPluginJobGetSerialized getSerialized;
6253  OrthancPluginJobStep step;
6254  OrthancPluginJobStop stop;
6255  OrthancPluginJobReset reset;
6256  } _OrthancPluginCreateJob;
6257 
6290  OrthancPluginContext *context,
6291  void *job,
6292  OrthancPluginJobFinalize finalize,
6293  const char *type,
6294  OrthancPluginJobGetProgress getProgress,
6295  OrthancPluginJobGetContent getContent,
6296  OrthancPluginJobGetSerialized getSerialized,
6297  OrthancPluginJobStep step,
6298  OrthancPluginJobStop stop,
6299  OrthancPluginJobReset reset)
6300  {
6301  OrthancPluginJob* target = NULL;
6302 
6303  _OrthancPluginCreateJob params;
6304  memset(&params, 0, sizeof(params));
6305 
6306  params.target = &target;
6307  params.job = job;
6308  params.finalize = finalize;
6309  params.type = type;
6310  params.getProgress = getProgress;
6311  params.getContent = getContent;
6312  params.getSerialized = getSerialized;
6313  params.step = step;
6314  params.stop = stop;
6315  params.reset = reset;
6316 
6317  if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6318  target == NULL)
6319  {
6320  /* Error */
6321  return NULL;
6322  }
6323  else
6324  {
6325  return target;
6326  }
6327  }
6328 
6329 
6330  typedef struct
6331  {
6332  OrthancPluginJob* job;
6333  } _OrthancPluginFreeJob;
6334 
6344  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6345  OrthancPluginContext* context,
6346  OrthancPluginJob* job)
6347  {
6348  _OrthancPluginFreeJob params;
6349  params.job = job;
6350 
6351  context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6352  }
6353 
6354 
6355 
6356  typedef struct
6357  {
6358  char** resultId;
6359  OrthancPluginJob *job;
6360  int priority;
6361  } _OrthancPluginSubmitJob;
6362 
6376  ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6377  OrthancPluginContext *context,
6378  OrthancPluginJob *job,
6379  int priority)
6380  {
6381  char* resultId = NULL;
6382 
6383  _OrthancPluginSubmitJob params;
6384  memset(&params, 0, sizeof(params));
6385 
6386  params.resultId = &resultId;
6387  params.job = job;
6388  params.priority = priority;
6389 
6390  if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6391  resultId == NULL)
6392  {
6393  /* Error */
6394  return NULL;
6395  }
6396  else
6397  {
6398  return resultId;
6399  }
6400  }
6401 
6402 
6403 
6404  typedef struct
6405  {
6406  OrthancPluginJobsUnserializer unserializer;
6407  } _OrthancPluginJobsUnserializer;
6408 
6421  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6422  OrthancPluginContext* context,
6423  OrthancPluginJobsUnserializer unserializer)
6424  {
6425  _OrthancPluginJobsUnserializer params;
6426  params.unserializer = unserializer;
6427 
6428  context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6429  }
6430 
6431 
6432 
6433  typedef struct
6434  {
6435  OrthancPluginRestOutput* output;
6436  const char* details;
6437  uint8_t log;
6438  } _OrthancPluginSetHttpErrorDetails;
6439 
6457  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
6458  OrthancPluginContext* context,
6459  OrthancPluginRestOutput* output,
6460  const char* details,
6461  uint8_t log)
6462  {
6463  _OrthancPluginSetHttpErrorDetails params;
6464  params.output = output;
6465  params.details = details;
6466  params.log = log;
6467  context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
6468  }
6469 
6470 
6471 
6472  typedef struct
6473  {
6474  const char** result;
6475  const char* argument;
6476  } _OrthancPluginRetrieveStaticString;
6477 
6489  ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
6490  OrthancPluginContext* context,
6491  const char* path)
6492  {
6493  const char* result = NULL;
6494 
6495  _OrthancPluginRetrieveStaticString params;
6496  params.result = &result;
6497  params.argument = path;
6498 
6499  if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
6500  {
6501  /* Error */
6502  return NULL;
6503  }
6504  else
6505  {
6506  return result;
6507  }
6508  }
6509 
6510 
6511 #ifdef __cplusplus
6512 }
6513 #endif
6514 
6515 
Definition: OrthancCPlugin.h:727
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2530
Definition: OrthancCPlugin.h:828
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:2709
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:2393
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:5959
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:904
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5538
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2494
Definition: OrthancCPlugin.h:750
Definition: OrthancCPlugin.h:270
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:1660
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:4997
Definition: OrthancCPlugin.h:829
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:2176
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:2081
Definition: OrthancCPlugin.h:668
Definition: OrthancCPlugin.h:749
Definition: OrthancCPlugin.h:844
const char * OrthancPluginGetInstanceData(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2596
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:3777
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:3869
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:854
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:1165
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1593
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:6457
Definition: OrthancCPlugin.h:262
Definition: OrthancCPlugin.h:205
Definition: OrthancCPlugin.h:260
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:839
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1330
Definition: OrthancCPlugin.h:747
Definition: OrthancCPlugin.h:872
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2563
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:4513
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:5205
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:6289
Definition: OrthancCPlugin.h:276
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:559
Definition: OrthancCPlugin.h:845
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:6376
Definition: OrthancCPlugin.h:601
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:2795
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:6489
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:1894
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:6204
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:1462
Definition: OrthancCPlugin.h:282
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4149
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:1034
Definition: OrthancCPlugin.h:224
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5169
Definition: OrthancCPlugin.h:856
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:983
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4074
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:1107
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:4328
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4109
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:2892
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:5628
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:5405
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:2934
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:599
Definition: OrthancCPlugin.h:795
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:792
Definition: OrthancCPlugin.h:873
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:2439
Definition: OrthancCPlugin.h:711
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5460
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1315
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:1796
Definition: OrthancCPlugin.h:871
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:5123
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:5251
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1387
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:4404
Definition: OrthancCPlugin.h:240
uint16_t group
Definition: OrthancCPlugin.h:1445
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:3647
Definition: OrthancCPlugin.h:740
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1448
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:4782
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:2747
Definition: OrthancCPlugin.h:870
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:868
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:935
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:927
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:2142
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3179
Definition: OrthancCPlugin.h:275
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:567
Definition: OrthancCPlugin.h:273
Definition: OrthancCPlugin.h:216
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:3578
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:738
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3212
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:3476
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:3690
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:991
Definition: OrthancCPlugin.h:269
Definition: OrthancCPlugin.h:712
Definition: OrthancCPlugin.h:745
Definition: OrthancCPlugin.h:286
Definition: OrthancCPlugin.h:858
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:2857
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:5897
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:583
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1443
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:3999
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:4708
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:975
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3512
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:4234
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3613
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:1853
Definition: OrthancCPlugin.h:291
Definition: OrthancCPlugin.h:297
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1363
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1449
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:1023
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:4601
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3113
Definition: OrthancCPlugin.h:242
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2416
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:5822
Definition: OrthancCPlugin.h:287
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:1628
Definition: OrthancCPlugin.h:230
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:5784
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:889
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4181
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:3009
Definition: OrthancCPlugin.h:843
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1927
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3423
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:1134
Definition: OrthancCPlugin.h:690
Definition: OrthancCPlugin.h:797
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1612
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:4746
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1050
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:1235
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:2058
Definition: OrthancCPlugin.h:762
Definition: OrthancCPlugin.h:669
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3361
Definition: OrthancCPlugin.h:751
Definition: OrthancCPlugin.h:830
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:959
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:5745
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:5035
Definition: OrthancCPlugin.h:753
Definition: OrthancCPlugin.h:247
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:2827
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3043
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:5294
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1088
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:4557
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:5659
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6421
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3147
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:3921
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:5078
Definition: OrthancCPlugin.h:264
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5332
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:4650
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:6124
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:1012
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:5925
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:2670
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:3324
Definition: OrthancCPlugin.h:257
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:4812
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:4964
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:1736
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1192
Definition: OrthancCPlugin.h:695
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5499
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:919
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:2106
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3253
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:943
Definition: OrthancCPlugin.h:202
Definition: OrthancCPlugin.h:228
Definition: OrthancCPlugin.h:221
Definition: OrthancCPlugin.h:827
Definition: OrthancCPlugin.h:295
Definition: OrthancCPlugin.h:266
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1289
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:2965
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1348
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4365
Definition: OrthancCPlugin.h:857
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6344
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:2208
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:4915
Definition: OrthancCPlugin.h:761
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:3732
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1447
uint16_t element
Definition: OrthancCPlugin.h:1446
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2348
Definition: OrthancCPlugin.h:694
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3082
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1275
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:3282
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:3392
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:1070
Definition: OrthancCPlugin.h:268
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2243
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:894
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:625
Definition: OrthancCPlugin.h:841
Definition: OrthancCPlugin.h:248
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1404
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance received by Orthanc.
Definition: OrthancCPlugin.h:911
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:1644
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:4850
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:1492
Definition: OrthancCPlugin.h:766
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:825
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:5567
Definition: OrthancCPlugin.h:319
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialized a custom job.
Definition: OrthancCPlugin.h:1420
Definition: OrthancCPlugin.h:239
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2469
Definition: OrthancCPlugin.h:686
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:5989
Definition: OrthancCPlugin.h:756
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2632
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6078
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5591
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:2987
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:1994
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:1764
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:4460
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:3958
Definition: OrthancCPlugin.h:743
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:617
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:1696
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2278
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:4889
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:1957
Definition: OrthancCPlugin.h:842
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:1002
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:951
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:2029
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:4286
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4036
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:884
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6037
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:5855
Definition: OrthancCPlugin.h:754
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1302
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2313
Definition: OrthancCPlugin.h:208
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1260
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:3545
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:3822
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:967
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:5697
Definition: OrthancCPlugin.h:238
Definition: OrthancCPlugin.h:231