Orthanc Plugin SDK  1.8.0
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1 
104 #pragma once
105 
106 
107 #include <stdio.h>
108 #include <string.h>
109 
110 #ifdef WIN32
111 # define ORTHANC_PLUGINS_API __declspec(dllexport)
112 #elif __GNUC__ >= 4
113 # define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default")))
114 #else
115 # define ORTHANC_PLUGINS_API
116 #endif
117 
118 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
119 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 8
120 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 0
121 
122 
123 #if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
124 #define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
125  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
126  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
127  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
128  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
129  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
130 #endif
131 
132 
133 
134 /********************************************************************
135  ** Check that function inlining is properly supported. The use of
136  ** inlining is required, to avoid the duplication of object code
137  ** between two compilation modules that would use the Orthanc Plugin
138  ** API.
139  ********************************************************************/
140 
141 /* If the auto-detection of the "inline" keyword below does not work
142  automatically and that your compiler is known to properly support
143  inlining, uncomment the following #define and adapt the definition
144  of "static inline". */
145 
146 /* #define ORTHANC_PLUGIN_INLINE static inline */
147 
148 #ifndef ORTHANC_PLUGIN_INLINE
149 # if __STDC_VERSION__ >= 199901L
150 /* This is C99 or above: http://predef.sourceforge.net/prestd.html */
151 # define ORTHANC_PLUGIN_INLINE static inline
152 # elif defined(__cplusplus)
153 /* This is C++ */
154 # define ORTHANC_PLUGIN_INLINE static inline
155 # elif defined(__GNUC__)
156 /* This is GCC running in C89 mode */
157 # define ORTHANC_PLUGIN_INLINE static __inline
158 # elif defined(_MSC_VER)
159 /* This is Visual Studio running in C89 mode */
160 # define ORTHANC_PLUGIN_INLINE static __inline
161 # else
162 # error Your compiler is not known to support the "inline" keyword
163 # endif
164 #endif
165 
166 
167 
168 /********************************************************************
169  ** Inclusion of standard libraries.
170  ********************************************************************/
171 
177 #include <stdint.h>
178 
179 #include <stdlib.h>
180 
181 
182 
183 /********************************************************************
184  ** Definition of the Orthanc Plugin API.
185  ********************************************************************/
186 
189 #ifdef __cplusplus
190 extern "C"
191 {
192 #endif
193 
197  typedef enum
198  {
302 
303  _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
305 
306 
311  ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
312 
313 
317  typedef enum
318  {
324  _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
326 
327 
332  typedef struct
333  {
338 
342  uint32_t groupsCount;
343 
347  const char* const* groups;
348 
352  uint32_t getCount;
353 
357  const char* const* getKeys;
358 
362  const char* const* getValues;
363 
367  const void* body;
368 
372  uint32_t bodySize;
373 
374 
375  /* --------------------------------------------------
376  New in version 0.8.1
377  -------------------------------------------------- */
378 
382  uint32_t headersCount;
383 
387  const char* const* headersKeys;
388 
392  const char* const* headersValues;
393 
395 
396 
397  typedef enum
398  {
399  /* Generic services */
400  _OrthancPluginService_LogInfo = 1,
401  _OrthancPluginService_LogWarning = 2,
402  _OrthancPluginService_LogError = 3,
403  _OrthancPluginService_GetOrthancPath = 4,
404  _OrthancPluginService_GetOrthancDirectory = 5,
405  _OrthancPluginService_GetConfigurationPath = 6,
406  _OrthancPluginService_SetPluginProperty = 7,
407  _OrthancPluginService_GetGlobalProperty = 8,
408  _OrthancPluginService_SetGlobalProperty = 9,
409  _OrthancPluginService_GetCommandLineArgumentsCount = 10,
410  _OrthancPluginService_GetCommandLineArgument = 11,
411  _OrthancPluginService_GetExpectedDatabaseVersion = 12,
412  _OrthancPluginService_GetConfiguration = 13,
413  _OrthancPluginService_BufferCompression = 14,
414  _OrthancPluginService_ReadFile = 15,
415  _OrthancPluginService_WriteFile = 16,
416  _OrthancPluginService_GetErrorDescription = 17,
417  _OrthancPluginService_CallHttpClient = 18,
418  _OrthancPluginService_RegisterErrorCode = 19,
419  _OrthancPluginService_RegisterDictionaryTag = 20,
420  _OrthancPluginService_DicomBufferToJson = 21,
421  _OrthancPluginService_DicomInstanceToJson = 22,
422  _OrthancPluginService_CreateDicom = 23,
423  _OrthancPluginService_ComputeMd5 = 24,
424  _OrthancPluginService_ComputeSha1 = 25,
425  _OrthancPluginService_LookupDictionary = 26,
426  _OrthancPluginService_CallHttpClient2 = 27,
427  _OrthancPluginService_GenerateUuid = 28,
428  _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
429  _OrthancPluginService_AutodetectMimeType = 30,
430  _OrthancPluginService_SetMetricsValue = 31,
431  _OrthancPluginService_EncodeDicomWebJson = 32,
432  _OrthancPluginService_EncodeDicomWebXml = 33,
433  _OrthancPluginService_ChunkedHttpClient = 34, /* New in Orthanc 1.5.7 */
434  _OrthancPluginService_GetTagName = 35, /* New in Orthanc 1.5.7 */
435  _OrthancPluginService_EncodeDicomWebJson2 = 36, /* New in Orthanc 1.7.0 */
436  _OrthancPluginService_EncodeDicomWebXml2 = 37, /* New in Orthanc 1.7.0 */
437  _OrthancPluginService_CreateMemoryBuffer = 38, /* New in Orthanc 1.7.0 */
438 
439  /* Registration of callbacks */
440  _OrthancPluginService_RegisterRestCallback = 1000,
441  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
442  _OrthancPluginService_RegisterStorageArea = 1002,
443  _OrthancPluginService_RegisterOnChangeCallback = 1003,
444  _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
445  _OrthancPluginService_RegisterWorklistCallback = 1005,
446  _OrthancPluginService_RegisterDecodeImageCallback = 1006,
447  _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
448  _OrthancPluginService_RegisterFindCallback = 1008,
449  _OrthancPluginService_RegisterMoveCallback = 1009,
450  _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
451  _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
452  _OrthancPluginService_RegisterChunkedRestCallback = 1012, /* New in Orthanc 1.5.7 */
453  _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
454  _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
455  _OrthancPluginService_RegisterTranscoderCallback = 1015, /* New in Orthanc 1.7.0 */
456 
457  /* Sending answers to REST calls */
458  _OrthancPluginService_AnswerBuffer = 2000,
459  _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
460  _OrthancPluginService_Redirect = 2002,
461  _OrthancPluginService_SendHttpStatusCode = 2003,
462  _OrthancPluginService_SendUnauthorized = 2004,
463  _OrthancPluginService_SendMethodNotAllowed = 2005,
464  _OrthancPluginService_SetCookie = 2006,
465  _OrthancPluginService_SetHttpHeader = 2007,
466  _OrthancPluginService_StartMultipartAnswer = 2008,
467  _OrthancPluginService_SendMultipartItem = 2009,
468  _OrthancPluginService_SendHttpStatus = 2010,
469  _OrthancPluginService_CompressAndAnswerImage = 2011,
470  _OrthancPluginService_SendMultipartItem2 = 2012,
471  _OrthancPluginService_SetHttpErrorDetails = 2013,
472 
473  /* Access to the Orthanc database and API */
474  _OrthancPluginService_GetDicomForInstance = 3000,
475  _OrthancPluginService_RestApiGet = 3001,
476  _OrthancPluginService_RestApiPost = 3002,
477  _OrthancPluginService_RestApiDelete = 3003,
478  _OrthancPluginService_RestApiPut = 3004,
479  _OrthancPluginService_LookupPatient = 3005,
480  _OrthancPluginService_LookupStudy = 3006,
481  _OrthancPluginService_LookupSeries = 3007,
482  _OrthancPluginService_LookupInstance = 3008,
483  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
484  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
485  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
486  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
487  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
488  _OrthancPluginService_ReconstructMainDicomTags = 3014,
489  _OrthancPluginService_RestApiGet2 = 3015,
490 
491  /* Access to DICOM instances */
492  _OrthancPluginService_GetInstanceRemoteAet = 4000,
493  _OrthancPluginService_GetInstanceSize = 4001,
494  _OrthancPluginService_GetInstanceData = 4002,
495  _OrthancPluginService_GetInstanceJson = 4003,
496  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
497  _OrthancPluginService_HasInstanceMetadata = 4005,
498  _OrthancPluginService_GetInstanceMetadata = 4006,
499  _OrthancPluginService_GetInstanceOrigin = 4007,
500  _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
501  _OrthancPluginService_HasInstancePixelData = 4009,
502  _OrthancPluginService_CreateDicomInstance = 4010, /* New in Orthanc 1.7.0 */
503  _OrthancPluginService_FreeDicomInstance = 4011, /* New in Orthanc 1.7.0 */
504  _OrthancPluginService_GetInstanceFramesCount = 4012, /* New in Orthanc 1.7.0 */
505  _OrthancPluginService_GetInstanceRawFrame = 4013, /* New in Orthanc 1.7.0 */
506  _OrthancPluginService_GetInstanceDecodedFrame = 4014, /* New in Orthanc 1.7.0 */
507  _OrthancPluginService_TranscodeDicomInstance = 4015, /* New in Orthanc 1.7.0 */
508  _OrthancPluginService_SerializeDicomInstance = 4016, /* New in Orthanc 1.7.0 */
509  _OrthancPluginService_GetInstanceAdvancedJson = 4017, /* New in Orthanc 1.7.0 */
510  _OrthancPluginService_GetInstanceDicomWebJson = 4018, /* New in Orthanc 1.7.0 */
511  _OrthancPluginService_GetInstanceDicomWebXml = 4019, /* New in Orthanc 1.7.0 */
512 
513  /* Services for plugins implementing a database back-end */
514  _OrthancPluginService_RegisterDatabaseBackend = 5000,
515  _OrthancPluginService_DatabaseAnswer = 5001,
516  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
517  _OrthancPluginService_StorageAreaCreate = 5003,
518  _OrthancPluginService_StorageAreaRead = 5004,
519  _OrthancPluginService_StorageAreaRemove = 5005,
520 
521  /* Primitives for handling images */
522  _OrthancPluginService_GetImagePixelFormat = 6000,
523  _OrthancPluginService_GetImageWidth = 6001,
524  _OrthancPluginService_GetImageHeight = 6002,
525  _OrthancPluginService_GetImagePitch = 6003,
526  _OrthancPluginService_GetImageBuffer = 6004,
527  _OrthancPluginService_UncompressImage = 6005,
528  _OrthancPluginService_FreeImage = 6006,
529  _OrthancPluginService_CompressImage = 6007,
530  _OrthancPluginService_ConvertPixelFormat = 6008,
531  _OrthancPluginService_GetFontsCount = 6009,
532  _OrthancPluginService_GetFontInfo = 6010,
533  _OrthancPluginService_DrawText = 6011,
534  _OrthancPluginService_CreateImage = 6012,
535  _OrthancPluginService_CreateImageAccessor = 6013,
536  _OrthancPluginService_DecodeDicomImage = 6014,
537 
538  /* Primitives for handling C-Find, C-Move and worklists */
539  _OrthancPluginService_WorklistAddAnswer = 7000,
540  _OrthancPluginService_WorklistMarkIncomplete = 7001,
541  _OrthancPluginService_WorklistIsMatch = 7002,
542  _OrthancPluginService_WorklistGetDicomQuery = 7003,
543  _OrthancPluginService_FindAddAnswer = 7004,
544  _OrthancPluginService_FindMarkIncomplete = 7005,
545  _OrthancPluginService_GetFindQuerySize = 7006,
546  _OrthancPluginService_GetFindQueryTag = 7007,
547  _OrthancPluginService_GetFindQueryTagName = 7008,
548  _OrthancPluginService_GetFindQueryValue = 7009,
549  _OrthancPluginService_CreateFindMatcher = 7010,
550  _OrthancPluginService_FreeFindMatcher = 7011,
551  _OrthancPluginService_FindMatcherIsMatch = 7012,
552 
553  /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
554  _OrthancPluginService_GetPeers = 8000,
555  _OrthancPluginService_FreePeers = 8001,
556  _OrthancPluginService_GetPeersCount = 8003,
557  _OrthancPluginService_GetPeerName = 8004,
558  _OrthancPluginService_GetPeerUrl = 8005,
559  _OrthancPluginService_CallPeerApi = 8006,
560  _OrthancPluginService_GetPeerUserProperty = 8007,
561 
562  /* Primitives for handling jobs (new in 1.4.2) */
563  _OrthancPluginService_CreateJob = 9000,
564  _OrthancPluginService_FreeJob = 9001,
565  _OrthancPluginService_SubmitJob = 9002,
566  _OrthancPluginService_RegisterJobsUnserializer = 9003,
567 
568  _OrthancPluginService_INTERNAL = 0x7fffffff
569  } _OrthancPluginService;
570 
571 
572  typedef enum
573  {
574  _OrthancPluginProperty_Description = 1,
575  _OrthancPluginProperty_RootUri = 2,
576  _OrthancPluginProperty_OrthancExplorer = 3,
577 
578  _OrthancPluginProperty_INTERNAL = 0x7fffffff
579  } _OrthancPluginProperty;
580 
581 
582 
587  typedef enum
588  {
596 
604 
612 
620 
628 
638 
646 
654 
662 
670 
671  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
673 
674 
675 
679  typedef enum
680  {
685  _OrthancPluginContentType_INTERNAL = 0x7fffffff
687 
688 
689 
693  typedef enum
694  {
701  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
703 
704 
705 
710  typedef enum
711  {
732  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
734 
735 
740  typedef enum
741  {
747  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
749 
750 
755  typedef enum
756  {
761  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
763 
764 
769  typedef enum
770  {
799  _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
801 
802 
808  typedef enum
809  {
814  _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
816 
817 
823  typedef enum
824  {
825  OrthancPluginDicomToJsonFlags_None = 0,
833  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
835 
836 
842  typedef enum
843  {
844  OrthancPluginCreateDicomFlags_None = 0,
848  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
850 
851 
857  typedef enum
858  {
864  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
866 
867 
872  typedef enum
873  {
880  _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
882 
883 
887  typedef enum
888  {
896  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
898 
899 
903  typedef enum
904  {
909 
910 
917  typedef enum
918  {
924 
925 
929  typedef enum
930  {
940 
941 
946  typedef enum
947  {
952 
953 
959  typedef enum
960  {
988 
989 
990 
998  typedef struct
999  {
1003  void* data;
1004 
1008  uint32_t size;
1010 
1011 
1012 
1013 
1018  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
1019 
1020 
1021 
1026  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
1027 
1028 
1029 
1034  typedef struct _OrthancPluginImage_t OrthancPluginImage;
1035 
1036 
1037 
1042  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
1043 
1044 
1045 
1050  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
1051 
1052 
1053 
1058  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
1059 
1060 
1061 
1066  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1067 
1068 
1069 
1074  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1075 
1076 
1077 
1082  typedef struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher;
1083 
1084 
1085 
1090  typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1091 
1092 
1093 
1098  typedef struct _OrthancPluginJob_t OrthancPluginJob;
1099 
1100 
1101 
1107  typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1108 
1109 
1110 
1116  OrthancPluginRestOutput* output,
1117  const char* url,
1118  const OrthancPluginHttpRequest* request);
1119 
1120 
1121 
1127  const OrthancPluginDicomInstance* instance,
1128  const char* instanceId);
1129 
1130 
1131 
1137  OrthancPluginChangeType changeType,
1138  OrthancPluginResourceType resourceType,
1139  const char* resourceId);
1140 
1141 
1142 
1148  OrthancPluginImage** target,
1149  const void* dicom,
1150  const uint32_t size,
1151  uint32_t frameIndex);
1152 
1153 
1154 
1159  typedef void (*OrthancPluginFree) (void* buffer);
1160 
1161 
1162 
1172  const char* bulkDataUri);
1173 
1174 
1175 
1189  const char* uuid,
1190  const void* content,
1191  int64_t size,
1193 
1194 
1195 
1215  void** content,
1216  int64_t* size,
1217  const char* uuid,
1219 
1220 
1221 
1233  const char* uuid,
1235 
1236 
1237 
1253  const OrthancPluginWorklistQuery* query,
1254  const char* issuerAet,
1255  const char* calledAet);
1256 
1257 
1258 
1279  OrthancPluginHttpMethod method,
1280  const char* uri,
1281  const char* ip,
1282  uint32_t headersCount,
1283  const char* const* headersKeys,
1284  const char* const* headersValues);
1285 
1286 
1287 
1310  OrthancPluginHttpMethod method,
1311  const char* uri,
1312  const char* ip,
1313  uint32_t headersCount,
1314  const char* const* headersKeys,
1315  const char* const* headersValues,
1316  uint32_t getArgumentsCount,
1317  const char* const* getArgumentsKeys,
1318  const char* const* getArgumentsValues);
1319 
1320 
1321 
1337  OrthancPluginFindAnswers* answers,
1338  const OrthancPluginFindQuery* query,
1339  const char* issuerAet,
1340  const char* calledAet);
1341 
1342 
1343 
1379  typedef void* (*OrthancPluginMoveCallback) (
1380  OrthancPluginResourceType resourceType,
1381  const char* patientId,
1382  const char* accessionNumber,
1383  const char* studyInstanceUid,
1384  const char* seriesInstanceUid,
1385  const char* sopInstanceUid,
1386  const char* originatorAet,
1387  const char* sourceAet,
1388  const char* targetAet,
1389  uint16_t originatorId);
1390 
1391 
1404  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1405 
1406 
1419  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1420 
1421 
1433  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1434 
1435 
1446  typedef void (*OrthancPluginJobFinalize) (void* job);
1447 
1448 
1459  typedef float (*OrthancPluginJobGetProgress) (void* job);
1460 
1461 
1474  typedef const char* (*OrthancPluginJobGetContent) (void* job);
1475 
1476 
1492  typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1493 
1494 
1508 
1509 
1533 
1534 
1549 
1550 
1564  typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1565  const char* serialized);
1566 
1567 
1568 
1583 
1584 
1585 
1613  uint32_t levelDepth,
1614  const uint16_t* levelTagGroup,
1615  const uint16_t* levelTagElement,
1616  const uint32_t* levelIndex,
1617  uint16_t tagGroup,
1618  uint16_t tagElement,
1620 
1621 
1622 
1651  uint32_t levelDepth,
1652  const uint16_t* levelTagGroup,
1653  const uint16_t* levelTagElement,
1654  const uint32_t* levelIndex,
1655  uint16_t tagGroup,
1656  uint16_t tagElement,
1658  void* payload);
1659 
1660 
1661 
1665  typedef struct _OrthancPluginContext_t
1666  {
1667  void* pluginsManager;
1668  const char* orthancVersion;
1669  OrthancPluginFree Free;
1670  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1671  _OrthancPluginService service,
1672  const void* params);
1674 
1675 
1676 
1680  typedef struct
1681  {
1682  uint16_t group;
1683  uint16_t element;
1685  uint32_t minMultiplicity;
1686  uint32_t maxMultiplicity;
1688 
1689 
1690 
1699  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1700  OrthancPluginContext* context,
1701  char* str)
1702  {
1703  if (str != NULL)
1704  {
1705  context->Free(str);
1706  }
1707  }
1708 
1709 
1729  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1730  OrthancPluginContext* context,
1731  int expectedMajor,
1732  int expectedMinor,
1733  int expectedRevision)
1734  {
1735  int major, minor, revision;
1736 
1737  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1738  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1739  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1740  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1741  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1742  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1743  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1744  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1745  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1746  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1747  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1748  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1749  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1750  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1751  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1752  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1753  sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1754  sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
1755  sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
1756  sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
1757  sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason))
1758  {
1759  /* Mismatch in the size of the enumerations */
1760  return 0;
1761  }
1762 
1763  /* Assume compatibility with the mainline */
1764  if (!strcmp(context->orthancVersion, "mainline"))
1765  {
1766  return 1;
1767  }
1768 
1769  /* Parse the version of the Orthanc core */
1770  if (
1771 #ifdef _MSC_VER
1772  sscanf_s
1773 #else
1774  sscanf
1775 #endif
1776  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1777  {
1778  return 0;
1779  }
1780 
1781  /* Check the major number of the version */
1782 
1783  if (major > expectedMajor)
1784  {
1785  return 1;
1786  }
1787 
1788  if (major < expectedMajor)
1789  {
1790  return 0;
1791  }
1792 
1793  /* Check the minor number of the version */
1794 
1795  if (minor > expectedMinor)
1796  {
1797  return 1;
1798  }
1799 
1800  if (minor < expectedMinor)
1801  {
1802  return 0;
1803  }
1804 
1805  /* Check the revision number of the version */
1806 
1807  if (revision >= expectedRevision)
1808  {
1809  return 1;
1810  }
1811  else
1812  {
1813  return 0;
1814  }
1815  }
1816 
1817 
1834  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1835  OrthancPluginContext* context)
1836  {
1838  context,
1839  ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1840  ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1841  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1842  }
1843 
1844 
1853  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1854  OrthancPluginContext* context,
1855  OrthancPluginMemoryBuffer* buffer)
1856  {
1857  context->Free(buffer->data);
1858  }
1859 
1860 
1869  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1870  OrthancPluginContext* context,
1871  const char* message)
1872  {
1873  context->InvokeService(context, _OrthancPluginService_LogError, message);
1874  }
1875 
1876 
1885  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
1886  OrthancPluginContext* context,
1887  const char* message)
1888  {
1889  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1890  }
1891 
1892 
1901  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
1902  OrthancPluginContext* context,
1903  const char* message)
1904  {
1905  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
1906  }
1907 
1908 
1909 
1910  typedef struct
1911  {
1912  const char* pathRegularExpression;
1913  OrthancPluginRestCallback callback;
1914  } _OrthancPluginRestCallback;
1915 
1937  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
1938  OrthancPluginContext* context,
1939  const char* pathRegularExpression,
1940  OrthancPluginRestCallback callback)
1941  {
1942  _OrthancPluginRestCallback params;
1943  params.pathRegularExpression = pathRegularExpression;
1944  params.callback = callback;
1945  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
1946  }
1947 
1948 
1949 
1977  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
1978  OrthancPluginContext* context,
1979  const char* pathRegularExpression,
1980  OrthancPluginRestCallback callback)
1981  {
1982  _OrthancPluginRestCallback params;
1983  params.pathRegularExpression = pathRegularExpression;
1984  params.callback = callback;
1985  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
1986  }
1987 
1988 
1989 
1990  typedef struct
1991  {
1993  } _OrthancPluginOnStoredInstanceCallback;
1994 
2016  OrthancPluginContext* context,
2018  {
2019  _OrthancPluginOnStoredInstanceCallback params;
2020  params.callback = callback;
2021 
2022  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
2023  }
2024 
2025 
2026 
2027  typedef struct
2028  {
2029  OrthancPluginRestOutput* output;
2030  const void* answer;
2031  uint32_t answerSize;
2032  const char* mimeType;
2033  } _OrthancPluginAnswerBuffer;
2034 
2047  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
2048  OrthancPluginContext* context,
2049  OrthancPluginRestOutput* output,
2050  const void* answer,
2051  uint32_t answerSize,
2052  const char* mimeType)
2053  {
2054  _OrthancPluginAnswerBuffer params;
2055  params.output = output;
2056  params.answer = answer;
2057  params.answerSize = answerSize;
2058  params.mimeType = mimeType;
2059  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
2060  }
2061 
2062 
2063  typedef struct
2064  {
2065  OrthancPluginRestOutput* output;
2066  OrthancPluginPixelFormat format;
2067  uint32_t width;
2068  uint32_t height;
2069  uint32_t pitch;
2070  const void* buffer;
2071  } _OrthancPluginCompressAndAnswerPngImage;
2072 
2073  typedef struct
2074  {
2075  OrthancPluginRestOutput* output;
2076  OrthancPluginImageFormat imageFormat;
2077  OrthancPluginPixelFormat pixelFormat;
2078  uint32_t width;
2079  uint32_t height;
2080  uint32_t pitch;
2081  const void* buffer;
2082  uint8_t quality;
2083  } _OrthancPluginCompressAndAnswerImage;
2084 
2085 
2104  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2105  OrthancPluginContext* context,
2106  OrthancPluginRestOutput* output,
2107  OrthancPluginPixelFormat format,
2108  uint32_t width,
2109  uint32_t height,
2110  uint32_t pitch,
2111  const void* buffer)
2112  {
2113  _OrthancPluginCompressAndAnswerImage params;
2114  params.output = output;
2115  params.imageFormat = OrthancPluginImageFormat_Png;
2116  params.pixelFormat = format;
2117  params.width = width;
2118  params.height = height;
2119  params.pitch = pitch;
2120  params.buffer = buffer;
2121  params.quality = 0; /* No quality for PNG */
2122  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2123  }
2124 
2125 
2126 
2127  typedef struct
2128  {
2129  OrthancPluginMemoryBuffer* target;
2130  const char* instanceId;
2131  } _OrthancPluginGetDicomForInstance;
2132 
2146  OrthancPluginContext* context,
2147  OrthancPluginMemoryBuffer* target,
2148  const char* instanceId)
2149  {
2150  _OrthancPluginGetDicomForInstance params;
2151  params.target = target;
2152  params.instanceId = instanceId;
2153  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2154  }
2155 
2156 
2157 
2158  typedef struct
2159  {
2160  OrthancPluginMemoryBuffer* target;
2161  const char* uri;
2162  } _OrthancPluginRestApiGet;
2163 
2179  OrthancPluginContext* context,
2180  OrthancPluginMemoryBuffer* target,
2181  const char* uri)
2182  {
2183  _OrthancPluginRestApiGet params;
2184  params.target = target;
2185  params.uri = uri;
2186  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2187  }
2188 
2189 
2190 
2209  OrthancPluginContext* context,
2210  OrthancPluginMemoryBuffer* target,
2211  const char* uri)
2212  {
2213  _OrthancPluginRestApiGet params;
2214  params.target = target;
2215  params.uri = uri;
2216  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2217  }
2218 
2219 
2220 
2221  typedef struct
2222  {
2223  OrthancPluginMemoryBuffer* target;
2224  const char* uri;
2225  const void* body;
2226  uint32_t bodySize;
2227  } _OrthancPluginRestApiPostPut;
2228 
2246  OrthancPluginContext* context,
2247  OrthancPluginMemoryBuffer* target,
2248  const char* uri,
2249  const void* body,
2250  uint32_t bodySize)
2251  {
2252  _OrthancPluginRestApiPostPut params;
2253  params.target = target;
2254  params.uri = uri;
2255  params.body = body;
2256  params.bodySize = bodySize;
2257  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2258  }
2259 
2260 
2281  OrthancPluginContext* context,
2282  OrthancPluginMemoryBuffer* target,
2283  const char* uri,
2284  const void* body,
2285  uint32_t bodySize)
2286  {
2287  _OrthancPluginRestApiPostPut params;
2288  params.target = target;
2289  params.uri = uri;
2290  params.body = body;
2291  params.bodySize = bodySize;
2292  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2293  }
2294 
2295 
2296 
2310  OrthancPluginContext* context,
2311  const char* uri)
2312  {
2313  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2314  }
2315 
2316 
2333  OrthancPluginContext* context,
2334  const char* uri)
2335  {
2336  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2337  }
2338 
2339 
2340 
2358  OrthancPluginContext* context,
2359  OrthancPluginMemoryBuffer* target,
2360  const char* uri,
2361  const void* body,
2362  uint32_t bodySize)
2363  {
2364  _OrthancPluginRestApiPostPut params;
2365  params.target = target;
2366  params.uri = uri;
2367  params.body = body;
2368  params.bodySize = bodySize;
2369  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2370  }
2371 
2372 
2373 
2394  OrthancPluginContext* context,
2395  OrthancPluginMemoryBuffer* target,
2396  const char* uri,
2397  const void* body,
2398  uint32_t bodySize)
2399  {
2400  _OrthancPluginRestApiPostPut params;
2401  params.target = target;
2402  params.uri = uri;
2403  params.body = body;
2404  params.bodySize = bodySize;
2405  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2406  }
2407 
2408 
2409 
2410  typedef struct
2411  {
2412  OrthancPluginRestOutput* output;
2413  const char* argument;
2414  } _OrthancPluginOutputPlusArgument;
2415 
2427  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2428  OrthancPluginContext* context,
2429  OrthancPluginRestOutput* output,
2430  const char* redirection)
2431  {
2432  _OrthancPluginOutputPlusArgument params;
2433  params.output = output;
2434  params.argument = redirection;
2435  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2436  }
2437 
2438 
2439 
2440  typedef struct
2441  {
2442  char** result;
2443  const char* argument;
2444  } _OrthancPluginRetrieveDynamicString;
2445 
2459  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2460  OrthancPluginContext* context,
2461  const char* patientID)
2462  {
2463  char* result;
2464 
2465  _OrthancPluginRetrieveDynamicString params;
2466  params.result = &result;
2467  params.argument = patientID;
2468 
2469  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2470  {
2471  /* Error */
2472  return NULL;
2473  }
2474  else
2475  {
2476  return result;
2477  }
2478  }
2479 
2480 
2494  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2495  OrthancPluginContext* context,
2496  const char* studyUID)
2497  {
2498  char* result;
2499 
2500  _OrthancPluginRetrieveDynamicString params;
2501  params.result = &result;
2502  params.argument = studyUID;
2503 
2504  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2505  {
2506  /* Error */
2507  return NULL;
2508  }
2509  else
2510  {
2511  return result;
2512  }
2513  }
2514 
2515 
2529  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
2530  OrthancPluginContext* context,
2531  const char* accessionNumber)
2532  {
2533  char* result;
2534 
2535  _OrthancPluginRetrieveDynamicString params;
2536  params.result = &result;
2537  params.argument = accessionNumber;
2538 
2539  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2540  {
2541  /* Error */
2542  return NULL;
2543  }
2544  else
2545  {
2546  return result;
2547  }
2548  }
2549 
2550 
2564  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2565  OrthancPluginContext* context,
2566  const char* seriesUID)
2567  {
2568  char* result;
2569 
2570  _OrthancPluginRetrieveDynamicString params;
2571  params.result = &result;
2572  params.argument = seriesUID;
2573 
2574  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2575  {
2576  /* Error */
2577  return NULL;
2578  }
2579  else
2580  {
2581  return result;
2582  }
2583  }
2584 
2585 
2599  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2600  OrthancPluginContext* context,
2601  const char* sopInstanceUID)
2602  {
2603  char* result;
2604 
2605  _OrthancPluginRetrieveDynamicString params;
2606  params.result = &result;
2607  params.argument = sopInstanceUID;
2608 
2609  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2610  {
2611  /* Error */
2612  return NULL;
2613  }
2614  else
2615  {
2616  return result;
2617  }
2618  }
2619 
2620 
2621 
2622  typedef struct
2623  {
2624  OrthancPluginRestOutput* output;
2625  uint16_t status;
2626  } _OrthancPluginSendHttpStatusCode;
2627 
2644  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2645  OrthancPluginContext* context,
2646  OrthancPluginRestOutput* output,
2647  uint16_t status)
2648  {
2649  _OrthancPluginSendHttpStatusCode params;
2650  params.output = output;
2651  params.status = status;
2652  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2653  }
2654 
2655 
2667  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2668  OrthancPluginContext* context,
2669  OrthancPluginRestOutput* output,
2670  const char* realm)
2671  {
2672  _OrthancPluginOutputPlusArgument params;
2673  params.output = output;
2674  params.argument = realm;
2675  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2676  }
2677 
2678 
2690  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2691  OrthancPluginContext* context,
2692  OrthancPluginRestOutput* output,
2693  const char* allowedMethods)
2694  {
2695  _OrthancPluginOutputPlusArgument params;
2696  params.output = output;
2697  params.argument = allowedMethods;
2698  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2699  }
2700 
2701 
2702  typedef struct
2703  {
2704  OrthancPluginRestOutput* output;
2705  const char* key;
2706  const char* value;
2707  } _OrthancPluginSetHttpHeader;
2708 
2720  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2721  OrthancPluginContext* context,
2722  OrthancPluginRestOutput* output,
2723  const char* cookie,
2724  const char* value)
2725  {
2726  _OrthancPluginSetHttpHeader params;
2727  params.output = output;
2728  params.key = cookie;
2729  params.value = value;
2730  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2731  }
2732 
2733 
2745  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2746  OrthancPluginContext* context,
2747  OrthancPluginRestOutput* output,
2748  const char* key,
2749  const char* value)
2750  {
2751  _OrthancPluginSetHttpHeader params;
2752  params.output = output;
2753  params.key = key;
2754  params.value = value;
2755  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2756  }
2757 
2758 
2759  typedef struct
2760  {
2761  char** resultStringToFree;
2762  const char** resultString;
2763  int64_t* resultInt64;
2764  const char* key;
2765  const OrthancPluginDicomInstance* instance;
2766  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2767  } _OrthancPluginAccessDicomInstance;
2768 
2769 
2781  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2782  OrthancPluginContext* context,
2783  const OrthancPluginDicomInstance* instance)
2784  {
2785  const char* result;
2786 
2787  _OrthancPluginAccessDicomInstance params;
2788  memset(&params, 0, sizeof(params));
2789  params.resultString = &result;
2790  params.instance = instance;
2791 
2792  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2793  {
2794  /* Error */
2795  return NULL;
2796  }
2797  else
2798  {
2799  return result;
2800  }
2801  }
2802 
2803 
2814  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2815  OrthancPluginContext* context,
2816  const OrthancPluginDicomInstance* instance)
2817  {
2818  int64_t size;
2819 
2820  _OrthancPluginAccessDicomInstance params;
2821  memset(&params, 0, sizeof(params));
2822  params.resultInt64 = &size;
2823  params.instance = instance;
2824 
2825  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2826  {
2827  /* Error */
2828  return -1;
2829  }
2830  else
2831  {
2832  return size;
2833  }
2834  }
2835 
2836 
2847  ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData(
2848  OrthancPluginContext* context,
2849  const OrthancPluginDicomInstance* instance)
2850  {
2851  const char* result;
2852 
2853  _OrthancPluginAccessDicomInstance params;
2854  memset(&params, 0, sizeof(params));
2855  params.resultString = &result;
2856  params.instance = instance;
2857 
2858  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2859  {
2860  /* Error */
2861  return NULL;
2862  }
2863  else
2864  {
2865  return result;
2866  }
2867  }
2868 
2869 
2883  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
2884  OrthancPluginContext* context,
2885  const OrthancPluginDicomInstance* instance)
2886  {
2887  char* result;
2888 
2889  _OrthancPluginAccessDicomInstance params;
2890  memset(&params, 0, sizeof(params));
2891  params.resultStringToFree = &result;
2892  params.instance = instance;
2893 
2894  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
2895  {
2896  /* Error */
2897  return NULL;
2898  }
2899  else
2900  {
2901  return result;
2902  }
2903  }
2904 
2905 
2921  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
2922  OrthancPluginContext* context,
2923  const OrthancPluginDicomInstance* instance)
2924  {
2925  char* result;
2926 
2927  _OrthancPluginAccessDicomInstance params;
2928  memset(&params, 0, sizeof(params));
2929  params.resultStringToFree = &result;
2930  params.instance = instance;
2931 
2932  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
2933  {
2934  /* Error */
2935  return NULL;
2936  }
2937  else
2938  {
2939  return result;
2940  }
2941  }
2942 
2943 
2960  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
2961  OrthancPluginContext* context,
2962  const OrthancPluginDicomInstance* instance,
2963  const char* metadata)
2964  {
2965  int64_t result;
2966 
2967  _OrthancPluginAccessDicomInstance params;
2968  memset(&params, 0, sizeof(params));
2969  params.resultInt64 = &result;
2970  params.instance = instance;
2971  params.key = metadata;
2972 
2973  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2974  {
2975  /* Error */
2976  return -1;
2977  }
2978  else
2979  {
2980  return (result != 0);
2981  }
2982  }
2983 
2984 
3001  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
3002  OrthancPluginContext* context,
3003  const OrthancPluginDicomInstance* instance,
3004  const char* metadata)
3005  {
3006  const char* result;
3007 
3008  _OrthancPluginAccessDicomInstance params;
3009  memset(&params, 0, sizeof(params));
3010  params.resultString = &result;
3011  params.instance = instance;
3012  params.key = metadata;
3013 
3014  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3015  {
3016  /* Error */
3017  return NULL;
3018  }
3019  else
3020  {
3021  return result;
3022  }
3023  }
3024 
3025 
3026 
3027  typedef struct
3028  {
3032  OrthancPluginFree free;
3033  } _OrthancPluginRegisterStorageArea;
3034 
3049  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
3050  OrthancPluginContext* context,
3054  {
3055  _OrthancPluginRegisterStorageArea params;
3056  params.create = create;
3057  params.read = read;
3058  params.remove = remove;
3059 
3060 #ifdef __cplusplus
3061  params.free = ::free;
3062 #else
3063  params.free = free;
3064 #endif
3065 
3066  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3067  }
3068 
3069 
3070 
3081  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3082  {
3083  char* result;
3084 
3085  _OrthancPluginRetrieveDynamicString params;
3086  params.result = &result;
3087  params.argument = NULL;
3088 
3089  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3090  {
3091  /* Error */
3092  return NULL;
3093  }
3094  else
3095  {
3096  return result;
3097  }
3098  }
3099 
3100 
3111  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3112  {
3113  char* result;
3114 
3115  _OrthancPluginRetrieveDynamicString params;
3116  params.result = &result;
3117  params.argument = NULL;
3118 
3119  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3120  {
3121  /* Error */
3122  return NULL;
3123  }
3124  else
3125  {
3126  return result;
3127  }
3128  }
3129 
3130 
3146  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3147  {
3148  char* result;
3149 
3150  _OrthancPluginRetrieveDynamicString params;
3151  params.result = &result;
3152  params.argument = NULL;
3153 
3154  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3155  {
3156  /* Error */
3157  return NULL;
3158  }
3159  else
3160  {
3161  return result;
3162  }
3163  }
3164 
3165 
3166 
3167  typedef struct
3168  {
3170  } _OrthancPluginOnChangeCallback;
3171 
3192  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3193  OrthancPluginContext* context,
3195  {
3196  _OrthancPluginOnChangeCallback params;
3197  params.callback = callback;
3198 
3199  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3200  }
3201 
3202 
3203 
3204  typedef struct
3205  {
3206  const char* plugin;
3207  _OrthancPluginProperty property;
3208  const char* value;
3209  } _OrthancPluginSetPluginProperty;
3210 
3211 
3223  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3224  OrthancPluginContext* context,
3225  const char* uri)
3226  {
3227  _OrthancPluginSetPluginProperty params;
3228  params.plugin = OrthancPluginGetName();
3229  params.property = _OrthancPluginProperty_RootUri;
3230  params.value = uri;
3231 
3232  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3233  }
3234 
3235 
3245  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3246  OrthancPluginContext* context,
3247  const char* description)
3248  {
3249  _OrthancPluginSetPluginProperty params;
3250  params.plugin = OrthancPluginGetName();
3251  params.property = _OrthancPluginProperty_Description;
3252  params.value = description;
3253 
3254  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3255  }
3256 
3257 
3267  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3268  OrthancPluginContext* context,
3269  const char* javascript)
3270  {
3271  _OrthancPluginSetPluginProperty params;
3272  params.plugin = OrthancPluginGetName();
3273  params.property = _OrthancPluginProperty_OrthancExplorer;
3274  params.value = javascript;
3275 
3276  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3277  }
3278 
3279 
3280  typedef struct
3281  {
3282  char** result;
3283  int32_t property;
3284  const char* value;
3285  } _OrthancPluginGlobalProperty;
3286 
3287 
3301  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3302  OrthancPluginContext* context,
3303  int32_t property,
3304  const char* defaultValue)
3305  {
3306  char* result;
3307 
3308  _OrthancPluginGlobalProperty params;
3309  params.result = &result;
3310  params.property = property;
3311  params.value = defaultValue;
3312 
3313  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3314  {
3315  /* Error */
3316  return NULL;
3317  }
3318  else
3319  {
3320  return result;
3321  }
3322  }
3323 
3324 
3341  OrthancPluginContext* context,
3342  int32_t property,
3343  const char* value)
3344  {
3345  _OrthancPluginGlobalProperty params;
3346  params.result = NULL;
3347  params.property = property;
3348  params.value = value;
3349 
3350  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3351  }
3352 
3353 
3354 
3355  typedef struct
3356  {
3357  int32_t *resultInt32;
3358  uint32_t *resultUint32;
3359  int64_t *resultInt64;
3360  uint64_t *resultUint64;
3361  } _OrthancPluginReturnSingleValue;
3362 
3371  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3372  OrthancPluginContext* context)
3373  {
3374  uint32_t count = 0;
3375 
3376  _OrthancPluginReturnSingleValue params;
3377  memset(&params, 0, sizeof(params));
3378  params.resultUint32 = &count;
3379 
3380  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3381  {
3382  /* Error */
3383  return 0;
3384  }
3385  else
3386  {
3387  return count;
3388  }
3389  }
3390 
3391 
3392 
3405  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3406  OrthancPluginContext* context,
3407  uint32_t argument)
3408  {
3409  char* result;
3410 
3411  _OrthancPluginGlobalProperty params;
3412  params.result = &result;
3413  params.property = (int32_t) argument;
3414  params.value = NULL;
3415 
3416  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3417  {
3418  /* Error */
3419  return NULL;
3420  }
3421  else
3422  {
3423  return result;
3424  }
3425  }
3426 
3427 
3437  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3438  OrthancPluginContext* context)
3439  {
3440  uint32_t count = 0;
3441 
3442  _OrthancPluginReturnSingleValue params;
3443  memset(&params, 0, sizeof(params));
3444  params.resultUint32 = &count;
3445 
3446  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3447  {
3448  /* Error */
3449  return 0;
3450  }
3451  else
3452  {
3453  return count;
3454  }
3455  }
3456 
3457 
3458 
3470  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3471  {
3472  char* result;
3473 
3474  _OrthancPluginRetrieveDynamicString params;
3475  params.result = &result;
3476  params.argument = NULL;
3477 
3478  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3479  {
3480  /* Error */
3481  return NULL;
3482  }
3483  else
3484  {
3485  return result;
3486  }
3487  }
3488 
3489 
3490 
3491  typedef struct
3492  {
3493  OrthancPluginRestOutput* output;
3494  const char* subType;
3495  const char* contentType;
3496  } _OrthancPluginStartMultipartAnswer;
3497 
3512  OrthancPluginContext* context,
3513  OrthancPluginRestOutput* output,
3514  const char* subType,
3515  const char* contentType)
3516  {
3517  _OrthancPluginStartMultipartAnswer params;
3518  params.output = output;
3519  params.subType = subType;
3520  params.contentType = contentType;
3521  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3522  }
3523 
3524 
3541  OrthancPluginContext* context,
3542  OrthancPluginRestOutput* output,
3543  const void* answer,
3544  uint32_t answerSize)
3545  {
3546  _OrthancPluginAnswerBuffer params;
3547  params.output = output;
3548  params.answer = answer;
3549  params.answerSize = answerSize;
3550  params.mimeType = NULL;
3551  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3552  }
3553 
3554 
3555 
3556  typedef struct
3557  {
3558  OrthancPluginMemoryBuffer* target;
3559  const void* source;
3560  uint32_t size;
3561  OrthancPluginCompressionType compression;
3562  uint8_t uncompress;
3563  } _OrthancPluginBufferCompression;
3564 
3565 
3583  OrthancPluginContext* context,
3584  OrthancPluginMemoryBuffer* target,
3585  const void* source,
3586  uint32_t size,
3587  OrthancPluginCompressionType compression,
3588  uint8_t uncompress)
3589  {
3590  _OrthancPluginBufferCompression params;
3591  params.target = target;
3592  params.source = source;
3593  params.size = size;
3594  params.compression = compression;
3595  params.uncompress = uncompress;
3596 
3597  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3598  }
3599 
3600 
3601 
3602  typedef struct
3603  {
3604  OrthancPluginMemoryBuffer* target;
3605  const char* path;
3606  } _OrthancPluginReadFile;
3607 
3620  OrthancPluginContext* context,
3621  OrthancPluginMemoryBuffer* target,
3622  const char* path)
3623  {
3624  _OrthancPluginReadFile params;
3625  params.target = target;
3626  params.path = path;
3627  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3628  }
3629 
3630 
3631 
3632  typedef struct
3633  {
3634  const char* path;
3635  const void* data;
3636  uint32_t size;
3637  } _OrthancPluginWriteFile;
3638 
3651  OrthancPluginContext* context,
3652  const char* path,
3653  const void* data,
3654  uint32_t size)
3655  {
3656  _OrthancPluginWriteFile params;
3657  params.path = path;
3658  params.data = data;
3659  params.size = size;
3660  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3661  }
3662 
3663 
3664 
3665  typedef struct
3666  {
3667  const char** target;
3668  OrthancPluginErrorCode error;
3669  } _OrthancPluginGetErrorDescription;
3670 
3681  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3682  OrthancPluginContext* context,
3683  OrthancPluginErrorCode error)
3684  {
3685  const char* result = NULL;
3686 
3687  _OrthancPluginGetErrorDescription params;
3688  params.target = &result;
3689  params.error = error;
3690 
3691  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3692  result == NULL)
3693  {
3694  return "Unknown error code";
3695  }
3696  else
3697  {
3698  return result;
3699  }
3700  }
3701 
3702 
3703 
3704  typedef struct
3705  {
3706  OrthancPluginRestOutput* output;
3707  uint16_t status;
3708  const char* body;
3709  uint32_t bodySize;
3710  } _OrthancPluginSendHttpStatus;
3711 
3734  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3735  OrthancPluginContext* context,
3736  OrthancPluginRestOutput* output,
3737  uint16_t status,
3738  const char* body,
3739  uint32_t bodySize)
3740  {
3741  _OrthancPluginSendHttpStatus params;
3742  params.output = output;
3743  params.status = status;
3744  params.body = body;
3745  params.bodySize = bodySize;
3746  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3747  }
3748 
3749 
3750 
3751  typedef struct
3752  {
3753  const OrthancPluginImage* image;
3754  uint32_t* resultUint32;
3755  OrthancPluginPixelFormat* resultPixelFormat;
3756  void** resultBuffer;
3757  } _OrthancPluginGetImageInfo;
3758 
3759 
3771  OrthancPluginContext* context,
3772  const OrthancPluginImage* image)
3773  {
3774  OrthancPluginPixelFormat target;
3775 
3776  _OrthancPluginGetImageInfo params;
3777  memset(&params, 0, sizeof(params));
3778  params.image = image;
3779  params.resultPixelFormat = &target;
3780 
3781  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3782  {
3784  }
3785  else
3786  {
3787  return (OrthancPluginPixelFormat) target;
3788  }
3789  }
3790 
3791 
3792 
3803  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3804  OrthancPluginContext* context,
3805  const OrthancPluginImage* image)
3806  {
3807  uint32_t width;
3808 
3809  _OrthancPluginGetImageInfo params;
3810  memset(&params, 0, sizeof(params));
3811  params.image = image;
3812  params.resultUint32 = &width;
3813 
3814  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3815  {
3816  return 0;
3817  }
3818  else
3819  {
3820  return width;
3821  }
3822  }
3823 
3824 
3825 
3836  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3837  OrthancPluginContext* context,
3838  const OrthancPluginImage* image)
3839  {
3840  uint32_t height;
3841 
3842  _OrthancPluginGetImageInfo params;
3843  memset(&params, 0, sizeof(params));
3844  params.image = image;
3845  params.resultUint32 = &height;
3846 
3847  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3848  {
3849  return 0;
3850  }
3851  else
3852  {
3853  return height;
3854  }
3855  }
3856 
3857 
3858 
3871  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3872  OrthancPluginContext* context,
3873  const OrthancPluginImage* image)
3874  {
3875  uint32_t pitch;
3876 
3877  _OrthancPluginGetImageInfo params;
3878  memset(&params, 0, sizeof(params));
3879  params.image = image;
3880  params.resultUint32 = &pitch;
3881 
3882  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
3883  {
3884  return 0;
3885  }
3886  else
3887  {
3888  return pitch;
3889  }
3890  }
3891 
3892 
3893 
3905  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
3906  OrthancPluginContext* context,
3907  const OrthancPluginImage* image)
3908  {
3909  void* target = NULL;
3910 
3911  _OrthancPluginGetImageInfo params;
3912  memset(&params, 0, sizeof(params));
3913  params.resultBuffer = &target;
3914  params.image = image;
3915 
3916  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
3917  {
3918  return NULL;
3919  }
3920  else
3921  {
3922  return target;
3923  }
3924  }
3925 
3926 
3927  typedef struct
3928  {
3929  OrthancPluginImage** target;
3930  const void* data;
3931  uint32_t size;
3932  OrthancPluginImageFormat format;
3933  } _OrthancPluginUncompressImage;
3934 
3935 
3949  OrthancPluginContext* context,
3950  const void* data,
3951  uint32_t size,
3952  OrthancPluginImageFormat format)
3953  {
3954  OrthancPluginImage* target = NULL;
3955 
3956  _OrthancPluginUncompressImage params;
3957  memset(&params, 0, sizeof(params));
3958  params.target = &target;
3959  params.data = data;
3960  params.size = size;
3961  params.format = format;
3962 
3963  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
3964  {
3965  return NULL;
3966  }
3967  else
3968  {
3969  return target;
3970  }
3971  }
3972 
3973 
3974 
3975 
3976  typedef struct
3977  {
3978  OrthancPluginImage* image;
3979  } _OrthancPluginFreeImage;
3980 
3990  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
3991  OrthancPluginContext* context,
3992  OrthancPluginImage* image)
3993  {
3994  _OrthancPluginFreeImage params;
3995  params.image = image;
3996 
3997  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
3998  }
3999 
4000 
4001 
4002 
4003  typedef struct
4004  {
4005  OrthancPluginMemoryBuffer* target;
4006  OrthancPluginImageFormat imageFormat;
4007  OrthancPluginPixelFormat pixelFormat;
4008  uint32_t width;
4009  uint32_t height;
4010  uint32_t pitch;
4011  const void* buffer;
4012  uint8_t quality;
4013  } _OrthancPluginCompressImage;
4014 
4015 
4036  OrthancPluginContext* context,
4037  OrthancPluginMemoryBuffer* target,
4038  OrthancPluginPixelFormat format,
4039  uint32_t width,
4040  uint32_t height,
4041  uint32_t pitch,
4042  const void* buffer)
4043  {
4044  _OrthancPluginCompressImage params;
4045  memset(&params, 0, sizeof(params));
4046  params.target = target;
4047  params.imageFormat = OrthancPluginImageFormat_Png;
4048  params.pixelFormat = format;
4049  params.width = width;
4050  params.height = height;
4051  params.pitch = pitch;
4052  params.buffer = buffer;
4053  params.quality = 0; /* Unused for PNG */
4054 
4055  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4056  }
4057 
4058 
4081  OrthancPluginContext* context,
4082  OrthancPluginMemoryBuffer* target,
4083  OrthancPluginPixelFormat format,
4084  uint32_t width,
4085  uint32_t height,
4086  uint32_t pitch,
4087  const void* buffer,
4088  uint8_t quality)
4089  {
4090  _OrthancPluginCompressImage params;
4091  memset(&params, 0, sizeof(params));
4092  params.target = target;
4093  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4094  params.pixelFormat = format;
4095  params.width = width;
4096  params.height = height;
4097  params.pitch = pitch;
4098  params.buffer = buffer;
4099  params.quality = quality;
4100 
4101  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4102  }
4103 
4104 
4105 
4127  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
4128  OrthancPluginContext* context,
4129  OrthancPluginRestOutput* output,
4130  OrthancPluginPixelFormat format,
4131  uint32_t width,
4132  uint32_t height,
4133  uint32_t pitch,
4134  const void* buffer,
4135  uint8_t quality)
4136  {
4137  _OrthancPluginCompressAndAnswerImage params;
4138  params.output = output;
4139  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4140  params.pixelFormat = format;
4141  params.width = width;
4142  params.height = height;
4143  params.pitch = pitch;
4144  params.buffer = buffer;
4145  params.quality = quality;
4146  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4147  }
4148 
4149 
4150 
4151 
4152  typedef struct
4153  {
4154  OrthancPluginMemoryBuffer* target;
4155  OrthancPluginHttpMethod method;
4156  const char* url;
4157  const char* username;
4158  const char* password;
4159  const void* body;
4160  uint32_t bodySize;
4161  } _OrthancPluginCallHttpClient;
4162 
4163 
4181  OrthancPluginContext* context,
4182  OrthancPluginMemoryBuffer* target,
4183  const char* url,
4184  const char* username,
4185  const char* password)
4186  {
4187  _OrthancPluginCallHttpClient params;
4188  memset(&params, 0, sizeof(params));
4189 
4190  params.target = target;
4191  params.method = OrthancPluginHttpMethod_Get;
4192  params.url = url;
4193  params.username = username;
4194  params.password = password;
4195 
4196  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4197  }
4198 
4199 
4219  OrthancPluginContext* context,
4220  OrthancPluginMemoryBuffer* target,
4221  const char* url,
4222  const void* body,
4223  uint32_t bodySize,
4224  const char* username,
4225  const char* password)
4226  {
4227  _OrthancPluginCallHttpClient params;
4228  memset(&params, 0, sizeof(params));
4229 
4230  params.target = target;
4231  params.method = OrthancPluginHttpMethod_Post;
4232  params.url = url;
4233  params.body = body;
4234  params.bodySize = bodySize;
4235  params.username = username;
4236  params.password = password;
4237 
4238  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4239  }
4240 
4241 
4261  OrthancPluginContext* context,
4262  OrthancPluginMemoryBuffer* target,
4263  const char* url,
4264  const void* body,
4265  uint32_t bodySize,
4266  const char* username,
4267  const char* password)
4268  {
4269  _OrthancPluginCallHttpClient params;
4270  memset(&params, 0, sizeof(params));
4271 
4272  params.target = target;
4273  params.method = OrthancPluginHttpMethod_Put;
4274  params.url = url;
4275  params.body = body;
4276  params.bodySize = bodySize;
4277  params.username = username;
4278  params.password = password;
4279 
4280  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4281  }
4282 
4283 
4299  OrthancPluginContext* context,
4300  const char* url,
4301  const char* username,
4302  const char* password)
4303  {
4304  _OrthancPluginCallHttpClient params;
4305  memset(&params, 0, sizeof(params));
4306 
4307  params.method = OrthancPluginHttpMethod_Delete;
4308  params.url = url;
4309  params.username = username;
4310  params.password = password;
4311 
4312  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4313  }
4314 
4315 
4316 
4317  typedef struct
4318  {
4319  OrthancPluginImage** target;
4320  const OrthancPluginImage* source;
4321  OrthancPluginPixelFormat targetFormat;
4322  } _OrthancPluginConvertPixelFormat;
4323 
4324 
4337  OrthancPluginContext* context,
4338  const OrthancPluginImage* source,
4339  OrthancPluginPixelFormat targetFormat)
4340  {
4341  OrthancPluginImage* target = NULL;
4342 
4343  _OrthancPluginConvertPixelFormat params;
4344  params.target = &target;
4345  params.source = source;
4346  params.targetFormat = targetFormat;
4347 
4348  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4349  {
4350  return NULL;
4351  }
4352  else
4353  {
4354  return target;
4355  }
4356  }
4357 
4358 
4359 
4371  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4372  OrthancPluginContext* context)
4373  {
4374  uint32_t count = 0;
4375 
4376  _OrthancPluginReturnSingleValue params;
4377  memset(&params, 0, sizeof(params));
4378  params.resultUint32 = &count;
4379 
4380  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4381  {
4382  /* Error */
4383  return 0;
4384  }
4385  else
4386  {
4387  return count;
4388  }
4389  }
4390 
4391 
4392 
4393 
4394  typedef struct
4395  {
4396  uint32_t fontIndex; /* in */
4397  const char** name; /* out */
4398  uint32_t* size; /* out */
4399  } _OrthancPluginGetFontInfo;
4400 
4411  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4412  OrthancPluginContext* context,
4413  uint32_t fontIndex)
4414  {
4415  const char* result = NULL;
4416 
4417  _OrthancPluginGetFontInfo params;
4418  memset(&params, 0, sizeof(params));
4419  params.name = &result;
4420  params.fontIndex = fontIndex;
4421 
4422  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4423  {
4424  return NULL;
4425  }
4426  else
4427  {
4428  return result;
4429  }
4430  }
4431 
4432 
4443  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4444  OrthancPluginContext* context,
4445  uint32_t fontIndex)
4446  {
4447  uint32_t result;
4448 
4449  _OrthancPluginGetFontInfo params;
4450  memset(&params, 0, sizeof(params));
4451  params.size = &result;
4452  params.fontIndex = fontIndex;
4453 
4454  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4455  {
4456  return 0;
4457  }
4458  else
4459  {
4460  return result;
4461  }
4462  }
4463 
4464 
4465 
4466  typedef struct
4467  {
4468  OrthancPluginImage* image;
4469  uint32_t fontIndex;
4470  const char* utf8Text;
4471  int32_t x;
4472  int32_t y;
4473  uint8_t r;
4474  uint8_t g;
4475  uint8_t b;
4476  } _OrthancPluginDrawText;
4477 
4478 
4497  OrthancPluginContext* context,
4498  OrthancPluginImage* image,
4499  uint32_t fontIndex,
4500  const char* utf8Text,
4501  int32_t x,
4502  int32_t y,
4503  uint8_t r,
4504  uint8_t g,
4505  uint8_t b)
4506  {
4507  _OrthancPluginDrawText params;
4508  memset(&params, 0, sizeof(params));
4509  params.image = image;
4510  params.fontIndex = fontIndex;
4511  params.utf8Text = utf8Text;
4512  params.x = x;
4513  params.y = y;
4514  params.r = r;
4515  params.g = g;
4516  params.b = b;
4517 
4518  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4519  }
4520 
4521 
4522 
4523  typedef struct
4524  {
4525  OrthancPluginStorageArea* storageArea;
4526  const char* uuid;
4527  const void* content;
4528  uint64_t size;
4530  } _OrthancPluginStorageAreaCreate;
4531 
4532 
4549  OrthancPluginContext* context,
4550  OrthancPluginStorageArea* storageArea,
4551  const char* uuid,
4552  const void* content,
4553  uint64_t size,
4555  {
4556  _OrthancPluginStorageAreaCreate params;
4557  params.storageArea = storageArea;
4558  params.uuid = uuid;
4559  params.content = content;
4560  params.size = size;
4561  params.type = type;
4562 
4563  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4564  }
4565 
4566 
4567  typedef struct
4568  {
4569  OrthancPluginMemoryBuffer* target;
4570  OrthancPluginStorageArea* storageArea;
4571  const char* uuid;
4573  } _OrthancPluginStorageAreaRead;
4574 
4575 
4591  OrthancPluginContext* context,
4592  OrthancPluginMemoryBuffer* target,
4593  OrthancPluginStorageArea* storageArea,
4594  const char* uuid,
4596  {
4597  _OrthancPluginStorageAreaRead params;
4598  params.target = target;
4599  params.storageArea = storageArea;
4600  params.uuid = uuid;
4601  params.type = type;
4602 
4603  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4604  }
4605 
4606 
4607  typedef struct
4608  {
4609  OrthancPluginStorageArea* storageArea;
4610  const char* uuid;
4612  } _OrthancPluginStorageAreaRemove;
4613 
4628  OrthancPluginContext* context,
4629  OrthancPluginStorageArea* storageArea,
4630  const char* uuid,
4632  {
4633  _OrthancPluginStorageAreaRemove params;
4634  params.storageArea = storageArea;
4635  params.uuid = uuid;
4636  params.type = type;
4637 
4638  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4639  }
4640 
4641 
4642 
4643  typedef struct
4644  {
4645  OrthancPluginErrorCode* target;
4646  int32_t code;
4647  uint16_t httpStatus;
4648  const char* message;
4649  } _OrthancPluginRegisterErrorCode;
4650 
4667  OrthancPluginContext* context,
4668  int32_t code,
4669  uint16_t httpStatus,
4670  const char* message)
4671  {
4672  OrthancPluginErrorCode target;
4673 
4674  _OrthancPluginRegisterErrorCode params;
4675  params.target = &target;
4676  params.code = code;
4677  params.httpStatus = httpStatus;
4678  params.message = message;
4679 
4680  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4681  {
4682  return target;
4683  }
4684  else
4685  {
4686  /* There was an error while assigned the error. Use a generic code. */
4688  }
4689  }
4690 
4691 
4692 
4693  typedef struct
4694  {
4695  uint16_t group;
4696  uint16_t element;
4698  const char* name;
4699  uint32_t minMultiplicity;
4700  uint32_t maxMultiplicity;
4701  } _OrthancPluginRegisterDictionaryTag;
4702 
4723  OrthancPluginContext* context,
4724  uint16_t group,
4725  uint16_t element,
4727  const char* name,
4728  uint32_t minMultiplicity,
4729  uint32_t maxMultiplicity)
4730  {
4731  _OrthancPluginRegisterDictionaryTag params;
4732  params.group = group;
4733  params.element = element;
4734  params.vr = vr;
4735  params.name = name;
4736  params.minMultiplicity = minMultiplicity;
4737  params.maxMultiplicity = maxMultiplicity;
4738 
4739  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4740  }
4741 
4742 
4743 
4744  typedef struct
4745  {
4746  uint16_t group;
4747  uint16_t element;
4749  const char* name;
4750  uint32_t minMultiplicity;
4751  uint32_t maxMultiplicity;
4752  const char* privateCreator;
4753  } _OrthancPluginRegisterPrivateDictionaryTag;
4754 
4776  OrthancPluginContext* context,
4777  uint16_t group,
4778  uint16_t element,
4780  const char* name,
4781  uint32_t minMultiplicity,
4782  uint32_t maxMultiplicity,
4783  const char* privateCreator)
4784  {
4785  _OrthancPluginRegisterPrivateDictionaryTag params;
4786  params.group = group;
4787  params.element = element;
4788  params.vr = vr;
4789  params.name = name;
4790  params.minMultiplicity = minMultiplicity;
4791  params.maxMultiplicity = maxMultiplicity;
4792  params.privateCreator = privateCreator;
4793 
4794  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4795  }
4796 
4797 
4798 
4799  typedef struct
4800  {
4801  OrthancPluginStorageArea* storageArea;
4803  } _OrthancPluginReconstructMainDicomTags;
4804 
4820  OrthancPluginContext* context,
4821  OrthancPluginStorageArea* storageArea,
4823  {
4824  _OrthancPluginReconstructMainDicomTags params;
4825  params.level = level;
4826  params.storageArea = storageArea;
4827 
4828  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
4829  }
4830 
4831 
4832  typedef struct
4833  {
4834  char** result;
4835  const char* instanceId;
4836  const void* buffer;
4837  uint32_t size;
4840  uint32_t maxStringLength;
4841  } _OrthancPluginDicomToJson;
4842 
4843 
4863  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4864  OrthancPluginContext* context,
4865  const void* buffer,
4866  uint32_t size,
4869  uint32_t maxStringLength)
4870  {
4871  char* result;
4872 
4873  _OrthancPluginDicomToJson params;
4874  memset(&params, 0, sizeof(params));
4875  params.result = &result;
4876  params.buffer = buffer;
4877  params.size = size;
4878  params.format = format;
4879  params.flags = flags;
4880  params.maxStringLength = maxStringLength;
4881 
4882  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
4883  {
4884  /* Error */
4885  return NULL;
4886  }
4887  else
4888  {
4889  return result;
4890  }
4891  }
4892 
4893 
4912  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
4913  OrthancPluginContext* context,
4914  const char* instanceId,
4917  uint32_t maxStringLength)
4918  {
4919  char* result;
4920 
4921  _OrthancPluginDicomToJson params;
4922  memset(&params, 0, sizeof(params));
4923  params.result = &result;
4924  params.instanceId = instanceId;
4925  params.format = format;
4926  params.flags = flags;
4927  params.maxStringLength = maxStringLength;
4928 
4929  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
4930  {
4931  /* Error */
4932  return NULL;
4933  }
4934  else
4935  {
4936  return result;
4937  }
4938  }
4939 
4940 
4941  typedef struct
4942  {
4943  OrthancPluginMemoryBuffer* target;
4944  const char* uri;
4945  uint32_t headersCount;
4946  const char* const* headersKeys;
4947  const char* const* headersValues;
4948  int32_t afterPlugins;
4949  } _OrthancPluginRestApiGet2;
4950 
4971  OrthancPluginContext* context,
4972  OrthancPluginMemoryBuffer* target,
4973  const char* uri,
4974  uint32_t headersCount,
4975  const char* const* headersKeys,
4976  const char* const* headersValues,
4977  int32_t afterPlugins)
4978  {
4979  _OrthancPluginRestApiGet2 params;
4980  params.target = target;
4981  params.uri = uri;
4982  params.headersCount = headersCount;
4983  params.headersKeys = headersKeys;
4984  params.headersValues = headersValues;
4985  params.afterPlugins = afterPlugins;
4986 
4987  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
4988  }
4989 
4990 
4991 
4992  typedef struct
4993  {
4995  } _OrthancPluginWorklistCallback;
4996 
5009  OrthancPluginContext* context,
5011  {
5012  _OrthancPluginWorklistCallback params;
5013  params.callback = callback;
5014 
5015  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
5016  }
5017 
5018 
5019 
5020  typedef struct
5021  {
5023  const OrthancPluginWorklistQuery* query;
5024  const void* dicom;
5025  uint32_t size;
5026  } _OrthancPluginWorklistAnswersOperation;
5027 
5045  OrthancPluginContext* context,
5047  const OrthancPluginWorklistQuery* query,
5048  const void* dicom,
5049  uint32_t size)
5050  {
5051  _OrthancPluginWorklistAnswersOperation params;
5052  params.answers = answers;
5053  params.query = query;
5054  params.dicom = dicom;
5055  params.size = size;
5056 
5057  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
5058  }
5059 
5060 
5075  OrthancPluginContext* context,
5077  {
5078  _OrthancPluginWorklistAnswersOperation params;
5079  params.answers = answers;
5080  params.query = NULL;
5081  params.dicom = NULL;
5082  params.size = 0;
5083 
5084  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5085  }
5086 
5087 
5088  typedef struct
5089  {
5090  const OrthancPluginWorklistQuery* query;
5091  const void* dicom;
5092  uint32_t size;
5093  int32_t* isMatch;
5094  OrthancPluginMemoryBuffer* target;
5095  } _OrthancPluginWorklistQueryOperation;
5096 
5112  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5113  OrthancPluginContext* context,
5114  const OrthancPluginWorklistQuery* query,
5115  const void* dicom,
5116  uint32_t size)
5117  {
5118  int32_t isMatch = 0;
5119 
5120  _OrthancPluginWorklistQueryOperation params;
5121  params.query = query;
5122  params.dicom = dicom;
5123  params.size = size;
5124  params.isMatch = &isMatch;
5125  params.target = NULL;
5126 
5127  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5128  {
5129  return isMatch;
5130  }
5131  else
5132  {
5133  /* Error: Assume non-match */
5134  return 0;
5135  }
5136  }
5137 
5138 
5152  OrthancPluginContext* context,
5153  OrthancPluginMemoryBuffer* target,
5154  const OrthancPluginWorklistQuery* query)
5155  {
5156  _OrthancPluginWorklistQueryOperation params;
5157  params.query = query;
5158  params.dicom = NULL;
5159  params.size = 0;
5160  params.isMatch = NULL;
5161  params.target = target;
5162 
5163  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5164  }
5165 
5166 
5178  OrthancPluginContext* context,
5179  const OrthancPluginDicomInstance* instance)
5180  {
5182 
5183  _OrthancPluginAccessDicomInstance params;
5184  memset(&params, 0, sizeof(params));
5185  params.resultOrigin = &origin;
5186  params.instance = instance;
5187 
5188  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5189  {
5190  /* Error */
5192  }
5193  else
5194  {
5195  return origin;
5196  }
5197  }
5198 
5199 
5200  typedef struct
5201  {
5202  OrthancPluginMemoryBuffer* target;
5203  const char* json;
5204  const OrthancPluginImage* pixelData;
5206  } _OrthancPluginCreateDicom;
5207 
5227  OrthancPluginContext* context,
5228  OrthancPluginMemoryBuffer* target,
5229  const char* json,
5230  const OrthancPluginImage* pixelData,
5232  {
5233  _OrthancPluginCreateDicom params;
5234  params.target = target;
5235  params.json = json;
5236  params.pixelData = pixelData;
5237  params.flags = flags;
5238 
5239  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5240  }
5241 
5242 
5243  typedef struct
5244  {
5246  } _OrthancPluginDecodeImageCallback;
5247 
5263  OrthancPluginContext* context,
5265  {
5266  _OrthancPluginDecodeImageCallback params;
5267  params.callback = callback;
5268 
5269  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5270  }
5271 
5272 
5273 
5274  typedef struct
5275  {
5276  OrthancPluginImage** target;
5277  OrthancPluginPixelFormat format;
5278  uint32_t width;
5279  uint32_t height;
5280  uint32_t pitch;
5281  void* buffer;
5282  const void* constBuffer;
5283  uint32_t bufferSize;
5284  uint32_t frameIndex;
5285  } _OrthancPluginCreateImage;
5286 
5287 
5301  OrthancPluginContext* context,
5302  OrthancPluginPixelFormat format,
5303  uint32_t width,
5304  uint32_t height)
5305  {
5306  OrthancPluginImage* target = NULL;
5307 
5308  _OrthancPluginCreateImage params;
5309  memset(&params, 0, sizeof(params));
5310  params.target = &target;
5311  params.format = format;
5312  params.width = width;
5313  params.height = height;
5314 
5315  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5316  {
5317  return NULL;
5318  }
5319  else
5320  {
5321  return target;
5322  }
5323  }
5324 
5325 
5344  OrthancPluginContext* context,
5345  OrthancPluginPixelFormat format,
5346  uint32_t width,
5347  uint32_t height,
5348  uint32_t pitch,
5349  void* buffer)
5350  {
5351  OrthancPluginImage* target = NULL;
5352 
5353  _OrthancPluginCreateImage params;
5354  memset(&params, 0, sizeof(params));
5355  params.target = &target;
5356  params.format = format;
5357  params.width = width;
5358  params.height = height;
5359  params.pitch = pitch;
5360  params.buffer = buffer;
5361 
5362  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5363  {
5364  return NULL;
5365  }
5366  else
5367  {
5368  return target;
5369  }
5370  }
5371 
5372 
5373 
5390  OrthancPluginContext* context,
5391  const void* buffer,
5392  uint32_t bufferSize,
5393  uint32_t frameIndex)
5394  {
5395  OrthancPluginImage* target = NULL;
5396 
5397  _OrthancPluginCreateImage params;
5398  memset(&params, 0, sizeof(params));
5399  params.target = &target;
5400  params.constBuffer = buffer;
5401  params.bufferSize = bufferSize;
5402  params.frameIndex = frameIndex;
5403 
5404  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5405  {
5406  return NULL;
5407  }
5408  else
5409  {
5410  return target;
5411  }
5412  }
5413 
5414 
5415 
5416  typedef struct
5417  {
5418  char** result;
5419  const void* buffer;
5420  uint32_t size;
5421  } _OrthancPluginComputeHash;
5422 
5435  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5436  OrthancPluginContext* context,
5437  const void* buffer,
5438  uint32_t size)
5439  {
5440  char* result;
5441 
5442  _OrthancPluginComputeHash params;
5443  params.result = &result;
5444  params.buffer = buffer;
5445  params.size = size;
5446 
5447  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5448  {
5449  /* Error */
5450  return NULL;
5451  }
5452  else
5453  {
5454  return result;
5455  }
5456  }
5457 
5458 
5471  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5472  OrthancPluginContext* context,
5473  const void* buffer,
5474  uint32_t size)
5475  {
5476  char* result;
5477 
5478  _OrthancPluginComputeHash params;
5479  params.result = &result;
5480  params.buffer = buffer;
5481  params.size = size;
5482 
5483  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5484  {
5485  /* Error */
5486  return NULL;
5487  }
5488  else
5489  {
5490  return result;
5491  }
5492  }
5493 
5494 
5495 
5496  typedef struct
5497  {
5499  const char* name;
5500  } _OrthancPluginLookupDictionary;
5501 
5518  OrthancPluginContext* context,
5520  const char* name)
5521  {
5522  _OrthancPluginLookupDictionary params;
5523  params.target = target;
5524  params.name = name;
5525  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5526  }
5527 
5528 
5529 
5530  typedef struct
5531  {
5532  OrthancPluginRestOutput* output;
5533  const void* answer;
5534  uint32_t answerSize;
5535  uint32_t headersCount;
5536  const char* const* headersKeys;
5537  const char* const* headersValues;
5538  } _OrthancPluginSendMultipartItem2;
5539 
5561  OrthancPluginContext* context,
5562  OrthancPluginRestOutput* output,
5563  const void* answer,
5564  uint32_t answerSize,
5565  uint32_t headersCount,
5566  const char* const* headersKeys,
5567  const char* const* headersValues)
5568  {
5569  _OrthancPluginSendMultipartItem2 params;
5570  params.output = output;
5571  params.answer = answer;
5572  params.answerSize = answerSize;
5573  params.headersCount = headersCount;
5574  params.headersKeys = headersKeys;
5575  params.headersValues = headersValues;
5576 
5577  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5578  }
5579 
5580 
5581  typedef struct
5582  {
5584  } _OrthancPluginIncomingHttpRequestFilter;
5585 
5599  OrthancPluginContext* context,
5601  {
5602  _OrthancPluginIncomingHttpRequestFilter params;
5603  params.callback = callback;
5604 
5605  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5606  }
5607 
5608 
5609 
5610  typedef struct
5611  {
5612  OrthancPluginMemoryBuffer* answerBody;
5613  OrthancPluginMemoryBuffer* answerHeaders;
5614  uint16_t* httpStatus;
5615  OrthancPluginHttpMethod method;
5616  const char* url;
5617  uint32_t headersCount;
5618  const char* const* headersKeys;
5619  const char* const* headersValues;
5620  const void* body;
5621  uint32_t bodySize;
5622  const char* username;
5623  const char* password;
5624  uint32_t timeout;
5625  const char* certificateFile;
5626  const char* certificateKeyFile;
5627  const char* certificateKeyPassword;
5628  uint8_t pkcs11;
5629  } _OrthancPluginCallHttpClient2;
5630 
5631 
5632 
5673  OrthancPluginContext* context,
5674  OrthancPluginMemoryBuffer* answerBody,
5675  OrthancPluginMemoryBuffer* answerHeaders,
5676  uint16_t* httpStatus,
5677  OrthancPluginHttpMethod method,
5678  const char* url,
5679  uint32_t headersCount,
5680  const char* const* headersKeys,
5681  const char* const* headersValues,
5682  const void* body,
5683  uint32_t bodySize,
5684  const char* username,
5685  const char* password,
5686  uint32_t timeout,
5687  const char* certificateFile,
5688  const char* certificateKeyFile,
5689  const char* certificateKeyPassword,
5690  uint8_t pkcs11)
5691  {
5692  _OrthancPluginCallHttpClient2 params;
5693  memset(&params, 0, sizeof(params));
5694 
5695  params.answerBody = answerBody;
5696  params.answerHeaders = answerHeaders;
5697  params.httpStatus = httpStatus;
5698  params.method = method;
5699  params.url = url;
5700  params.headersCount = headersCount;
5701  params.headersKeys = headersKeys;
5702  params.headersValues = headersValues;
5703  params.body = body;
5704  params.bodySize = bodySize;
5705  params.username = username;
5706  params.password = password;
5707  params.timeout = timeout;
5708  params.certificateFile = certificateFile;
5709  params.certificateKeyFile = certificateKeyFile;
5710  params.certificateKeyPassword = certificateKeyPassword;
5711  params.pkcs11 = pkcs11;
5712 
5713  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5714  }
5715 
5716 
5727  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5728  OrthancPluginContext* context)
5729  {
5730  char* result;
5731 
5732  _OrthancPluginRetrieveDynamicString params;
5733  params.result = &result;
5734  params.argument = NULL;
5735 
5736  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5737  {
5738  /* Error */
5739  return NULL;
5740  }
5741  else
5742  {
5743  return result;
5744  }
5745  }
5746 
5747 
5748 
5749 
5750  typedef struct
5751  {
5752  OrthancPluginFindCallback callback;
5753  } _OrthancPluginFindCallback;
5754 
5767  OrthancPluginContext* context,
5768  OrthancPluginFindCallback callback)
5769  {
5770  _OrthancPluginFindCallback params;
5771  params.callback = callback;
5772 
5773  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5774  }
5775 
5776 
5777  typedef struct
5778  {
5779  OrthancPluginFindAnswers *answers;
5780  const OrthancPluginFindQuery *query;
5781  const void *dicom;
5782  uint32_t size;
5783  uint32_t index;
5784  uint32_t *resultUint32;
5785  uint16_t *resultGroup;
5786  uint16_t *resultElement;
5787  char **resultString;
5788  } _OrthancPluginFindOperation;
5789 
5806  OrthancPluginContext* context,
5807  OrthancPluginFindAnswers* answers,
5808  const void* dicom,
5809  uint32_t size)
5810  {
5811  _OrthancPluginFindOperation params;
5812  memset(&params, 0, sizeof(params));
5813  params.answers = answers;
5814  params.dicom = dicom;
5815  params.size = size;
5816 
5817  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
5818  }
5819 
5820 
5835  OrthancPluginContext* context,
5836  OrthancPluginFindAnswers* answers)
5837  {
5838  _OrthancPluginFindOperation params;
5839  memset(&params, 0, sizeof(params));
5840  params.answers = answers;
5841 
5842  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
5843  }
5844 
5845 
5846 
5858  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
5859  OrthancPluginContext* context,
5860  const OrthancPluginFindQuery* query)
5861  {
5862  uint32_t count = 0;
5863 
5864  _OrthancPluginFindOperation params;
5865  memset(&params, 0, sizeof(params));
5866  params.query = query;
5867  params.resultUint32 = &count;
5868 
5869  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
5870  {
5871  /* Error */
5872  return 0;
5873  }
5874  else
5875  {
5876  return count;
5877  }
5878  }
5879 
5880 
5896  OrthancPluginContext* context,
5897  uint16_t* group,
5898  uint16_t* element,
5899  const OrthancPluginFindQuery* query,
5900  uint32_t index)
5901  {
5902  _OrthancPluginFindOperation params;
5903  memset(&params, 0, sizeof(params));
5904  params.query = query;
5905  params.index = index;
5906  params.resultGroup = group;
5907  params.resultElement = element;
5908 
5909  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
5910  }
5911 
5912 
5926  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
5927  OrthancPluginContext* context,
5928  const OrthancPluginFindQuery* query,
5929  uint32_t index)
5930  {
5931  char* result;
5932 
5933  _OrthancPluginFindOperation params;
5934  memset(&params, 0, sizeof(params));
5935  params.query = query;
5936  params.index = index;
5937  params.resultString = &result;
5938 
5939  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
5940  {
5941  /* Error */
5942  return NULL;
5943  }
5944  else
5945  {
5946  return result;
5947  }
5948  }
5949 
5950 
5964  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
5965  OrthancPluginContext* context,
5966  const OrthancPluginFindQuery* query,
5967  uint32_t index)
5968  {
5969  char* result;
5970 
5971  _OrthancPluginFindOperation params;
5972  memset(&params, 0, sizeof(params));
5973  params.query = query;
5974  params.index = index;
5975  params.resultString = &result;
5976 
5977  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
5978  {
5979  /* Error */
5980  return NULL;
5981  }
5982  else
5983  {
5984  return result;
5985  }
5986  }
5987 
5988 
5989 
5990 
5991  typedef struct
5992  {
5993  OrthancPluginMoveCallback callback;
5994  OrthancPluginGetMoveSize getMoveSize;
5995  OrthancPluginApplyMove applyMove;
5996  OrthancPluginFreeMove freeMove;
5997  } _OrthancPluginMoveCallback;
5998 
6013  OrthancPluginContext* context,
6014  OrthancPluginMoveCallback callback,
6015  OrthancPluginGetMoveSize getMoveSize,
6016  OrthancPluginApplyMove applyMove,
6017  OrthancPluginFreeMove freeMove)
6018  {
6019  _OrthancPluginMoveCallback params;
6020  params.callback = callback;
6021  params.getMoveSize = getMoveSize;
6022  params.applyMove = applyMove;
6023  params.freeMove = freeMove;
6024 
6025  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
6026  }
6027 
6028 
6029 
6030  typedef struct
6031  {
6032  OrthancPluginFindMatcher** target;
6033  const void* query;
6034  uint32_t size;
6035  } _OrthancPluginCreateFindMatcher;
6036 
6037 
6052  OrthancPluginContext* context,
6053  const void* query,
6054  uint32_t size)
6055  {
6056  OrthancPluginFindMatcher* target = NULL;
6057 
6058  _OrthancPluginCreateFindMatcher params;
6059  memset(&params, 0, sizeof(params));
6060  params.target = &target;
6061  params.query = query;
6062  params.size = size;
6063 
6064  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
6065  {
6066  return NULL;
6067  }
6068  else
6069  {
6070  return target;
6071  }
6072  }
6073 
6074 
6075  typedef struct
6076  {
6077  OrthancPluginFindMatcher* matcher;
6078  } _OrthancPluginFreeFindMatcher;
6079 
6089  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6090  OrthancPluginContext* context,
6091  OrthancPluginFindMatcher* matcher)
6092  {
6093  _OrthancPluginFreeFindMatcher params;
6094  params.matcher = matcher;
6095 
6096  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6097  }
6098 
6099 
6100  typedef struct
6101  {
6102  const OrthancPluginFindMatcher* matcher;
6103  const void* dicom;
6104  uint32_t size;
6105  int32_t* isMatch;
6106  } _OrthancPluginFindMatcherIsMatch;
6107 
6122  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6123  OrthancPluginContext* context,
6124  const OrthancPluginFindMatcher* matcher,
6125  const void* dicom,
6126  uint32_t size)
6127  {
6128  int32_t isMatch = 0;
6129 
6130  _OrthancPluginFindMatcherIsMatch params;
6131  params.matcher = matcher;
6132  params.dicom = dicom;
6133  params.size = size;
6134  params.isMatch = &isMatch;
6135 
6136  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6137  {
6138  return isMatch;
6139  }
6140  else
6141  {
6142  /* Error: Assume non-match */
6143  return 0;
6144  }
6145  }
6146 
6147 
6148  typedef struct
6149  {
6151  } _OrthancPluginIncomingHttpRequestFilter2;
6152 
6165  OrthancPluginContext* context,
6167  {
6168  _OrthancPluginIncomingHttpRequestFilter2 params;
6169  params.callback = callback;
6170 
6171  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6172  }
6173 
6174 
6175 
6176  typedef struct
6177  {
6178  OrthancPluginPeers** peers;
6179  } _OrthancPluginGetPeers;
6180 
6193  OrthancPluginContext* context)
6194  {
6195  OrthancPluginPeers* peers = NULL;
6196 
6197  _OrthancPluginGetPeers params;
6198  memset(&params, 0, sizeof(params));
6199  params.peers = &peers;
6200 
6201  if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6202  {
6203  return NULL;
6204  }
6205  else
6206  {
6207  return peers;
6208  }
6209  }
6210 
6211 
6212  typedef struct
6213  {
6214  OrthancPluginPeers* peers;
6215  } _OrthancPluginFreePeers;
6216 
6226  ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6227  OrthancPluginContext* context,
6228  OrthancPluginPeers* peers)
6229  {
6230  _OrthancPluginFreePeers params;
6231  params.peers = peers;
6232 
6233  context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6234  }
6235 
6236 
6237  typedef struct
6238  {
6239  uint32_t* target;
6240  const OrthancPluginPeers* peers;
6241  } _OrthancPluginGetPeersCount;
6242 
6256  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6257  OrthancPluginContext* context,
6258  const OrthancPluginPeers* peers)
6259  {
6260  uint32_t target = 0;
6261 
6262  _OrthancPluginGetPeersCount params;
6263  memset(&params, 0, sizeof(params));
6264  params.target = &target;
6265  params.peers = peers;
6266 
6267  if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6268  {
6269  /* Error */
6270  return 0;
6271  }
6272  else
6273  {
6274  return target;
6275  }
6276  }
6277 
6278 
6279  typedef struct
6280  {
6281  const char** target;
6282  const OrthancPluginPeers* peers;
6283  uint32_t peerIndex;
6284  const char* userProperty;
6285  } _OrthancPluginGetPeerProperty;
6286 
6304  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6305  OrthancPluginContext* context,
6306  const OrthancPluginPeers* peers,
6307  uint32_t peerIndex)
6308  {
6309  const char* target = NULL;
6310 
6311  _OrthancPluginGetPeerProperty params;
6312  memset(&params, 0, sizeof(params));
6313  params.target = &target;
6314  params.peers = peers;
6315  params.peerIndex = peerIndex;
6316  params.userProperty = NULL;
6317 
6318  if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6319  {
6320  /* Error */
6321  return NULL;
6322  }
6323  else
6324  {
6325  return target;
6326  }
6327  }
6328 
6329 
6345  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6346  OrthancPluginContext* context,
6347  const OrthancPluginPeers* peers,
6348  uint32_t peerIndex)
6349  {
6350  const char* target = NULL;
6351 
6352  _OrthancPluginGetPeerProperty params;
6353  memset(&params, 0, sizeof(params));
6354  params.target = &target;
6355  params.peers = peers;
6356  params.peerIndex = peerIndex;
6357  params.userProperty = NULL;
6358 
6359  if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6360  {
6361  /* Error */
6362  return NULL;
6363  }
6364  else
6365  {
6366  return target;
6367  }
6368  }
6369 
6370 
6371 
6391  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6392  OrthancPluginContext* context,
6393  const OrthancPluginPeers* peers,
6394  uint32_t peerIndex,
6395  const char* userProperty)
6396  {
6397  const char* target = NULL;
6398 
6399  _OrthancPluginGetPeerProperty params;
6400  memset(&params, 0, sizeof(params));
6401  params.target = &target;
6402  params.peers = peers;
6403  params.peerIndex = peerIndex;
6404  params.userProperty = userProperty;
6405 
6406  if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6407  {
6408  /* No such user property */
6409  return NULL;
6410  }
6411  else
6412  {
6413  return target;
6414  }
6415  }
6416 
6417 
6418 
6419  typedef struct
6420  {
6421  OrthancPluginMemoryBuffer* answerBody;
6422  OrthancPluginMemoryBuffer* answerHeaders;
6423  uint16_t* httpStatus;
6424  const OrthancPluginPeers* peers;
6425  uint32_t peerIndex;
6426  OrthancPluginHttpMethod method;
6427  const char* uri;
6428  uint32_t additionalHeadersCount;
6429  const char* const* additionalHeadersKeys;
6430  const char* const* additionalHeadersValues;
6431  const void* body;
6432  uint32_t bodySize;
6433  uint32_t timeout;
6434  } _OrthancPluginCallPeerApi;
6435 
6472  OrthancPluginContext* context,
6473  OrthancPluginMemoryBuffer* answerBody,
6474  OrthancPluginMemoryBuffer* answerHeaders,
6475  uint16_t* httpStatus,
6476  const OrthancPluginPeers* peers,
6477  uint32_t peerIndex,
6478  OrthancPluginHttpMethod method,
6479  const char* uri,
6480  uint32_t additionalHeadersCount,
6481  const char* const* additionalHeadersKeys,
6482  const char* const* additionalHeadersValues,
6483  const void* body,
6484  uint32_t bodySize,
6485  uint32_t timeout)
6486  {
6487  _OrthancPluginCallPeerApi params;
6488  memset(&params, 0, sizeof(params));
6489 
6490  params.answerBody = answerBody;
6491  params.answerHeaders = answerHeaders;
6492  params.httpStatus = httpStatus;
6493  params.peers = peers;
6494  params.peerIndex = peerIndex;
6495  params.method = method;
6496  params.uri = uri;
6497  params.additionalHeadersCount = additionalHeadersCount;
6498  params.additionalHeadersKeys = additionalHeadersKeys;
6499  params.additionalHeadersValues = additionalHeadersValues;
6500  params.body = body;
6501  params.bodySize = bodySize;
6502  params.timeout = timeout;
6503 
6504  return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6505  }
6506 
6507 
6508 
6509 
6510 
6511  typedef struct
6512  {
6513  OrthancPluginJob** target;
6514  void *job;
6515  OrthancPluginJobFinalize finalize;
6516  const char *type;
6517  OrthancPluginJobGetProgress getProgress;
6518  OrthancPluginJobGetContent getContent;
6519  OrthancPluginJobGetSerialized getSerialized;
6520  OrthancPluginJobStep step;
6521  OrthancPluginJobStop stop;
6522  OrthancPluginJobReset reset;
6523  } _OrthancPluginCreateJob;
6524 
6557  OrthancPluginContext *context,
6558  void *job,
6559  OrthancPluginJobFinalize finalize,
6560  const char *type,
6561  OrthancPluginJobGetProgress getProgress,
6562  OrthancPluginJobGetContent getContent,
6563  OrthancPluginJobGetSerialized getSerialized,
6564  OrthancPluginJobStep step,
6565  OrthancPluginJobStop stop,
6566  OrthancPluginJobReset reset)
6567  {
6568  OrthancPluginJob* target = NULL;
6569 
6570  _OrthancPluginCreateJob params;
6571  memset(&params, 0, sizeof(params));
6572 
6573  params.target = &target;
6574  params.job = job;
6575  params.finalize = finalize;
6576  params.type = type;
6577  params.getProgress = getProgress;
6578  params.getContent = getContent;
6579  params.getSerialized = getSerialized;
6580  params.step = step;
6581  params.stop = stop;
6582  params.reset = reset;
6583 
6584  if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6585  target == NULL)
6586  {
6587  /* Error */
6588  return NULL;
6589  }
6590  else
6591  {
6592  return target;
6593  }
6594  }
6595 
6596 
6597  typedef struct
6598  {
6599  OrthancPluginJob* job;
6600  } _OrthancPluginFreeJob;
6601 
6611  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6612  OrthancPluginContext* context,
6613  OrthancPluginJob* job)
6614  {
6615  _OrthancPluginFreeJob params;
6616  params.job = job;
6617 
6618  context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6619  }
6620 
6621 
6622 
6623  typedef struct
6624  {
6625  char** resultId;
6626  OrthancPluginJob *job;
6627  int priority;
6628  } _OrthancPluginSubmitJob;
6629 
6643  ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6644  OrthancPluginContext *context,
6645  OrthancPluginJob *job,
6646  int priority)
6647  {
6648  char* resultId = NULL;
6649 
6650  _OrthancPluginSubmitJob params;
6651  memset(&params, 0, sizeof(params));
6652 
6653  params.resultId = &resultId;
6654  params.job = job;
6655  params.priority = priority;
6656 
6657  if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6658  resultId == NULL)
6659  {
6660  /* Error */
6661  return NULL;
6662  }
6663  else
6664  {
6665  return resultId;
6666  }
6667  }
6668 
6669 
6670 
6671  typedef struct
6672  {
6673  OrthancPluginJobsUnserializer unserializer;
6674  } _OrthancPluginJobsUnserializer;
6675 
6688  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6689  OrthancPluginContext* context,
6690  OrthancPluginJobsUnserializer unserializer)
6691  {
6692  _OrthancPluginJobsUnserializer params;
6693  params.unserializer = unserializer;
6694 
6695  context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6696  }
6697 
6698 
6699 
6700  typedef struct
6701  {
6702  OrthancPluginRestOutput* output;
6703  const char* details;
6704  uint8_t log;
6705  } _OrthancPluginSetHttpErrorDetails;
6706 
6724  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
6725  OrthancPluginContext* context,
6726  OrthancPluginRestOutput* output,
6727  const char* details,
6728  uint8_t log)
6729  {
6730  _OrthancPluginSetHttpErrorDetails params;
6731  params.output = output;
6732  params.details = details;
6733  params.log = log;
6734  context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
6735  }
6736 
6737 
6738 
6739  typedef struct
6740  {
6741  const char** result;
6742  const char* argument;
6743  } _OrthancPluginRetrieveStaticString;
6744 
6756  ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
6757  OrthancPluginContext* context,
6758  const char* path)
6759  {
6760  const char* result = NULL;
6761 
6762  _OrthancPluginRetrieveStaticString params;
6763  params.result = &result;
6764  params.argument = path;
6765 
6766  if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
6767  {
6768  /* Error */
6769  return NULL;
6770  }
6771  else
6772  {
6773  return result;
6774  }
6775  }
6776 
6777 
6778 
6779  typedef struct
6780  {
6781  const char* name;
6782  float value;
6784  } _OrthancPluginSetMetricsValue;
6785 
6800  ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
6801  OrthancPluginContext* context,
6802  const char* name,
6803  float value,
6805  {
6806  _OrthancPluginSetMetricsValue params;
6807  params.name = name;
6808  params.value = value;
6809  params.type = type;
6810  context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
6811  }
6812 
6813 
6814 
6815  typedef struct
6816  {
6818  } _OrthancPluginRegisterRefreshMetricsCallback;
6819 
6831  OrthancPluginContext* context,
6833  {
6834  _OrthancPluginRegisterRefreshMetricsCallback params;
6835  params.callback = callback;
6836  context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
6837  }
6838 
6839 
6840 
6841 
6842  typedef struct
6843  {
6844  char** target;
6845  const void* dicom;
6846  uint32_t dicomSize;
6848  } _OrthancPluginEncodeDicomWeb;
6849 
6866  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
6867  OrthancPluginContext* context,
6868  const void* dicom,
6869  uint32_t dicomSize,
6871  {
6872  char* target = NULL;
6873 
6874  _OrthancPluginEncodeDicomWeb params;
6875  params.target = &target;
6876  params.dicom = dicom;
6877  params.dicomSize = dicomSize;
6878  params.callback = callback;
6879 
6880  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
6881  {
6882  /* Error */
6883  return NULL;
6884  }
6885  else
6886  {
6887  return target;
6888  }
6889  }
6890 
6891 
6908  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
6909  OrthancPluginContext* context,
6910  const void* dicom,
6911  uint32_t dicomSize,
6913  {
6914  char* target = NULL;
6915 
6916  _OrthancPluginEncodeDicomWeb params;
6917  params.target = &target;
6918  params.dicom = dicom;
6919  params.dicomSize = dicomSize;
6920  params.callback = callback;
6921 
6922  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
6923  {
6924  /* Error */
6925  return NULL;
6926  }
6927  else
6928  {
6929  return target;
6930  }
6931  }
6932 
6933 
6934 
6935  typedef struct
6936  {
6937  char** target;
6938  const void* dicom;
6939  uint32_t dicomSize;
6941  void* payload;
6942  } _OrthancPluginEncodeDicomWeb2;
6943 
6960  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson2(
6961  OrthancPluginContext* context,
6962  const void* dicom,
6963  uint32_t dicomSize,
6965  void* payload)
6966  {
6967  char* target = NULL;
6968 
6969  _OrthancPluginEncodeDicomWeb2 params;
6970  params.target = &target;
6971  params.dicom = dicom;
6972  params.dicomSize = dicomSize;
6973  params.callback = callback;
6974  params.payload = payload;
6975 
6976  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson2, &params) != OrthancPluginErrorCode_Success)
6977  {
6978  /* Error */
6979  return NULL;
6980  }
6981  else
6982  {
6983  return target;
6984  }
6985  }
6986 
6987 
7004  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml2(
7005  OrthancPluginContext* context,
7006  const void* dicom,
7007  uint32_t dicomSize,
7009  void* payload)
7010  {
7011  char* target = NULL;
7012 
7013  _OrthancPluginEncodeDicomWeb2 params;
7014  params.target = &target;
7015  params.dicom = dicom;
7016  params.dicomSize = dicomSize;
7017  params.callback = callback;
7018  params.payload = payload;
7019 
7020  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml2, &params) != OrthancPluginErrorCode_Success)
7021  {
7022  /* Error */
7023  return NULL;
7024  }
7025  else
7026  {
7027  return target;
7028  }
7029  }
7030 
7031 
7032 
7049  void* answer,
7050  const char* key,
7051  const char* value);
7052 
7053 
7070  void* answer,
7071  const void* data,
7072  uint32_t size);
7073 
7074 
7089  typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
7090 
7091 
7107 
7108 
7122  typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
7123 
7124 
7138  typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
7139 
7140 
7141  typedef struct
7142  {
7143  void* answer;
7146  uint16_t* httpStatus;
7147  OrthancPluginHttpMethod method;
7148  const char* url;
7149  uint32_t headersCount;
7150  const char* const* headersKeys;
7151  const char* const* headersValues;
7152  void* request;
7157  const char* username;
7158  const char* password;
7159  uint32_t timeout;
7160  const char* certificateFile;
7161  const char* certificateKeyFile;
7162  const char* certificateKeyPassword;
7163  uint8_t pkcs11;
7164  } _OrthancPluginChunkedHttpClient;
7165 
7166 
7218  OrthancPluginContext* context,
7219  void* answer,
7222  uint16_t* httpStatus,
7223  OrthancPluginHttpMethod method,
7224  const char* url,
7225  uint32_t headersCount,
7226  const char* const* headersKeys,
7227  const char* const* headersValues,
7228  void* request,
7233  const char* username,
7234  const char* password,
7235  uint32_t timeout,
7236  const char* certificateFile,
7237  const char* certificateKeyFile,
7238  const char* certificateKeyPassword,
7239  uint8_t pkcs11)
7240  {
7241  _OrthancPluginChunkedHttpClient params;
7242  memset(&params, 0, sizeof(params));
7243 
7244  /* In common with OrthancPluginHttpClient() */
7245  params.httpStatus = httpStatus;
7246  params.method = method;
7247  params.url = url;
7248  params.headersCount = headersCount;
7249  params.headersKeys = headersKeys;
7250  params.headersValues = headersValues;
7251  params.username = username;
7252  params.password = password;
7253  params.timeout = timeout;
7254  params.certificateFile = certificateFile;
7255  params.certificateKeyFile = certificateKeyFile;
7256  params.certificateKeyPassword = certificateKeyPassword;
7257  params.pkcs11 = pkcs11;
7258 
7259  /* For chunked body/answer */
7260  params.answer = answer;
7261  params.answerAddChunk = answerAddChunk;
7262  params.answerAddHeader = answerAddHeader;
7263  params.request = request;
7264  params.requestIsDone = requestIsDone;
7265  params.requestChunkData = requestChunkData;
7266  params.requestChunkSize = requestChunkSize;
7267  params.requestNext = requestNext;
7268 
7269  return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7270  }
7271 
7272 
7273 
7278  typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7279 
7280 
7281 
7299  const char* url,
7300  const OrthancPluginHttpRequest* request);
7301 
7302 
7318  const void* data,
7319  uint32_t size);
7320 
7321 
7338  OrthancPluginRestOutput* output);
7339 
7340 
7356 
7357  typedef struct
7358  {
7359  const char* pathRegularExpression;
7360  OrthancPluginRestCallback getHandler;
7362  OrthancPluginRestCallback deleteHandler;
7367  } _OrthancPluginChunkedRestCallback;
7368 
7369 
7399  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterChunkedRestCallback(
7400  OrthancPluginContext* context,
7401  const char* pathRegularExpression,
7402  OrthancPluginRestCallback getHandler,
7404  OrthancPluginRestCallback deleteHandler,
7409  {
7410  _OrthancPluginChunkedRestCallback params;
7411  params.pathRegularExpression = pathRegularExpression;
7412  params.getHandler = getHandler;
7413  params.postHandler = postHandler;
7414  params.deleteHandler = deleteHandler;
7415  params.putHandler = putHandler;
7416  params.addChunk = addChunk;
7417  params.execute = execute;
7418  params.finalize = finalize;
7419 
7420  context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
7421  }
7422 
7423 
7424 
7425 
7426 
7427  typedef struct
7428  {
7429  char** result;
7430  uint16_t group;
7431  uint16_t element;
7432  const char* privateCreator;
7433  } _OrthancPluginGetTagName;
7434 
7450  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
7451  OrthancPluginContext* context,
7452  uint16_t group,
7453  uint16_t element,
7454  const char* privateCreator)
7455  {
7456  char* result;
7457 
7458  _OrthancPluginGetTagName params;
7459  params.result = &result;
7460  params.group = group;
7461  params.element = element;
7462  params.privateCreator = privateCreator;
7463 
7464  if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
7465  {
7466  /* Error */
7467  return NULL;
7468  }
7469  else
7470  {
7471  return result;
7472  }
7473  }
7474 
7475 
7476 
7506  void** handler /* out */,
7507  const char* jobId,
7508  const char* transactionUid,
7509  const char* const* sopClassUids,
7510  const char* const* sopInstanceUids,
7511  uint32_t countInstances,
7512  const char* remoteAet,
7513  const char* calledAet);
7514 
7515 
7527  typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
7528 
7529 
7550  void* handler,
7551  const char* sopClassUid,
7552  const char* sopInstanceUid);
7553 
7554 
7555  typedef struct
7556  {
7560  } _OrthancPluginRegisterStorageCommitmentScpCallback;
7561 
7576  OrthancPluginContext* context,
7580  {
7581  _OrthancPluginRegisterStorageCommitmentScpCallback params;
7582  params.factory = factory;
7583  params.destructor = destructor;
7584  params.lookup = lookup;
7585  return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
7586  }
7587 
7588 
7589 
7606  const OrthancPluginDicomInstance* instance);
7607 
7608 
7609  typedef struct
7610  {
7612  } _OrthancPluginIncomingDicomInstanceFilter;
7613 
7637  OrthancPluginContext* context,
7639  {
7640  _OrthancPluginIncomingDicomInstanceFilter params;
7641  params.callback = callback;
7642 
7643  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, &params);
7644  }
7645 
7646 
7660  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceTransferSyntaxUid(
7661  OrthancPluginContext* context,
7662  const OrthancPluginDicomInstance* instance)
7663  {
7664  char* result;
7665 
7666  _OrthancPluginAccessDicomInstance params;
7667  memset(&params, 0, sizeof(params));
7668  params.resultStringToFree = &result;
7669  params.instance = instance;
7670 
7671  if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, &params) != OrthancPluginErrorCode_Success)
7672  {
7673  /* Error */
7674  return NULL;
7675  }
7676  else
7677  {
7678  return result;
7679  }
7680  }
7681 
7682 
7695  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData(
7696  OrthancPluginContext* context,
7697  const OrthancPluginDicomInstance* instance)
7698  {
7699  int64_t hasPixelData;
7700 
7701  _OrthancPluginAccessDicomInstance params;
7702  memset(&params, 0, sizeof(params));
7703  params.resultInt64 = &hasPixelData;
7704  params.instance = instance;
7705 
7706  if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, &params) != OrthancPluginErrorCode_Success ||
7707  hasPixelData < 0 ||
7708  hasPixelData > 1)
7709  {
7710  /* Error */
7711  return -1;
7712  }
7713  else
7714  {
7715  return (hasPixelData != 0);
7716  }
7717  }
7718 
7719 
7720 
7721 
7722 
7723 
7724  typedef struct
7725  {
7726  OrthancPluginDicomInstance** target;
7727  const void* buffer;
7728  uint32_t size;
7729  const char* transferSyntax;
7730  } _OrthancPluginCreateDicomInstance;
7731 
7746  OrthancPluginContext* context,
7747  const void* buffer,
7748  uint32_t size)
7749  {
7750  OrthancPluginDicomInstance* target = NULL;
7751 
7752  _OrthancPluginCreateDicomInstance params;
7753  params.target = &target;
7754  params.buffer = buffer;
7755  params.size = size;
7756 
7757  if (context->InvokeService(context, _OrthancPluginService_CreateDicomInstance, &params) != OrthancPluginErrorCode_Success)
7758  {
7759  /* Error */
7760  return NULL;
7761  }
7762  else
7763  {
7764  return target;
7765  }
7766  }
7767 
7768  typedef struct
7769  {
7771  } _OrthancPluginFreeDicomInstance;
7772 
7783  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeDicomInstance(
7784  OrthancPluginContext* context,
7786  {
7787  _OrthancPluginFreeDicomInstance params;
7788  params.dicom = dicom;
7789 
7790  context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, &params);
7791  }
7792 
7793 
7794  typedef struct
7795  {
7796  uint32_t* targetUint32;
7797  OrthancPluginMemoryBuffer* targetBuffer;
7798  OrthancPluginImage** targetImage;
7799  char** targetStringToFree;
7800  const OrthancPluginDicomInstance* instance;
7801  uint32_t frameIndex;
7804  uint32_t maxStringLength;
7805  OrthancPluginDicomWebBinaryCallback2 dicomWebCallback;
7806  void* dicomWebPayload;
7807  } _OrthancPluginAccessDicomInstance2;
7808 
7820  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetInstanceFramesCount(
7821  OrthancPluginContext* context,
7822  const OrthancPluginDicomInstance* instance)
7823  {
7824  uint32_t count;
7825 
7826  _OrthancPluginAccessDicomInstance2 params;
7827  memset(&params, 0, sizeof(params));
7828  params.targetUint32 = &count;
7829  params.instance = instance;
7830 
7831  if (context->InvokeService(context, _OrthancPluginService_GetInstanceFramesCount, &params) != OrthancPluginErrorCode_Success)
7832  {
7833  /* Error */
7834  return 0;
7835  }
7836  else
7837  {
7838  return count;
7839  }
7840  }
7841 
7842 
7861  OrthancPluginContext* context,
7862  OrthancPluginMemoryBuffer* target,
7863  const OrthancPluginDicomInstance* instance,
7864  uint32_t frameIndex)
7865  {
7866  _OrthancPluginAccessDicomInstance2 params;
7867  memset(&params, 0, sizeof(params));
7868  params.targetBuffer = target;
7869  params.instance = instance;
7870  params.frameIndex = frameIndex;
7871 
7872  return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, &params);
7873  }
7874 
7875 
7889  OrthancPluginContext* context,
7890  const OrthancPluginDicomInstance* instance,
7891  uint32_t frameIndex)
7892  {
7893  OrthancPluginImage* target = NULL;
7894 
7895  _OrthancPluginAccessDicomInstance2 params;
7896  memset(&params, 0, sizeof(params));
7897  params.targetImage = &target;
7898  params.instance = instance;
7899  params.frameIndex = frameIndex;
7900 
7901  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDecodedFrame, &params) != OrthancPluginErrorCode_Success)
7902  {
7903  return NULL;
7904  }
7905  else
7906  {
7907  return target;
7908  }
7909  }
7910 
7911 
7928  OrthancPluginContext* context,
7929  const void* buffer,
7930  uint32_t size,
7931  const char* transferSyntax)
7932  {
7933  OrthancPluginDicomInstance* target = NULL;
7934 
7935  _OrthancPluginCreateDicomInstance params;
7936  params.target = &target;
7937  params.buffer = buffer;
7938  params.size = size;
7939  params.transferSyntax = transferSyntax;
7940 
7941  if (context->InvokeService(context, _OrthancPluginService_TranscodeDicomInstance, &params) != OrthancPluginErrorCode_Success)
7942  {
7943  /* Error */
7944  return NULL;
7945  }
7946  else
7947  {
7948  return target;
7949  }
7950  }
7951 
7966  OrthancPluginContext* context,
7967  OrthancPluginMemoryBuffer* target,
7968  const OrthancPluginDicomInstance* instance)
7969  {
7970  _OrthancPluginAccessDicomInstance2 params;
7971  memset(&params, 0, sizeof(params));
7972  params.targetBuffer = target;
7973  params.instance = instance;
7974 
7975  return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, &params);
7976  }
7977 
7978 
7997  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceAdvancedJson(
7998  OrthancPluginContext* context,
7999  const OrthancPluginDicomInstance* instance,
8002  uint32_t maxStringLength)
8003  {
8004  char* result = NULL;
8005 
8006  _OrthancPluginAccessDicomInstance2 params;
8007  memset(&params, 0, sizeof(params));
8008  params.targetStringToFree = &result;
8009  params.instance = instance;
8010  params.format = format;
8011  params.flags = flags;
8012  params.maxStringLength = maxStringLength;
8013 
8014  if (context->InvokeService(context, _OrthancPluginService_GetInstanceAdvancedJson, &params) != OrthancPluginErrorCode_Success)
8015  {
8016  /* Error */
8017  return NULL;
8018  }
8019  else
8020  {
8021  return result;
8022  }
8023  }
8024 
8025 
8040  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebJson(
8041  OrthancPluginContext* context,
8042  const OrthancPluginDicomInstance* instance,
8044  void* payload)
8045  {
8046  char* target = NULL;
8047 
8048  _OrthancPluginAccessDicomInstance2 params;
8049  params.targetStringToFree = &target;
8050  params.instance = instance;
8051  params.dicomWebCallback = callback;
8052  params.dicomWebPayload = payload;
8053 
8054  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebJson, &params) != OrthancPluginErrorCode_Success)
8055  {
8056  /* Error */
8057  return NULL;
8058  }
8059  else
8060  {
8061  return target;
8062  }
8063  }
8064 
8065 
8080  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebXml(
8081  OrthancPluginContext* context,
8082  const OrthancPluginDicomInstance* instance,
8084  void* payload)
8085  {
8086  char* target = NULL;
8087 
8088  _OrthancPluginAccessDicomInstance2 params;
8089  params.targetStringToFree = &target;
8090  params.instance = instance;
8091  params.dicomWebCallback = callback;
8092  params.dicomWebPayload = payload;
8093 
8094  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebXml, &params) != OrthancPluginErrorCode_Success)
8095  {
8096  /* Error */
8097  return NULL;
8098  }
8099  else
8100  {
8101  return target;
8102  }
8103  }
8104 
8105 
8106 
8126  OrthancPluginMemoryBuffer* transcoded /* out */,
8127  const void* buffer,
8128  uint64_t size,
8129  const char* const* allowedSyntaxes,
8130  uint32_t countSyntaxes,
8131  uint8_t allowNewSopInstanceUid);
8132 
8133 
8134  typedef struct
8135  {
8137  } _OrthancPluginTranscoderCallback;
8138 
8153  OrthancPluginContext* context,
8155  {
8156  _OrthancPluginTranscoderCallback params;
8157  params.callback = callback;
8158 
8159  return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, &params);
8160  }
8161 
8162 
8163 
8164  typedef struct
8165  {
8166  OrthancPluginMemoryBuffer* target;
8167  uint32_t size;
8168  } _OrthancPluginCreateMemoryBuffer;
8169 
8188  OrthancPluginContext* context,
8189  OrthancPluginMemoryBuffer* target,
8190  uint32_t size)
8191  {
8192  _OrthancPluginCreateMemoryBuffer params;
8193  params.target = target;
8194  params.size = size;
8195 
8196  return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, &params);
8197  }
8198 
8199 
8200 #ifdef __cplusplus
8201 }
8202 #endif
8203 
8204 
OrthancPluginJobGetProgress
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1459
OrthancPluginMetricsType_Default
@ OrthancPluginMetricsType_Default
Definition: OrthancCPlugin.h:931
OrthancPluginChangeType_NewPatient
@ OrthancPluginChangeType_NewPatient
Definition: OrthancCPlugin.h:716
OrthancPluginErrorCode_SQLiteStatementAlreadyUsed
@ OrthancPluginErrorCode_SQLiteStatementAlreadyUsed
Definition: OrthancCPlugin.h:243
OrthancPluginConvertPixelFormat
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4336
OrthancPluginGetMoveSize
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1404
OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
Definition: OrthancCPlugin.h:831
OrthancPluginErrorCode_CannotExecuteLua
@ OrthancPluginErrorCode_CannotExecuteLua
Definition: OrthancCPlugin.h:287
OrthancPluginCheckVersion
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1834
OrthancPluginChangeType_JobFailure
@ OrthancPluginChangeType_JobFailure
Definition: OrthancCPlugin.h:730
OrthancPluginErrorCode_NoWorklistHandler
@ OrthancPluginErrorCode_NoWorklistHandler
Definition: OrthancCPlugin.h:297
OrthancPluginCompressionType_Gzip
@ OrthancPluginCompressionType_Gzip
Definition: OrthancCPlugin.h:744
OrthancPluginExtendOrthancExplorer
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:3267
OrthancPluginHttpClient
OrthancPluginErrorCode OrthancPluginHttpClient(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, OrthancPluginHttpMethod method, const char *url, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, const void *body, uint32_t bodySize, const char *username, const char *password, uint32_t timeout, const char *certificateFile, const char *certificateKeyFile, const char *certificateKeyPassword, uint8_t pkcs11)
Issue a HTTP call with full flexibility.
Definition: OrthancCPlugin.h:5672
OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii
Definition: OrthancCPlugin.h:830
OrthancPluginErrorCode_SQLiteBindOutOfRange
@ OrthancPluginErrorCode_SQLiteBindOutOfRange
Definition: OrthancCPlugin.h:251
OrthancPluginRegisterOnStoredInstanceCallback
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:2015
OrthancPluginValueRepresentation_AS
@ OrthancPluginValueRepresentation_AS
Definition: OrthancCPlugin.h:772
OrthancPluginValueRepresentation_UT
@ OrthancPluginValueRepresentation_UT
Definition: OrthancCPlugin.h:797
OrthancPluginErrorCode_SystemCommand
@ OrthancPluginErrorCode_SystemCommand
Definition: OrthancCPlugin.h:210
OrthancPluginContext
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginErrorCode_NotEnoughMemory
@ OrthancPluginErrorCode_NotEnoughMemory
Definition: OrthancCPlugin.h:204
OrthancPluginChangeType_UpdatedAttachment
@ OrthancPluginChangeType_UpdatedAttachment
Definition: OrthancCPlugin.h:724
OrthancPluginSendHttpStatus
void OrthancPluginSendHttpStatus(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status, const char *body, uint32_t bodySize)
Send a HTTP status, with a custom body.
Definition: OrthancCPlugin.h:3734
OrthancPluginInstanceOrigin_Plugin
@ OrthancPluginInstanceOrigin_Plugin
Definition: OrthancCPlugin.h:892
OrthancPluginFindAddAnswer
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5805
OrthancPluginGetOrthancDirectory
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:3111
OrthancPluginDicomToJsonFlags_IncludePrivateTags
@ OrthancPluginDicomToJsonFlags_IncludePrivateTags
Definition: OrthancCPlugin.h:827
OrthancPluginAnswerBuffer
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:2047
OrthancPluginPixelFormat_RGBA32
@ OrthancPluginPixelFormat_RGBA32
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:627
OrthancPluginChangeType_StableStudy
@ OrthancPluginChangeType_StableStudy
Definition: OrthancCPlugin.h:721
OrthancPluginRestApiDelete
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2309
OrthancPluginValueRepresentation_FD
@ OrthancPluginValueRepresentation_FD
Definition: OrthancCPlugin.h:778
OrthancPluginCreateDicomInstance
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition: OrthancCPlugin.h:7745
OrthancPluginRestApiPutAfterPlugins
OrthancPluginErrorCode OrthancPluginRestApiPutAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a PUT call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2393
OrthancPluginErrorCode_Unauthorized
@ OrthancPluginErrorCode_Unauthorized
Definition: OrthancCPlugin.h:229
OrthancPluginServerChunkedRequestReaderFactory
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderFactory)(OrthancPluginServerChunkedRequestReader **reader, const char *url, const OrthancPluginHttpRequest *request)
Callback to create a reader to handle incoming chunked HTTP transfers.
Definition: OrthancCPlugin.h:7297
OrthancPluginErrorCode_CreateDicomNoPayload
@ OrthancPluginErrorCode_CreateDicomNoPayload
Definition: OrthancCPlugin.h:278
OrthancPluginErrorCode_InexistentTag
@ OrthancPluginErrorCode_InexistentTag
Definition: OrthancCPlugin.h:221
OrthancPluginComputeSha1
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5471
OrthancPluginErrorCode_CreateDicomUseContent
@ OrthancPluginErrorCode_CreateDicomUseContent
Definition: OrthancCPlugin.h:277
OrthancPluginPixelFormat_BGRA32
@ OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:661
OrthancPluginErrorCode_Timeout
@ OrthancPluginErrorCode_Timeout
Definition: OrthancCPlugin.h:216
OrthancPluginResourceType_Patient
@ OrthancPluginResourceType_Patient
Definition: OrthancCPlugin.h:695
OrthancPluginErrorCode_JsonToLuaTable
@ OrthancPluginErrorCode_JsonToLuaTable
Definition: OrthancCPlugin.h:285
OrthancPluginErrorCode_LuaReturnsNoString
@ OrthancPluginErrorCode_LuaReturnsNoString
Definition: OrthancCPlugin.h:291
OrthancPluginPixelFormat_Float32
@ OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:653
OrthancPluginDictionaryEntry::group
uint16_t group
Definition: OrthancCPlugin.h:1682
OrthancPluginCreateDicomFlags_DecodeDataUriScheme
@ OrthancPluginCreateDicomFlags_DecodeDataUriScheme
Definition: OrthancCPlugin.h:845
OrthancPluginCreateImage
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5300
OrthancPluginLookupSeries
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2564
OrthancPluginServerChunkedRequestReaderAddChunk
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderAddChunk)(OrthancPluginServerChunkedRequestReader *reader, const void *data, uint32_t size)
Callback invoked whenever a new data chunk is available during a chunked transfer.
Definition: OrthancCPlugin.h:7316
OrthancPluginIncomingDicomInstanceFilter
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition: OrthancCPlugin.h:7605
OrthancPluginChangeType_OrthancStopped
@ OrthancPluginChangeType_OrthancStopped
Definition: OrthancCPlugin.h:723
OrthancPluginErrorCode_LuaAlreadyExecuted
@ OrthancPluginErrorCode_LuaAlreadyExecuted
Definition: OrthancCPlugin.h:288
OrthancPluginGetInstanceRemoteAet
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2781
OrthancPluginDicomToJsonFlags
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:824
OrthancPluginErrorCode_SQLiteCannotStep
@ OrthancPluginErrorCode_SQLiteCannotStep
Definition: OrthancCPlugin.h:250
OrthancPluginCompressAndAnswerJpegImage
void OrthancPluginCompressAndAnswerJpegImage(OrthancPluginContext *context, OrthancPluginRestOutput *output, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, const void *buffer, uint8_t quality)
Answer to a REST request with a JPEG image.
Definition: OrthancCPlugin.h:4127
OrthancPluginGetPeerUrl
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6345
OrthancPluginErrorCode_NoCGetHandler
@ OrthancPluginErrorCode_NoCGetHandler
Definition: OrthancCPlugin.h:300
OrthancPluginValueRepresentation_ST
@ OrthancPluginValueRepresentation_ST
Definition: OrthancCPlugin.h:791
OrthancPluginImageFormat
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:756
OrthancPluginConstraintType_Wildcard
@ OrthancPluginConstraintType_Wildcard
Definition: OrthancCPlugin.h:877
OrthancPluginStorageAreaRead
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4590
OrthancPluginRegisterDecodeImageCallback
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5262
OrthancPluginRestApiPostAfterPlugins
OrthancPluginErrorCode OrthancPluginRestApiPostAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a POST call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2280
OrthancPluginErrorCode_SQLiteCannotOpen
@ OrthancPluginErrorCode_SQLiteCannotOpen
Definition: OrthancCPlugin.h:242
OrthancPluginChangeType_CompletedSeries
@ OrthancPluginChangeType_CompletedSeries
Definition: OrthancCPlugin.h:712
OrthancPluginErrorCode_SQLiteFlush
@ OrthancPluginErrorCode_SQLiteFlush
Definition: OrthancCPlugin.h:248
OrthancPluginErrorCode_SQLiteExecute
@ OrthancPluginErrorCode_SQLiteExecute
Definition: OrthancCPlugin.h:244
OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
@ OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
Definition: OrthancCPlugin.h:967
OrthancPluginHttpRequest
The parameters of a REST request.
Definition: OrthancCPlugin.h:333
OrthancPluginInstanceOrigin_Unknown
@ OrthancPluginInstanceOrigin_Unknown
Definition: OrthancCPlugin.h:889
OrthancPluginValueRepresentation_DA
@ OrthancPluginValueRepresentation_DA
Definition: OrthancCPlugin.h:775
OrthancPluginIdentifierConstraint_SmallerOrEqual
@ OrthancPluginIdentifierConstraint_SmallerOrEqual
Definition: OrthancCPlugin.h:860
OrthancPluginGetImageWidth
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3803
OrthancPluginChangeType_JobSuccess
@ OrthancPluginChangeType_JobSuccess
Definition: OrthancCPlugin.h:729
OrthancPluginConstraintType
OrthancPluginConstraintType
Definition: OrthancCPlugin.h:873
OrthancPluginHasInstanceMetadata
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:2960
OrthancPluginGetPeerName
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6304
OrthancPluginErrorCode_InternalError
@ OrthancPluginErrorCode_InternalError
Definition: OrthancCPlugin.h:199
OrthancPluginDicomWebBinaryCallback2
void(* OrthancPluginDicomWebBinaryCallback2)(OrthancPluginDicomWebNode *node, OrthancPluginDicomWebSetBinaryNode setter, uint32_t levelDepth, const uint16_t *levelTagGroup, const uint16_t *levelTagElement, const uint32_t *levelIndex, uint16_t tagGroup, uint16_t tagElement, OrthancPluginValueRepresentation vr, void *payload)
Callback executed to encode a binary tag in DICOMweb.
Definition: OrthancCPlugin.h:1648
OrthancPluginChangeType_NewChildInstance
@ OrthancPluginChangeType_NewChildInstance
Definition: OrthancCPlugin.h:714
OrthancPluginWorklistCallback
OrthancPluginErrorCode(* OrthancPluginWorklistCallback)(OrthancPluginWorklistAnswers *answers, const OrthancPluginWorklistQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle the C-Find SCP requests for worklists.
Definition: OrthancCPlugin.h:1251
OrthancPluginChangeType_UpdatedPeers
@ OrthancPluginChangeType_UpdatedPeers
Definition: OrthancCPlugin.h:726
OrthancPluginGetImagePitch
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3871
OrthancPluginFindMatcher
struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher
Opaque structure to an object that can be used to check whether a DICOM instance matches a C-Find que...
Definition: OrthancCPlugin.h:1082
OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
@ OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
Definition: OrthancCPlugin.h:975
OrthancPluginErrorCode_BadApplicationEntityTitle
@ OrthancPluginErrorCode_BadApplicationEntityTitle
Definition: OrthancCPlugin.h:265
OrthancPluginGetInstanceMetadata
const char * OrthancPluginGetInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Get the value of some metadata associated with a given DICOM instance.
Definition: OrthancCPlugin.h:3001
OrthancPluginErrorCode_NoCMoveHandler
@ OrthancPluginErrorCode_NoCMoveHandler
Definition: OrthancCPlugin.h:267
OrthancPluginErrorCode_SQLiteCannotRun
@ OrthancPluginErrorCode_SQLiteCannotRun
Definition: OrthancCPlugin.h:249
OrthancPluginDicomToJsonFlags_IncludeBinary
@ OrthancPluginDicomToJsonFlags_IncludeBinary
Definition: OrthancCPlugin.h:826
OrthancPluginRegisterStorageCommitmentScpCallback
OrthancPluginErrorCode OrthancPluginRegisterStorageCommitmentScpCallback(OrthancPluginContext *context, OrthancPluginStorageCommitmentFactory factory, OrthancPluginStorageCommitmentDestructor destructor, OrthancPluginStorageCommitmentLookup lookup)
Register a callback to handle incoming requests to the storage commitment SCP.
Definition: OrthancCPlugin.h:7575
OrthancPluginJobStopReason_Failure
@ OrthancPluginJobStopReason_Failure
Definition: OrthancCPlugin.h:921
OrthancPluginGetInstanceFramesCount
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition: OrthancCPlugin.h:7820
OrthancPluginHttpRequest::groups
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:347
OrthancPluginCreateDicomFlags_GenerateIdentifiers
@ OrthancPluginCreateDicomFlags_GenerateIdentifiers
Definition: OrthancCPlugin.h:846
OrthancPluginErrorCode_SQLitePrepareStatement
@ OrthancPluginErrorCode_SQLitePrepareStatement
Definition: OrthancCPlugin.h:252
OrthancPluginRestCallback
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1115
OrthancPluginHttpRequest::bodySize
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:372
OrthancPluginReconstructMainDicomTags
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4819
OrthancPluginGetTagName
char * OrthancPluginGetTagName(OrthancPluginContext *context, uint16_t group, uint16_t element, const char *privateCreator)
Returns the symbolic name of a DICOM tag.
Definition: OrthancCPlugin.h:7450
OrthancPluginGetFindQueryTag
OrthancPluginErrorCode OrthancPluginGetFindQueryTag(OrthancPluginContext *context, uint16_t *group, uint16_t *element, const OrthancPluginFindQuery *query, uint32_t index)
Get one tag in a C-Find query.
Definition: OrthancCPlugin.h:5895
OrthancPluginLookupDictionary
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5517
OrthancPluginDicomBufferToJson
char * OrthancPluginDicomBufferToJson(OrthancPluginContext *context, const void *buffer, uint32_t size, OrthancPluginDicomToJsonFormat format, OrthancPluginDicomToJsonFlags flags, uint32_t maxStringLength)
Format a DICOM memory buffer as a JSON string.
Definition: OrthancCPlugin.h:4863
OrthancPluginGetConfigurationPath
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:3146
OrthancPluginHttpDelete
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4298
OrthancPluginCompressionType
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:741
OrthancPluginJobStep
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1507
OrthancPluginDictionaryEntry::minMultiplicity
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1685
OrthancPluginErrorCode_InexistentFile
@ OrthancPluginErrorCode_InexistentFile
Definition: OrthancCPlugin.h:213
OrthancPluginErrorCode_ParameterOutOfRange
@ OrthancPluginErrorCode_ParameterOutOfRange
Definition: OrthancCPlugin.h:203
OrthancPluginContentType_Dicom
@ OrthancPluginContentType_Dicom
Definition: OrthancCPlugin.h:682
OrthancPluginErrorCode_UnknownResource
@ OrthancPluginErrorCode_UnknownResource
Definition: OrthancCPlugin.h:217
OrthancPluginErrorCode_DirectoryExpected
@ OrthancPluginErrorCode_DirectoryExpected
Definition: OrthancCPlugin.h:258
OrthancPluginResourceType_Instance
@ OrthancPluginResourceType_Instance
Definition: OrthancCPlugin.h:698
OrthancPluginRegisterIncomingHttpRequestFilter
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5598
OrthancPluginEncodeDicomWebXml2
char * OrthancPluginEncodeDicomWebXml2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7004
OrthancPluginErrorCode_Success
@ OrthancPluginErrorCode_Success
Definition: OrthancCPlugin.h:200
OrthancPluginCompressPngImage
OrthancPluginErrorCode OrthancPluginCompressPngImage(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, const void *buffer)
Encode a PNG image.
Definition: OrthancCPlugin.h:4035
OrthancPluginErrorCode_MakeDirectory
@ OrthancPluginErrorCode_MakeDirectory
Definition: OrthancCPlugin.h:264
OrthancPluginErrorCode_UnsupportedMediaType
@ OrthancPluginErrorCode_UnsupportedMediaType
Definition: OrthancCPlugin.h:301
OrthancPluginChangeType_NewInstance
@ OrthancPluginChangeType_NewInstance
Definition: OrthancCPlugin.h:715
OrthancPluginDrawText
OrthancPluginErrorCode OrthancPluginDrawText(OrthancPluginContext *context, OrthancPluginImage *image, uint32_t fontIndex, const char *utf8Text, int32_t x, int32_t y, uint8_t r, uint8_t g, uint8_t b)
Draw text on an image.
Definition: OrthancCPlugin.h:4496
OrthancPluginResourceType_None
@ OrthancPluginResourceType_None
Definition: OrthancCPlugin.h:699
OrthancPluginSetMetricsValue
void OrthancPluginSetMetricsValue(OrthancPluginContext *context, const char *name, float value, OrthancPluginMetricsType type)
Set the value of a metrics.
Definition: OrthancCPlugin.h:6800
OrthancPluginErrorCode_CannotStoreInstance
@ OrthancPluginErrorCode_CannotStoreInstance
Definition: OrthancCPlugin.h:274
OrthancPluginHttpMethod_Get
@ OrthancPluginHttpMethod_Get
Definition: OrthancCPlugin.h:319
OrthancPluginGetInstanceTransferSyntaxUid
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition: OrthancCPlugin.h:7660
OrthancPluginCreateDicomFlags
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:843
OrthancPluginWorklistAddAnswer
OrthancPluginErrorCode OrthancPluginWorklistAddAnswer(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Add one answer to some modality worklist request.
Definition: OrthancCPlugin.h:5044
OrthancPluginPixelFormat_Grayscale8
@ OrthancPluginPixelFormat_Grayscale8
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:595
OrthancPluginStorageArea
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:1042
OrthancPluginSendHttpStatusCode
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2644
OrthancPluginIdentifierConstraint
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:858
OrthancPluginRestApiDeleteAfterPlugins
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2332
OrthancPluginPeers
struct _OrthancPluginPeers_t OrthancPluginPeers
Opaque structure to the set of remote Orthanc Peers that are known to the local Orthanc server.
Definition: OrthancCPlugin.h:1090
OrthancPluginRefreshMetricsCallback
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1582
OrthancPluginDicomWebBinaryMode_BulkDataUri
@ OrthancPluginDicomWebBinaryMode_BulkDataUri
Definition: OrthancCPlugin.h:950
OrthancPluginPixelFormat_Unknown
@ OrthancPluginPixelFormat_Unknown
Definition: OrthancCPlugin.h:629
OrthancPluginValueRepresentation_LO
@ OrthancPluginValueRepresentation_LO
Definition: OrthancCPlugin.h:781
OrthancPluginRegisterIncomingHttpRequestFilter2
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6164
OrthancPluginValueRepresentation_AE
@ OrthancPluginValueRepresentation_AE
Definition: OrthancCPlugin.h:771
OrthancPluginGetInstanceDecodedFrame
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:7888
OrthancPluginRestApiGet2
OrthancPluginErrorCode OrthancPluginRestApiGet2(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, int32_t afterPlugins)
Make a GET call to the Orthanc REST API, with custom HTTP headers.
Definition: OrthancCPlugin.h:4970
OrthancPluginResourceType
OrthancPluginResourceType
Definition: OrthancCPlugin.h:694
OrthancPluginCreateFindMatcher
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:6051
OrthancPluginErrorCode_NoSopClassOrInstance
@ OrthancPluginErrorCode_NoSopClassOrInstance
Definition: OrthancCPlugin.h:270
OrthancPluginJobStop
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1531
OrthancPluginValueRepresentation_AT
@ OrthancPluginValueRepresentation_AT
Definition: OrthancCPlugin.h:773
OrthancPluginReadFile
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3619
OrthancPluginCallPeerApi
OrthancPluginErrorCode OrthancPluginCallPeerApi(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, const OrthancPluginPeers *peers, uint32_t peerIndex, OrthancPluginHttpMethod method, const char *uri, uint32_t additionalHeadersCount, const char *const *additionalHeadersKeys, const char *const *additionalHeadersValues, const void *body, uint32_t bodySize, uint32_t timeout)
Call the REST API of an Orthanc peer.
Definition: OrthancCPlugin.h:6471
OrthancPluginOnChangeCallback
OrthancPluginErrorCode(* OrthancPluginOnChangeCallback)(OrthancPluginChangeType changeType, OrthancPluginResourceType resourceType, const char *resourceId)
Signature of a callback function that is triggered when a change happens to some DICOM resource.
Definition: OrthancCPlugin.h:1136
OrthancPluginInstanceOrigin_RestApi
@ OrthancPluginInstanceOrigin_RestApi
Definition: OrthancCPlugin.h:891
OrthancPluginChunkedClientRequestIsDone
uint8_t(* OrthancPluginChunkedClientRequestIsDone)(void *request)
Callback to know whether the request body is entirely read during a chunked transfer.
Definition: OrthancCPlugin.h:7089
OrthancPluginErrorCode_NoApplicationEntityFilter
@ OrthancPluginErrorCode_NoApplicationEntityFilter
Definition: OrthancCPlugin.h:269
OrthancPluginLookupStudyWithAccessionNumber
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2529
OrthancPluginCompressionType_ZlibWithSize
@ OrthancPluginCompressionType_ZlibWithSize
Definition: OrthancCPlugin.h:743
OrthancPluginGetCommandLineArgumentsCount
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3371
OrthancPluginErrorCode_ReadOnly
@ OrthancPluginErrorCode_ReadOnly
Definition: OrthancCPlugin.h:222
OrthancPluginErrorCode_SQLiteTransactionAlreadyStarted
@ OrthancPluginErrorCode_SQLiteTransactionAlreadyStarted
Definition: OrthancCPlugin.h:253
OrthancPluginFreeDicomInstance
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition: OrthancCPlugin.h:7783
OrthancPluginValueRepresentation_TM
@ OrthancPluginValueRepresentation_TM
Definition: OrthancCPlugin.h:792
OrthancPluginErrorCode_StorageAreaPlugin
@ OrthancPluginErrorCode_StorageAreaPlugin
Definition: OrthancCPlugin.h:232
OrthancPluginWorklistQuery
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1050
OrthancPluginHasInstancePixelData
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:7695
OrthancPluginGetInstanceDicomWebXml
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:8080
OrthancPluginGetInstanceSize
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2814
OrthancPluginEncodeDicomWebXml
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:6908
OrthancPluginImageFormat_Jpeg
@ OrthancPluginImageFormat_Jpeg
Definition: OrthancCPlugin.h:758
OrthancPluginErrorCode_BadRequest
@ OrthancPluginErrorCode_BadRequest
Definition: OrthancCPlugin.h:208
OrthancPluginDicomWebSetBinaryNode
void(* OrthancPluginDicomWebSetBinaryNode)(OrthancPluginDicomWebNode *node, OrthancPluginDicomWebBinaryMode mode, const char *bulkDataUri)
Signature of a function to set the content of a node encoding a binary DICOM tag, into a JSON or XML ...
Definition: OrthancCPlugin.h:1169
OrthancPluginCreateMemoryBuffer
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, uint32_t size)
Create a memory buffer.
Definition: OrthancCPlugin.h:8187
OrthancPluginOnStoredInstanceCallback
OrthancPluginErrorCode(* OrthancPluginOnStoredInstanceCallback)(const OrthancPluginDicomInstance *instance, const char *instanceId)
Signature of a callback function that is triggered when Orthanc stores a new DICOM instance.
Definition: OrthancCPlugin.h:1126
OrthancPluginRestApiGet
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2178
OrthancPluginConstraintType_SmallerOrEqual
@ OrthancPluginConstraintType_SmallerOrEqual
Definition: OrthancCPlugin.h:875
OrthancPluginRestOutput
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:1018
OrthancPluginServerChunkedRequestReaderFinalize
void(* OrthancPluginServerChunkedRequestReaderFinalize)(OrthancPluginServerChunkedRequestReader *reader)
Callback invoked to release the resources associated with an incoming HTTP chunked transfer.
Definition: OrthancCPlugin.h:7354
OrthancPluginCompressionType_Zlib
@ OrthancPluginCompressionType_Zlib
Definition: OrthancCPlugin.h:742
OrthancPluginErrorCode_NoCStoreHandler
@ OrthancPluginErrorCode_NoCStoreHandler
Definition: OrthancCPlugin.h:268
OrthancPluginErrorCode_CreateDicomParentEncoding
@ OrthancPluginErrorCode_CreateDicomParentEncoding
Definition: OrthancCPlugin.h:282
OrthancPluginDicomToJsonFormat_Short
@ OrthancPluginDicomToJsonFormat_Short
Definition: OrthancCPlugin.h:811
OrthancPluginLogError
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:1869
OrthancPluginPixelFormat_RGB48
@ OrthancPluginPixelFormat_RGB48
Color image in RGB48 format.
Definition: OrthancCPlugin.h:637
OrthancPluginCompressAndAnswerPngImage
void OrthancPluginCompressAndAnswerPngImage(OrthancPluginContext *context, OrthancPluginRestOutput *output, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, const void *buffer)
Answer to a REST request with a PNG image.
Definition: OrthancCPlugin.h:2104
OrthancPluginValueRepresentation_SL
@ OrthancPluginValueRepresentation_SL
Definition: OrthancCPlugin.h:788
OrthancPluginErrorCode_DicomFindUnavailable
@ OrthancPluginErrorCode_DicomFindUnavailable
Definition: OrthancCPlugin.h:272
OrthancPluginErrorCode_InexistentItem
@ OrthancPluginErrorCode_InexistentItem
Definition: OrthancCPlugin.h:207
OrthancPluginGetInstanceSimplifiedJson
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:2921
OrthancPluginJobStopReason_Canceled
@ OrthancPluginJobStopReason_Canceled
Definition: OrthancCPlugin.h:922
OrthancPluginErrorCode_SslInitialization
@ OrthancPluginErrorCode_SslInitialization
Definition: OrthancCPlugin.h:239
OrthancPluginDicomToJsonFormat
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:809
OrthancPluginErrorCode_IncompatibleDatabaseVersion
@ OrthancPluginErrorCode_IncompatibleDatabaseVersion
Definition: OrthancCPlugin.h:218
OrthancPluginErrorCode_AlreadyExistingTag
@ OrthancPluginErrorCode_AlreadyExistingTag
Definition: OrthancCPlugin.h:298
OrthancPluginErrorCode_CreateDicomNotString
@ OrthancPluginErrorCode_CreateDicomNotString
Definition: OrthancCPlugin.h:275
OrthancPluginErrorCode_BadFont
@ OrthancPluginErrorCode_BadFont
Definition: OrthancCPlugin.h:230
OrthancPluginConstraintType_Equal
@ OrthancPluginConstraintType_Equal
Definition: OrthancCPlugin.h:874
OrthancPluginErrorCode_IncompatibleImageSize
@ OrthancPluginErrorCode_IncompatibleImageSize
Definition: OrthancCPlugin.h:224
OrthancPluginErrorCode_SQLiteTransactionCommit
@ OrthancPluginErrorCode_SQLiteTransactionCommit
Definition: OrthancCPlugin.h:254
OrthancPluginHttpMethod_Post
@ OrthancPluginHttpMethod_Post
Definition: OrthancCPlugin.h:320
OrthancPluginErrorCode_UnknownPluginService
@ OrthancPluginErrorCode_UnknownPluginService
Definition: OrthancCPlugin.h:226
OrthancPluginErrorCode_CorruptedFile
@ OrthancPluginErrorCode_CorruptedFile
Definition: OrthancCPlugin.h:220
OrthancPluginDicomWebBinaryMode_InlineBinary
@ OrthancPluginDicomWebBinaryMode_InlineBinary
Definition: OrthancCPlugin.h:949
OrthancPluginIncomingHttpRequestFilter
int32_t(* OrthancPluginIncomingHttpRequestFilter)(OrthancPluginHttpMethod method, const char *uri, const char *ip, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues)
Callback to filter incoming HTTP requests received by Orthanc.
Definition: OrthancCPlugin.h:1278
OrthancPluginChangeType_StableSeries
@ OrthancPluginChangeType_StableSeries
Definition: OrthancCPlugin.h:720
OrthancPluginGetOrthancPath
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:3081
OrthancPluginGetInstanceOrigin
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5177
OrthancPluginStorageCreate
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1188
OrthancPluginContentType
OrthancPluginContentType
Definition: OrthancCPlugin.h:680
OrthancPluginGenerateUuid
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5727
OrthancPluginValueRepresentation_LT
@ OrthancPluginValueRepresentation_LT
Definition: OrthancCPlugin.h:782
OrthancPluginFreeMemoryBuffer
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1853
OrthancPluginMetricsType_Timer
@ OrthancPluginMetricsType_Timer
Definition: OrthancCPlugin.h:938
OrthancPluginHttpRequest::headersCount
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:382
OrthancPluginServerChunkedRequestReaderExecute
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderExecute)(OrthancPluginServerChunkedRequestReader *reader, OrthancPluginRestOutput *output)
Callback invoked whenever the request body is entirely received.
Definition: OrthancCPlugin.h:7336
OrthancPluginInstanceOrigin_Lua
@ OrthancPluginInstanceOrigin_Lua
Definition: OrthancCPlugin.h:893
OrthancPluginSerializeDicomInstance
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition: OrthancCPlugin.h:7965
OrthancPluginSetRootUri
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:3223
OrthancPluginCompressionType_GzipWithSize
@ OrthancPluginCompressionType_GzipWithSize
Definition: OrthancCPlugin.h:745
OrthancPluginStartMultipartAnswer
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3511
OrthancPluginErrorCode_CannotOrderSlices
@ OrthancPluginErrorCode_CannotOrderSlices
Definition: OrthancCPlugin.h:296
OrthancPluginGetImageBuffer
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:3905
OrthancPluginStorageRemove
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1232
OrthancPluginErrorCode_SQLiteTransactionBegin
@ OrthancPluginErrorCode_SQLiteTransactionBegin
Definition: OrthancCPlugin.h:255
OrthancPluginErrorCode_BadJobOrdering
@ OrthancPluginErrorCode_BadJobOrdering
Definition: OrthancCPlugin.h:284
OrthancPluginHttpRequest::headersValues
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:392
OrthancPluginValueRepresentation_DS
@ OrthancPluginValueRepresentation_DS
Definition: OrthancCPlugin.h:776
OrthancPluginChunkedClientRequestGetChunkData
const void *(* OrthancPluginChunkedClientRequestGetChunkData)(void *request)
Callback to read the current chunk of the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7122
OrthancPluginInstanceOrigin
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:888
OrthancPluginRestApiPut
OrthancPluginErrorCode OrthancPluginRestApiPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a PUT call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2357
OrthancPluginErrorCode_CreateDicomOverrideTag
@ OrthancPluginErrorCode_CreateDicomOverrideTag
Definition: OrthancCPlugin.h:276
OrthancPluginTranscodeDicomInstance
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition: OrthancCPlugin.h:7927
OrthancPluginDicomWebBinaryMode_Ignore
@ OrthancPluginDicomWebBinaryMode_Ignore
Definition: OrthancCPlugin.h:948
OrthancPluginGetFontsCount
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4371
OrthancPluginRegisterIncomingDicomInstanceFilter
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition: OrthancCPlugin.h:7636
OrthancPluginChangeType_StablePatient
@ OrthancPluginChangeType_StablePatient
Definition: OrthancCPlugin.h:719
OrthancPluginSendMultipartItem
OrthancPluginErrorCode OrthancPluginSendMultipartItem(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize)
Send an item as a part of some HTTP multipart answer.
Definition: OrthancCPlugin.h:3540
OrthancPluginGetExpectedDatabaseVersion
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3437
OrthancPluginRegisterOnChangeCallback
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3192
OrthancPluginChangeType_OrthancStarted
@ OrthancPluginChangeType_OrthancStarted
Definition: OrthancCPlugin.h:722
OrthancPluginFreeJob
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6611
OrthancPluginChangeType_NewSeries
@ OrthancPluginChangeType_NewSeries
Definition: OrthancCPlugin.h:717
OrthancPluginDicomToJsonFormat_Human
@ OrthancPluginDicomToJsonFormat_Human
Definition: OrthancCPlugin.h:812
OrthancPluginChunkedClientAnswerAddChunk
OrthancPluginErrorCode(* OrthancPluginChunkedClientAnswerAddChunk)(void *answer, const void *data, uint32_t size)
Callback executed when an answer chunk is received during a chunked transfer.
Definition: OrthancCPlugin.h:7069
OrthancPluginServerChunkedRequestReader
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition: OrthancCPlugin.h:7278
OrthancPluginIdentifierConstraint_GreaterOrEqual
@ OrthancPluginIdentifierConstraint_GreaterOrEqual
Definition: OrthancCPlugin.h:861
OrthancPluginValueRepresentation
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:770
OrthancPluginErrorCode_CannotWriteFile
@ OrthancPluginErrorCode_CannotWriteFile
Definition: OrthancCPlugin.h:214
OrthancPluginDictionaryEntry::maxMultiplicity
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1686
OrthancPluginIdentifierConstraint_Equal
@ OrthancPluginIdentifierConstraint_Equal
Definition: OrthancCPlugin.h:859
OrthancPluginErrorCode_Database
@ OrthancPluginErrorCode_Database
Definition: OrthancCPlugin.h:211
OrthancPluginErrorCode_DirectoryOverFile
@ OrthancPluginErrorCode_DirectoryOverFile
Definition: OrthancCPlugin.h:256
OrthancPluginRegisterWorklistCallback
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:5008
OrthancPluginCreateDicom
OrthancPluginErrorCode OrthancPluginCreateDicom(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *json, const OrthancPluginImage *pixelData, OrthancPluginCreateDicomFlags flags)
Create a DICOM instance from a JSON string and an image.
Definition: OrthancCPlugin.h:5226
OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered
@ OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered
Definition: OrthancCPlugin.h:293
OrthancPluginGetFontSize
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4443
OrthancPluginGetErrorDescription
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3681
OrthancPluginErrorCode_DatabaseUnavailable
@ OrthancPluginErrorCode_DatabaseUnavailable
Definition: OrthancCPlugin.h:236
OrthancPluginSetGlobalProperty
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3340
OrthancPluginDecodeImageCallback
OrthancPluginErrorCode(* OrthancPluginDecodeImageCallback)(OrthancPluginImage **target, const void *dicom, const uint32_t size, uint32_t frameIndex)
Signature of a callback function to decode a DICOM instance as an image.
Definition: OrthancCPlugin.h:1147
OrthancPluginRegisterRestCallback
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:1937
OrthancPluginChangeType_Deleted
@ OrthancPluginChangeType_Deleted
Definition: OrthancCPlugin.h:713
OrthancPluginMoveCallback
void *(* OrthancPluginMoveCallback)(OrthancPluginResourceType resourceType, const char *patientId, const char *accessionNumber, const char *studyInstanceUid, const char *seriesInstanceUid, const char *sopInstanceUid, const char *originatorAet, const char *sourceAet, const char *targetAet, uint16_t originatorId)
Callback to handle incoming C-Move SCP requests.
Definition: OrthancCPlugin.h:1379
OrthancPluginImageFormat_Dicom
@ OrthancPluginImageFormat_Dicom
Definition: OrthancCPlugin.h:759
OrthancPluginGetGlobalProperty
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3301
OrthancPluginValueRepresentation_SH
@ OrthancPluginValueRepresentation_SH
Definition: OrthancCPlugin.h:787
OrthancPluginGetImageHeight
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:3836
OrthancPluginValueRepresentation_OB
@ OrthancPluginValueRepresentation_OB
Definition: OrthancCPlugin.h:783
OrthancPluginValueRepresentation_DT
@ OrthancPluginValueRepresentation_DT
Definition: OrthancCPlugin.h:777
OrthancPluginValueRepresentation_UL
@ OrthancPluginValueRepresentation_UL
Definition: OrthancCPlugin.h:794
OrthancPluginPixelFormat_RGB24
@ OrthancPluginPixelFormat_RGB24
Color image in RGB24 format.
Definition: OrthancCPlugin.h:619
OrthancPluginValueRepresentation_SQ
@ OrthancPluginValueRepresentation_SQ
Definition: OrthancCPlugin.h:789
OrthancPluginJobGetSerialized
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1492
OrthancPluginFindAnswers
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1074
OrthancPluginRegisterErrorCode
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4666
OrthancPluginComputeMd5
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5435
OrthancPluginErrorCode_SQLiteRegisterFunction
@ OrthancPluginErrorCode_SQLiteRegisterFunction
Definition: OrthancCPlugin.h:247
OrthancPluginErrorCode_NoStorageCommitmentHandler
@ OrthancPluginErrorCode_NoStorageCommitmentHandler
Definition: OrthancCPlugin.h:299
OrthancPluginValueRepresentation_CS
@ OrthancPluginValueRepresentation_CS
Definition: OrthancCPlugin.h:774
OrthancPluginMemoryBuffer::data
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1003
OrthancPluginPixelFormat_SignedGrayscale16
@ OrthancPluginPixelFormat_SignedGrayscale16
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:611
OrthancPluginFreeFindMatcher
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:6089
OrthancPluginCompressJpegImage
OrthancPluginErrorCode OrthancPluginCompressJpegImage(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, const void *buffer, uint8_t quality)
Encode a JPEG image.
Definition: OrthancCPlugin.h:4080
OrthancPluginGetInstanceJson
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2883
OrthancPluginInstanceOrigin_WebDav
@ OrthancPluginInstanceOrigin_WebDav
Definition: OrthancCPlugin.h:894
OrthancPluginHttpMethod_Put
@ OrthancPluginHttpMethod_Put
Definition: OrthancCPlugin.h:321
OrthancPluginStorageAreaCreate
OrthancPluginErrorCode OrthancPluginStorageAreaCreate(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, const void *content, uint64_t size, OrthancPluginContentType type)
Create a file inside the storage area.
Definition: OrthancCPlugin.h:4548
OrthancPluginHttpRequest::body
const void * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:367
OrthancPluginStorageCommitmentLookup
OrthancPluginErrorCode(* OrthancPluginStorageCommitmentLookup)(OrthancPluginStorageCommitmentFailureReason *target, void *handler, const char *sopClassUid, const char *sopInstanceUid)
Callback to get the status of one DICOM instance in the storage commitment SCP.
Definition: OrthancCPlugin.h:7548
OrthancPluginRegisterChunkedRestCallback
void OrthancPluginRegisterChunkedRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback getHandler, OrthancPluginServerChunkedRequestReaderFactory postHandler, OrthancPluginRestCallback deleteHandler, OrthancPluginServerChunkedRequestReaderFactory putHandler, OrthancPluginServerChunkedRequestReaderAddChunk addChunk, OrthancPluginServerChunkedRequestReaderExecute execute, OrthancPluginServerChunkedRequestReaderFinalize finalize)
Register a REST callback to handle chunked HTTP transfers.
Definition: OrthancCPlugin.h:7399
OrthancPluginErrorCode_NotImplemented
@ OrthancPluginErrorCode_NotImplemented
Definition: OrthancCPlugin.h:202
OrthancPluginDicomToJsonFlags_IncludePixelData
@ OrthancPluginDicomToJsonFlags_IncludePixelData
Definition: OrthancCPlugin.h:829
OrthancPluginRegisterMoveCallback
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:6012
OrthancPluginRegisterJobsUnserializer
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6688
OrthancPluginErrorCode_UnknownModality
@ OrthancPluginErrorCode_UnknownModality
Definition: OrthancCPlugin.h:283
OrthancPluginErrorCode_CreateDicomBadParent
@ OrthancPluginErrorCode_CreateDicomBadParent
Definition: OrthancCPlugin.h:280
OrthancPluginHttpPost
OrthancPluginErrorCode OrthancPluginHttpPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const void *body, uint32_t bodySize, const char *username, const char *password)
Issue a HTTP POST call.
Definition: OrthancCPlugin.h:4218
OrthancPluginHttpPut
OrthancPluginErrorCode OrthancPluginHttpPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const void *body, uint32_t bodySize, const char *username, const char *password)
Issue a HTTP PUT call.
Definition: OrthancCPlugin.h:4260
OrthancPluginDicomInstanceToJson
char * OrthancPluginDicomInstanceToJson(OrthancPluginContext *context, const char *instanceId, OrthancPluginDicomToJsonFormat format, OrthancPluginDicomToJsonFlags flags, uint32_t maxStringLength)
Format a DICOM instance as a JSON string.
Definition: OrthancCPlugin.h:4912
OrthancPluginChangeType_UpdatedModalities
@ OrthancPluginChangeType_UpdatedModalities
Definition: OrthancCPlugin.h:727
OrthancPluginValueRepresentation_UN
@ OrthancPluginValueRepresentation_UN
Definition: OrthancCPlugin.h:795
OrthancPluginSetDescription
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:3245
OrthancPluginDicomWebBinaryMode
OrthancPluginDicomWebBinaryMode
Definition: OrthancCPlugin.h:947
OrthancPluginIdentifierConstraint_Wildcard
@ OrthancPluginIdentifierConstraint_Wildcard
Definition: OrthancCPlugin.h:862
OrthancPluginPixelFormat_Grayscale64
@ OrthancPluginPixelFormat_Grayscale64
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:669
OrthancPluginConstraintType_GreaterOrEqual
@ OrthancPluginConstraintType_GreaterOrEqual
Definition: OrthancCPlugin.h:876
OrthancPluginErrorCode_NoCFindHandler
@ OrthancPluginErrorCode_NoCFindHandler
Definition: OrthancCPlugin.h:266
OrthancPluginValueRepresentation_IS
@ OrthancPluginValueRepresentation_IS
Definition: OrthancCPlugin.h:780
OrthancPluginErrorCode_BadGeometry
@ OrthancPluginErrorCode_BadGeometry
Definition: OrthancCPlugin.h:238
OrthancPluginLogWarning
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:1885
OrthancPluginValueRepresentation_UI
@ OrthancPluginValueRepresentation_UI
Definition: OrthancCPlugin.h:793
OrthancPluginGetImagePixelFormat
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3770
OrthancPluginStorageCommitmentFailureReason_Success
@ OrthancPluginStorageCommitmentFailureReason_Success
Definition: OrthancCPlugin.h:961
OrthancPluginErrorCode_CreateDicomParentIsInstance
@ OrthancPluginErrorCode_CreateDicomParentIsInstance
Definition: OrthancCPlugin.h:281
OrthancPluginFree
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1159
OrthancPluginRedirect
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2427
OrthancPluginValueRepresentation_SS
@ OrthancPluginValueRepresentation_SS
Definition: OrthancCPlugin.h:790
OrthancPluginJobReset
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1548
OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
@ OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
Definition: OrthancCPlugin.h:979
OrthancPluginGetFindQueryTagName
char * OrthancPluginGetFindQueryTagName(OrthancPluginContext *context, const OrthancPluginFindQuery *query, uint32_t index)
Get the symbolic name of one tag in a C-Find query.
Definition: OrthancCPlugin.h:5926
OrthancPluginCreateJob
OrthancPluginJob * OrthancPluginCreateJob(OrthancPluginContext *context, void *job, OrthancPluginJobFinalize finalize, const char *type, OrthancPluginJobGetProgress getProgress, OrthancPluginJobGetContent getContent, OrthancPluginJobGetSerialized getSerialized, OrthancPluginJobStep step, OrthancPluginJobStop stop, OrthancPluginJobReset reset)
Create a custom job.
Definition: OrthancCPlugin.h:6556
OrthancPluginWorklistMarkIncomplete
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5074
OrthancPluginEncodeDicomWebJson
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:6866
OrthancPluginHttpRequest::method
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:337
OrthancPluginErrorCode_SQLiteCommitWithoutTransaction
@ OrthancPluginErrorCode_SQLiteCommitWithoutTransaction
Definition: OrthancCPlugin.h:246
OrthancPluginValueRepresentation_PN
@ OrthancPluginValueRepresentation_PN
Definition: OrthancCPlugin.h:786
OrthancPluginErrorCode
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:198
OrthancPluginHttpRequest::getValues
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:362
OrthancPluginErrorCode_Plugin
@ OrthancPluginErrorCode_Plugin
Definition: OrthancCPlugin.h:201
OrthancPluginErrorCode_UriSyntax
@ OrthancPluginErrorCode_UriSyntax
Definition: OrthancCPlugin.h:212
OrthancPluginHttpRequest::headersKeys
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:387
OrthancPluginStorageRead
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1214
OrthancPluginJobsUnserializer
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1564
OrthancPluginChangeType_UpdatedMetadata
@ OrthancPluginChangeType_UpdatedMetadata
Definition: OrthancCPlugin.h:725
OrthancPluginChangeType_JobSubmitted
@ OrthancPluginChangeType_JobSubmitted
Definition: OrthancCPlugin.h:728
OrthancPluginMemoryBuffer
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:999
OrthancPluginJobGetContent
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1474
OrthancPluginValueRepresentation_FL
@ OrthancPluginValueRepresentation_FL
Definition: OrthancCPlugin.h:779
OrthancPluginFreePeers
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6226
OrthancPluginWorklistAnswers
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1058
OrthancPluginRegisterFindCallback
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5766
OrthancPluginDictionaryEntry::vr
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1684
OrthancPluginImage
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1034
OrthancPluginConstraintType_List
@ OrthancPluginConstraintType_List
Definition: OrthancCPlugin.h:878
OrthancPluginJob
struct _OrthancPluginJob_t OrthancPluginJob
Opaque structure to a job to be executed by Orthanc.
Definition: OrthancCPlugin.h:1098
OrthancPluginErrorCode_BadSequenceOfCalls
@ OrthancPluginErrorCode_BadSequenceOfCalls
Definition: OrthancCPlugin.h:206
OrthancPluginContentType_Unknown
@ OrthancPluginContentType_Unknown
Definition: OrthancCPlugin.h:681
OrthancPluginIncomingHttpRequestFilter2
int32_t(* OrthancPluginIncomingHttpRequestFilter2)(OrthancPluginHttpMethod method, const char *uri, const char *ip, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, uint32_t getArgumentsCount, const char *const *getArgumentsKeys, const char *const *getArgumentsValues)
Callback to filter incoming HTTP requests received by Orthanc.
Definition: OrthancCPlugin.h:1309
OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
@ OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
Definition: OrthancCPlugin.h:984
OrthancPluginHttpMethod
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:318
OrthancPluginFindCallback
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1336
OrthancPluginFreeImage
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:3990
OrthancPluginHttpRequest::groupsCount
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:342
OrthancPluginDicomWebNode
struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode
Opaque structure that represents a node in a JSON or XML document used in DICOMweb.
Definition: OrthancCPlugin.h:1107
OrthancPluginAutodetectMimeType
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:6756
OrthancPluginErrorCode_DicomMoveUnavailable
@ OrthancPluginErrorCode_DicomMoveUnavailable
Definition: OrthancCPlugin.h:273
OrthancPluginErrorCode_DicomPortInUse
@ OrthancPluginErrorCode_DicomPortInUse
Definition: OrthancCPlugin.h:260
OrthancPluginFreeMove
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1433
OrthancPluginGetFontName
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4411
OrthancPluginSetCookie
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2720
OrthancPluginJobFinalize
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1446
OrthancPluginApplyMove
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1419
OrthancPluginErrorCode_EmptyRequest
@ OrthancPluginErrorCode_EmptyRequest
Definition: OrthancCPlugin.h:233
OrthancPluginErrorCode_CanceledJob
@ OrthancPluginErrorCode_CanceledJob
Definition: OrthancCPlugin.h:237
OrthancPluginJobStepStatus_Failure
@ OrthancPluginJobStepStatus_Failure
Definition: OrthancCPlugin.h:906
OrthancPluginGetInstanceRawFrame
OrthancPluginErrorCode OrthancPluginGetInstanceRawFrame(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Get the raw content of a frame in a DICOM instance.
Definition: OrthancCPlugin.h:7860
OrthancPluginPixelFormat_Grayscale32
@ OrthancPluginPixelFormat_Grayscale32
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:645
OrthancPluginGetPeers
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6192
OrthancPluginErrorCode_NoPresentationContext
@ OrthancPluginErrorCode_NoPresentationContext
Definition: OrthancCPlugin.h:271
OrthancPluginErrorCode_NetworkProtocol
@ OrthancPluginErrorCode_NetworkProtocol
Definition: OrthancCPlugin.h:209
OrthancPluginSubmitJob
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int priority)
Submit a new job to the jobs engine of Orthanc.
Definition: OrthancCPlugin.h:6643
OrthancPluginDicomToJsonFormat_Full
@ OrthancPluginDicomToJsonFormat_Full
Definition: OrthancCPlugin.h:810
OrthancPluginRegisterRefreshMetricsCallback
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:6830
OrthancPluginGetInstanceAdvancedJson
char * OrthancPluginGetInstanceAdvancedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomToJsonFormat format, OrthancPluginDicomToJsonFlags flags, uint32_t maxStringLength)
Format a DICOM memory buffer as a JSON string.
Definition: OrthancCPlugin.h:7997
OrthancPluginHttpMethod_Delete
@ OrthancPluginHttpMethod_Delete
Definition: OrthancCPlugin.h:322
OrthancPluginHttpRequest::getCount
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:352
OrthancPluginErrorCode_UnknownDicomTag
@ OrthancPluginErrorCode_UnknownDicomTag
Definition: OrthancCPlugin.h:227
OrthancPluginInstanceOrigin_DicomProtocol
@ OrthancPluginInstanceOrigin_DicomProtocol
Definition: OrthancCPlugin.h:890
OrthancPluginResourceType_Series
@ OrthancPluginResourceType_Series
Definition: OrthancCPlugin.h:697
OrthancPluginErrorCode_IncompatibleImageFormat
@ OrthancPluginErrorCode_IncompatibleImageFormat
Definition: OrthancCPlugin.h:223
OrthancPluginChangeType_NewStudy
@ OrthancPluginChangeType_NewStudy
Definition: OrthancCPlugin.h:718
OrthancPluginErrorCode_FullStorage
@ OrthancPluginErrorCode_FullStorage
Definition: OrthancCPlugin.h:219
OrthancPluginDictionaryEntry
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1681
OrthancPluginCreateImageAccessor
OrthancPluginImage * OrthancPluginCreateImageAccessor(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, void *buffer)
Create an image pointing to a memory buffer.
Definition: OrthancCPlugin.h:5343
OrthancPluginJobStopReason_Paused
@ OrthancPluginJobStopReason_Paused
Definition: OrthancCPlugin.h:920
OrthancPluginGetPeerUserProperty
const char * OrthancPluginGetPeerUserProperty(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex, const char *userProperty)
Get some user-defined property of an Orthanc peer.
Definition: OrthancCPlugin.h:6391
OrthancPluginLookupPatient
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2459
OrthancPluginJobStopReason_Success
@ OrthancPluginJobStopReason_Success
Definition: OrthancCPlugin.h:919
OrthancPluginErrorCode_SQLiteAlreadyOpened
@ OrthancPluginErrorCode_SQLiteAlreadyOpened
Definition: OrthancCPlugin.h:241
OrthancPluginFreeString
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1699
OrthancPluginWriteFile
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3650
OrthancPluginGetCommandLineArgument
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3405
OrthancPluginJobStepStatus_Continue
@ OrthancPluginJobStepStatus_Continue
Definition: OrthancCPlugin.h:907
OrthancPluginErrorCode_RegularFileExpected
@ OrthancPluginErrorCode_RegularFileExpected
Definition: OrthancCPlugin.h:262
OrthancPluginLookupInstance
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2599
OrthancPluginChunkedHttpClient
OrthancPluginErrorCode OrthancPluginChunkedHttpClient(OrthancPluginContext *context, void *answer, OrthancPluginChunkedClientAnswerAddChunk answerAddChunk, OrthancPluginChunkedClientAnswerAddHeader answerAddHeader, uint16_t *httpStatus, OrthancPluginHttpMethod method, const char *url, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, void *request, OrthancPluginChunkedClientRequestIsDone requestIsDone, OrthancPluginChunkedClientRequestGetChunkData requestChunkData, OrthancPluginChunkedClientRequestGetChunkSize requestChunkSize, OrthancPluginChunkedClientRequestNext requestNext, const char *username, const char *password, uint32_t timeout, const char *certificateFile, const char *certificateKeyFile, const char *certificateKeyPassword, uint8_t pkcs11)
Issue a HTTP call, using chunked HTTP transfers.
Definition: OrthancCPlugin.h:7217
OrthancPluginErrorCode_SslDisabled
@ OrthancPluginErrorCode_SslDisabled
Definition: OrthancCPlugin.h:295
OrthancPluginErrorCode_CreateDicomUseDataUriScheme
@ OrthancPluginErrorCode_CreateDicomUseDataUriScheme
Definition: OrthancCPlugin.h:279
OrthancPluginChangeType
OrthancPluginChangeType
Definition: OrthancCPlugin.h:711
OrthancPluginErrorCode_CannotCreateLua
@ OrthancPluginErrorCode_CannotCreateLua
Definition: OrthancCPlugin.h:286
OrthancPluginErrorCode_BadHttpStatusInRest
@ OrthancPluginErrorCode_BadHttpStatusInRest
Definition: OrthancCPlugin.h:261
OrthancPluginErrorCode_StorageAreaAlreadyRegistered
@ OrthancPluginErrorCode_StorageAreaAlreadyRegistered
Definition: OrthancCPlugin.h:292
OrthancPluginJobStepStatus
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:904
OrthancPluginUncompressImage
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:3948
OrthancPluginRegisterRestCallbackNoLock
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:1977
OrthancPluginCheckVersionAdvanced
int OrthancPluginCheckVersionAdvanced(OrthancPluginContext *context, int expectedMajor, int expectedMinor, int expectedRevision)
Check that the version of the hosting Orthanc is above a given version.
Definition: OrthancCPlugin.h:1729
OrthancPluginValueRepresentation_US
@ OrthancPluginValueRepresentation_US
Definition: OrthancCPlugin.h:796
OrthancPluginWorklistIsMatch
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:5112
OrthancPluginErrorCode_DatabaseNotInitialized
@ OrthancPluginErrorCode_DatabaseNotInitialized
Definition: OrthancCPlugin.h:294
OrthancPluginSendMultipartItem2
OrthancPluginErrorCode OrthancPluginSendMultipartItem2(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *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:5560
OrthancPluginDicomToJsonFlags_IncludeUnknownTags
@ OrthancPluginDicomToJsonFlags_IncludeUnknownTags
Definition: OrthancCPlugin.h:828
OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
@ OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
Definition: OrthancCPlugin.h:971
OrthancPluginMemoryBuffer::size
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1008
OrthancPluginJobStopReason
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:918
OrthancPluginRegisterPrivateDictionaryTag
OrthancPluginErrorCode OrthancPluginRegisterPrivateDictionaryTag(OrthancPluginContext *context, uint16_t group, uint16_t element, OrthancPluginValueRepresentation vr, const char *name, uint32_t minMultiplicity, uint32_t maxMultiplicity, const char *privateCreator)
Register a new private tag into the DICOM dictionary.
Definition: OrthancCPlugin.h:4775
OrthancPluginEncodeDicomWebJson2
char * OrthancPluginEncodeDicomWebJson2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:6960
OrthancPluginStorageAreaRemove
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4627
OrthancPluginGetPeersCount
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6256
OrthancPluginGetFindQuerySize
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5858
OrthancPluginLogInfo
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:1901
OrthancPluginErrorCode_SQLiteRollbackWithoutTransaction
@ OrthancPluginErrorCode_SQLiteRollbackWithoutTransaction
Definition: OrthancCPlugin.h:245
OrthancPluginFindMarkIncomplete
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:5834
OrthancPluginFindQuery
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1066
OrthancPluginHttpGet
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:4180
OrthancPluginGetInstanceData
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2847
OrthancPluginGetInstanceDicomWebJson
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:8040
OrthancPluginErrorCode_BadFileFormat
@ OrthancPluginErrorCode_BadFileFormat
Definition: OrthancCPlugin.h:215
OrthancPluginErrorCode_BadJson
@ OrthancPluginErrorCode_BadJson
Definition: OrthancCPlugin.h:228
OrthancPluginHttpRequest::getKeys
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:357
OrthancPluginChunkedClientRequestGetChunkSize
uint32_t(* OrthancPluginChunkedClientRequestGetChunkSize)(void *request)
Callback to read the size of the current request chunk during a chunked transfer.
Definition: OrthancCPlugin.h:7138
OrthancPluginResourceType_Study
@ OrthancPluginResourceType_Study
Definition: OrthancCPlugin.h:696
OrthancPluginStorageCommitmentFailureReason
OrthancPluginStorageCommitmentFailureReason
Definition: OrthancCPlugin.h:960
OrthancPluginContentType_DicomAsJson
@ OrthancPluginContentType_DicomAsJson
Definition: OrthancCPlugin.h:683
OrthancPluginDicomWebBinaryCallback
void(* OrthancPluginDicomWebBinaryCallback)(OrthancPluginDicomWebNode *node, OrthancPluginDicomWebSetBinaryNode setter, uint32_t levelDepth, const uint16_t *levelTagGroup, const uint16_t *levelTagElement, const uint32_t *levelIndex, uint16_t tagGroup, uint16_t tagElement, OrthancPluginValueRepresentation vr)
Callback executed to encode a binary tag in DICOMweb.
Definition: OrthancCPlugin.h:1610
OrthancPluginErrorCode_HttpPortInUse
@ OrthancPluginErrorCode_HttpPortInUse
Definition: OrthancCPlugin.h:259
OrthancPluginErrorCode_PathToExecutable
@ OrthancPluginErrorCode_PathToExecutable
Definition: OrthancCPlugin.h:263
OrthancPluginMetricsType
OrthancPluginMetricsType
Definition: OrthancCPlugin.h:930
OrthancPluginBufferCompression
OrthancPluginErrorCode OrthancPluginBufferCompression(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const void *source, uint32_t size, OrthancPluginCompressionType compression, uint8_t uncompress)
Compress or decompress a buffer.
Definition: OrthancCPlugin.h:3582
OrthancPluginGetDicomForInstance
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2145
OrthancPluginWorklistGetDicomQuery
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5151
OrthancPluginErrorCode_NullPointer
@ OrthancPluginErrorCode_NullPointer
Definition: OrthancCPlugin.h:235
OrthancPluginSetHttpErrorDetails
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:6724
OrthancPluginErrorCode_SharedLibrary
@ OrthancPluginErrorCode_SharedLibrary
Definition: OrthancCPlugin.h:225
OrthancPluginChunkedClientAnswerAddHeader
OrthancPluginErrorCode(* OrthancPluginChunkedClientAnswerAddHeader)(void *answer, const char *key, const char *value)
Callback executed when a HTTP header is received during a chunked transfer.
Definition: OrthancCPlugin.h:7048
OrthancPluginErrorCode_FileStorageCannotWrite
@ OrthancPluginErrorCode_FileStorageCannotWrite
Definition: OrthancCPlugin.h:257
OrthancPluginFindMatcherIsMatch
int32_t OrthancPluginFindMatcherIsMatch(OrthancPluginContext *context, const OrthancPluginFindMatcher *matcher, const void *dicom, uint32_t size)
Test whether a DICOM instance matches a C-Find query.
Definition: OrthancCPlugin.h:6122
OrthancPluginValueRepresentation_OW
@ OrthancPluginValueRepresentation_OW
Definition: OrthancCPlugin.h:785
OrthancPluginValueRepresentation_OF
@ OrthancPluginValueRepresentation_OF
Definition: OrthancCPlugin.h:784
OrthancPluginChunkedClientRequestNext
OrthancPluginErrorCode(* OrthancPluginChunkedClientRequestNext)(void *request)
Callback to advance in the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7106
OrthancPluginErrorCode_SQLiteNotOpened
@ OrthancPluginErrorCode_SQLiteNotOpened
Definition: OrthancCPlugin.h:240
OrthancPluginRestApiPost
OrthancPluginErrorCode OrthancPluginRestApiPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a POST call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2245
OrthancPluginRegisterStorageArea
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:3049
OrthancPluginTranscoderCallback
OrthancPluginErrorCode(* OrthancPluginTranscoderCallback)(OrthancPluginMemoryBuffer *transcoded, const void *buffer, uint64_t size, const char *const *allowedSyntaxes, uint32_t countSyntaxes, uint8_t allowNewSopInstanceUid)
Signature of a callback function to transcode a DICOM instance.
Definition: OrthancCPlugin.h:8125
OrthancPluginStorageCommitmentFactory
OrthancPluginErrorCode(* OrthancPluginStorageCommitmentFactory)(void **handler, const char *jobId, const char *transactionUid, const char *const *sopClassUids, const char *const *sopInstanceUids, uint32_t countInstances, const char *remoteAet, const char *calledAet)
Callback executed by the storage commitment SCP.
Definition: OrthancCPlugin.h:7505
OrthancPluginJobStepStatus_Success
@ OrthancPluginJobStepStatus_Success
Definition: OrthancCPlugin.h:905
OrthancPluginErrorCode_BadParameterType
@ OrthancPluginErrorCode_BadParameterType
Definition: OrthancCPlugin.h:205
OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
@ OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
Definition: OrthancCPlugin.h:964
OrthancPluginRestApiGetAfterPlugins
OrthancPluginErrorCode OrthancPluginRestApiGetAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2208
OrthancPluginRegisterTranscoderCallback
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition: OrthancCPlugin.h:8152
OrthancPluginGetFindQueryValue
char * OrthancPluginGetFindQueryValue(OrthancPluginContext *context, const OrthancPluginFindQuery *query, uint32_t index)
Get the value associated with one tag in a C-Find query.
Definition: OrthancCPlugin.h:5964
OrthancPluginImageFormat_Png
@ OrthancPluginImageFormat_Png
Definition: OrthancCPlugin.h:757
OrthancPluginPixelFormat
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:588
OrthancPluginErrorCode_LuaBadOutput
@ OrthancPluginErrorCode_LuaBadOutput
Definition: OrthancCPlugin.h:289
OrthancPluginSendUnauthorized
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2667
OrthancPluginDicomInstance
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition: OrthancCPlugin.h:1026
OrthancPluginErrorCode_DatabasePlugin
@ OrthancPluginErrorCode_DatabasePlugin
Definition: OrthancCPlugin.h:231
OrthancPluginPixelFormat_Grayscale16
@ OrthancPluginPixelFormat_Grayscale16
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:603
OrthancPluginSendMethodNotAllowed
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2690
OrthancPluginStorageCommitmentDestructor
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7527
OrthancPluginSetHttpHeader
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2745
OrthancPluginRegisterDictionaryTag
OrthancPluginErrorCode OrthancPluginRegisterDictionaryTag(OrthancPluginContext *context, uint16_t group, uint16_t element, OrthancPluginValueRepresentation vr, const char *name, uint32_t minMultiplicity, uint32_t maxMultiplicity)
Register a new tag into the DICOM dictionary.
Definition: OrthancCPlugin.h:4722
OrthancPluginErrorCode_NotLuaPredicate
@ OrthancPluginErrorCode_NotLuaPredicate
Definition: OrthancCPlugin.h:290
OrthancPluginLookupStudy
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2494
OrthancPluginDictionaryEntry::element
uint16_t element
Definition: OrthancCPlugin.h:1683
OrthancPluginErrorCode_NotAcceptable
@ OrthancPluginErrorCode_NotAcceptable
Definition: OrthancCPlugin.h:234
OrthancPluginDecodeDicomImage
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5389
OrthancPluginGetConfiguration
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3470