Orthanc Plugin SDK  1.7.2
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 7
120 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 2
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  {
895  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
897 
898 
902  typedef enum
903  {
908 
909 
916  typedef enum
917  {
923 
924 
928  typedef enum
929  {
939 
940 
945  typedef enum
946  {
951 
952 
958  typedef enum
959  {
987 
988 
989 
997  typedef struct
998  {
1002  void* data;
1003 
1007  uint32_t size;
1009 
1010 
1011 
1012 
1017  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
1018 
1019 
1020 
1025  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
1026 
1027 
1028 
1033  typedef struct _OrthancPluginImage_t OrthancPluginImage;
1034 
1035 
1036 
1041  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
1042 
1043 
1044 
1049  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
1050 
1051 
1052 
1057  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
1058 
1059 
1060 
1065  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1066 
1067 
1068 
1073  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1074 
1075 
1076 
1081  typedef struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher;
1082 
1083 
1084 
1089  typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1090 
1091 
1092 
1097  typedef struct _OrthancPluginJob_t OrthancPluginJob;
1098 
1099 
1100 
1106  typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1107 
1108 
1109 
1115  OrthancPluginRestOutput* output,
1116  const char* url,
1117  const OrthancPluginHttpRequest* request);
1118 
1119 
1120 
1126  const OrthancPluginDicomInstance* instance,
1127  const char* instanceId);
1128 
1129 
1130 
1136  OrthancPluginChangeType changeType,
1137  OrthancPluginResourceType resourceType,
1138  const char* resourceId);
1139 
1140 
1141 
1147  OrthancPluginImage** target,
1148  const void* dicom,
1149  const uint32_t size,
1150  uint32_t frameIndex);
1151 
1152 
1153 
1158  typedef void (*OrthancPluginFree) (void* buffer);
1159 
1160 
1161 
1171  const char* bulkDataUri);
1172 
1173 
1174 
1188  const char* uuid,
1189  const void* content,
1190  int64_t size,
1192 
1193 
1194 
1214  void** content,
1215  int64_t* size,
1216  const char* uuid,
1218 
1219 
1220 
1232  const char* uuid,
1234 
1235 
1236 
1252  const OrthancPluginWorklistQuery* query,
1253  const char* issuerAet,
1254  const char* calledAet);
1255 
1256 
1257 
1278  OrthancPluginHttpMethod method,
1279  const char* uri,
1280  const char* ip,
1281  uint32_t headersCount,
1282  const char* const* headersKeys,
1283  const char* const* headersValues);
1284 
1285 
1286 
1309  OrthancPluginHttpMethod method,
1310  const char* uri,
1311  const char* ip,
1312  uint32_t headersCount,
1313  const char* const* headersKeys,
1314  const char* const* headersValues,
1315  uint32_t getArgumentsCount,
1316  const char* const* getArgumentsKeys,
1317  const char* const* getArgumentsValues);
1318 
1319 
1320 
1336  OrthancPluginFindAnswers* answers,
1337  const OrthancPluginFindQuery* query,
1338  const char* issuerAet,
1339  const char* calledAet);
1340 
1341 
1342 
1378  typedef void* (*OrthancPluginMoveCallback) (
1379  OrthancPluginResourceType resourceType,
1380  const char* patientId,
1381  const char* accessionNumber,
1382  const char* studyInstanceUid,
1383  const char* seriesInstanceUid,
1384  const char* sopInstanceUid,
1385  const char* originatorAet,
1386  const char* sourceAet,
1387  const char* targetAet,
1388  uint16_t originatorId);
1389 
1390 
1403  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1404 
1405 
1418  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1419 
1420 
1432  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1433 
1434 
1445  typedef void (*OrthancPluginJobFinalize) (void* job);
1446 
1447 
1458  typedef float (*OrthancPluginJobGetProgress) (void* job);
1459 
1460 
1473  typedef const char* (*OrthancPluginJobGetContent) (void* job);
1474 
1475 
1491  typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1492 
1493 
1507 
1508 
1532 
1533 
1548 
1549 
1563  typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1564  const char* serialized);
1565 
1566 
1567 
1582 
1583 
1584 
1612  uint32_t levelDepth,
1613  const uint16_t* levelTagGroup,
1614  const uint16_t* levelTagElement,
1615  const uint32_t* levelIndex,
1616  uint16_t tagGroup,
1617  uint16_t tagElement,
1619 
1620 
1621 
1650  uint32_t levelDepth,
1651  const uint16_t* levelTagGroup,
1652  const uint16_t* levelTagElement,
1653  const uint32_t* levelIndex,
1654  uint16_t tagGroup,
1655  uint16_t tagElement,
1657  void* payload);
1658 
1659 
1660 
1664  typedef struct _OrthancPluginContext_t
1665  {
1666  void* pluginsManager;
1667  const char* orthancVersion;
1668  OrthancPluginFree Free;
1669  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1670  _OrthancPluginService service,
1671  const void* params);
1673 
1674 
1675 
1679  typedef struct
1680  {
1681  uint16_t group;
1682  uint16_t element;
1684  uint32_t minMultiplicity;
1685  uint32_t maxMultiplicity;
1687 
1688 
1689 
1698  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1699  OrthancPluginContext* context,
1700  char* str)
1701  {
1702  if (str != NULL)
1703  {
1704  context->Free(str);
1705  }
1706  }
1707 
1708 
1728  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1729  OrthancPluginContext* context,
1730  int expectedMajor,
1731  int expectedMinor,
1732  int expectedRevision)
1733  {
1734  int major, minor, revision;
1735 
1736  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1737  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1738  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1739  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1740  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1741  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1742  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1743  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1744  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1745  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1746  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1747  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1748  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1749  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1750  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1751  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1752  sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1753  sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
1754  sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
1755  sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
1756  sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason))
1757  {
1758  /* Mismatch in the size of the enumerations */
1759  return 0;
1760  }
1761 
1762  /* Assume compatibility with the mainline */
1763  if (!strcmp(context->orthancVersion, "mainline"))
1764  {
1765  return 1;
1766  }
1767 
1768  /* Parse the version of the Orthanc core */
1769  if (
1770 #ifdef _MSC_VER
1771  sscanf_s
1772 #else
1773  sscanf
1774 #endif
1775  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1776  {
1777  return 0;
1778  }
1779 
1780  /* Check the major number of the version */
1781 
1782  if (major > expectedMajor)
1783  {
1784  return 1;
1785  }
1786 
1787  if (major < expectedMajor)
1788  {
1789  return 0;
1790  }
1791 
1792  /* Check the minor number of the version */
1793 
1794  if (minor > expectedMinor)
1795  {
1796  return 1;
1797  }
1798 
1799  if (minor < expectedMinor)
1800  {
1801  return 0;
1802  }
1803 
1804  /* Check the revision number of the version */
1805 
1806  if (revision >= expectedRevision)
1807  {
1808  return 1;
1809  }
1810  else
1811  {
1812  return 0;
1813  }
1814  }
1815 
1816 
1833  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1834  OrthancPluginContext* context)
1835  {
1837  context,
1838  ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1839  ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1840  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1841  }
1842 
1843 
1852  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1853  OrthancPluginContext* context,
1854  OrthancPluginMemoryBuffer* buffer)
1855  {
1856  context->Free(buffer->data);
1857  }
1858 
1859 
1868  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1869  OrthancPluginContext* context,
1870  const char* message)
1871  {
1872  context->InvokeService(context, _OrthancPluginService_LogError, message);
1873  }
1874 
1875 
1884  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
1885  OrthancPluginContext* context,
1886  const char* message)
1887  {
1888  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1889  }
1890 
1891 
1900  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
1901  OrthancPluginContext* context,
1902  const char* message)
1903  {
1904  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
1905  }
1906 
1907 
1908 
1909  typedef struct
1910  {
1911  const char* pathRegularExpression;
1912  OrthancPluginRestCallback callback;
1913  } _OrthancPluginRestCallback;
1914 
1936  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
1937  OrthancPluginContext* context,
1938  const char* pathRegularExpression,
1939  OrthancPluginRestCallback callback)
1940  {
1941  _OrthancPluginRestCallback params;
1942  params.pathRegularExpression = pathRegularExpression;
1943  params.callback = callback;
1944  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
1945  }
1946 
1947 
1948 
1976  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
1977  OrthancPluginContext* context,
1978  const char* pathRegularExpression,
1979  OrthancPluginRestCallback callback)
1980  {
1981  _OrthancPluginRestCallback params;
1982  params.pathRegularExpression = pathRegularExpression;
1983  params.callback = callback;
1984  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
1985  }
1986 
1987 
1988 
1989  typedef struct
1990  {
1992  } _OrthancPluginOnStoredInstanceCallback;
1993 
2005  OrthancPluginContext* context,
2007  {
2008  _OrthancPluginOnStoredInstanceCallback params;
2009  params.callback = callback;
2010 
2011  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
2012  }
2013 
2014 
2015 
2016  typedef struct
2017  {
2018  OrthancPluginRestOutput* output;
2019  const void* answer;
2020  uint32_t answerSize;
2021  const char* mimeType;
2022  } _OrthancPluginAnswerBuffer;
2023 
2036  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
2037  OrthancPluginContext* context,
2038  OrthancPluginRestOutput* output,
2039  const void* answer,
2040  uint32_t answerSize,
2041  const char* mimeType)
2042  {
2043  _OrthancPluginAnswerBuffer params;
2044  params.output = output;
2045  params.answer = answer;
2046  params.answerSize = answerSize;
2047  params.mimeType = mimeType;
2048  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
2049  }
2050 
2051 
2052  typedef struct
2053  {
2054  OrthancPluginRestOutput* output;
2055  OrthancPluginPixelFormat format;
2056  uint32_t width;
2057  uint32_t height;
2058  uint32_t pitch;
2059  const void* buffer;
2060  } _OrthancPluginCompressAndAnswerPngImage;
2061 
2062  typedef struct
2063  {
2064  OrthancPluginRestOutput* output;
2065  OrthancPluginImageFormat imageFormat;
2066  OrthancPluginPixelFormat pixelFormat;
2067  uint32_t width;
2068  uint32_t height;
2069  uint32_t pitch;
2070  const void* buffer;
2071  uint8_t quality;
2072  } _OrthancPluginCompressAndAnswerImage;
2073 
2074 
2093  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2094  OrthancPluginContext* context,
2095  OrthancPluginRestOutput* output,
2096  OrthancPluginPixelFormat format,
2097  uint32_t width,
2098  uint32_t height,
2099  uint32_t pitch,
2100  const void* buffer)
2101  {
2102  _OrthancPluginCompressAndAnswerImage params;
2103  params.output = output;
2104  params.imageFormat = OrthancPluginImageFormat_Png;
2105  params.pixelFormat = format;
2106  params.width = width;
2107  params.height = height;
2108  params.pitch = pitch;
2109  params.buffer = buffer;
2110  params.quality = 0; /* No quality for PNG */
2111  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2112  }
2113 
2114 
2115 
2116  typedef struct
2117  {
2118  OrthancPluginMemoryBuffer* target;
2119  const char* instanceId;
2120  } _OrthancPluginGetDicomForInstance;
2121 
2135  OrthancPluginContext* context,
2136  OrthancPluginMemoryBuffer* target,
2137  const char* instanceId)
2138  {
2139  _OrthancPluginGetDicomForInstance params;
2140  params.target = target;
2141  params.instanceId = instanceId;
2142  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2143  }
2144 
2145 
2146 
2147  typedef struct
2148  {
2149  OrthancPluginMemoryBuffer* target;
2150  const char* uri;
2151  } _OrthancPluginRestApiGet;
2152 
2168  OrthancPluginContext* context,
2169  OrthancPluginMemoryBuffer* target,
2170  const char* uri)
2171  {
2172  _OrthancPluginRestApiGet params;
2173  params.target = target;
2174  params.uri = uri;
2175  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2176  }
2177 
2178 
2179 
2198  OrthancPluginContext* context,
2199  OrthancPluginMemoryBuffer* target,
2200  const char* uri)
2201  {
2202  _OrthancPluginRestApiGet params;
2203  params.target = target;
2204  params.uri = uri;
2205  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2206  }
2207 
2208 
2209 
2210  typedef struct
2211  {
2212  OrthancPluginMemoryBuffer* target;
2213  const char* uri;
2214  const void* body;
2215  uint32_t bodySize;
2216  } _OrthancPluginRestApiPostPut;
2217 
2235  OrthancPluginContext* context,
2236  OrthancPluginMemoryBuffer* target,
2237  const char* uri,
2238  const void* body,
2239  uint32_t bodySize)
2240  {
2241  _OrthancPluginRestApiPostPut params;
2242  params.target = target;
2243  params.uri = uri;
2244  params.body = body;
2245  params.bodySize = bodySize;
2246  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2247  }
2248 
2249 
2270  OrthancPluginContext* context,
2271  OrthancPluginMemoryBuffer* target,
2272  const char* uri,
2273  const void* body,
2274  uint32_t bodySize)
2275  {
2276  _OrthancPluginRestApiPostPut params;
2277  params.target = target;
2278  params.uri = uri;
2279  params.body = body;
2280  params.bodySize = bodySize;
2281  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2282  }
2283 
2284 
2285 
2299  OrthancPluginContext* context,
2300  const char* uri)
2301  {
2302  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2303  }
2304 
2305 
2322  OrthancPluginContext* context,
2323  const char* uri)
2324  {
2325  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2326  }
2327 
2328 
2329 
2347  OrthancPluginContext* context,
2348  OrthancPluginMemoryBuffer* target,
2349  const char* uri,
2350  const void* body,
2351  uint32_t bodySize)
2352  {
2353  _OrthancPluginRestApiPostPut params;
2354  params.target = target;
2355  params.uri = uri;
2356  params.body = body;
2357  params.bodySize = bodySize;
2358  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2359  }
2360 
2361 
2362 
2383  OrthancPluginContext* context,
2384  OrthancPluginMemoryBuffer* target,
2385  const char* uri,
2386  const void* body,
2387  uint32_t bodySize)
2388  {
2389  _OrthancPluginRestApiPostPut params;
2390  params.target = target;
2391  params.uri = uri;
2392  params.body = body;
2393  params.bodySize = bodySize;
2394  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2395  }
2396 
2397 
2398 
2399  typedef struct
2400  {
2401  OrthancPluginRestOutput* output;
2402  const char* argument;
2403  } _OrthancPluginOutputPlusArgument;
2404 
2416  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2417  OrthancPluginContext* context,
2418  OrthancPluginRestOutput* output,
2419  const char* redirection)
2420  {
2421  _OrthancPluginOutputPlusArgument params;
2422  params.output = output;
2423  params.argument = redirection;
2424  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2425  }
2426 
2427 
2428 
2429  typedef struct
2430  {
2431  char** result;
2432  const char* argument;
2433  } _OrthancPluginRetrieveDynamicString;
2434 
2448  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2449  OrthancPluginContext* context,
2450  const char* patientID)
2451  {
2452  char* result;
2453 
2454  _OrthancPluginRetrieveDynamicString params;
2455  params.result = &result;
2456  params.argument = patientID;
2457 
2458  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2459  {
2460  /* Error */
2461  return NULL;
2462  }
2463  else
2464  {
2465  return result;
2466  }
2467  }
2468 
2469 
2483  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2484  OrthancPluginContext* context,
2485  const char* studyUID)
2486  {
2487  char* result;
2488 
2489  _OrthancPluginRetrieveDynamicString params;
2490  params.result = &result;
2491  params.argument = studyUID;
2492 
2493  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2494  {
2495  /* Error */
2496  return NULL;
2497  }
2498  else
2499  {
2500  return result;
2501  }
2502  }
2503 
2504 
2518  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
2519  OrthancPluginContext* context,
2520  const char* accessionNumber)
2521  {
2522  char* result;
2523 
2524  _OrthancPluginRetrieveDynamicString params;
2525  params.result = &result;
2526  params.argument = accessionNumber;
2527 
2528  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2529  {
2530  /* Error */
2531  return NULL;
2532  }
2533  else
2534  {
2535  return result;
2536  }
2537  }
2538 
2539 
2553  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2554  OrthancPluginContext* context,
2555  const char* seriesUID)
2556  {
2557  char* result;
2558 
2559  _OrthancPluginRetrieveDynamicString params;
2560  params.result = &result;
2561  params.argument = seriesUID;
2562 
2563  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2564  {
2565  /* Error */
2566  return NULL;
2567  }
2568  else
2569  {
2570  return result;
2571  }
2572  }
2573 
2574 
2588  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2589  OrthancPluginContext* context,
2590  const char* sopInstanceUID)
2591  {
2592  char* result;
2593 
2594  _OrthancPluginRetrieveDynamicString params;
2595  params.result = &result;
2596  params.argument = sopInstanceUID;
2597 
2598  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2599  {
2600  /* Error */
2601  return NULL;
2602  }
2603  else
2604  {
2605  return result;
2606  }
2607  }
2608 
2609 
2610 
2611  typedef struct
2612  {
2613  OrthancPluginRestOutput* output;
2614  uint16_t status;
2615  } _OrthancPluginSendHttpStatusCode;
2616 
2633  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2634  OrthancPluginContext* context,
2635  OrthancPluginRestOutput* output,
2636  uint16_t status)
2637  {
2638  _OrthancPluginSendHttpStatusCode params;
2639  params.output = output;
2640  params.status = status;
2641  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2642  }
2643 
2644 
2656  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2657  OrthancPluginContext* context,
2658  OrthancPluginRestOutput* output,
2659  const char* realm)
2660  {
2661  _OrthancPluginOutputPlusArgument params;
2662  params.output = output;
2663  params.argument = realm;
2664  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2665  }
2666 
2667 
2679  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2680  OrthancPluginContext* context,
2681  OrthancPluginRestOutput* output,
2682  const char* allowedMethods)
2683  {
2684  _OrthancPluginOutputPlusArgument params;
2685  params.output = output;
2686  params.argument = allowedMethods;
2687  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2688  }
2689 
2690 
2691  typedef struct
2692  {
2693  OrthancPluginRestOutput* output;
2694  const char* key;
2695  const char* value;
2696  } _OrthancPluginSetHttpHeader;
2697 
2709  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2710  OrthancPluginContext* context,
2711  OrthancPluginRestOutput* output,
2712  const char* cookie,
2713  const char* value)
2714  {
2715  _OrthancPluginSetHttpHeader params;
2716  params.output = output;
2717  params.key = cookie;
2718  params.value = value;
2719  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2720  }
2721 
2722 
2734  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2735  OrthancPluginContext* context,
2736  OrthancPluginRestOutput* output,
2737  const char* key,
2738  const char* value)
2739  {
2740  _OrthancPluginSetHttpHeader params;
2741  params.output = output;
2742  params.key = key;
2743  params.value = value;
2744  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2745  }
2746 
2747 
2748  typedef struct
2749  {
2750  char** resultStringToFree;
2751  const char** resultString;
2752  int64_t* resultInt64;
2753  const char* key;
2754  const OrthancPluginDicomInstance* instance;
2755  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2756  } _OrthancPluginAccessDicomInstance;
2757 
2758 
2770  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2771  OrthancPluginContext* context,
2772  const OrthancPluginDicomInstance* instance)
2773  {
2774  const char* result;
2775 
2776  _OrthancPluginAccessDicomInstance params;
2777  memset(&params, 0, sizeof(params));
2778  params.resultString = &result;
2779  params.instance = instance;
2780 
2781  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2782  {
2783  /* Error */
2784  return NULL;
2785  }
2786  else
2787  {
2788  return result;
2789  }
2790  }
2791 
2792 
2803  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2804  OrthancPluginContext* context,
2805  const OrthancPluginDicomInstance* instance)
2806  {
2807  int64_t size;
2808 
2809  _OrthancPluginAccessDicomInstance params;
2810  memset(&params, 0, sizeof(params));
2811  params.resultInt64 = &size;
2812  params.instance = instance;
2813 
2814  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2815  {
2816  /* Error */
2817  return -1;
2818  }
2819  else
2820  {
2821  return size;
2822  }
2823  }
2824 
2825 
2836  ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData(
2837  OrthancPluginContext* context,
2838  const OrthancPluginDicomInstance* instance)
2839  {
2840  const char* result;
2841 
2842  _OrthancPluginAccessDicomInstance params;
2843  memset(&params, 0, sizeof(params));
2844  params.resultString = &result;
2845  params.instance = instance;
2846 
2847  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2848  {
2849  /* Error */
2850  return NULL;
2851  }
2852  else
2853  {
2854  return result;
2855  }
2856  }
2857 
2858 
2872  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
2873  OrthancPluginContext* context,
2874  const OrthancPluginDicomInstance* instance)
2875  {
2876  char* result;
2877 
2878  _OrthancPluginAccessDicomInstance params;
2879  memset(&params, 0, sizeof(params));
2880  params.resultStringToFree = &result;
2881  params.instance = instance;
2882 
2883  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
2884  {
2885  /* Error */
2886  return NULL;
2887  }
2888  else
2889  {
2890  return result;
2891  }
2892  }
2893 
2894 
2910  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
2911  OrthancPluginContext* context,
2912  const OrthancPluginDicomInstance* instance)
2913  {
2914  char* result;
2915 
2916  _OrthancPluginAccessDicomInstance params;
2917  memset(&params, 0, sizeof(params));
2918  params.resultStringToFree = &result;
2919  params.instance = instance;
2920 
2921  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
2922  {
2923  /* Error */
2924  return NULL;
2925  }
2926  else
2927  {
2928  return result;
2929  }
2930  }
2931 
2932 
2949  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
2950  OrthancPluginContext* context,
2951  const OrthancPluginDicomInstance* instance,
2952  const char* metadata)
2953  {
2954  int64_t result;
2955 
2956  _OrthancPluginAccessDicomInstance params;
2957  memset(&params, 0, sizeof(params));
2958  params.resultInt64 = &result;
2959  params.instance = instance;
2960  params.key = metadata;
2961 
2962  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2963  {
2964  /* Error */
2965  return -1;
2966  }
2967  else
2968  {
2969  return (result != 0);
2970  }
2971  }
2972 
2973 
2990  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
2991  OrthancPluginContext* context,
2992  const OrthancPluginDicomInstance* instance,
2993  const char* metadata)
2994  {
2995  const char* result;
2996 
2997  _OrthancPluginAccessDicomInstance params;
2998  memset(&params, 0, sizeof(params));
2999  params.resultString = &result;
3000  params.instance = instance;
3001  params.key = metadata;
3002 
3003  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3004  {
3005  /* Error */
3006  return NULL;
3007  }
3008  else
3009  {
3010  return result;
3011  }
3012  }
3013 
3014 
3015 
3016  typedef struct
3017  {
3021  OrthancPluginFree free;
3022  } _OrthancPluginRegisterStorageArea;
3023 
3038  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
3039  OrthancPluginContext* context,
3043  {
3044  _OrthancPluginRegisterStorageArea params;
3045  params.create = create;
3046  params.read = read;
3047  params.remove = remove;
3048 
3049 #ifdef __cplusplus
3050  params.free = ::free;
3051 #else
3052  params.free = free;
3053 #endif
3054 
3055  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3056  }
3057 
3058 
3059 
3070  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3071  {
3072  char* result;
3073 
3074  _OrthancPluginRetrieveDynamicString params;
3075  params.result = &result;
3076  params.argument = NULL;
3077 
3078  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3079  {
3080  /* Error */
3081  return NULL;
3082  }
3083  else
3084  {
3085  return result;
3086  }
3087  }
3088 
3089 
3100  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3101  {
3102  char* result;
3103 
3104  _OrthancPluginRetrieveDynamicString params;
3105  params.result = &result;
3106  params.argument = NULL;
3107 
3108  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3109  {
3110  /* Error */
3111  return NULL;
3112  }
3113  else
3114  {
3115  return result;
3116  }
3117  }
3118 
3119 
3135  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3136  {
3137  char* result;
3138 
3139  _OrthancPluginRetrieveDynamicString params;
3140  params.result = &result;
3141  params.argument = NULL;
3142 
3143  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3144  {
3145  /* Error */
3146  return NULL;
3147  }
3148  else
3149  {
3150  return result;
3151  }
3152  }
3153 
3154 
3155 
3156  typedef struct
3157  {
3159  } _OrthancPluginOnChangeCallback;
3160 
3177  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3178  OrthancPluginContext* context,
3180  {
3181  _OrthancPluginOnChangeCallback params;
3182  params.callback = callback;
3183 
3184  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3185  }
3186 
3187 
3188 
3189  typedef struct
3190  {
3191  const char* plugin;
3192  _OrthancPluginProperty property;
3193  const char* value;
3194  } _OrthancPluginSetPluginProperty;
3195 
3196 
3208  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3209  OrthancPluginContext* context,
3210  const char* uri)
3211  {
3212  _OrthancPluginSetPluginProperty params;
3213  params.plugin = OrthancPluginGetName();
3214  params.property = _OrthancPluginProperty_RootUri;
3215  params.value = uri;
3216 
3217  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3218  }
3219 
3220 
3230  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3231  OrthancPluginContext* context,
3232  const char* description)
3233  {
3234  _OrthancPluginSetPluginProperty params;
3235  params.plugin = OrthancPluginGetName();
3236  params.property = _OrthancPluginProperty_Description;
3237  params.value = description;
3238 
3239  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3240  }
3241 
3242 
3252  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3253  OrthancPluginContext* context,
3254  const char* javascript)
3255  {
3256  _OrthancPluginSetPluginProperty params;
3257  params.plugin = OrthancPluginGetName();
3258  params.property = _OrthancPluginProperty_OrthancExplorer;
3259  params.value = javascript;
3260 
3261  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3262  }
3263 
3264 
3265  typedef struct
3266  {
3267  char** result;
3268  int32_t property;
3269  const char* value;
3270  } _OrthancPluginGlobalProperty;
3271 
3272 
3286  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3287  OrthancPluginContext* context,
3288  int32_t property,
3289  const char* defaultValue)
3290  {
3291  char* result;
3292 
3293  _OrthancPluginGlobalProperty params;
3294  params.result = &result;
3295  params.property = property;
3296  params.value = defaultValue;
3297 
3298  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3299  {
3300  /* Error */
3301  return NULL;
3302  }
3303  else
3304  {
3305  return result;
3306  }
3307  }
3308 
3309 
3326  OrthancPluginContext* context,
3327  int32_t property,
3328  const char* value)
3329  {
3330  _OrthancPluginGlobalProperty params;
3331  params.result = NULL;
3332  params.property = property;
3333  params.value = value;
3334 
3335  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3336  }
3337 
3338 
3339 
3340  typedef struct
3341  {
3342  int32_t *resultInt32;
3343  uint32_t *resultUint32;
3344  int64_t *resultInt64;
3345  uint64_t *resultUint64;
3346  } _OrthancPluginReturnSingleValue;
3347 
3356  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3357  OrthancPluginContext* context)
3358  {
3359  uint32_t count = 0;
3360 
3361  _OrthancPluginReturnSingleValue params;
3362  memset(&params, 0, sizeof(params));
3363  params.resultUint32 = &count;
3364 
3365  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3366  {
3367  /* Error */
3368  return 0;
3369  }
3370  else
3371  {
3372  return count;
3373  }
3374  }
3375 
3376 
3377 
3390  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3391  OrthancPluginContext* context,
3392  uint32_t argument)
3393  {
3394  char* result;
3395 
3396  _OrthancPluginGlobalProperty params;
3397  params.result = &result;
3398  params.property = (int32_t) argument;
3399  params.value = NULL;
3400 
3401  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3402  {
3403  /* Error */
3404  return NULL;
3405  }
3406  else
3407  {
3408  return result;
3409  }
3410  }
3411 
3412 
3422  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3423  OrthancPluginContext* context)
3424  {
3425  uint32_t count = 0;
3426 
3427  _OrthancPluginReturnSingleValue params;
3428  memset(&params, 0, sizeof(params));
3429  params.resultUint32 = &count;
3430 
3431  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3432  {
3433  /* Error */
3434  return 0;
3435  }
3436  else
3437  {
3438  return count;
3439  }
3440  }
3441 
3442 
3443 
3455  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3456  {
3457  char* result;
3458 
3459  _OrthancPluginRetrieveDynamicString params;
3460  params.result = &result;
3461  params.argument = NULL;
3462 
3463  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3464  {
3465  /* Error */
3466  return NULL;
3467  }
3468  else
3469  {
3470  return result;
3471  }
3472  }
3473 
3474 
3475 
3476  typedef struct
3477  {
3478  OrthancPluginRestOutput* output;
3479  const char* subType;
3480  const char* contentType;
3481  } _OrthancPluginStartMultipartAnswer;
3482 
3497  OrthancPluginContext* context,
3498  OrthancPluginRestOutput* output,
3499  const char* subType,
3500  const char* contentType)
3501  {
3502  _OrthancPluginStartMultipartAnswer params;
3503  params.output = output;
3504  params.subType = subType;
3505  params.contentType = contentType;
3506  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3507  }
3508 
3509 
3526  OrthancPluginContext* context,
3527  OrthancPluginRestOutput* output,
3528  const void* answer,
3529  uint32_t answerSize)
3530  {
3531  _OrthancPluginAnswerBuffer params;
3532  params.output = output;
3533  params.answer = answer;
3534  params.answerSize = answerSize;
3535  params.mimeType = NULL;
3536  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3537  }
3538 
3539 
3540 
3541  typedef struct
3542  {
3543  OrthancPluginMemoryBuffer* target;
3544  const void* source;
3545  uint32_t size;
3546  OrthancPluginCompressionType compression;
3547  uint8_t uncompress;
3548  } _OrthancPluginBufferCompression;
3549 
3550 
3568  OrthancPluginContext* context,
3569  OrthancPluginMemoryBuffer* target,
3570  const void* source,
3571  uint32_t size,
3572  OrthancPluginCompressionType compression,
3573  uint8_t uncompress)
3574  {
3575  _OrthancPluginBufferCompression params;
3576  params.target = target;
3577  params.source = source;
3578  params.size = size;
3579  params.compression = compression;
3580  params.uncompress = uncompress;
3581 
3582  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3583  }
3584 
3585 
3586 
3587  typedef struct
3588  {
3589  OrthancPluginMemoryBuffer* target;
3590  const char* path;
3591  } _OrthancPluginReadFile;
3592 
3605  OrthancPluginContext* context,
3606  OrthancPluginMemoryBuffer* target,
3607  const char* path)
3608  {
3609  _OrthancPluginReadFile params;
3610  params.target = target;
3611  params.path = path;
3612  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3613  }
3614 
3615 
3616 
3617  typedef struct
3618  {
3619  const char* path;
3620  const void* data;
3621  uint32_t size;
3622  } _OrthancPluginWriteFile;
3623 
3636  OrthancPluginContext* context,
3637  const char* path,
3638  const void* data,
3639  uint32_t size)
3640  {
3641  _OrthancPluginWriteFile params;
3642  params.path = path;
3643  params.data = data;
3644  params.size = size;
3645  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3646  }
3647 
3648 
3649 
3650  typedef struct
3651  {
3652  const char** target;
3653  OrthancPluginErrorCode error;
3654  } _OrthancPluginGetErrorDescription;
3655 
3666  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3667  OrthancPluginContext* context,
3668  OrthancPluginErrorCode error)
3669  {
3670  const char* result = NULL;
3671 
3672  _OrthancPluginGetErrorDescription params;
3673  params.target = &result;
3674  params.error = error;
3675 
3676  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3677  result == NULL)
3678  {
3679  return "Unknown error code";
3680  }
3681  else
3682  {
3683  return result;
3684  }
3685  }
3686 
3687 
3688 
3689  typedef struct
3690  {
3691  OrthancPluginRestOutput* output;
3692  uint16_t status;
3693  const char* body;
3694  uint32_t bodySize;
3695  } _OrthancPluginSendHttpStatus;
3696 
3719  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3720  OrthancPluginContext* context,
3721  OrthancPluginRestOutput* output,
3722  uint16_t status,
3723  const char* body,
3724  uint32_t bodySize)
3725  {
3726  _OrthancPluginSendHttpStatus params;
3727  params.output = output;
3728  params.status = status;
3729  params.body = body;
3730  params.bodySize = bodySize;
3731  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3732  }
3733 
3734 
3735 
3736  typedef struct
3737  {
3738  const OrthancPluginImage* image;
3739  uint32_t* resultUint32;
3740  OrthancPluginPixelFormat* resultPixelFormat;
3741  void** resultBuffer;
3742  } _OrthancPluginGetImageInfo;
3743 
3744 
3756  OrthancPluginContext* context,
3757  const OrthancPluginImage* image)
3758  {
3759  OrthancPluginPixelFormat target;
3760 
3761  _OrthancPluginGetImageInfo params;
3762  memset(&params, 0, sizeof(params));
3763  params.image = image;
3764  params.resultPixelFormat = &target;
3765 
3766  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3767  {
3769  }
3770  else
3771  {
3772  return (OrthancPluginPixelFormat) target;
3773  }
3774  }
3775 
3776 
3777 
3788  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3789  OrthancPluginContext* context,
3790  const OrthancPluginImage* image)
3791  {
3792  uint32_t width;
3793 
3794  _OrthancPluginGetImageInfo params;
3795  memset(&params, 0, sizeof(params));
3796  params.image = image;
3797  params.resultUint32 = &width;
3798 
3799  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3800  {
3801  return 0;
3802  }
3803  else
3804  {
3805  return width;
3806  }
3807  }
3808 
3809 
3810 
3821  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3822  OrthancPluginContext* context,
3823  const OrthancPluginImage* image)
3824  {
3825  uint32_t height;
3826 
3827  _OrthancPluginGetImageInfo params;
3828  memset(&params, 0, sizeof(params));
3829  params.image = image;
3830  params.resultUint32 = &height;
3831 
3832  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3833  {
3834  return 0;
3835  }
3836  else
3837  {
3838  return height;
3839  }
3840  }
3841 
3842 
3843 
3856  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3857  OrthancPluginContext* context,
3858  const OrthancPluginImage* image)
3859  {
3860  uint32_t pitch;
3861 
3862  _OrthancPluginGetImageInfo params;
3863  memset(&params, 0, sizeof(params));
3864  params.image = image;
3865  params.resultUint32 = &pitch;
3866 
3867  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
3868  {
3869  return 0;
3870  }
3871  else
3872  {
3873  return pitch;
3874  }
3875  }
3876 
3877 
3878 
3890  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
3891  OrthancPluginContext* context,
3892  const OrthancPluginImage* image)
3893  {
3894  void* target = NULL;
3895 
3896  _OrthancPluginGetImageInfo params;
3897  memset(&params, 0, sizeof(params));
3898  params.resultBuffer = &target;
3899  params.image = image;
3900 
3901  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
3902  {
3903  return NULL;
3904  }
3905  else
3906  {
3907  return target;
3908  }
3909  }
3910 
3911 
3912  typedef struct
3913  {
3914  OrthancPluginImage** target;
3915  const void* data;
3916  uint32_t size;
3917  OrthancPluginImageFormat format;
3918  } _OrthancPluginUncompressImage;
3919 
3920 
3934  OrthancPluginContext* context,
3935  const void* data,
3936  uint32_t size,
3937  OrthancPluginImageFormat format)
3938  {
3939  OrthancPluginImage* target = NULL;
3940 
3941  _OrthancPluginUncompressImage params;
3942  memset(&params, 0, sizeof(params));
3943  params.target = &target;
3944  params.data = data;
3945  params.size = size;
3946  params.format = format;
3947 
3948  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
3949  {
3950  return NULL;
3951  }
3952  else
3953  {
3954  return target;
3955  }
3956  }
3957 
3958 
3959 
3960 
3961  typedef struct
3962  {
3963  OrthancPluginImage* image;
3964  } _OrthancPluginFreeImage;
3965 
3975  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
3976  OrthancPluginContext* context,
3977  OrthancPluginImage* image)
3978  {
3979  _OrthancPluginFreeImage params;
3980  params.image = image;
3981 
3982  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
3983  }
3984 
3985 
3986 
3987 
3988  typedef struct
3989  {
3990  OrthancPluginMemoryBuffer* target;
3991  OrthancPluginImageFormat imageFormat;
3992  OrthancPluginPixelFormat pixelFormat;
3993  uint32_t width;
3994  uint32_t height;
3995  uint32_t pitch;
3996  const void* buffer;
3997  uint8_t quality;
3998  } _OrthancPluginCompressImage;
3999 
4000 
4021  OrthancPluginContext* context,
4022  OrthancPluginMemoryBuffer* target,
4023  OrthancPluginPixelFormat format,
4024  uint32_t width,
4025  uint32_t height,
4026  uint32_t pitch,
4027  const void* buffer)
4028  {
4029  _OrthancPluginCompressImage params;
4030  memset(&params, 0, sizeof(params));
4031  params.target = target;
4032  params.imageFormat = OrthancPluginImageFormat_Png;
4033  params.pixelFormat = format;
4034  params.width = width;
4035  params.height = height;
4036  params.pitch = pitch;
4037  params.buffer = buffer;
4038  params.quality = 0; /* Unused for PNG */
4039 
4040  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4041  }
4042 
4043 
4066  OrthancPluginContext* context,
4067  OrthancPluginMemoryBuffer* target,
4068  OrthancPluginPixelFormat format,
4069  uint32_t width,
4070  uint32_t height,
4071  uint32_t pitch,
4072  const void* buffer,
4073  uint8_t quality)
4074  {
4075  _OrthancPluginCompressImage params;
4076  memset(&params, 0, sizeof(params));
4077  params.target = target;
4078  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4079  params.pixelFormat = format;
4080  params.width = width;
4081  params.height = height;
4082  params.pitch = pitch;
4083  params.buffer = buffer;
4084  params.quality = quality;
4085 
4086  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4087  }
4088 
4089 
4090 
4112  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
4113  OrthancPluginContext* context,
4114  OrthancPluginRestOutput* output,
4115  OrthancPluginPixelFormat format,
4116  uint32_t width,
4117  uint32_t height,
4118  uint32_t pitch,
4119  const void* buffer,
4120  uint8_t quality)
4121  {
4122  _OrthancPluginCompressAndAnswerImage params;
4123  params.output = output;
4124  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4125  params.pixelFormat = format;
4126  params.width = width;
4127  params.height = height;
4128  params.pitch = pitch;
4129  params.buffer = buffer;
4130  params.quality = quality;
4131  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4132  }
4133 
4134 
4135 
4136 
4137  typedef struct
4138  {
4139  OrthancPluginMemoryBuffer* target;
4140  OrthancPluginHttpMethod method;
4141  const char* url;
4142  const char* username;
4143  const char* password;
4144  const void* body;
4145  uint32_t bodySize;
4146  } _OrthancPluginCallHttpClient;
4147 
4148 
4166  OrthancPluginContext* context,
4167  OrthancPluginMemoryBuffer* target,
4168  const char* url,
4169  const char* username,
4170  const char* password)
4171  {
4172  _OrthancPluginCallHttpClient params;
4173  memset(&params, 0, sizeof(params));
4174 
4175  params.target = target;
4176  params.method = OrthancPluginHttpMethod_Get;
4177  params.url = url;
4178  params.username = username;
4179  params.password = password;
4180 
4181  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4182  }
4183 
4184 
4204  OrthancPluginContext* context,
4205  OrthancPluginMemoryBuffer* target,
4206  const char* url,
4207  const void* body,
4208  uint32_t bodySize,
4209  const char* username,
4210  const char* password)
4211  {
4212  _OrthancPluginCallHttpClient params;
4213  memset(&params, 0, sizeof(params));
4214 
4215  params.target = target;
4216  params.method = OrthancPluginHttpMethod_Post;
4217  params.url = url;
4218  params.body = body;
4219  params.bodySize = bodySize;
4220  params.username = username;
4221  params.password = password;
4222 
4223  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4224  }
4225 
4226 
4246  OrthancPluginContext* context,
4247  OrthancPluginMemoryBuffer* target,
4248  const char* url,
4249  const void* body,
4250  uint32_t bodySize,
4251  const char* username,
4252  const char* password)
4253  {
4254  _OrthancPluginCallHttpClient params;
4255  memset(&params, 0, sizeof(params));
4256 
4257  params.target = target;
4258  params.method = OrthancPluginHttpMethod_Put;
4259  params.url = url;
4260  params.body = body;
4261  params.bodySize = bodySize;
4262  params.username = username;
4263  params.password = password;
4264 
4265  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4266  }
4267 
4268 
4284  OrthancPluginContext* context,
4285  const char* url,
4286  const char* username,
4287  const char* password)
4288  {
4289  _OrthancPluginCallHttpClient params;
4290  memset(&params, 0, sizeof(params));
4291 
4292  params.method = OrthancPluginHttpMethod_Delete;
4293  params.url = url;
4294  params.username = username;
4295  params.password = password;
4296 
4297  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4298  }
4299 
4300 
4301 
4302  typedef struct
4303  {
4304  OrthancPluginImage** target;
4305  const OrthancPluginImage* source;
4306  OrthancPluginPixelFormat targetFormat;
4307  } _OrthancPluginConvertPixelFormat;
4308 
4309 
4322  OrthancPluginContext* context,
4323  const OrthancPluginImage* source,
4324  OrthancPluginPixelFormat targetFormat)
4325  {
4326  OrthancPluginImage* target = NULL;
4327 
4328  _OrthancPluginConvertPixelFormat params;
4329  params.target = &target;
4330  params.source = source;
4331  params.targetFormat = targetFormat;
4332 
4333  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4334  {
4335  return NULL;
4336  }
4337  else
4338  {
4339  return target;
4340  }
4341  }
4342 
4343 
4344 
4356  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4357  OrthancPluginContext* context)
4358  {
4359  uint32_t count = 0;
4360 
4361  _OrthancPluginReturnSingleValue params;
4362  memset(&params, 0, sizeof(params));
4363  params.resultUint32 = &count;
4364 
4365  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4366  {
4367  /* Error */
4368  return 0;
4369  }
4370  else
4371  {
4372  return count;
4373  }
4374  }
4375 
4376 
4377 
4378 
4379  typedef struct
4380  {
4381  uint32_t fontIndex; /* in */
4382  const char** name; /* out */
4383  uint32_t* size; /* out */
4384  } _OrthancPluginGetFontInfo;
4385 
4396  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4397  OrthancPluginContext* context,
4398  uint32_t fontIndex)
4399  {
4400  const char* result = NULL;
4401 
4402  _OrthancPluginGetFontInfo params;
4403  memset(&params, 0, sizeof(params));
4404  params.name = &result;
4405  params.fontIndex = fontIndex;
4406 
4407  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4408  {
4409  return NULL;
4410  }
4411  else
4412  {
4413  return result;
4414  }
4415  }
4416 
4417 
4428  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4429  OrthancPluginContext* context,
4430  uint32_t fontIndex)
4431  {
4432  uint32_t result;
4433 
4434  _OrthancPluginGetFontInfo params;
4435  memset(&params, 0, sizeof(params));
4436  params.size = &result;
4437  params.fontIndex = fontIndex;
4438 
4439  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4440  {
4441  return 0;
4442  }
4443  else
4444  {
4445  return result;
4446  }
4447  }
4448 
4449 
4450 
4451  typedef struct
4452  {
4453  OrthancPluginImage* image;
4454  uint32_t fontIndex;
4455  const char* utf8Text;
4456  int32_t x;
4457  int32_t y;
4458  uint8_t r;
4459  uint8_t g;
4460  uint8_t b;
4461  } _OrthancPluginDrawText;
4462 
4463 
4482  OrthancPluginContext* context,
4483  OrthancPluginImage* image,
4484  uint32_t fontIndex,
4485  const char* utf8Text,
4486  int32_t x,
4487  int32_t y,
4488  uint8_t r,
4489  uint8_t g,
4490  uint8_t b)
4491  {
4492  _OrthancPluginDrawText params;
4493  memset(&params, 0, sizeof(params));
4494  params.image = image;
4495  params.fontIndex = fontIndex;
4496  params.utf8Text = utf8Text;
4497  params.x = x;
4498  params.y = y;
4499  params.r = r;
4500  params.g = g;
4501  params.b = b;
4502 
4503  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4504  }
4505 
4506 
4507 
4508  typedef struct
4509  {
4510  OrthancPluginStorageArea* storageArea;
4511  const char* uuid;
4512  const void* content;
4513  uint64_t size;
4515  } _OrthancPluginStorageAreaCreate;
4516 
4517 
4534  OrthancPluginContext* context,
4535  OrthancPluginStorageArea* storageArea,
4536  const char* uuid,
4537  const void* content,
4538  uint64_t size,
4540  {
4541  _OrthancPluginStorageAreaCreate params;
4542  params.storageArea = storageArea;
4543  params.uuid = uuid;
4544  params.content = content;
4545  params.size = size;
4546  params.type = type;
4547 
4548  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4549  }
4550 
4551 
4552  typedef struct
4553  {
4554  OrthancPluginMemoryBuffer* target;
4555  OrthancPluginStorageArea* storageArea;
4556  const char* uuid;
4558  } _OrthancPluginStorageAreaRead;
4559 
4560 
4576  OrthancPluginContext* context,
4577  OrthancPluginMemoryBuffer* target,
4578  OrthancPluginStorageArea* storageArea,
4579  const char* uuid,
4581  {
4582  _OrthancPluginStorageAreaRead params;
4583  params.target = target;
4584  params.storageArea = storageArea;
4585  params.uuid = uuid;
4586  params.type = type;
4587 
4588  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4589  }
4590 
4591 
4592  typedef struct
4593  {
4594  OrthancPluginStorageArea* storageArea;
4595  const char* uuid;
4597  } _OrthancPluginStorageAreaRemove;
4598 
4613  OrthancPluginContext* context,
4614  OrthancPluginStorageArea* storageArea,
4615  const char* uuid,
4617  {
4618  _OrthancPluginStorageAreaRemove params;
4619  params.storageArea = storageArea;
4620  params.uuid = uuid;
4621  params.type = type;
4622 
4623  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4624  }
4625 
4626 
4627 
4628  typedef struct
4629  {
4630  OrthancPluginErrorCode* target;
4631  int32_t code;
4632  uint16_t httpStatus;
4633  const char* message;
4634  } _OrthancPluginRegisterErrorCode;
4635 
4652  OrthancPluginContext* context,
4653  int32_t code,
4654  uint16_t httpStatus,
4655  const char* message)
4656  {
4657  OrthancPluginErrorCode target;
4658 
4659  _OrthancPluginRegisterErrorCode params;
4660  params.target = &target;
4661  params.code = code;
4662  params.httpStatus = httpStatus;
4663  params.message = message;
4664 
4665  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4666  {
4667  return target;
4668  }
4669  else
4670  {
4671  /* There was an error while assigned the error. Use a generic code. */
4673  }
4674  }
4675 
4676 
4677 
4678  typedef struct
4679  {
4680  uint16_t group;
4681  uint16_t element;
4683  const char* name;
4684  uint32_t minMultiplicity;
4685  uint32_t maxMultiplicity;
4686  } _OrthancPluginRegisterDictionaryTag;
4687 
4708  OrthancPluginContext* context,
4709  uint16_t group,
4710  uint16_t element,
4712  const char* name,
4713  uint32_t minMultiplicity,
4714  uint32_t maxMultiplicity)
4715  {
4716  _OrthancPluginRegisterDictionaryTag params;
4717  params.group = group;
4718  params.element = element;
4719  params.vr = vr;
4720  params.name = name;
4721  params.minMultiplicity = minMultiplicity;
4722  params.maxMultiplicity = maxMultiplicity;
4723 
4724  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4725  }
4726 
4727 
4728 
4729  typedef struct
4730  {
4731  uint16_t group;
4732  uint16_t element;
4734  const char* name;
4735  uint32_t minMultiplicity;
4736  uint32_t maxMultiplicity;
4737  const char* privateCreator;
4738  } _OrthancPluginRegisterPrivateDictionaryTag;
4739 
4761  OrthancPluginContext* context,
4762  uint16_t group,
4763  uint16_t element,
4765  const char* name,
4766  uint32_t minMultiplicity,
4767  uint32_t maxMultiplicity,
4768  const char* privateCreator)
4769  {
4770  _OrthancPluginRegisterPrivateDictionaryTag params;
4771  params.group = group;
4772  params.element = element;
4773  params.vr = vr;
4774  params.name = name;
4775  params.minMultiplicity = minMultiplicity;
4776  params.maxMultiplicity = maxMultiplicity;
4777  params.privateCreator = privateCreator;
4778 
4779  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4780  }
4781 
4782 
4783 
4784  typedef struct
4785  {
4786  OrthancPluginStorageArea* storageArea;
4788  } _OrthancPluginReconstructMainDicomTags;
4789 
4805  OrthancPluginContext* context,
4806  OrthancPluginStorageArea* storageArea,
4808  {
4809  _OrthancPluginReconstructMainDicomTags params;
4810  params.level = level;
4811  params.storageArea = storageArea;
4812 
4813  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
4814  }
4815 
4816 
4817  typedef struct
4818  {
4819  char** result;
4820  const char* instanceId;
4821  const void* buffer;
4822  uint32_t size;
4825  uint32_t maxStringLength;
4826  } _OrthancPluginDicomToJson;
4827 
4828 
4848  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4849  OrthancPluginContext* context,
4850  const void* buffer,
4851  uint32_t size,
4854  uint32_t maxStringLength)
4855  {
4856  char* result;
4857 
4858  _OrthancPluginDicomToJson params;
4859  memset(&params, 0, sizeof(params));
4860  params.result = &result;
4861  params.buffer = buffer;
4862  params.size = size;
4863  params.format = format;
4864  params.flags = flags;
4865  params.maxStringLength = maxStringLength;
4866 
4867  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
4868  {
4869  /* Error */
4870  return NULL;
4871  }
4872  else
4873  {
4874  return result;
4875  }
4876  }
4877 
4878 
4897  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
4898  OrthancPluginContext* context,
4899  const char* instanceId,
4902  uint32_t maxStringLength)
4903  {
4904  char* result;
4905 
4906  _OrthancPluginDicomToJson params;
4907  memset(&params, 0, sizeof(params));
4908  params.result = &result;
4909  params.instanceId = instanceId;
4910  params.format = format;
4911  params.flags = flags;
4912  params.maxStringLength = maxStringLength;
4913 
4914  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
4915  {
4916  /* Error */
4917  return NULL;
4918  }
4919  else
4920  {
4921  return result;
4922  }
4923  }
4924 
4925 
4926  typedef struct
4927  {
4928  OrthancPluginMemoryBuffer* target;
4929  const char* uri;
4930  uint32_t headersCount;
4931  const char* const* headersKeys;
4932  const char* const* headersValues;
4933  int32_t afterPlugins;
4934  } _OrthancPluginRestApiGet2;
4935 
4956  OrthancPluginContext* context,
4957  OrthancPluginMemoryBuffer* target,
4958  const char* uri,
4959  uint32_t headersCount,
4960  const char* const* headersKeys,
4961  const char* const* headersValues,
4962  int32_t afterPlugins)
4963  {
4964  _OrthancPluginRestApiGet2 params;
4965  params.target = target;
4966  params.uri = uri;
4967  params.headersCount = headersCount;
4968  params.headersKeys = headersKeys;
4969  params.headersValues = headersValues;
4970  params.afterPlugins = afterPlugins;
4971 
4972  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
4973  }
4974 
4975 
4976 
4977  typedef struct
4978  {
4980  } _OrthancPluginWorklistCallback;
4981 
4994  OrthancPluginContext* context,
4996  {
4997  _OrthancPluginWorklistCallback params;
4998  params.callback = callback;
4999 
5000  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
5001  }
5002 
5003 
5004 
5005  typedef struct
5006  {
5008  const OrthancPluginWorklistQuery* query;
5009  const void* dicom;
5010  uint32_t size;
5011  } _OrthancPluginWorklistAnswersOperation;
5012 
5030  OrthancPluginContext* context,
5032  const OrthancPluginWorklistQuery* query,
5033  const void* dicom,
5034  uint32_t size)
5035  {
5036  _OrthancPluginWorklistAnswersOperation params;
5037  params.answers = answers;
5038  params.query = query;
5039  params.dicom = dicom;
5040  params.size = size;
5041 
5042  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
5043  }
5044 
5045 
5060  OrthancPluginContext* context,
5062  {
5063  _OrthancPluginWorklistAnswersOperation params;
5064  params.answers = answers;
5065  params.query = NULL;
5066  params.dicom = NULL;
5067  params.size = 0;
5068 
5069  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5070  }
5071 
5072 
5073  typedef struct
5074  {
5075  const OrthancPluginWorklistQuery* query;
5076  const void* dicom;
5077  uint32_t size;
5078  int32_t* isMatch;
5079  OrthancPluginMemoryBuffer* target;
5080  } _OrthancPluginWorklistQueryOperation;
5081 
5097  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5098  OrthancPluginContext* context,
5099  const OrthancPluginWorklistQuery* query,
5100  const void* dicom,
5101  uint32_t size)
5102  {
5103  int32_t isMatch = 0;
5104 
5105  _OrthancPluginWorklistQueryOperation params;
5106  params.query = query;
5107  params.dicom = dicom;
5108  params.size = size;
5109  params.isMatch = &isMatch;
5110  params.target = NULL;
5111 
5112  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5113  {
5114  return isMatch;
5115  }
5116  else
5117  {
5118  /* Error: Assume non-match */
5119  return 0;
5120  }
5121  }
5122 
5123 
5137  OrthancPluginContext* context,
5138  OrthancPluginMemoryBuffer* target,
5139  const OrthancPluginWorklistQuery* query)
5140  {
5141  _OrthancPluginWorklistQueryOperation params;
5142  params.query = query;
5143  params.dicom = NULL;
5144  params.size = 0;
5145  params.isMatch = NULL;
5146  params.target = target;
5147 
5148  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5149  }
5150 
5151 
5163  OrthancPluginContext* context,
5164  const OrthancPluginDicomInstance* instance)
5165  {
5167 
5168  _OrthancPluginAccessDicomInstance params;
5169  memset(&params, 0, sizeof(params));
5170  params.resultOrigin = &origin;
5171  params.instance = instance;
5172 
5173  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5174  {
5175  /* Error */
5177  }
5178  else
5179  {
5180  return origin;
5181  }
5182  }
5183 
5184 
5185  typedef struct
5186  {
5187  OrthancPluginMemoryBuffer* target;
5188  const char* json;
5189  const OrthancPluginImage* pixelData;
5191  } _OrthancPluginCreateDicom;
5192 
5212  OrthancPluginContext* context,
5213  OrthancPluginMemoryBuffer* target,
5214  const char* json,
5215  const OrthancPluginImage* pixelData,
5217  {
5218  _OrthancPluginCreateDicom params;
5219  params.target = target;
5220  params.json = json;
5221  params.pixelData = pixelData;
5222  params.flags = flags;
5223 
5224  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5225  }
5226 
5227 
5228  typedef struct
5229  {
5231  } _OrthancPluginDecodeImageCallback;
5232 
5248  OrthancPluginContext* context,
5250  {
5251  _OrthancPluginDecodeImageCallback params;
5252  params.callback = callback;
5253 
5254  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5255  }
5256 
5257 
5258 
5259  typedef struct
5260  {
5261  OrthancPluginImage** target;
5262  OrthancPluginPixelFormat format;
5263  uint32_t width;
5264  uint32_t height;
5265  uint32_t pitch;
5266  void* buffer;
5267  const void* constBuffer;
5268  uint32_t bufferSize;
5269  uint32_t frameIndex;
5270  } _OrthancPluginCreateImage;
5271 
5272 
5286  OrthancPluginContext* context,
5287  OrthancPluginPixelFormat format,
5288  uint32_t width,
5289  uint32_t height)
5290  {
5291  OrthancPluginImage* target = NULL;
5292 
5293  _OrthancPluginCreateImage params;
5294  memset(&params, 0, sizeof(params));
5295  params.target = &target;
5296  params.format = format;
5297  params.width = width;
5298  params.height = height;
5299 
5300  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5301  {
5302  return NULL;
5303  }
5304  else
5305  {
5306  return target;
5307  }
5308  }
5309 
5310 
5329  OrthancPluginContext* context,
5330  OrthancPluginPixelFormat format,
5331  uint32_t width,
5332  uint32_t height,
5333  uint32_t pitch,
5334  void* buffer)
5335  {
5336  OrthancPluginImage* target = NULL;
5337 
5338  _OrthancPluginCreateImage params;
5339  memset(&params, 0, sizeof(params));
5340  params.target = &target;
5341  params.format = format;
5342  params.width = width;
5343  params.height = height;
5344  params.pitch = pitch;
5345  params.buffer = buffer;
5346 
5347  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5348  {
5349  return NULL;
5350  }
5351  else
5352  {
5353  return target;
5354  }
5355  }
5356 
5357 
5358 
5375  OrthancPluginContext* context,
5376  const void* buffer,
5377  uint32_t bufferSize,
5378  uint32_t frameIndex)
5379  {
5380  OrthancPluginImage* target = NULL;
5381 
5382  _OrthancPluginCreateImage params;
5383  memset(&params, 0, sizeof(params));
5384  params.target = &target;
5385  params.constBuffer = buffer;
5386  params.bufferSize = bufferSize;
5387  params.frameIndex = frameIndex;
5388 
5389  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5390  {
5391  return NULL;
5392  }
5393  else
5394  {
5395  return target;
5396  }
5397  }
5398 
5399 
5400 
5401  typedef struct
5402  {
5403  char** result;
5404  const void* buffer;
5405  uint32_t size;
5406  } _OrthancPluginComputeHash;
5407 
5420  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5421  OrthancPluginContext* context,
5422  const void* buffer,
5423  uint32_t size)
5424  {
5425  char* result;
5426 
5427  _OrthancPluginComputeHash params;
5428  params.result = &result;
5429  params.buffer = buffer;
5430  params.size = size;
5431 
5432  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5433  {
5434  /* Error */
5435  return NULL;
5436  }
5437  else
5438  {
5439  return result;
5440  }
5441  }
5442 
5443 
5456  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5457  OrthancPluginContext* context,
5458  const void* buffer,
5459  uint32_t size)
5460  {
5461  char* result;
5462 
5463  _OrthancPluginComputeHash params;
5464  params.result = &result;
5465  params.buffer = buffer;
5466  params.size = size;
5467 
5468  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5469  {
5470  /* Error */
5471  return NULL;
5472  }
5473  else
5474  {
5475  return result;
5476  }
5477  }
5478 
5479 
5480 
5481  typedef struct
5482  {
5484  const char* name;
5485  } _OrthancPluginLookupDictionary;
5486 
5503  OrthancPluginContext* context,
5505  const char* name)
5506  {
5507  _OrthancPluginLookupDictionary params;
5508  params.target = target;
5509  params.name = name;
5510  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5511  }
5512 
5513 
5514 
5515  typedef struct
5516  {
5517  OrthancPluginRestOutput* output;
5518  const void* answer;
5519  uint32_t answerSize;
5520  uint32_t headersCount;
5521  const char* const* headersKeys;
5522  const char* const* headersValues;
5523  } _OrthancPluginSendMultipartItem2;
5524 
5546  OrthancPluginContext* context,
5547  OrthancPluginRestOutput* output,
5548  const void* answer,
5549  uint32_t answerSize,
5550  uint32_t headersCount,
5551  const char* const* headersKeys,
5552  const char* const* headersValues)
5553  {
5554  _OrthancPluginSendMultipartItem2 params;
5555  params.output = output;
5556  params.answer = answer;
5557  params.answerSize = answerSize;
5558  params.headersCount = headersCount;
5559  params.headersKeys = headersKeys;
5560  params.headersValues = headersValues;
5561 
5562  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5563  }
5564 
5565 
5566  typedef struct
5567  {
5569  } _OrthancPluginIncomingHttpRequestFilter;
5570 
5584  OrthancPluginContext* context,
5586  {
5587  _OrthancPluginIncomingHttpRequestFilter params;
5588  params.callback = callback;
5589 
5590  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5591  }
5592 
5593 
5594 
5595  typedef struct
5596  {
5597  OrthancPluginMemoryBuffer* answerBody;
5598  OrthancPluginMemoryBuffer* answerHeaders;
5599  uint16_t* httpStatus;
5600  OrthancPluginHttpMethod method;
5601  const char* url;
5602  uint32_t headersCount;
5603  const char* const* headersKeys;
5604  const char* const* headersValues;
5605  const void* body;
5606  uint32_t bodySize;
5607  const char* username;
5608  const char* password;
5609  uint32_t timeout;
5610  const char* certificateFile;
5611  const char* certificateKeyFile;
5612  const char* certificateKeyPassword;
5613  uint8_t pkcs11;
5614  } _OrthancPluginCallHttpClient2;
5615 
5616 
5617 
5658  OrthancPluginContext* context,
5659  OrthancPluginMemoryBuffer* answerBody,
5660  OrthancPluginMemoryBuffer* answerHeaders,
5661  uint16_t* httpStatus,
5662  OrthancPluginHttpMethod method,
5663  const char* url,
5664  uint32_t headersCount,
5665  const char* const* headersKeys,
5666  const char* const* headersValues,
5667  const void* body,
5668  uint32_t bodySize,
5669  const char* username,
5670  const char* password,
5671  uint32_t timeout,
5672  const char* certificateFile,
5673  const char* certificateKeyFile,
5674  const char* certificateKeyPassword,
5675  uint8_t pkcs11)
5676  {
5677  _OrthancPluginCallHttpClient2 params;
5678  memset(&params, 0, sizeof(params));
5679 
5680  params.answerBody = answerBody;
5681  params.answerHeaders = answerHeaders;
5682  params.httpStatus = httpStatus;
5683  params.method = method;
5684  params.url = url;
5685  params.headersCount = headersCount;
5686  params.headersKeys = headersKeys;
5687  params.headersValues = headersValues;
5688  params.body = body;
5689  params.bodySize = bodySize;
5690  params.username = username;
5691  params.password = password;
5692  params.timeout = timeout;
5693  params.certificateFile = certificateFile;
5694  params.certificateKeyFile = certificateKeyFile;
5695  params.certificateKeyPassword = certificateKeyPassword;
5696  params.pkcs11 = pkcs11;
5697 
5698  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5699  }
5700 
5701 
5712  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5713  OrthancPluginContext* context)
5714  {
5715  char* result;
5716 
5717  _OrthancPluginRetrieveDynamicString params;
5718  params.result = &result;
5719  params.argument = NULL;
5720 
5721  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5722  {
5723  /* Error */
5724  return NULL;
5725  }
5726  else
5727  {
5728  return result;
5729  }
5730  }
5731 
5732 
5733 
5734 
5735  typedef struct
5736  {
5737  OrthancPluginFindCallback callback;
5738  } _OrthancPluginFindCallback;
5739 
5752  OrthancPluginContext* context,
5753  OrthancPluginFindCallback callback)
5754  {
5755  _OrthancPluginFindCallback params;
5756  params.callback = callback;
5757 
5758  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5759  }
5760 
5761 
5762  typedef struct
5763  {
5764  OrthancPluginFindAnswers *answers;
5765  const OrthancPluginFindQuery *query;
5766  const void *dicom;
5767  uint32_t size;
5768  uint32_t index;
5769  uint32_t *resultUint32;
5770  uint16_t *resultGroup;
5771  uint16_t *resultElement;
5772  char **resultString;
5773  } _OrthancPluginFindOperation;
5774 
5791  OrthancPluginContext* context,
5792  OrthancPluginFindAnswers* answers,
5793  const void* dicom,
5794  uint32_t size)
5795  {
5796  _OrthancPluginFindOperation params;
5797  memset(&params, 0, sizeof(params));
5798  params.answers = answers;
5799  params.dicom = dicom;
5800  params.size = size;
5801 
5802  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
5803  }
5804 
5805 
5820  OrthancPluginContext* context,
5821  OrthancPluginFindAnswers* answers)
5822  {
5823  _OrthancPluginFindOperation params;
5824  memset(&params, 0, sizeof(params));
5825  params.answers = answers;
5826 
5827  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
5828  }
5829 
5830 
5831 
5843  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
5844  OrthancPluginContext* context,
5845  const OrthancPluginFindQuery* query)
5846  {
5847  uint32_t count = 0;
5848 
5849  _OrthancPluginFindOperation params;
5850  memset(&params, 0, sizeof(params));
5851  params.query = query;
5852  params.resultUint32 = &count;
5853 
5854  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
5855  {
5856  /* Error */
5857  return 0;
5858  }
5859  else
5860  {
5861  return count;
5862  }
5863  }
5864 
5865 
5881  OrthancPluginContext* context,
5882  uint16_t* group,
5883  uint16_t* element,
5884  const OrthancPluginFindQuery* query,
5885  uint32_t index)
5886  {
5887  _OrthancPluginFindOperation params;
5888  memset(&params, 0, sizeof(params));
5889  params.query = query;
5890  params.index = index;
5891  params.resultGroup = group;
5892  params.resultElement = element;
5893 
5894  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
5895  }
5896 
5897 
5911  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
5912  OrthancPluginContext* context,
5913  const OrthancPluginFindQuery* query,
5914  uint32_t index)
5915  {
5916  char* result;
5917 
5918  _OrthancPluginFindOperation params;
5919  memset(&params, 0, sizeof(params));
5920  params.query = query;
5921  params.index = index;
5922  params.resultString = &result;
5923 
5924  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
5925  {
5926  /* Error */
5927  return NULL;
5928  }
5929  else
5930  {
5931  return result;
5932  }
5933  }
5934 
5935 
5949  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
5950  OrthancPluginContext* context,
5951  const OrthancPluginFindQuery* query,
5952  uint32_t index)
5953  {
5954  char* result;
5955 
5956  _OrthancPluginFindOperation params;
5957  memset(&params, 0, sizeof(params));
5958  params.query = query;
5959  params.index = index;
5960  params.resultString = &result;
5961 
5962  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
5963  {
5964  /* Error */
5965  return NULL;
5966  }
5967  else
5968  {
5969  return result;
5970  }
5971  }
5972 
5973 
5974 
5975 
5976  typedef struct
5977  {
5978  OrthancPluginMoveCallback callback;
5979  OrthancPluginGetMoveSize getMoveSize;
5980  OrthancPluginApplyMove applyMove;
5981  OrthancPluginFreeMove freeMove;
5982  } _OrthancPluginMoveCallback;
5983 
5998  OrthancPluginContext* context,
5999  OrthancPluginMoveCallback callback,
6000  OrthancPluginGetMoveSize getMoveSize,
6001  OrthancPluginApplyMove applyMove,
6002  OrthancPluginFreeMove freeMove)
6003  {
6004  _OrthancPluginMoveCallback params;
6005  params.callback = callback;
6006  params.getMoveSize = getMoveSize;
6007  params.applyMove = applyMove;
6008  params.freeMove = freeMove;
6009 
6010  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
6011  }
6012 
6013 
6014 
6015  typedef struct
6016  {
6017  OrthancPluginFindMatcher** target;
6018  const void* query;
6019  uint32_t size;
6020  } _OrthancPluginCreateFindMatcher;
6021 
6022 
6037  OrthancPluginContext* context,
6038  const void* query,
6039  uint32_t size)
6040  {
6041  OrthancPluginFindMatcher* target = NULL;
6042 
6043  _OrthancPluginCreateFindMatcher params;
6044  memset(&params, 0, sizeof(params));
6045  params.target = &target;
6046  params.query = query;
6047  params.size = size;
6048 
6049  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
6050  {
6051  return NULL;
6052  }
6053  else
6054  {
6055  return target;
6056  }
6057  }
6058 
6059 
6060  typedef struct
6061  {
6062  OrthancPluginFindMatcher* matcher;
6063  } _OrthancPluginFreeFindMatcher;
6064 
6074  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6075  OrthancPluginContext* context,
6076  OrthancPluginFindMatcher* matcher)
6077  {
6078  _OrthancPluginFreeFindMatcher params;
6079  params.matcher = matcher;
6080 
6081  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6082  }
6083 
6084 
6085  typedef struct
6086  {
6087  const OrthancPluginFindMatcher* matcher;
6088  const void* dicom;
6089  uint32_t size;
6090  int32_t* isMatch;
6091  } _OrthancPluginFindMatcherIsMatch;
6092 
6107  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6108  OrthancPluginContext* context,
6109  const OrthancPluginFindMatcher* matcher,
6110  const void* dicom,
6111  uint32_t size)
6112  {
6113  int32_t isMatch = 0;
6114 
6115  _OrthancPluginFindMatcherIsMatch params;
6116  params.matcher = matcher;
6117  params.dicom = dicom;
6118  params.size = size;
6119  params.isMatch = &isMatch;
6120 
6121  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6122  {
6123  return isMatch;
6124  }
6125  else
6126  {
6127  /* Error: Assume non-match */
6128  return 0;
6129  }
6130  }
6131 
6132 
6133  typedef struct
6134  {
6136  } _OrthancPluginIncomingHttpRequestFilter2;
6137 
6150  OrthancPluginContext* context,
6152  {
6153  _OrthancPluginIncomingHttpRequestFilter2 params;
6154  params.callback = callback;
6155 
6156  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6157  }
6158 
6159 
6160 
6161  typedef struct
6162  {
6163  OrthancPluginPeers** peers;
6164  } _OrthancPluginGetPeers;
6165 
6178  OrthancPluginContext* context)
6179  {
6180  OrthancPluginPeers* peers = NULL;
6181 
6182  _OrthancPluginGetPeers params;
6183  memset(&params, 0, sizeof(params));
6184  params.peers = &peers;
6185 
6186  if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6187  {
6188  return NULL;
6189  }
6190  else
6191  {
6192  return peers;
6193  }
6194  }
6195 
6196 
6197  typedef struct
6198  {
6199  OrthancPluginPeers* peers;
6200  } _OrthancPluginFreePeers;
6201 
6211  ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6212  OrthancPluginContext* context,
6213  OrthancPluginPeers* peers)
6214  {
6215  _OrthancPluginFreePeers params;
6216  params.peers = peers;
6217 
6218  context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6219  }
6220 
6221 
6222  typedef struct
6223  {
6224  uint32_t* target;
6225  const OrthancPluginPeers* peers;
6226  } _OrthancPluginGetPeersCount;
6227 
6241  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6242  OrthancPluginContext* context,
6243  const OrthancPluginPeers* peers)
6244  {
6245  uint32_t target = 0;
6246 
6247  _OrthancPluginGetPeersCount params;
6248  memset(&params, 0, sizeof(params));
6249  params.target = &target;
6250  params.peers = peers;
6251 
6252  if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6253  {
6254  /* Error */
6255  return 0;
6256  }
6257  else
6258  {
6259  return target;
6260  }
6261  }
6262 
6263 
6264  typedef struct
6265  {
6266  const char** target;
6267  const OrthancPluginPeers* peers;
6268  uint32_t peerIndex;
6269  const char* userProperty;
6270  } _OrthancPluginGetPeerProperty;
6271 
6289  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6290  OrthancPluginContext* context,
6291  const OrthancPluginPeers* peers,
6292  uint32_t peerIndex)
6293  {
6294  const char* target = NULL;
6295 
6296  _OrthancPluginGetPeerProperty params;
6297  memset(&params, 0, sizeof(params));
6298  params.target = &target;
6299  params.peers = peers;
6300  params.peerIndex = peerIndex;
6301  params.userProperty = NULL;
6302 
6303  if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6304  {
6305  /* Error */
6306  return NULL;
6307  }
6308  else
6309  {
6310  return target;
6311  }
6312  }
6313 
6314 
6330  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6331  OrthancPluginContext* context,
6332  const OrthancPluginPeers* peers,
6333  uint32_t peerIndex)
6334  {
6335  const char* target = NULL;
6336 
6337  _OrthancPluginGetPeerProperty params;
6338  memset(&params, 0, sizeof(params));
6339  params.target = &target;
6340  params.peers = peers;
6341  params.peerIndex = peerIndex;
6342  params.userProperty = NULL;
6343 
6344  if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6345  {
6346  /* Error */
6347  return NULL;
6348  }
6349  else
6350  {
6351  return target;
6352  }
6353  }
6354 
6355 
6356 
6376  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6377  OrthancPluginContext* context,
6378  const OrthancPluginPeers* peers,
6379  uint32_t peerIndex,
6380  const char* userProperty)
6381  {
6382  const char* target = NULL;
6383 
6384  _OrthancPluginGetPeerProperty params;
6385  memset(&params, 0, sizeof(params));
6386  params.target = &target;
6387  params.peers = peers;
6388  params.peerIndex = peerIndex;
6389  params.userProperty = userProperty;
6390 
6391  if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6392  {
6393  /* No such user property */
6394  return NULL;
6395  }
6396  else
6397  {
6398  return target;
6399  }
6400  }
6401 
6402 
6403 
6404  typedef struct
6405  {
6406  OrthancPluginMemoryBuffer* answerBody;
6407  OrthancPluginMemoryBuffer* answerHeaders;
6408  uint16_t* httpStatus;
6409  const OrthancPluginPeers* peers;
6410  uint32_t peerIndex;
6411  OrthancPluginHttpMethod method;
6412  const char* uri;
6413  uint32_t additionalHeadersCount;
6414  const char* const* additionalHeadersKeys;
6415  const char* const* additionalHeadersValues;
6416  const void* body;
6417  uint32_t bodySize;
6418  uint32_t timeout;
6419  } _OrthancPluginCallPeerApi;
6420 
6457  OrthancPluginContext* context,
6458  OrthancPluginMemoryBuffer* answerBody,
6459  OrthancPluginMemoryBuffer* answerHeaders,
6460  uint16_t* httpStatus,
6461  const OrthancPluginPeers* peers,
6462  uint32_t peerIndex,
6463  OrthancPluginHttpMethod method,
6464  const char* uri,
6465  uint32_t additionalHeadersCount,
6466  const char* const* additionalHeadersKeys,
6467  const char* const* additionalHeadersValues,
6468  const void* body,
6469  uint32_t bodySize,
6470  uint32_t timeout)
6471  {
6472  _OrthancPluginCallPeerApi params;
6473  memset(&params, 0, sizeof(params));
6474 
6475  params.answerBody = answerBody;
6476  params.answerHeaders = answerHeaders;
6477  params.httpStatus = httpStatus;
6478  params.peers = peers;
6479  params.peerIndex = peerIndex;
6480  params.method = method;
6481  params.uri = uri;
6482  params.additionalHeadersCount = additionalHeadersCount;
6483  params.additionalHeadersKeys = additionalHeadersKeys;
6484  params.additionalHeadersValues = additionalHeadersValues;
6485  params.body = body;
6486  params.bodySize = bodySize;
6487  params.timeout = timeout;
6488 
6489  return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6490  }
6491 
6492 
6493 
6494 
6495 
6496  typedef struct
6497  {
6498  OrthancPluginJob** target;
6499  void *job;
6500  OrthancPluginJobFinalize finalize;
6501  const char *type;
6502  OrthancPluginJobGetProgress getProgress;
6503  OrthancPluginJobGetContent getContent;
6504  OrthancPluginJobGetSerialized getSerialized;
6505  OrthancPluginJobStep step;
6506  OrthancPluginJobStop stop;
6507  OrthancPluginJobReset reset;
6508  } _OrthancPluginCreateJob;
6509 
6542  OrthancPluginContext *context,
6543  void *job,
6544  OrthancPluginJobFinalize finalize,
6545  const char *type,
6546  OrthancPluginJobGetProgress getProgress,
6547  OrthancPluginJobGetContent getContent,
6548  OrthancPluginJobGetSerialized getSerialized,
6549  OrthancPluginJobStep step,
6550  OrthancPluginJobStop stop,
6551  OrthancPluginJobReset reset)
6552  {
6553  OrthancPluginJob* target = NULL;
6554 
6555  _OrthancPluginCreateJob params;
6556  memset(&params, 0, sizeof(params));
6557 
6558  params.target = &target;
6559  params.job = job;
6560  params.finalize = finalize;
6561  params.type = type;
6562  params.getProgress = getProgress;
6563  params.getContent = getContent;
6564  params.getSerialized = getSerialized;
6565  params.step = step;
6566  params.stop = stop;
6567  params.reset = reset;
6568 
6569  if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6570  target == NULL)
6571  {
6572  /* Error */
6573  return NULL;
6574  }
6575  else
6576  {
6577  return target;
6578  }
6579  }
6580 
6581 
6582  typedef struct
6583  {
6584  OrthancPluginJob* job;
6585  } _OrthancPluginFreeJob;
6586 
6596  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6597  OrthancPluginContext* context,
6598  OrthancPluginJob* job)
6599  {
6600  _OrthancPluginFreeJob params;
6601  params.job = job;
6602 
6603  context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6604  }
6605 
6606 
6607 
6608  typedef struct
6609  {
6610  char** resultId;
6611  OrthancPluginJob *job;
6612  int priority;
6613  } _OrthancPluginSubmitJob;
6614 
6628  ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6629  OrthancPluginContext *context,
6630  OrthancPluginJob *job,
6631  int priority)
6632  {
6633  char* resultId = NULL;
6634 
6635  _OrthancPluginSubmitJob params;
6636  memset(&params, 0, sizeof(params));
6637 
6638  params.resultId = &resultId;
6639  params.job = job;
6640  params.priority = priority;
6641 
6642  if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6643  resultId == NULL)
6644  {
6645  /* Error */
6646  return NULL;
6647  }
6648  else
6649  {
6650  return resultId;
6651  }
6652  }
6653 
6654 
6655 
6656  typedef struct
6657  {
6658  OrthancPluginJobsUnserializer unserializer;
6659  } _OrthancPluginJobsUnserializer;
6660 
6673  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6674  OrthancPluginContext* context,
6675  OrthancPluginJobsUnserializer unserializer)
6676  {
6677  _OrthancPluginJobsUnserializer params;
6678  params.unserializer = unserializer;
6679 
6680  context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6681  }
6682 
6683 
6684 
6685  typedef struct
6686  {
6687  OrthancPluginRestOutput* output;
6688  const char* details;
6689  uint8_t log;
6690  } _OrthancPluginSetHttpErrorDetails;
6691 
6709  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
6710  OrthancPluginContext* context,
6711  OrthancPluginRestOutput* output,
6712  const char* details,
6713  uint8_t log)
6714  {
6715  _OrthancPluginSetHttpErrorDetails params;
6716  params.output = output;
6717  params.details = details;
6718  params.log = log;
6719  context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
6720  }
6721 
6722 
6723 
6724  typedef struct
6725  {
6726  const char** result;
6727  const char* argument;
6728  } _OrthancPluginRetrieveStaticString;
6729 
6741  ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
6742  OrthancPluginContext* context,
6743  const char* path)
6744  {
6745  const char* result = NULL;
6746 
6747  _OrthancPluginRetrieveStaticString params;
6748  params.result = &result;
6749  params.argument = path;
6750 
6751  if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
6752  {
6753  /* Error */
6754  return NULL;
6755  }
6756  else
6757  {
6758  return result;
6759  }
6760  }
6761 
6762 
6763 
6764  typedef struct
6765  {
6766  const char* name;
6767  float value;
6769  } _OrthancPluginSetMetricsValue;
6770 
6785  ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
6786  OrthancPluginContext* context,
6787  const char* name,
6788  float value,
6790  {
6791  _OrthancPluginSetMetricsValue params;
6792  params.name = name;
6793  params.value = value;
6794  params.type = type;
6795  context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
6796  }
6797 
6798 
6799 
6800  typedef struct
6801  {
6803  } _OrthancPluginRegisterRefreshMetricsCallback;
6804 
6816  OrthancPluginContext* context,
6818  {
6819  _OrthancPluginRegisterRefreshMetricsCallback params;
6820  params.callback = callback;
6821  context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
6822  }
6823 
6824 
6825 
6826 
6827  typedef struct
6828  {
6829  char** target;
6830  const void* dicom;
6831  uint32_t dicomSize;
6833  } _OrthancPluginEncodeDicomWeb;
6834 
6851  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
6852  OrthancPluginContext* context,
6853  const void* dicom,
6854  uint32_t dicomSize,
6856  {
6857  char* target = NULL;
6858 
6859  _OrthancPluginEncodeDicomWeb params;
6860  params.target = &target;
6861  params.dicom = dicom;
6862  params.dicomSize = dicomSize;
6863  params.callback = callback;
6864 
6865  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
6866  {
6867  /* Error */
6868  return NULL;
6869  }
6870  else
6871  {
6872  return target;
6873  }
6874  }
6875 
6876 
6893  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
6894  OrthancPluginContext* context,
6895  const void* dicom,
6896  uint32_t dicomSize,
6898  {
6899  char* target = NULL;
6900 
6901  _OrthancPluginEncodeDicomWeb params;
6902  params.target = &target;
6903  params.dicom = dicom;
6904  params.dicomSize = dicomSize;
6905  params.callback = callback;
6906 
6907  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
6908  {
6909  /* Error */
6910  return NULL;
6911  }
6912  else
6913  {
6914  return target;
6915  }
6916  }
6917 
6918 
6919 
6920  typedef struct
6921  {
6922  char** target;
6923  const void* dicom;
6924  uint32_t dicomSize;
6926  void* payload;
6927  } _OrthancPluginEncodeDicomWeb2;
6928 
6945  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson2(
6946  OrthancPluginContext* context,
6947  const void* dicom,
6948  uint32_t dicomSize,
6950  void* payload)
6951  {
6952  char* target = NULL;
6953 
6954  _OrthancPluginEncodeDicomWeb2 params;
6955  params.target = &target;
6956  params.dicom = dicom;
6957  params.dicomSize = dicomSize;
6958  params.callback = callback;
6959  params.payload = payload;
6960 
6961  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson2, &params) != OrthancPluginErrorCode_Success)
6962  {
6963  /* Error */
6964  return NULL;
6965  }
6966  else
6967  {
6968  return target;
6969  }
6970  }
6971 
6972 
6989  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml2(
6990  OrthancPluginContext* context,
6991  const void* dicom,
6992  uint32_t dicomSize,
6994  void* payload)
6995  {
6996  char* target = NULL;
6997 
6998  _OrthancPluginEncodeDicomWeb2 params;
6999  params.target = &target;
7000  params.dicom = dicom;
7001  params.dicomSize = dicomSize;
7002  params.callback = callback;
7003  params.payload = payload;
7004 
7005  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml2, &params) != OrthancPluginErrorCode_Success)
7006  {
7007  /* Error */
7008  return NULL;
7009  }
7010  else
7011  {
7012  return target;
7013  }
7014  }
7015 
7016 
7017 
7034  void* answer,
7035  const char* key,
7036  const char* value);
7037 
7038 
7055  void* answer,
7056  const void* data,
7057  uint32_t size);
7058 
7059 
7074  typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
7075 
7076 
7092 
7093 
7107  typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
7108 
7109 
7123  typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
7124 
7125 
7126  typedef struct
7127  {
7128  void* answer;
7131  uint16_t* httpStatus;
7132  OrthancPluginHttpMethod method;
7133  const char* url;
7134  uint32_t headersCount;
7135  const char* const* headersKeys;
7136  const char* const* headersValues;
7137  void* request;
7142  const char* username;
7143  const char* password;
7144  uint32_t timeout;
7145  const char* certificateFile;
7146  const char* certificateKeyFile;
7147  const char* certificateKeyPassword;
7148  uint8_t pkcs11;
7149  } _OrthancPluginChunkedHttpClient;
7150 
7151 
7203  OrthancPluginContext* context,
7204  void* answer,
7207  uint16_t* httpStatus,
7208  OrthancPluginHttpMethod method,
7209  const char* url,
7210  uint32_t headersCount,
7211  const char* const* headersKeys,
7212  const char* const* headersValues,
7213  void* request,
7218  const char* username,
7219  const char* password,
7220  uint32_t timeout,
7221  const char* certificateFile,
7222  const char* certificateKeyFile,
7223  const char* certificateKeyPassword,
7224  uint8_t pkcs11)
7225  {
7226  _OrthancPluginChunkedHttpClient params;
7227  memset(&params, 0, sizeof(params));
7228 
7229  /* In common with OrthancPluginHttpClient() */
7230  params.httpStatus = httpStatus;
7231  params.method = method;
7232  params.url = url;
7233  params.headersCount = headersCount;
7234  params.headersKeys = headersKeys;
7235  params.headersValues = headersValues;
7236  params.username = username;
7237  params.password = password;
7238  params.timeout = timeout;
7239  params.certificateFile = certificateFile;
7240  params.certificateKeyFile = certificateKeyFile;
7241  params.certificateKeyPassword = certificateKeyPassword;
7242  params.pkcs11 = pkcs11;
7243 
7244  /* For chunked body/answer */
7245  params.answer = answer;
7246  params.answerAddChunk = answerAddChunk;
7247  params.answerAddHeader = answerAddHeader;
7248  params.request = request;
7249  params.requestIsDone = requestIsDone;
7250  params.requestChunkData = requestChunkData;
7251  params.requestChunkSize = requestChunkSize;
7252  params.requestNext = requestNext;
7253 
7254  return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7255  }
7256 
7257 
7258 
7263  typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7264 
7265 
7266 
7284  const char* url,
7285  const OrthancPluginHttpRequest* request);
7286 
7287 
7303  const void* data,
7304  uint32_t size);
7305 
7306 
7323  OrthancPluginRestOutput* output);
7324 
7325 
7341 
7342  typedef struct
7343  {
7344  const char* pathRegularExpression;
7345  OrthancPluginRestCallback getHandler;
7347  OrthancPluginRestCallback deleteHandler;
7352  } _OrthancPluginChunkedRestCallback;
7353 
7354 
7384  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterChunkedRestCallback(
7385  OrthancPluginContext* context,
7386  const char* pathRegularExpression,
7387  OrthancPluginRestCallback getHandler,
7389  OrthancPluginRestCallback deleteHandler,
7394  {
7395  _OrthancPluginChunkedRestCallback params;
7396  params.pathRegularExpression = pathRegularExpression;
7397  params.getHandler = getHandler;
7398  params.postHandler = postHandler;
7399  params.deleteHandler = deleteHandler;
7400  params.putHandler = putHandler;
7401  params.addChunk = addChunk;
7402  params.execute = execute;
7403  params.finalize = finalize;
7404 
7405  context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
7406  }
7407 
7408 
7409 
7410 
7411 
7412  typedef struct
7413  {
7414  char** result;
7415  uint16_t group;
7416  uint16_t element;
7417  const char* privateCreator;
7418  } _OrthancPluginGetTagName;
7419 
7435  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
7436  OrthancPluginContext* context,
7437  uint16_t group,
7438  uint16_t element,
7439  const char* privateCreator)
7440  {
7441  char* result;
7442 
7443  _OrthancPluginGetTagName params;
7444  params.result = &result;
7445  params.group = group;
7446  params.element = element;
7447  params.privateCreator = privateCreator;
7448 
7449  if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
7450  {
7451  /* Error */
7452  return NULL;
7453  }
7454  else
7455  {
7456  return result;
7457  }
7458  }
7459 
7460 
7461 
7491  void** handler /* out */,
7492  const char* jobId,
7493  const char* transactionUid,
7494  const char* const* sopClassUids,
7495  const char* const* sopInstanceUids,
7496  uint32_t countInstances,
7497  const char* remoteAet,
7498  const char* calledAet);
7499 
7500 
7512  typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
7513 
7514 
7535  void* handler,
7536  const char* sopClassUid,
7537  const char* sopInstanceUid);
7538 
7539 
7540  typedef struct
7541  {
7545  } _OrthancPluginRegisterStorageCommitmentScpCallback;
7546 
7561  OrthancPluginContext* context,
7565  {
7566  _OrthancPluginRegisterStorageCommitmentScpCallback params;
7567  params.factory = factory;
7568  params.destructor = destructor;
7569  params.lookup = lookup;
7570  return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
7571  }
7572 
7573 
7574 
7591  const OrthancPluginDicomInstance* instance);
7592 
7593 
7594  typedef struct
7595  {
7597  } _OrthancPluginIncomingDicomInstanceFilter;
7598 
7612  OrthancPluginContext* context,
7614  {
7615  _OrthancPluginIncomingDicomInstanceFilter params;
7616  params.callback = callback;
7617 
7618  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, &params);
7619  }
7620 
7621 
7635  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceTransferSyntaxUid(
7636  OrthancPluginContext* context,
7637  const OrthancPluginDicomInstance* instance)
7638  {
7639  char* result;
7640 
7641  _OrthancPluginAccessDicomInstance params;
7642  memset(&params, 0, sizeof(params));
7643  params.resultStringToFree = &result;
7644  params.instance = instance;
7645 
7646  if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, &params) != OrthancPluginErrorCode_Success)
7647  {
7648  /* Error */
7649  return NULL;
7650  }
7651  else
7652  {
7653  return result;
7654  }
7655  }
7656 
7657 
7670  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData(
7671  OrthancPluginContext* context,
7672  const OrthancPluginDicomInstance* instance)
7673  {
7674  int64_t hasPixelData;
7675 
7676  _OrthancPluginAccessDicomInstance params;
7677  memset(&params, 0, sizeof(params));
7678  params.resultInt64 = &hasPixelData;
7679  params.instance = instance;
7680 
7681  if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, &params) != OrthancPluginErrorCode_Success ||
7682  hasPixelData < 0 ||
7683  hasPixelData > 1)
7684  {
7685  /* Error */
7686  return -1;
7687  }
7688  else
7689  {
7690  return (hasPixelData != 0);
7691  }
7692  }
7693 
7694 
7695 
7696 
7697 
7698 
7699  typedef struct
7700  {
7701  OrthancPluginDicomInstance** target;
7702  const void* buffer;
7703  uint32_t size;
7704  const char* transferSyntax;
7705  } _OrthancPluginCreateDicomInstance;
7706 
7721  OrthancPluginContext* context,
7722  const void* buffer,
7723  uint32_t size)
7724  {
7725  OrthancPluginDicomInstance* target = NULL;
7726 
7727  _OrthancPluginCreateDicomInstance params;
7728  params.target = &target;
7729  params.buffer = buffer;
7730  params.size = size;
7731 
7732  if (context->InvokeService(context, _OrthancPluginService_CreateDicomInstance, &params) != OrthancPluginErrorCode_Success)
7733  {
7734  /* Error */
7735  return NULL;
7736  }
7737  else
7738  {
7739  return target;
7740  }
7741  }
7742 
7743  typedef struct
7744  {
7746  } _OrthancPluginFreeDicomInstance;
7747 
7758  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeDicomInstance(
7759  OrthancPluginContext* context,
7761  {
7762  _OrthancPluginFreeDicomInstance params;
7763  params.dicom = dicom;
7764 
7765  context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, &params);
7766  }
7767 
7768 
7769  typedef struct
7770  {
7771  uint32_t* targetUint32;
7772  OrthancPluginMemoryBuffer* targetBuffer;
7773  OrthancPluginImage** targetImage;
7774  char** targetStringToFree;
7775  const OrthancPluginDicomInstance* instance;
7776  uint32_t frameIndex;
7779  uint32_t maxStringLength;
7780  OrthancPluginDicomWebBinaryCallback2 dicomWebCallback;
7781  void* dicomWebPayload;
7782  } _OrthancPluginAccessDicomInstance2;
7783 
7795  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetInstanceFramesCount(
7796  OrthancPluginContext* context,
7797  const OrthancPluginDicomInstance* instance)
7798  {
7799  uint32_t count;
7800 
7801  _OrthancPluginAccessDicomInstance2 params;
7802  memset(&params, 0, sizeof(params));
7803  params.targetUint32 = &count;
7804  params.instance = instance;
7805 
7806  if (context->InvokeService(context, _OrthancPluginService_GetInstanceFramesCount, &params) != OrthancPluginErrorCode_Success)
7807  {
7808  /* Error */
7809  return 0;
7810  }
7811  else
7812  {
7813  return count;
7814  }
7815  }
7816 
7817 
7836  OrthancPluginContext* context,
7837  OrthancPluginMemoryBuffer* target,
7838  const OrthancPluginDicomInstance* instance,
7839  uint32_t frameIndex)
7840  {
7841  _OrthancPluginAccessDicomInstance2 params;
7842  memset(&params, 0, sizeof(params));
7843  params.targetBuffer = target;
7844  params.instance = instance;
7845  params.frameIndex = frameIndex;
7846 
7847  return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, &params);
7848  }
7849 
7850 
7864  OrthancPluginContext* context,
7865  const OrthancPluginDicomInstance* instance,
7866  uint32_t frameIndex)
7867  {
7868  OrthancPluginImage* target = NULL;
7869 
7870  _OrthancPluginAccessDicomInstance2 params;
7871  memset(&params, 0, sizeof(params));
7872  params.targetImage = &target;
7873  params.instance = instance;
7874  params.frameIndex = frameIndex;
7875 
7876  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDecodedFrame, &params) != OrthancPluginErrorCode_Success)
7877  {
7878  return NULL;
7879  }
7880  else
7881  {
7882  return target;
7883  }
7884  }
7885 
7886 
7903  OrthancPluginContext* context,
7904  const void* buffer,
7905  uint32_t size,
7906  const char* transferSyntax)
7907  {
7908  OrthancPluginDicomInstance* target = NULL;
7909 
7910  _OrthancPluginCreateDicomInstance params;
7911  params.target = &target;
7912  params.buffer = buffer;
7913  params.size = size;
7914  params.transferSyntax = transferSyntax;
7915 
7916  if (context->InvokeService(context, _OrthancPluginService_TranscodeDicomInstance, &params) != OrthancPluginErrorCode_Success)
7917  {
7918  /* Error */
7919  return NULL;
7920  }
7921  else
7922  {
7923  return target;
7924  }
7925  }
7926 
7941  OrthancPluginContext* context,
7942  OrthancPluginMemoryBuffer* target,
7943  const OrthancPluginDicomInstance* instance)
7944  {
7945  _OrthancPluginAccessDicomInstance2 params;
7946  memset(&params, 0, sizeof(params));
7947  params.targetBuffer = target;
7948  params.instance = instance;
7949 
7950  return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, &params);
7951  }
7952 
7953 
7972  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceAdvancedJson(
7973  OrthancPluginContext* context,
7974  const OrthancPluginDicomInstance* instance,
7977  uint32_t maxStringLength)
7978  {
7979  char* result = NULL;
7980 
7981  _OrthancPluginAccessDicomInstance2 params;
7982  memset(&params, 0, sizeof(params));
7983  params.targetStringToFree = &result;
7984  params.instance = instance;
7985  params.format = format;
7986  params.flags = flags;
7987  params.maxStringLength = maxStringLength;
7988 
7989  if (context->InvokeService(context, _OrthancPluginService_GetInstanceAdvancedJson, &params) != OrthancPluginErrorCode_Success)
7990  {
7991  /* Error */
7992  return NULL;
7993  }
7994  else
7995  {
7996  return result;
7997  }
7998  }
7999 
8000 
8015  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebJson(
8016  OrthancPluginContext* context,
8017  const OrthancPluginDicomInstance* instance,
8019  void* payload)
8020  {
8021  char* target = NULL;
8022 
8023  _OrthancPluginAccessDicomInstance2 params;
8024  params.targetStringToFree = &target;
8025  params.instance = instance;
8026  params.dicomWebCallback = callback;
8027  params.dicomWebPayload = payload;
8028 
8029  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebJson, &params) != OrthancPluginErrorCode_Success)
8030  {
8031  /* Error */
8032  return NULL;
8033  }
8034  else
8035  {
8036  return target;
8037  }
8038  }
8039 
8040 
8055  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebXml(
8056  OrthancPluginContext* context,
8057  const OrthancPluginDicomInstance* instance,
8059  void* payload)
8060  {
8061  char* target = NULL;
8062 
8063  _OrthancPluginAccessDicomInstance2 params;
8064  params.targetStringToFree = &target;
8065  params.instance = instance;
8066  params.dicomWebCallback = callback;
8067  params.dicomWebPayload = payload;
8068 
8069  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebXml, &params) != OrthancPluginErrorCode_Success)
8070  {
8071  /* Error */
8072  return NULL;
8073  }
8074  else
8075  {
8076  return target;
8077  }
8078  }
8079 
8080 
8081 
8101  OrthancPluginMemoryBuffer* transcoded /* out */,
8102  const void* buffer,
8103  uint64_t size,
8104  const char* const* allowedSyntaxes,
8105  uint32_t countSyntaxes,
8106  uint8_t allowNewSopInstanceUid);
8107 
8108 
8109  typedef struct
8110  {
8112  } _OrthancPluginTranscoderCallback;
8113 
8128  OrthancPluginContext* context,
8130  {
8131  _OrthancPluginTranscoderCallback params;
8132  params.callback = callback;
8133 
8134  return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, &params);
8135  }
8136 
8137 
8138 
8139  typedef struct
8140  {
8141  OrthancPluginMemoryBuffer* target;
8142  uint32_t size;
8143  } _OrthancPluginCreateMemoryBuffer;
8144 
8163  OrthancPluginContext* context,
8164  OrthancPluginMemoryBuffer* target,
8165  uint32_t size)
8166  {
8167  _OrthancPluginCreateMemoryBuffer params;
8168  params.target = target;
8169  params.size = size;
8170 
8171  return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, &params);
8172  }
8173 
8174 
8175 #ifdef __cplusplus
8176 }
8177 #endif
8178 
8179 
OrthancPluginJobGetProgress
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1458
OrthancPluginMetricsType_Default
@ OrthancPluginMetricsType_Default
Definition: OrthancCPlugin.h:930
OrthancPluginChangeType_NewPatient
@ OrthancPluginChangeType_NewPatient
Definition: OrthancCPlugin.h:716
OrthancPluginErrorCode_SQLiteStatementAlreadyUsed
@ OrthancPluginErrorCode_SQLiteStatementAlreadyUsed
Definition: OrthancCPlugin.h:252
OrthancPluginConvertPixelFormat
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4321
OrthancPluginGetMoveSize
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1403
OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
Definition: OrthancCPlugin.h:831
OrthancPluginErrorCode_CannotExecuteLua
@ OrthancPluginErrorCode_CannotExecuteLua
Definition: OrthancCPlugin.h:296
OrthancPluginCheckVersion
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1833
OrthancPluginChangeType_JobFailure
@ OrthancPluginChangeType_JobFailure
Definition: OrthancCPlugin.h:730
OrthancPluginErrorCode_NoWorklistHandler
@ OrthancPluginErrorCode_NoWorklistHandler
Definition: OrthancCPlugin.h:306
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:3252
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:5657
OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii
Definition: OrthancCPlugin.h:830
OrthancPluginErrorCode_SQLiteBindOutOfRange
@ OrthancPluginErrorCode_SQLiteBindOutOfRange
Definition: OrthancCPlugin.h:260
OrthancPluginRegisterOnStoredInstanceCallback
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:2004
OrthancPluginValueRepresentation_AS
@ OrthancPluginValueRepresentation_AS
Definition: OrthancCPlugin.h:772
OrthancPluginValueRepresentation_UT
@ OrthancPluginValueRepresentation_UT
Definition: OrthancCPlugin.h:797
OrthancPluginErrorCode_SystemCommand
@ OrthancPluginErrorCode_SystemCommand
Definition: OrthancCPlugin.h:219
OrthancPluginContext
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginErrorCode_NotEnoughMemory
@ OrthancPluginErrorCode_NotEnoughMemory
Definition: OrthancCPlugin.h:213
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:3719
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:5790
OrthancPluginGetOrthancDirectory
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:3100
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:2036
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:2298
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:7720
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:2382
OrthancPluginErrorCode_Unauthorized
@ OrthancPluginErrorCode_Unauthorized
Definition: OrthancCPlugin.h:238
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:7282
OrthancPluginErrorCode_CreateDicomNoPayload
@ OrthancPluginErrorCode_CreateDicomNoPayload
Definition: OrthancCPlugin.h:287
OrthancPluginErrorCode_InexistentTag
@ OrthancPluginErrorCode_InexistentTag
Definition: OrthancCPlugin.h:230
OrthancPluginComputeSha1
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5456
OrthancPluginErrorCode_CreateDicomUseContent
@ OrthancPluginErrorCode_CreateDicomUseContent
Definition: OrthancCPlugin.h:286
OrthancPluginPixelFormat_BGRA32
@ OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:661
OrthancPluginErrorCode_Timeout
@ OrthancPluginErrorCode_Timeout
Definition: OrthancCPlugin.h:225
OrthancPluginResourceType_Patient
@ OrthancPluginResourceType_Patient
Definition: OrthancCPlugin.h:695
OrthancPluginErrorCode_JsonToLuaTable
@ OrthancPluginErrorCode_JsonToLuaTable
Definition: OrthancCPlugin.h:294
OrthancPluginErrorCode_LuaReturnsNoString
@ OrthancPluginErrorCode_LuaReturnsNoString
Definition: OrthancCPlugin.h:300
OrthancPluginPixelFormat_Float32
@ OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:653
OrthancPluginDictionaryEntry::group
uint16_t group
Definition: OrthancCPlugin.h:1681
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:5285
OrthancPluginLookupSeries
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2553
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:7301
OrthancPluginJobGetSerialized
const typedef char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1491
OrthancPluginJobGetContent
const typedef char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1473
OrthancPluginIncomingDicomInstanceFilter
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition: OrthancCPlugin.h:7590
OrthancPluginChangeType_OrthancStopped
@ OrthancPluginChangeType_OrthancStopped
Definition: OrthancCPlugin.h:723
OrthancPluginErrorCode_LuaAlreadyExecuted
@ OrthancPluginErrorCode_LuaAlreadyExecuted
Definition: OrthancCPlugin.h:297
OrthancPluginGetInstanceRemoteAet
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2770
OrthancPluginDicomToJsonFlags
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:823
OrthancPluginErrorCode_SQLiteCannotStep
@ OrthancPluginErrorCode_SQLiteCannotStep
Definition: OrthancCPlugin.h:259
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:4112
OrthancPluginGetPeerUrl
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6330
OrthancPluginErrorCode_NoCGetHandler
@ OrthancPluginErrorCode_NoCGetHandler
Definition: OrthancCPlugin.h:309
OrthancPluginValueRepresentation_ST
@ OrthancPluginValueRepresentation_ST
Definition: OrthancCPlugin.h:791
OrthancPluginImageFormat
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:755
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:4575
OrthancPluginRegisterDecodeImageCallback
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5247
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:2269
OrthancPluginErrorCode_SQLiteCannotOpen
@ OrthancPluginErrorCode_SQLiteCannotOpen
Definition: OrthancCPlugin.h:251
OrthancPluginChangeType_CompletedSeries
@ OrthancPluginChangeType_CompletedSeries
Definition: OrthancCPlugin.h:712
OrthancPluginErrorCode_SQLiteFlush
@ OrthancPluginErrorCode_SQLiteFlush
Definition: OrthancCPlugin.h:257
OrthancPluginErrorCode_SQLiteExecute
@ OrthancPluginErrorCode_SQLiteExecute
Definition: OrthancCPlugin.h:253
OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
@ OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
Definition: OrthancCPlugin.h:966
OrthancPluginHttpRequest
The parameters of a REST request.
Definition: OrthancCPlugin.h:332
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:3788
OrthancPluginChangeType_JobSuccess
@ OrthancPluginChangeType_JobSuccess
Definition: OrthancCPlugin.h:729
OrthancPluginConstraintType
OrthancPluginConstraintType
Definition: OrthancCPlugin.h:872
OrthancPluginHasInstanceMetadata
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:2949
OrthancPluginGetPeerName
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6289
OrthancPluginErrorCode_InternalError
@ OrthancPluginErrorCode_InternalError
Definition: OrthancCPlugin.h:208
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:1647
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:1250
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:3856
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:1081
OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
@ OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
Definition: OrthancCPlugin.h:974
OrthancPluginErrorCode_BadApplicationEntityTitle
@ OrthancPluginErrorCode_BadApplicationEntityTitle
Definition: OrthancCPlugin.h:274
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:2990
OrthancPluginErrorCode_NoCMoveHandler
@ OrthancPluginErrorCode_NoCMoveHandler
Definition: OrthancCPlugin.h:276
OrthancPluginErrorCode_SQLiteCannotRun
@ OrthancPluginErrorCode_SQLiteCannotRun
Definition: OrthancCPlugin.h:258
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:7560
OrthancPluginJobStopReason_Failure
@ OrthancPluginJobStopReason_Failure
Definition: OrthancCPlugin.h:920
OrthancPluginGetInstanceFramesCount
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition: OrthancCPlugin.h:7795
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:261
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:1114
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:4804
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:7435
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:5880
OrthancPluginLookupDictionary
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5502
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:4848
OrthancPluginGetConfigurationPath
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:3135
OrthancPluginHttpDelete
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4283
OrthancPluginCompressionType
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:740
OrthancPluginJobStep
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1506
OrthancPluginDictionaryEntry::minMultiplicity
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1684
OrthancPluginErrorCode_InexistentFile
@ OrthancPluginErrorCode_InexistentFile
Definition: OrthancCPlugin.h:222
OrthancPluginErrorCode_ParameterOutOfRange
@ OrthancPluginErrorCode_ParameterOutOfRange
Definition: OrthancCPlugin.h:212
OrthancPluginContentType_Dicom
@ OrthancPluginContentType_Dicom
Definition: OrthancCPlugin.h:682
OrthancPluginErrorCode_UnknownResource
@ OrthancPluginErrorCode_UnknownResource
Definition: OrthancCPlugin.h:226
OrthancPluginErrorCode_DirectoryExpected
@ OrthancPluginErrorCode_DirectoryExpected
Definition: OrthancCPlugin.h:267
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:5583
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:6989
OrthancPluginErrorCode_Success
@ OrthancPluginErrorCode_Success
Definition: OrthancCPlugin.h:209
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:4020
OrthancPluginErrorCode_MakeDirectory
@ OrthancPluginErrorCode_MakeDirectory
Definition: OrthancCPlugin.h:273
OrthancPluginErrorCode_UnsupportedMediaType
@ OrthancPluginErrorCode_UnsupportedMediaType
Definition: OrthancCPlugin.h:310
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:4481
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:6785
OrthancPluginErrorCode_CannotStoreInstance
@ OrthancPluginErrorCode_CannotStoreInstance
Definition: OrthancCPlugin.h:283
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:7635
OrthancPluginCreateDicomFlags
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:842
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:5029
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:1041
OrthancPluginSendHttpStatusCode
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2633
OrthancPluginIdentifierConstraint
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:857
OrthancPluginRestApiDeleteAfterPlugins
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2321
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:1089
OrthancPluginRefreshMetricsCallback
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1581
OrthancPluginDicomWebBinaryMode_BulkDataUri
@ OrthancPluginDicomWebBinaryMode_BulkDataUri
Definition: OrthancCPlugin.h:949
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:6149
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:7863
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:4955
OrthancPluginResourceType
OrthancPluginResourceType
Definition: OrthancCPlugin.h:693
OrthancPluginCreateFindMatcher
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:6036
OrthancPluginErrorCode_NoSopClassOrInstance
@ OrthancPluginErrorCode_NoSopClassOrInstance
Definition: OrthancCPlugin.h:279
OrthancPluginJobStop
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1530
OrthancPluginValueRepresentation_AT
@ OrthancPluginValueRepresentation_AT
Definition: OrthancCPlugin.h:773
OrthancPluginReadFile
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3604
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:6456
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:1135
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:7074
OrthancPluginErrorCode_NoApplicationEntityFilter
@ OrthancPluginErrorCode_NoApplicationEntityFilter
Definition: OrthancCPlugin.h:278
OrthancPluginLookupStudyWithAccessionNumber
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2518
OrthancPluginCompressionType_ZlibWithSize
@ OrthancPluginCompressionType_ZlibWithSize
Definition: OrthancCPlugin.h:743
OrthancPluginGetCommandLineArgumentsCount
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3356
OrthancPluginErrorCode_ReadOnly
@ OrthancPluginErrorCode_ReadOnly
Definition: OrthancCPlugin.h:231
OrthancPluginErrorCode_SQLiteTransactionAlreadyStarted
@ OrthancPluginErrorCode_SQLiteTransactionAlreadyStarted
Definition: OrthancCPlugin.h:262
OrthancPluginFreeDicomInstance
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition: OrthancCPlugin.h:7758
OrthancPluginValueRepresentation_TM
@ OrthancPluginValueRepresentation_TM
Definition: OrthancCPlugin.h:792
OrthancPluginErrorCode_StorageAreaPlugin
@ OrthancPluginErrorCode_StorageAreaPlugin
Definition: OrthancCPlugin.h:241
OrthancPluginWorklistQuery
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1049
OrthancPluginHasInstancePixelData
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:7670
OrthancPluginGetInstanceDicomWebXml
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:8055
OrthancPluginGetInstanceSize
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2803
OrthancPluginEncodeDicomWebXml
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:6893
OrthancPluginImageFormat_Jpeg
@ OrthancPluginImageFormat_Jpeg
Definition: OrthancCPlugin.h:758
OrthancPluginErrorCode_BadRequest
@ OrthancPluginErrorCode_BadRequest
Definition: OrthancCPlugin.h:217
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:1168
OrthancPluginCreateMemoryBuffer
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, uint32_t size)
Create a memory buffer.
Definition: OrthancCPlugin.h:8162
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:1125
OrthancPluginRestApiGet
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2167
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:1017
OrthancPluginServerChunkedRequestReaderFinalize
void(* OrthancPluginServerChunkedRequestReaderFinalize)(OrthancPluginServerChunkedRequestReader *reader)
Callback invoked to release the resources associated with an incoming HTTP chunked transfer.
Definition: OrthancCPlugin.h:7339
OrthancPluginCompressionType_Zlib
@ OrthancPluginCompressionType_Zlib
Definition: OrthancCPlugin.h:742
OrthancPluginErrorCode_NoCStoreHandler
@ OrthancPluginErrorCode_NoCStoreHandler
Definition: OrthancCPlugin.h:277
OrthancPluginErrorCode_CreateDicomParentEncoding
@ OrthancPluginErrorCode_CreateDicomParentEncoding
Definition: OrthancCPlugin.h:291
OrthancPluginDicomToJsonFormat_Short
@ OrthancPluginDicomToJsonFormat_Short
Definition: OrthancCPlugin.h:811
OrthancPluginLogError
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:1868
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:2093
OrthancPluginValueRepresentation_SL
@ OrthancPluginValueRepresentation_SL
Definition: OrthancCPlugin.h:788
OrthancPluginErrorCode_DicomFindUnavailable
@ OrthancPluginErrorCode_DicomFindUnavailable
Definition: OrthancCPlugin.h:281
OrthancPluginErrorCode_InexistentItem
@ OrthancPluginErrorCode_InexistentItem
Definition: OrthancCPlugin.h:216
OrthancPluginGetInstanceSimplifiedJson
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:2910
OrthancPluginJobStopReason_Canceled
@ OrthancPluginJobStopReason_Canceled
Definition: OrthancCPlugin.h:921
OrthancPluginErrorCode_SslInitialization
@ OrthancPluginErrorCode_SslInitialization
Definition: OrthancCPlugin.h:248
OrthancPluginDicomToJsonFormat
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:808
OrthancPluginErrorCode_IncompatibleDatabaseVersion
@ OrthancPluginErrorCode_IncompatibleDatabaseVersion
Definition: OrthancCPlugin.h:227
OrthancPluginErrorCode_AlreadyExistingTag
@ OrthancPluginErrorCode_AlreadyExistingTag
Definition: OrthancCPlugin.h:307
OrthancPluginErrorCode_CreateDicomNotString
@ OrthancPluginErrorCode_CreateDicomNotString
Definition: OrthancCPlugin.h:284
OrthancPluginErrorCode_BadFont
@ OrthancPluginErrorCode_BadFont
Definition: OrthancCPlugin.h:239
OrthancPluginConstraintType_Equal
@ OrthancPluginConstraintType_Equal
Definition: OrthancCPlugin.h:874
OrthancPluginErrorCode_IncompatibleImageSize
@ OrthancPluginErrorCode_IncompatibleImageSize
Definition: OrthancCPlugin.h:233
OrthancPluginErrorCode_SQLiteTransactionCommit
@ OrthancPluginErrorCode_SQLiteTransactionCommit
Definition: OrthancCPlugin.h:263
OrthancPluginHttpMethod_Post
@ OrthancPluginHttpMethod_Post
Definition: OrthancCPlugin.h:320
OrthancPluginErrorCode_UnknownPluginService
@ OrthancPluginErrorCode_UnknownPluginService
Definition: OrthancCPlugin.h:235
OrthancPluginErrorCode_CorruptedFile
@ OrthancPluginErrorCode_CorruptedFile
Definition: OrthancCPlugin.h:229
OrthancPluginDicomWebBinaryMode_InlineBinary
@ OrthancPluginDicomWebBinaryMode_InlineBinary
Definition: OrthancCPlugin.h:948
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:1277
OrthancPluginChangeType_StableSeries
@ OrthancPluginChangeType_StableSeries
Definition: OrthancCPlugin.h:720
OrthancPluginGetOrthancPath
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:3070
OrthancPluginGetInstanceOrigin
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5162
OrthancPluginStorageCreate
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1187
OrthancPluginContentType
OrthancPluginContentType
Definition: OrthancCPlugin.h:679
OrthancPluginGenerateUuid
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5712
OrthancPluginValueRepresentation_LT
@ OrthancPluginValueRepresentation_LT
Definition: OrthancCPlugin.h:782
OrthancPluginFreeMemoryBuffer
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1852
OrthancPluginMetricsType_Timer
@ OrthancPluginMetricsType_Timer
Definition: OrthancCPlugin.h:937
OrthancPluginChunkedClientRequestGetChunkData
const typedef void *(* OrthancPluginChunkedClientRequestGetChunkData)(void *request)
Callback to read the current chunk of the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7107
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:7321
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:7940
OrthancPluginSetRootUri
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:3208
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:3496
OrthancPluginErrorCode_CannotOrderSlices
@ OrthancPluginErrorCode_CannotOrderSlices
Definition: OrthancCPlugin.h:305
OrthancPluginGetImageBuffer
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:3890
OrthancPluginStorageRemove
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1231
OrthancPluginErrorCode_SQLiteTransactionBegin
@ OrthancPluginErrorCode_SQLiteTransactionBegin
Definition: OrthancCPlugin.h:264
OrthancPluginErrorCode_BadJobOrdering
@ OrthancPluginErrorCode_BadJobOrdering
Definition: OrthancCPlugin.h:293
OrthancPluginHttpRequest::headersValues
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:392
OrthancPluginValueRepresentation_DS
@ OrthancPluginValueRepresentation_DS
Definition: OrthancCPlugin.h:776
OrthancPluginInstanceOrigin
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:887
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:2346
OrthancPluginErrorCode_CreateDicomOverrideTag
@ OrthancPluginErrorCode_CreateDicomOverrideTag
Definition: OrthancCPlugin.h:285
OrthancPluginTranscodeDicomInstance
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition: OrthancCPlugin.h:7902
OrthancPluginDicomWebBinaryMode_Ignore
@ OrthancPluginDicomWebBinaryMode_Ignore
Definition: OrthancCPlugin.h:947
OrthancPluginGetFontsCount
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4356
OrthancPluginRegisterIncomingDicomInstanceFilter
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instance.
Definition: OrthancCPlugin.h:7611
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:3525
OrthancPluginGetExpectedDatabaseVersion
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3422
OrthancPluginRegisterOnChangeCallback
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3177
OrthancPluginChangeType_OrthancStarted
@ OrthancPluginChangeType_OrthancStarted
Definition: OrthancCPlugin.h:722
OrthancPluginFreeJob
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6596
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:7054
OrthancPluginServerChunkedRequestReader
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition: OrthancCPlugin.h:7263
OrthancPluginIdentifierConstraint_GreaterOrEqual
@ OrthancPluginIdentifierConstraint_GreaterOrEqual
Definition: OrthancCPlugin.h:861
OrthancPluginValueRepresentation
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:769
OrthancPluginErrorCode_CannotWriteFile
@ OrthancPluginErrorCode_CannotWriteFile
Definition: OrthancCPlugin.h:223
OrthancPluginDictionaryEntry::maxMultiplicity
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1685
OrthancPluginIdentifierConstraint_Equal
@ OrthancPluginIdentifierConstraint_Equal
Definition: OrthancCPlugin.h:859
OrthancPluginErrorCode_Database
@ OrthancPluginErrorCode_Database
Definition: OrthancCPlugin.h:220
OrthancPluginErrorCode_DirectoryOverFile
@ OrthancPluginErrorCode_DirectoryOverFile
Definition: OrthancCPlugin.h:265
OrthancPluginRegisterWorklistCallback
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:4993
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:5211
OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered
@ OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered
Definition: OrthancCPlugin.h:302
OrthancPluginGetFontSize
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4428
OrthancPluginGetErrorDescription
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3666
OrthancPluginErrorCode_DatabaseUnavailable
@ OrthancPluginErrorCode_DatabaseUnavailable
Definition: OrthancCPlugin.h:245
OrthancPluginSetGlobalProperty
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3325
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:1146
OrthancPluginRegisterRestCallback
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:1936
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:1378
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:3286
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:3821
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
OrthancPluginFindAnswers
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1073
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:4651
OrthancPluginComputeMd5
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5420
OrthancPluginErrorCode_SQLiteRegisterFunction
@ OrthancPluginErrorCode_SQLiteRegisterFunction
Definition: OrthancCPlugin.h:256
OrthancPluginErrorCode_NoStorageCommitmentHandler
@ OrthancPluginErrorCode_NoStorageCommitmentHandler
Definition: OrthancCPlugin.h:308
OrthancPluginValueRepresentation_CS
@ OrthancPluginValueRepresentation_CS
Definition: OrthancCPlugin.h:774
OrthancPluginMemoryBuffer::data
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1002
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:6074
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:4065
OrthancPluginGetInstanceJson
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2872
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:4533
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:7533
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:7384
OrthancPluginErrorCode_NotImplemented
@ OrthancPluginErrorCode_NotImplemented
Definition: OrthancCPlugin.h:211
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:5997
OrthancPluginRegisterJobsUnserializer
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6673
OrthancPluginErrorCode_UnknownModality
@ OrthancPluginErrorCode_UnknownModality
Definition: OrthancCPlugin.h:292
OrthancPluginErrorCode_CreateDicomBadParent
@ OrthancPluginErrorCode_CreateDicomBadParent
Definition: OrthancCPlugin.h:289
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:4203
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:4245
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:4897
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:3230
OrthancPluginDicomWebBinaryMode
OrthancPluginDicomWebBinaryMode
Definition: OrthancCPlugin.h:945
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:275
OrthancPluginValueRepresentation_IS
@ OrthancPluginValueRepresentation_IS
Definition: OrthancCPlugin.h:780
OrthancPluginErrorCode_BadGeometry
@ OrthancPluginErrorCode_BadGeometry
Definition: OrthancCPlugin.h:247
OrthancPluginLogWarning
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:1884
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:3755
OrthancPluginStorageCommitmentFailureReason_Success
@ OrthancPluginStorageCommitmentFailureReason_Success
Definition: OrthancCPlugin.h:960
OrthancPluginErrorCode_CreateDicomParentIsInstance
@ OrthancPluginErrorCode_CreateDicomParentIsInstance
Definition: OrthancCPlugin.h:290
OrthancPluginFree
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1158
OrthancPluginRedirect
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2416
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:1547
OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
@ OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
Definition: OrthancCPlugin.h:978
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:5911
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:6541
OrthancPluginWorklistMarkIncomplete
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5059
OrthancPluginEncodeDicomWebJson
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:6851
OrthancPluginHttpRequest::method
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:337
OrthancPluginErrorCode_SQLiteCommitWithoutTransaction
@ OrthancPluginErrorCode_SQLiteCommitWithoutTransaction
Definition: OrthancCPlugin.h:255
OrthancPluginValueRepresentation_PN
@ OrthancPluginValueRepresentation_PN
Definition: OrthancCPlugin.h:786
OrthancPluginErrorCode
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:197
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:210
OrthancPluginErrorCode_UriSyntax
@ OrthancPluginErrorCode_UriSyntax
Definition: OrthancCPlugin.h:221
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:1213
OrthancPluginJobsUnserializer
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1563
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:997
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:6211
OrthancPluginWorklistAnswers
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1057
OrthancPluginRegisterFindCallback
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5751
OrthancPluginDictionaryEntry::vr
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1683
OrthancPluginImage
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1033
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:1097
OrthancPluginErrorCode_BadSequenceOfCalls
@ OrthancPluginErrorCode_BadSequenceOfCalls
Definition: OrthancCPlugin.h:215
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:1308
OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
@ OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
Definition: OrthancCPlugin.h:983
OrthancPluginHttpMethod
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:317
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:1335
OrthancPluginFreeImage
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:3975
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:1106
OrthancPluginAutodetectMimeType
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:6741
OrthancPluginErrorCode_DicomMoveUnavailable
@ OrthancPluginErrorCode_DicomMoveUnavailable
Definition: OrthancCPlugin.h:282
OrthancPluginErrorCode_DicomPortInUse
@ OrthancPluginErrorCode_DicomPortInUse
Definition: OrthancCPlugin.h:269
OrthancPluginFreeMove
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1432
OrthancPluginGetFontName
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4396
OrthancPluginSetCookie
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2709
OrthancPluginJobFinalize
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1445
OrthancPluginApplyMove
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1418
OrthancPluginErrorCode_EmptyRequest
@ OrthancPluginErrorCode_EmptyRequest
Definition: OrthancCPlugin.h:242
OrthancPluginErrorCode_CanceledJob
@ OrthancPluginErrorCode_CanceledJob
Definition: OrthancCPlugin.h:246
OrthancPluginJobStepStatus_Failure
@ OrthancPluginJobStepStatus_Failure
Definition: OrthancCPlugin.h:905
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:7835
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:6177
OrthancPluginErrorCode_NoPresentationContext
@ OrthancPluginErrorCode_NoPresentationContext
Definition: OrthancCPlugin.h:280
OrthancPluginErrorCode_NetworkProtocol
@ OrthancPluginErrorCode_NetworkProtocol
Definition: OrthancCPlugin.h:218
OrthancPluginSubmitJob
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int priority)
Submit a new job to the jobs engine of Orthanc.
Definition: OrthancCPlugin.h:6628
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:6815
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:7972
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:236
OrthancPluginInstanceOrigin_DicomProtocol
@ OrthancPluginInstanceOrigin_DicomProtocol
Definition: OrthancCPlugin.h:890
OrthancPluginResourceType_Series
@ OrthancPluginResourceType_Series
Definition: OrthancCPlugin.h:697
OrthancPluginErrorCode_IncompatibleImageFormat
@ OrthancPluginErrorCode_IncompatibleImageFormat
Definition: OrthancCPlugin.h:232
OrthancPluginChangeType_NewStudy
@ OrthancPluginChangeType_NewStudy
Definition: OrthancCPlugin.h:718
OrthancPluginErrorCode_FullStorage
@ OrthancPluginErrorCode_FullStorage
Definition: OrthancCPlugin.h:228
OrthancPluginDictionaryEntry
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1679
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:5328
OrthancPluginJobStopReason_Paused
@ OrthancPluginJobStopReason_Paused
Definition: OrthancCPlugin.h:919
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:6376
OrthancPluginLookupPatient
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2448
OrthancPluginJobStopReason_Success
@ OrthancPluginJobStopReason_Success
Definition: OrthancCPlugin.h:918
OrthancPluginErrorCode_SQLiteAlreadyOpened
@ OrthancPluginErrorCode_SQLiteAlreadyOpened
Definition: OrthancCPlugin.h:250
OrthancPluginFreeString
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1698
OrthancPluginWriteFile
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3635
OrthancPluginGetCommandLineArgument
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3390
OrthancPluginJobStepStatus_Continue
@ OrthancPluginJobStepStatus_Continue
Definition: OrthancCPlugin.h:906
OrthancPluginErrorCode_RegularFileExpected
@ OrthancPluginErrorCode_RegularFileExpected
Definition: OrthancCPlugin.h:271
OrthancPluginLookupInstance
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2588
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:7202
OrthancPluginErrorCode_SslDisabled
@ OrthancPluginErrorCode_SslDisabled
Definition: OrthancCPlugin.h:304
OrthancPluginErrorCode_CreateDicomUseDataUriScheme
@ OrthancPluginErrorCode_CreateDicomUseDataUriScheme
Definition: OrthancCPlugin.h:288
OrthancPluginChangeType
OrthancPluginChangeType
Definition: OrthancCPlugin.h:710
OrthancPluginErrorCode_CannotCreateLua
@ OrthancPluginErrorCode_CannotCreateLua
Definition: OrthancCPlugin.h:295
OrthancPluginErrorCode_BadHttpStatusInRest
@ OrthancPluginErrorCode_BadHttpStatusInRest
Definition: OrthancCPlugin.h:270
OrthancPluginErrorCode_StorageAreaAlreadyRegistered
@ OrthancPluginErrorCode_StorageAreaAlreadyRegistered
Definition: OrthancCPlugin.h:301
OrthancPluginJobStepStatus
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:902
OrthancPluginUncompressImage
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:3933
OrthancPluginRegisterRestCallbackNoLock
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:1976
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:1728
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:5097
OrthancPluginErrorCode_DatabaseNotInitialized
@ OrthancPluginErrorCode_DatabaseNotInitialized
Definition: OrthancCPlugin.h:303
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:5545
OrthancPluginDicomToJsonFlags_IncludeUnknownTags
@ OrthancPluginDicomToJsonFlags_IncludeUnknownTags
Definition: OrthancCPlugin.h:828
OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
@ OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
Definition: OrthancCPlugin.h:970
OrthancPluginMemoryBuffer::size
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1007
OrthancPluginJobStopReason
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:916
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:4760
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:6945
OrthancPluginStorageAreaRemove
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4612
OrthancPluginGetPeersCount
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6241
OrthancPluginGetFindQuerySize
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5843
OrthancPluginLogInfo
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:1900
OrthancPluginErrorCode_SQLiteRollbackWithoutTransaction
@ OrthancPluginErrorCode_SQLiteRollbackWithoutTransaction
Definition: OrthancCPlugin.h:254
OrthancPluginFindMarkIncomplete
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:5819
OrthancPluginFindQuery
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1065
OrthancPluginHttpGet
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:4165
OrthancPluginGetInstanceData
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2836
OrthancPluginGetInstanceDicomWebJson
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:8015
OrthancPluginErrorCode_BadFileFormat
@ OrthancPluginErrorCode_BadFileFormat
Definition: OrthancCPlugin.h:224
OrthancPluginErrorCode_BadJson
@ OrthancPluginErrorCode_BadJson
Definition: OrthancCPlugin.h:237
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:7123
OrthancPluginResourceType_Study
@ OrthancPluginResourceType_Study
Definition: OrthancCPlugin.h:696
OrthancPluginStorageCommitmentFailureReason
OrthancPluginStorageCommitmentFailureReason
Definition: OrthancCPlugin.h:958
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:1609
OrthancPluginErrorCode_HttpPortInUse
@ OrthancPluginErrorCode_HttpPortInUse
Definition: OrthancCPlugin.h:268
OrthancPluginErrorCode_PathToExecutable
@ OrthancPluginErrorCode_PathToExecutable
Definition: OrthancCPlugin.h:272
OrthancPluginMetricsType
OrthancPluginMetricsType
Definition: OrthancCPlugin.h:928
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:3567
OrthancPluginGetDicomForInstance
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2134
OrthancPluginWorklistGetDicomQuery
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5136
OrthancPluginErrorCode_NullPointer
@ OrthancPluginErrorCode_NullPointer
Definition: OrthancCPlugin.h:244
OrthancPluginSetHttpErrorDetails
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:6709
OrthancPluginErrorCode_SharedLibrary
@ OrthancPluginErrorCode_SharedLibrary
Definition: OrthancCPlugin.h:234
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:7033
OrthancPluginErrorCode_FileStorageCannotWrite
@ OrthancPluginErrorCode_FileStorageCannotWrite
Definition: OrthancCPlugin.h:266
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:6107
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:7091
OrthancPluginErrorCode_SQLiteNotOpened
@ OrthancPluginErrorCode_SQLiteNotOpened
Definition: OrthancCPlugin.h:249
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:2234
OrthancPluginRegisterStorageArea
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:3038
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:8100
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:7490
OrthancPluginJobStepStatus_Success
@ OrthancPluginJobStepStatus_Success
Definition: OrthancCPlugin.h:904
OrthancPluginErrorCode_BadParameterType
@ OrthancPluginErrorCode_BadParameterType
Definition: OrthancCPlugin.h:214
OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
@ OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
Definition: OrthancCPlugin.h:963
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:2197
OrthancPluginRegisterTranscoderCallback
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition: OrthancCPlugin.h:8127
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:5949
OrthancPluginImageFormat_Png
@ OrthancPluginImageFormat_Png
Definition: OrthancCPlugin.h:757
OrthancPluginPixelFormat
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:587
OrthancPluginErrorCode_LuaBadOutput
@ OrthancPluginErrorCode_LuaBadOutput
Definition: OrthancCPlugin.h:298
OrthancPluginSendUnauthorized
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2656
OrthancPluginDicomInstance
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition: OrthancCPlugin.h:1025
OrthancPluginErrorCode_DatabasePlugin
@ OrthancPluginErrorCode_DatabasePlugin
Definition: OrthancCPlugin.h:240
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:2679
OrthancPluginStorageCommitmentDestructor
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7512
OrthancPluginSetHttpHeader
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2734
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:4707
OrthancPluginErrorCode_NotLuaPredicate
@ OrthancPluginErrorCode_NotLuaPredicate
Definition: OrthancCPlugin.h:299
OrthancPluginLookupStudy
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2483
OrthancPluginDictionaryEntry::element
uint16_t element
Definition: OrthancCPlugin.h:1682
OrthancPluginErrorCode_NotAcceptable
@ OrthancPluginErrorCode_NotAcceptable
Definition: OrthancCPlugin.h:243
OrthancPluginDecodeDicomImage
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5374
OrthancPluginGetConfiguration
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3455