Orthanc Plugin SDK  1.12.3
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1 
107 #pragma once
108 
109 
110 #include <stdio.h>
111 #include <string.h>
112 
113 #ifdef WIN32
114 # define ORTHANC_PLUGINS_API __declspec(dllexport)
115 #elif __GNUC__ >= 4
116 # define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default")))
117 #else
118 # define ORTHANC_PLUGINS_API
119 #endif
120 
121 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
122 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 12
123 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 3
124 
125 
126 #if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
127 #define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
128  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
129  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
130  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
131  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
132  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
133 #endif
134 
135 
136 
137 /********************************************************************
138  ** Check that function inlining is properly supported. The use of
139  ** inlining is required, to avoid the duplication of object code
140  ** between two compilation modules that would use the Orthanc Plugin
141  ** API.
142  ********************************************************************/
143 
144 /* If the auto-detection of the "inline" keyword below does not work
145  automatically and that your compiler is known to properly support
146  inlining, uncomment the following #define and adapt the definition
147  of "static inline". */
148 
149 /* #define ORTHANC_PLUGIN_INLINE static inline */
150 
151 #ifndef ORTHANC_PLUGIN_INLINE
152 # if __STDC_VERSION__ >= 199901L
153 /* This is C99 or above: http://predef.sourceforge.net/prestd.html */
154 # define ORTHANC_PLUGIN_INLINE static inline
155 # elif defined(__cplusplus)
156 /* This is C++ */
157 # define ORTHANC_PLUGIN_INLINE static inline
158 # elif defined(__GNUC__)
159 /* This is GCC running in C89 mode */
160 # define ORTHANC_PLUGIN_INLINE static __inline
161 # elif defined(_MSC_VER)
162 /* This is Visual Studio running in C89 mode */
163 # define ORTHANC_PLUGIN_INLINE static __inline
164 # else
165 # error Your compiler is not known to support the "inline" keyword
166 # endif
167 #endif
168 
169 
170 
171 /********************************************************************
172  ** Inclusion of standard libraries.
173  ********************************************************************/
174 
180 #include <stdint.h>
181 
182 #include <stdlib.h>
183 
184 
185 
186 /********************************************************************
187  ** Definition of the Orthanc Plugin API.
188  ********************************************************************/
189 
192 #ifdef __cplusplus
193 extern "C"
194 {
195 #endif
196 
200  typedef enum
201  {
312 
313  _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
315 
316 
321  ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
322 
323 
327  typedef enum
328  {
334  _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
336 
337 
342  typedef struct
343  {
348 
352  uint32_t groupsCount;
353 
357  const char* const* groups;
358 
362  uint32_t getCount;
363 
367  const char* const* getKeys;
368 
372  const char* const* getValues;
373 
377  const void* body;
378 
382  uint32_t bodySize;
383 
384 
385  /* --------------------------------------------------
386  New in version 0.8.1
387  -------------------------------------------------- */
388 
392  uint32_t headersCount;
393 
397  const char* const* headersKeys;
398 
402  const char* const* headersValues;
403 
405 
406 
407  typedef enum
408  {
409  /* Generic services */
410  _OrthancPluginService_LogInfo = 1,
411  _OrthancPluginService_LogWarning = 2,
412  _OrthancPluginService_LogError = 3,
413  _OrthancPluginService_GetOrthancPath = 4,
414  _OrthancPluginService_GetOrthancDirectory = 5,
415  _OrthancPluginService_GetConfigurationPath = 6,
416  _OrthancPluginService_SetPluginProperty = 7,
417  _OrthancPluginService_GetGlobalProperty = 8,
418  _OrthancPluginService_SetGlobalProperty = 9,
419  _OrthancPluginService_GetCommandLineArgumentsCount = 10,
420  _OrthancPluginService_GetCommandLineArgument = 11,
421  _OrthancPluginService_GetExpectedDatabaseVersion = 12,
422  _OrthancPluginService_GetConfiguration = 13,
423  _OrthancPluginService_BufferCompression = 14,
424  _OrthancPluginService_ReadFile = 15,
425  _OrthancPluginService_WriteFile = 16,
426  _OrthancPluginService_GetErrorDescription = 17,
427  _OrthancPluginService_CallHttpClient = 18,
428  _OrthancPluginService_RegisterErrorCode = 19,
429  _OrthancPluginService_RegisterDictionaryTag = 20,
430  _OrthancPluginService_DicomBufferToJson = 21,
431  _OrthancPluginService_DicomInstanceToJson = 22,
432  _OrthancPluginService_CreateDicom = 23,
433  _OrthancPluginService_ComputeMd5 = 24,
434  _OrthancPluginService_ComputeSha1 = 25,
435  _OrthancPluginService_LookupDictionary = 26,
436  _OrthancPluginService_CallHttpClient2 = 27,
437  _OrthancPluginService_GenerateUuid = 28,
438  _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
439  _OrthancPluginService_AutodetectMimeType = 30,
440  _OrthancPluginService_SetMetricsValue = 31,
441  _OrthancPluginService_EncodeDicomWebJson = 32,
442  _OrthancPluginService_EncodeDicomWebXml = 33,
443  _OrthancPluginService_ChunkedHttpClient = 34, /* New in Orthanc 1.5.7 */
444  _OrthancPluginService_GetTagName = 35, /* New in Orthanc 1.5.7 */
445  _OrthancPluginService_EncodeDicomWebJson2 = 36, /* New in Orthanc 1.7.0 */
446  _OrthancPluginService_EncodeDicomWebXml2 = 37, /* New in Orthanc 1.7.0 */
447  _OrthancPluginService_CreateMemoryBuffer = 38, /* New in Orthanc 1.7.0 */
448  _OrthancPluginService_GenerateRestApiAuthorizationToken = 39, /* New in Orthanc 1.8.1 */
449  _OrthancPluginService_CreateMemoryBuffer64 = 40, /* New in Orthanc 1.9.0 */
450  _OrthancPluginService_CreateDicom2 = 41, /* New in Orthanc 1.9.0 */
451  _OrthancPluginService_GetDatabaseServerIdentifier = 42, /* New in Orthanc 1.11.1 */
452  _OrthancPluginService_SetMetricsIntegerValue = 43, /* New in Orthanc 1.12.1 */
453  _OrthancPluginService_SetCurrentThreadName = 44, /* New in Orthanc 1.12.2 */
454 
455 
456  /* Registration of callbacks */
457  _OrthancPluginService_RegisterRestCallback = 1000,
458  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
459  _OrthancPluginService_RegisterStorageArea = 1002,
460  _OrthancPluginService_RegisterOnChangeCallback = 1003,
461  _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
462  _OrthancPluginService_RegisterWorklistCallback = 1005,
463  _OrthancPluginService_RegisterDecodeImageCallback = 1006,
464  _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
465  _OrthancPluginService_RegisterFindCallback = 1008,
466  _OrthancPluginService_RegisterMoveCallback = 1009,
467  _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
468  _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
469  _OrthancPluginService_RegisterChunkedRestCallback = 1012, /* New in Orthanc 1.5.7 */
470  _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
471  _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
472  _OrthancPluginService_RegisterTranscoderCallback = 1015, /* New in Orthanc 1.7.0 */
473  _OrthancPluginService_RegisterStorageArea2 = 1016, /* New in Orthanc 1.9.0 */
474  _OrthancPluginService_RegisterIncomingCStoreInstanceFilter = 1017, /* New in Orthanc 1.10.0 */
475  _OrthancPluginService_RegisterReceivedInstanceCallback = 1018, /* New in Orthanc 1.10.0 */
476  _OrthancPluginService_RegisterWebDavCollection = 1019, /* New in Orthanc 1.10.1 */
477 
478  /* Sending answers to REST calls */
479  _OrthancPluginService_AnswerBuffer = 2000,
480  _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
481  _OrthancPluginService_Redirect = 2002,
482  _OrthancPluginService_SendHttpStatusCode = 2003,
483  _OrthancPluginService_SendUnauthorized = 2004,
484  _OrthancPluginService_SendMethodNotAllowed = 2005,
485  _OrthancPluginService_SetCookie = 2006,
486  _OrthancPluginService_SetHttpHeader = 2007,
487  _OrthancPluginService_StartMultipartAnswer = 2008,
488  _OrthancPluginService_SendMultipartItem = 2009,
489  _OrthancPluginService_SendHttpStatus = 2010,
490  _OrthancPluginService_CompressAndAnswerImage = 2011,
491  _OrthancPluginService_SendMultipartItem2 = 2012,
492  _OrthancPluginService_SetHttpErrorDetails = 2013,
493 
494  /* Access to the Orthanc database and API */
495  _OrthancPluginService_GetDicomForInstance = 3000,
496  _OrthancPluginService_RestApiGet = 3001,
497  _OrthancPluginService_RestApiPost = 3002,
498  _OrthancPluginService_RestApiDelete = 3003,
499  _OrthancPluginService_RestApiPut = 3004,
500  _OrthancPluginService_LookupPatient = 3005,
501  _OrthancPluginService_LookupStudy = 3006,
502  _OrthancPluginService_LookupSeries = 3007,
503  _OrthancPluginService_LookupInstance = 3008,
504  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
505  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
506  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
507  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
508  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
509  _OrthancPluginService_ReconstructMainDicomTags = 3014,
510  _OrthancPluginService_RestApiGet2 = 3015,
511  _OrthancPluginService_CallRestApi = 3016, /* New in Orthanc 1.9.2 */
512 
513  /* Access to DICOM instances */
514  _OrthancPluginService_GetInstanceRemoteAet = 4000,
515  _OrthancPluginService_GetInstanceSize = 4001,
516  _OrthancPluginService_GetInstanceData = 4002,
517  _OrthancPluginService_GetInstanceJson = 4003,
518  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
519  _OrthancPluginService_HasInstanceMetadata = 4005,
520  _OrthancPluginService_GetInstanceMetadata = 4006,
521  _OrthancPluginService_GetInstanceOrigin = 4007,
522  _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
523  _OrthancPluginService_HasInstancePixelData = 4009,
524  _OrthancPluginService_CreateDicomInstance = 4010, /* New in Orthanc 1.7.0 */
525  _OrthancPluginService_FreeDicomInstance = 4011, /* New in Orthanc 1.7.0 */
526  _OrthancPluginService_GetInstanceFramesCount = 4012, /* New in Orthanc 1.7.0 */
527  _OrthancPluginService_GetInstanceRawFrame = 4013, /* New in Orthanc 1.7.0 */
528  _OrthancPluginService_GetInstanceDecodedFrame = 4014, /* New in Orthanc 1.7.0 */
529  _OrthancPluginService_TranscodeDicomInstance = 4015, /* New in Orthanc 1.7.0 */
530  _OrthancPluginService_SerializeDicomInstance = 4016, /* New in Orthanc 1.7.0 */
531  _OrthancPluginService_GetInstanceAdvancedJson = 4017, /* New in Orthanc 1.7.0 */
532  _OrthancPluginService_GetInstanceDicomWebJson = 4018, /* New in Orthanc 1.7.0 */
533  _OrthancPluginService_GetInstanceDicomWebXml = 4019, /* New in Orthanc 1.7.0 */
534  _OrthancPluginService_LoadDicomInstance = 4020, /* New in Orthanc 1.12.1 */
535 
536  /* Services for plugins implementing a database back-end */
537  _OrthancPluginService_RegisterDatabaseBackend = 5000, /* New in Orthanc 0.8.6 */
538  _OrthancPluginService_DatabaseAnswer = 5001,
539  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002, /* New in Orthanc 0.9.4 */
540  _OrthancPluginService_StorageAreaCreate = 5003,
541  _OrthancPluginService_StorageAreaRead = 5004,
542  _OrthancPluginService_StorageAreaRemove = 5005,
543  _OrthancPluginService_RegisterDatabaseBackendV3 = 5006, /* New in Orthanc 1.9.2 */
544  _OrthancPluginService_RegisterDatabaseBackendV4 = 5007, /* New in Orthanc 1.12.0 */
545 
546  /* Primitives for handling images */
547  _OrthancPluginService_GetImagePixelFormat = 6000,
548  _OrthancPluginService_GetImageWidth = 6001,
549  _OrthancPluginService_GetImageHeight = 6002,
550  _OrthancPluginService_GetImagePitch = 6003,
551  _OrthancPluginService_GetImageBuffer = 6004,
552  _OrthancPluginService_UncompressImage = 6005,
553  _OrthancPluginService_FreeImage = 6006,
554  _OrthancPluginService_CompressImage = 6007,
555  _OrthancPluginService_ConvertPixelFormat = 6008,
556  _OrthancPluginService_GetFontsCount = 6009,
557  _OrthancPluginService_GetFontInfo = 6010,
558  _OrthancPluginService_DrawText = 6011,
559  _OrthancPluginService_CreateImage = 6012,
560  _OrthancPluginService_CreateImageAccessor = 6013,
561  _OrthancPluginService_DecodeDicomImage = 6014,
562 
563  /* Primitives for handling C-Find, C-Move and worklists */
564  _OrthancPluginService_WorklistAddAnswer = 7000,
565  _OrthancPluginService_WorklistMarkIncomplete = 7001,
566  _OrthancPluginService_WorklistIsMatch = 7002,
567  _OrthancPluginService_WorklistGetDicomQuery = 7003,
568  _OrthancPluginService_FindAddAnswer = 7004,
569  _OrthancPluginService_FindMarkIncomplete = 7005,
570  _OrthancPluginService_GetFindQuerySize = 7006,
571  _OrthancPluginService_GetFindQueryTag = 7007,
572  _OrthancPluginService_GetFindQueryTagName = 7008,
573  _OrthancPluginService_GetFindQueryValue = 7009,
574  _OrthancPluginService_CreateFindMatcher = 7010,
575  _OrthancPluginService_FreeFindMatcher = 7011,
576  _OrthancPluginService_FindMatcherIsMatch = 7012,
577 
578  /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
579  _OrthancPluginService_GetPeers = 8000,
580  _OrthancPluginService_FreePeers = 8001,
581  _OrthancPluginService_GetPeersCount = 8003,
582  _OrthancPluginService_GetPeerName = 8004,
583  _OrthancPluginService_GetPeerUrl = 8005,
584  _OrthancPluginService_CallPeerApi = 8006,
585  _OrthancPluginService_GetPeerUserProperty = 8007,
586 
587  /* Primitives for handling jobs (new in 1.4.2) */
588  _OrthancPluginService_CreateJob = 9000, /* Deprecated since SDK 1.11.3 */
589  _OrthancPluginService_FreeJob = 9001,
590  _OrthancPluginService_SubmitJob = 9002,
591  _OrthancPluginService_RegisterJobsUnserializer = 9003,
592  _OrthancPluginService_CreateJob2 = 9004, /* New in SDK 1.11.3 */
593 
594  _OrthancPluginService_INTERNAL = 0x7fffffff
595  } _OrthancPluginService;
596 
597 
598  typedef enum
599  {
600  _OrthancPluginProperty_Description = 1,
601  _OrthancPluginProperty_RootUri = 2,
602  _OrthancPluginProperty_OrthancExplorer = 3,
603 
604  _OrthancPluginProperty_INTERNAL = 0x7fffffff
605  } _OrthancPluginProperty;
606 
607 
608 
613  typedef enum
614  {
622 
630 
638 
646 
654 
664 
672 
680 
688 
696 
697  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
699 
700 
701 
705  typedef enum
706  {
712  _OrthancPluginContentType_INTERNAL = 0x7fffffff
714 
715 
716 
720  typedef enum
721  {
728  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
730 
731 
732 
737  typedef enum
738  {
759  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
761 
762 
767  typedef enum
768  {
774  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
776 
777 
782  typedef enum
783  {
788  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
790 
791 
796  typedef enum
797  {
826  _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
828 
829 
835  typedef enum
836  {
841  _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
843 
844 
850  typedef enum
851  {
862  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
864 
865 
871  typedef enum
872  {
877  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
879 
880 
886  typedef enum
887  {
893  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
895 
896 
901  typedef enum
902  {
909  _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
911 
912 
916  typedef enum
917  {
925  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
927 
928 
932  typedef enum
933  {
938 
939 
946  typedef enum
947  {
953 
954 
958  typedef enum
959  {
969 
970 
975  typedef enum
976  {
981 
982 
988  typedef enum
989  {
994 
999 
1005 
1011 
1017 
1024 
1031 
1032 
1036  typedef enum
1037  {
1042  _OrthancPluginReceivedInstanceAction_INTERNAL = 0x7fffffff
1044 
1045 
1050  typedef enum
1051  {
1056 
1062 
1069 
1070  _OrthancPluginLoadDicomInstanceMode_INTERNAL = 0x7fffffff
1072 
1073 
1081  typedef struct
1082  {
1086  void* data;
1087 
1091  uint32_t size;
1093 
1094 
1095 
1103  typedef struct
1104  {
1108  void* data;
1109 
1113  uint64_t size;
1115 
1116 
1117 
1118 
1123  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
1124 
1125 
1126 
1131  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
1132 
1133 
1134 
1139  typedef struct _OrthancPluginImage_t OrthancPluginImage;
1140 
1141 
1142 
1147  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
1148 
1149 
1150 
1155  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
1156 
1157 
1158 
1163  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
1164 
1165 
1166 
1171  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1172 
1173 
1174 
1179  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1180 
1181 
1182 
1187  typedef struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher;
1188 
1189 
1190 
1195  typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1196 
1197 
1198 
1203  typedef struct _OrthancPluginJob_t OrthancPluginJob;
1204 
1205 
1206 
1212  typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1213 
1214 
1215 
1221  OrthancPluginRestOutput* output,
1222  const char* url,
1223  const OrthancPluginHttpRequest* request);
1224 
1225 
1226 
1232  const OrthancPluginDicomInstance* instance,
1233  const char* instanceId);
1234 
1235 
1236 
1242  OrthancPluginChangeType changeType,
1243  OrthancPluginResourceType resourceType,
1244  const char* resourceId);
1245 
1246 
1247 
1253  OrthancPluginImage** target,
1254  const void* dicom,
1255  const uint32_t size,
1256  uint32_t frameIndex);
1257 
1258 
1259 
1264  typedef void (*OrthancPluginFree) (void* buffer);
1265 
1266 
1267 
1277  const char* bulkDataUri);
1278 
1279 
1280 
1294  const char* uuid,
1295  const void* content,
1296  int64_t size,
1298 
1299 
1300 
1321  void** content,
1322  int64_t* size,
1323  const char* uuid,
1325 
1326 
1327 
1342  const char* uuid,
1344 
1345 
1346 
1365  const char* uuid,
1367  uint64_t rangeStart);
1368 
1369 
1370 
1382  const char* uuid,
1384 
1385 
1386 
1402  const OrthancPluginWorklistQuery* query,
1403  const char* issuerAet,
1404  const char* calledAet);
1405 
1406 
1407 
1432  OrthancPluginHttpMethod method,
1433  const char* uri,
1434  const char* ip,
1435  uint32_t headersCount,
1436  const char* const* headersKeys,
1437  const char* const* headersValues);
1438 
1439 
1440 
1467  OrthancPluginHttpMethod method,
1468  const char* uri,
1469  const char* ip,
1470  uint32_t headersCount,
1471  const char* const* headersKeys,
1472  const char* const* headersValues,
1473  uint32_t getArgumentsCount,
1474  const char* const* getArgumentsKeys,
1475  const char* const* getArgumentsValues);
1476 
1477 
1478 
1494  OrthancPluginFindAnswers* answers,
1495  const OrthancPluginFindQuery* query,
1496  const char* issuerAet,
1497  const char* calledAet);
1498 
1499 
1500 
1536  typedef void* (*OrthancPluginMoveCallback) (
1537  OrthancPluginResourceType resourceType,
1538  const char* patientId,
1539  const char* accessionNumber,
1540  const char* studyInstanceUid,
1541  const char* seriesInstanceUid,
1542  const char* sopInstanceUid,
1543  const char* originatorAet,
1544  const char* sourceAet,
1545  const char* targetAet,
1546  uint16_t originatorId);
1547 
1548 
1561  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1562 
1563 
1576  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1577 
1578 
1590  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1591 
1592 
1603  typedef void (*OrthancPluginJobFinalize) (void* job);
1604 
1605 
1616  typedef float (*OrthancPluginJobGetProgress) (void* job);
1617 
1618 
1632  typedef const char* (*OrthancPluginJobGetContent) (void* job);
1633 
1634 
1651  void* job);
1652 
1653 
1670  typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1671 
1672 
1691  void* job);
1692 
1693 
1707 
1708 
1732 
1733 
1748 
1749 
1763  typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1764  const char* serialized);
1765 
1766 
1767 
1783 
1784 
1785 
1813  uint32_t levelDepth,
1814  const uint16_t* levelTagGroup,
1815  const uint16_t* levelTagElement,
1816  const uint32_t* levelIndex,
1817  uint16_t tagGroup,
1818  uint16_t tagElement,
1820 
1821 
1822 
1851  uint32_t levelDepth,
1852  const uint16_t* levelTagGroup,
1853  const uint16_t* levelTagElement,
1854  const uint32_t* levelIndex,
1855  uint16_t tagGroup,
1856  uint16_t tagElement,
1858  void* payload);
1859 
1860 
1861 
1865  typedef struct _OrthancPluginContext_t
1866  {
1867  void* pluginsManager;
1868  const char* orthancVersion;
1869  OrthancPluginFree Free;
1870  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1871  _OrthancPluginService service,
1872  const void* params);
1874 
1875 
1876 
1880  typedef struct
1881  {
1882  uint16_t group;
1883  uint16_t element;
1885  uint32_t minMultiplicity;
1886  uint32_t maxMultiplicity;
1888 
1889 
1890 
1899  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1900  OrthancPluginContext* context,
1901  char* str)
1902  {
1903  if (str != NULL)
1904  {
1905  context->Free(str);
1906  }
1907  }
1908 
1909 
1929  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginCheckVersionAdvanced(
1930  OrthancPluginContext* context,
1931  int32_t expectedMajor,
1932  int32_t expectedMinor,
1933  int32_t expectedRevision)
1934  {
1935  int32_t major, minor, revision;
1936 
1937  if (sizeof(int) != sizeof(int32_t) || /* Ensure binary compatibility with Orthanc SDK <= 1.12.1 */
1938  sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1939  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1940  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1941  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1942  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1943  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1944  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1945  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1946  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1947  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1948  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1949  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1950  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1951  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1952  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1953  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1954  sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1955  sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
1956  sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
1957  sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
1958  sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason) ||
1959  sizeof(int32_t) != sizeof(OrthancPluginLoadDicomInstanceMode))
1960  {
1961  /* Mismatch in the size of the enumerations */
1962  return 0;
1963  }
1964 
1965  /* Assume compatibility with the mainline */
1966  if (!strcmp(context->orthancVersion, "mainline"))
1967  {
1968  return 1;
1969  }
1970 
1971  /* Parse the version of the Orthanc core */
1972  if (
1973 #ifdef _MSC_VER
1974  sscanf_s
1975 #else
1976  sscanf
1977 #endif
1978  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1979  {
1980  return 0;
1981  }
1982 
1983  /* Check the major number of the version */
1984 
1985  if (major > expectedMajor)
1986  {
1987  return 1;
1988  }
1989 
1990  if (major < expectedMajor)
1991  {
1992  return 0;
1993  }
1994 
1995  /* Check the minor number of the version */
1996 
1997  if (minor > expectedMinor)
1998  {
1999  return 1;
2000  }
2001 
2002  if (minor < expectedMinor)
2003  {
2004  return 0;
2005  }
2006 
2007  /* Check the revision number of the version */
2008 
2009  if (revision >= expectedRevision)
2010  {
2011  return 1;
2012  }
2013  else
2014  {
2015  return 0;
2016  }
2017  }
2018 
2019 
2036  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginCheckVersion(
2037  OrthancPluginContext* context)
2038  {
2040  context,
2041  ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
2042  ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
2043  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
2044  }
2045 
2046 
2055  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
2056  OrthancPluginContext* context,
2057  OrthancPluginMemoryBuffer* buffer)
2058  {
2059  context->Free(buffer->data);
2060  }
2061 
2062 
2071  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer64(
2072  OrthancPluginContext* context,
2074  {
2075  context->Free(buffer->data);
2076  }
2077 
2078 
2087  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
2088  OrthancPluginContext* context,
2089  const char* message)
2090  {
2091  context->InvokeService(context, _OrthancPluginService_LogError, message);
2092  }
2093 
2094 
2103  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
2104  OrthancPluginContext* context,
2105  const char* message)
2106  {
2107  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
2108  }
2109 
2110 
2119  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
2120  OrthancPluginContext* context,
2121  const char* message)
2122  {
2123  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
2124  }
2125 
2126 
2127 
2128  typedef struct
2129  {
2130  const char* pathRegularExpression;
2131  OrthancPluginRestCallback callback;
2132  } _OrthancPluginRestCallback;
2133 
2155  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
2156  OrthancPluginContext* context,
2157  const char* pathRegularExpression,
2158  OrthancPluginRestCallback callback)
2159  {
2160  _OrthancPluginRestCallback params;
2161  params.pathRegularExpression = pathRegularExpression;
2162  params.callback = callback;
2163  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
2164  }
2165 
2166 
2167 
2195  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
2196  OrthancPluginContext* context,
2197  const char* pathRegularExpression,
2198  OrthancPluginRestCallback callback)
2199  {
2200  _OrthancPluginRestCallback params;
2201  params.pathRegularExpression = pathRegularExpression;
2202  params.callback = callback;
2203  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
2204  }
2205 
2206 
2207 
2208  typedef struct
2209  {
2211  } _OrthancPluginOnStoredInstanceCallback;
2212 
2234  OrthancPluginContext* context,
2236  {
2237  _OrthancPluginOnStoredInstanceCallback params;
2238  params.callback = callback;
2239 
2240  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
2241  }
2242 
2243 
2244 
2245  typedef struct
2246  {
2247  OrthancPluginRestOutput* output;
2248  const void* answer;
2249  uint32_t answerSize;
2250  const char* mimeType;
2251  } _OrthancPluginAnswerBuffer;
2252 
2265  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
2266  OrthancPluginContext* context,
2267  OrthancPluginRestOutput* output,
2268  const void* answer,
2269  uint32_t answerSize,
2270  const char* mimeType)
2271  {
2272  _OrthancPluginAnswerBuffer params;
2273  params.output = output;
2274  params.answer = answer;
2275  params.answerSize = answerSize;
2276  params.mimeType = mimeType;
2277  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
2278  }
2279 
2280 
2281  typedef struct
2282  {
2283  OrthancPluginRestOutput* output;
2284  OrthancPluginPixelFormat format;
2285  uint32_t width;
2286  uint32_t height;
2287  uint32_t pitch;
2288  const void* buffer;
2289  } _OrthancPluginCompressAndAnswerPngImage;
2290 
2291  typedef struct
2292  {
2293  OrthancPluginRestOutput* output;
2294  OrthancPluginImageFormat imageFormat;
2295  OrthancPluginPixelFormat pixelFormat;
2296  uint32_t width;
2297  uint32_t height;
2298  uint32_t pitch;
2299  const void* buffer;
2300  uint8_t quality;
2301  } _OrthancPluginCompressAndAnswerImage;
2302 
2303 
2322  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2323  OrthancPluginContext* context,
2324  OrthancPluginRestOutput* output,
2325  OrthancPluginPixelFormat format,
2326  uint32_t width,
2327  uint32_t height,
2328  uint32_t pitch,
2329  const void* buffer)
2330  {
2331  _OrthancPluginCompressAndAnswerImage params;
2332  params.output = output;
2333  params.imageFormat = OrthancPluginImageFormat_Png;
2334  params.pixelFormat = format;
2335  params.width = width;
2336  params.height = height;
2337  params.pitch = pitch;
2338  params.buffer = buffer;
2339  params.quality = 0; /* No quality for PNG */
2340  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2341  }
2342 
2343 
2344 
2345  typedef struct
2346  {
2347  OrthancPluginMemoryBuffer* target;
2348  const char* instanceId;
2349  } _OrthancPluginGetDicomForInstance;
2350 
2364  OrthancPluginContext* context,
2365  OrthancPluginMemoryBuffer* target,
2366  const char* instanceId)
2367  {
2368  _OrthancPluginGetDicomForInstance params;
2369  params.target = target;
2370  params.instanceId = instanceId;
2371  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2372  }
2373 
2374 
2375 
2376  typedef struct
2377  {
2378  OrthancPluginMemoryBuffer* target;
2379  const char* uri;
2380  } _OrthancPluginRestApiGet;
2381 
2397  OrthancPluginContext* context,
2398  OrthancPluginMemoryBuffer* target,
2399  const char* uri)
2400  {
2401  _OrthancPluginRestApiGet params;
2402  params.target = target;
2403  params.uri = uri;
2404  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2405  }
2406 
2407 
2408 
2427  OrthancPluginContext* context,
2428  OrthancPluginMemoryBuffer* target,
2429  const char* uri)
2430  {
2431  _OrthancPluginRestApiGet params;
2432  params.target = target;
2433  params.uri = uri;
2434  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2435  }
2436 
2437 
2438 
2439  typedef struct
2440  {
2441  OrthancPluginMemoryBuffer* target;
2442  const char* uri;
2443  const void* body;
2444  uint32_t bodySize;
2445  } _OrthancPluginRestApiPostPut;
2446 
2464  OrthancPluginContext* context,
2465  OrthancPluginMemoryBuffer* target,
2466  const char* uri,
2467  const void* body,
2468  uint32_t bodySize)
2469  {
2470  _OrthancPluginRestApiPostPut params;
2471  params.target = target;
2472  params.uri = uri;
2473  params.body = body;
2474  params.bodySize = bodySize;
2475  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2476  }
2477 
2478 
2499  OrthancPluginContext* context,
2500  OrthancPluginMemoryBuffer* target,
2501  const char* uri,
2502  const void* body,
2503  uint32_t bodySize)
2504  {
2505  _OrthancPluginRestApiPostPut params;
2506  params.target = target;
2507  params.uri = uri;
2508  params.body = body;
2509  params.bodySize = bodySize;
2510  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2511  }
2512 
2513 
2514 
2528  OrthancPluginContext* context,
2529  const char* uri)
2530  {
2531  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2532  }
2533 
2534 
2551  OrthancPluginContext* context,
2552  const char* uri)
2553  {
2554  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2555  }
2556 
2557 
2558 
2576  OrthancPluginContext* context,
2577  OrthancPluginMemoryBuffer* target,
2578  const char* uri,
2579  const void* body,
2580  uint32_t bodySize)
2581  {
2582  _OrthancPluginRestApiPostPut params;
2583  params.target = target;
2584  params.uri = uri;
2585  params.body = body;
2586  params.bodySize = bodySize;
2587  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2588  }
2589 
2590 
2591 
2612  OrthancPluginContext* context,
2613  OrthancPluginMemoryBuffer* target,
2614  const char* uri,
2615  const void* body,
2616  uint32_t bodySize)
2617  {
2618  _OrthancPluginRestApiPostPut params;
2619  params.target = target;
2620  params.uri = uri;
2621  params.body = body;
2622  params.bodySize = bodySize;
2623  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2624  }
2625 
2626 
2627 
2628  typedef struct
2629  {
2630  OrthancPluginRestOutput* output;
2631  const char* argument;
2632  } _OrthancPluginOutputPlusArgument;
2633 
2645  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2646  OrthancPluginContext* context,
2647  OrthancPluginRestOutput* output,
2648  const char* redirection)
2649  {
2650  _OrthancPluginOutputPlusArgument params;
2651  params.output = output;
2652  params.argument = redirection;
2653  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2654  }
2655 
2656 
2657 
2658  typedef struct
2659  {
2660  char** result;
2661  const char* argument;
2662  } _OrthancPluginRetrieveDynamicString;
2663 
2677  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2678  OrthancPluginContext* context,
2679  const char* patientID)
2680  {
2681  char* result;
2682 
2683  _OrthancPluginRetrieveDynamicString params;
2684  params.result = &result;
2685  params.argument = patientID;
2686 
2687  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2688  {
2689  /* Error */
2690  return NULL;
2691  }
2692  else
2693  {
2694  return result;
2695  }
2696  }
2697 
2698 
2712  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2713  OrthancPluginContext* context,
2714  const char* studyUID)
2715  {
2716  char* result;
2717 
2718  _OrthancPluginRetrieveDynamicString params;
2719  params.result = &result;
2720  params.argument = studyUID;
2721 
2722  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2723  {
2724  /* Error */
2725  return NULL;
2726  }
2727  else
2728  {
2729  return result;
2730  }
2731  }
2732 
2733 
2747  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
2748  OrthancPluginContext* context,
2749  const char* accessionNumber)
2750  {
2751  char* result;
2752 
2753  _OrthancPluginRetrieveDynamicString params;
2754  params.result = &result;
2755  params.argument = accessionNumber;
2756 
2757  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2758  {
2759  /* Error */
2760  return NULL;
2761  }
2762  else
2763  {
2764  return result;
2765  }
2766  }
2767 
2768 
2782  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2783  OrthancPluginContext* context,
2784  const char* seriesUID)
2785  {
2786  char* result;
2787 
2788  _OrthancPluginRetrieveDynamicString params;
2789  params.result = &result;
2790  params.argument = seriesUID;
2791 
2792  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2793  {
2794  /* Error */
2795  return NULL;
2796  }
2797  else
2798  {
2799  return result;
2800  }
2801  }
2802 
2803 
2817  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2818  OrthancPluginContext* context,
2819  const char* sopInstanceUID)
2820  {
2821  char* result;
2822 
2823  _OrthancPluginRetrieveDynamicString params;
2824  params.result = &result;
2825  params.argument = sopInstanceUID;
2826 
2827  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2828  {
2829  /* Error */
2830  return NULL;
2831  }
2832  else
2833  {
2834  return result;
2835  }
2836  }
2837 
2838 
2839 
2840  typedef struct
2841  {
2842  OrthancPluginRestOutput* output;
2843  uint16_t status;
2844  } _OrthancPluginSendHttpStatusCode;
2845 
2862  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2863  OrthancPluginContext* context,
2864  OrthancPluginRestOutput* output,
2865  uint16_t status)
2866  {
2867  _OrthancPluginSendHttpStatusCode params;
2868  params.output = output;
2869  params.status = status;
2870  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2871  }
2872 
2873 
2885  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2886  OrthancPluginContext* context,
2887  OrthancPluginRestOutput* output,
2888  const char* realm)
2889  {
2890  _OrthancPluginOutputPlusArgument params;
2891  params.output = output;
2892  params.argument = realm;
2893  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2894  }
2895 
2896 
2908  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2909  OrthancPluginContext* context,
2910  OrthancPluginRestOutput* output,
2911  const char* allowedMethods)
2912  {
2913  _OrthancPluginOutputPlusArgument params;
2914  params.output = output;
2915  params.argument = allowedMethods;
2916  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2917  }
2918 
2919 
2920  typedef struct
2921  {
2922  OrthancPluginRestOutput* output;
2923  const char* key;
2924  const char* value;
2925  } _OrthancPluginSetHttpHeader;
2926 
2938  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2939  OrthancPluginContext* context,
2940  OrthancPluginRestOutput* output,
2941  const char* cookie,
2942  const char* value)
2943  {
2944  _OrthancPluginSetHttpHeader params;
2945  params.output = output;
2946  params.key = cookie;
2947  params.value = value;
2948  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2949  }
2950 
2951 
2963  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2964  OrthancPluginContext* context,
2965  OrthancPluginRestOutput* output,
2966  const char* key,
2967  const char* value)
2968  {
2969  _OrthancPluginSetHttpHeader params;
2970  params.output = output;
2971  params.key = key;
2972  params.value = value;
2973  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2974  }
2975 
2976 
2977  typedef struct
2978  {
2979  char** resultStringToFree;
2980  const char** resultString;
2981  int64_t* resultInt64;
2982  const char* key;
2983  const OrthancPluginDicomInstance* instance;
2984  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2985  } _OrthancPluginAccessDicomInstance;
2986 
2987 
2999  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
3000  OrthancPluginContext* context,
3001  const OrthancPluginDicomInstance* instance)
3002  {
3003  const char* result;
3004 
3005  _OrthancPluginAccessDicomInstance params;
3006  memset(&params, 0, sizeof(params));
3007  params.resultString = &result;
3008  params.instance = instance;
3009 
3010  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
3011  {
3012  /* Error */
3013  return NULL;
3014  }
3015  else
3016  {
3017  return result;
3018  }
3019  }
3020 
3021 
3032  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
3033  OrthancPluginContext* context,
3034  const OrthancPluginDicomInstance* instance)
3035  {
3036  int64_t size;
3037 
3038  _OrthancPluginAccessDicomInstance params;
3039  memset(&params, 0, sizeof(params));
3040  params.resultInt64 = &size;
3041  params.instance = instance;
3042 
3043  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
3044  {
3045  /* Error */
3046  return -1;
3047  }
3048  else
3049  {
3050  return size;
3051  }
3052  }
3053 
3054 
3065  ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData(
3066  OrthancPluginContext* context,
3067  const OrthancPluginDicomInstance* instance)
3068  {
3069  const char* result;
3070 
3071  _OrthancPluginAccessDicomInstance params;
3072  memset(&params, 0, sizeof(params));
3073  params.resultString = &result;
3074  params.instance = instance;
3075 
3076  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
3077  {
3078  /* Error */
3079  return NULL;
3080  }
3081  else
3082  {
3083  return result;
3084  }
3085  }
3086 
3087 
3101  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
3102  OrthancPluginContext* context,
3103  const OrthancPluginDicomInstance* instance)
3104  {
3105  char* result;
3106 
3107  _OrthancPluginAccessDicomInstance params;
3108  memset(&params, 0, sizeof(params));
3109  params.resultStringToFree = &result;
3110  params.instance = instance;
3111 
3112  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
3113  {
3114  /* Error */
3115  return NULL;
3116  }
3117  else
3118  {
3119  return result;
3120  }
3121  }
3122 
3123 
3139  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
3140  OrthancPluginContext* context,
3141  const OrthancPluginDicomInstance* instance)
3142  {
3143  char* result;
3144 
3145  _OrthancPluginAccessDicomInstance params;
3146  memset(&params, 0, sizeof(params));
3147  params.resultStringToFree = &result;
3148  params.instance = instance;
3149 
3150  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
3151  {
3152  /* Error */
3153  return NULL;
3154  }
3155  else
3156  {
3157  return result;
3158  }
3159  }
3160 
3161 
3178  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstanceMetadata(
3179  OrthancPluginContext* context,
3180  const OrthancPluginDicomInstance* instance,
3181  const char* metadata)
3182  {
3183  int64_t result;
3184 
3185  _OrthancPluginAccessDicomInstance params;
3186  memset(&params, 0, sizeof(params));
3187  params.resultInt64 = &result;
3188  params.instance = instance;
3189  params.key = metadata;
3190 
3191  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3192  {
3193  /* Error */
3194  return -1;
3195  }
3196  else
3197  {
3198  return (result != 0);
3199  }
3200  }
3201 
3202 
3219  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
3220  OrthancPluginContext* context,
3221  const OrthancPluginDicomInstance* instance,
3222  const char* metadata)
3223  {
3224  const char* result;
3225 
3226  _OrthancPluginAccessDicomInstance params;
3227  memset(&params, 0, sizeof(params));
3228  params.resultString = &result;
3229  params.instance = instance;
3230  params.key = metadata;
3231 
3232  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3233  {
3234  /* Error */
3235  return NULL;
3236  }
3237  else
3238  {
3239  return result;
3240  }
3241  }
3242 
3243 
3244 
3245  typedef struct
3246  {
3250  OrthancPluginFree free;
3251  } _OrthancPluginRegisterStorageArea;
3252 
3268  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
3269  OrthancPluginContext* context,
3273  {
3274  _OrthancPluginRegisterStorageArea params;
3275  params.create = create;
3276  params.read = read;
3277  params.remove = remove;
3278 
3279 #ifdef __cplusplus
3280  params.free = ::free;
3281 #else
3282  params.free = free;
3283 #endif
3284 
3285  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3286  }
3287 
3288 
3289 
3300  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3301  {
3302  char* result;
3303 
3304  _OrthancPluginRetrieveDynamicString params;
3305  params.result = &result;
3306  params.argument = NULL;
3307 
3308  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3309  {
3310  /* Error */
3311  return NULL;
3312  }
3313  else
3314  {
3315  return result;
3316  }
3317  }
3318 
3319 
3330  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3331  {
3332  char* result;
3333 
3334  _OrthancPluginRetrieveDynamicString params;
3335  params.result = &result;
3336  params.argument = NULL;
3337 
3338  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3339  {
3340  /* Error */
3341  return NULL;
3342  }
3343  else
3344  {
3345  return result;
3346  }
3347  }
3348 
3349 
3365  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3366  {
3367  char* result;
3368 
3369  _OrthancPluginRetrieveDynamicString params;
3370  params.result = &result;
3371  params.argument = NULL;
3372 
3373  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3374  {
3375  /* Error */
3376  return NULL;
3377  }
3378  else
3379  {
3380  return result;
3381  }
3382  }
3383 
3384 
3385 
3386  typedef struct
3387  {
3389  } _OrthancPluginOnChangeCallback;
3390 
3411  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3412  OrthancPluginContext* context,
3414  {
3415  _OrthancPluginOnChangeCallback params;
3416  params.callback = callback;
3417 
3418  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3419  }
3420 
3421 
3422 
3423  typedef struct
3424  {
3425  const char* plugin;
3426  _OrthancPluginProperty property;
3427  const char* value;
3428  } _OrthancPluginSetPluginProperty;
3429 
3430 
3442  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3443  OrthancPluginContext* context,
3444  const char* uri)
3445  {
3446  _OrthancPluginSetPluginProperty params;
3447  params.plugin = OrthancPluginGetName();
3448  params.property = _OrthancPluginProperty_RootUri;
3449  params.value = uri;
3450 
3451  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3452  }
3453 
3454 
3464  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3465  OrthancPluginContext* context,
3466  const char* description)
3467  {
3468  _OrthancPluginSetPluginProperty params;
3469  params.plugin = OrthancPluginGetName();
3470  params.property = _OrthancPluginProperty_Description;
3471  params.value = description;
3472 
3473  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3474  }
3475 
3476 
3486  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3487  OrthancPluginContext* context,
3488  const char* javascript)
3489  {
3490  _OrthancPluginSetPluginProperty params;
3491  params.plugin = OrthancPluginGetName();
3492  params.property = _OrthancPluginProperty_OrthancExplorer;
3493  params.value = javascript;
3494 
3495  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3496  }
3497 
3498 
3499  typedef struct
3500  {
3501  char** result;
3502  int32_t property;
3503  const char* value;
3504  } _OrthancPluginGlobalProperty;
3505 
3506 
3520  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3521  OrthancPluginContext* context,
3522  int32_t property,
3523  const char* defaultValue)
3524  {
3525  char* result;
3526 
3527  _OrthancPluginGlobalProperty params;
3528  params.result = &result;
3529  params.property = property;
3530  params.value = defaultValue;
3531 
3532  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3533  {
3534  /* Error */
3535  return NULL;
3536  }
3537  else
3538  {
3539  return result;
3540  }
3541  }
3542 
3543 
3560  OrthancPluginContext* context,
3561  int32_t property,
3562  const char* value)
3563  {
3564  _OrthancPluginGlobalProperty params;
3565  params.result = NULL;
3566  params.property = property;
3567  params.value = value;
3568 
3569  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3570  }
3571 
3572 
3573 
3574  typedef struct
3575  {
3576  int32_t *resultInt32;
3577  uint32_t *resultUint32;
3578  int64_t *resultInt64;
3579  uint64_t *resultUint64;
3580  } _OrthancPluginReturnSingleValue;
3581 
3590  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3591  OrthancPluginContext* context)
3592  {
3593  uint32_t count = 0;
3594 
3595  _OrthancPluginReturnSingleValue params;
3596  memset(&params, 0, sizeof(params));
3597  params.resultUint32 = &count;
3598 
3599  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3600  {
3601  /* Error */
3602  return 0;
3603  }
3604  else
3605  {
3606  return count;
3607  }
3608  }
3609 
3610 
3611 
3624  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3625  OrthancPluginContext* context,
3626  uint32_t argument)
3627  {
3628  char* result;
3629 
3630  _OrthancPluginGlobalProperty params;
3631  params.result = &result;
3632  params.property = (int32_t) argument;
3633  params.value = NULL;
3634 
3635  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3636  {
3637  /* Error */
3638  return NULL;
3639  }
3640  else
3641  {
3642  return result;
3643  }
3644  }
3645 
3646 
3656  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3657  OrthancPluginContext* context)
3658  {
3659  uint32_t count = 0;
3660 
3661  _OrthancPluginReturnSingleValue params;
3662  memset(&params, 0, sizeof(params));
3663  params.resultUint32 = &count;
3664 
3665  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3666  {
3667  /* Error */
3668  return 0;
3669  }
3670  else
3671  {
3672  return count;
3673  }
3674  }
3675 
3676 
3677 
3689  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3690  {
3691  char* result;
3692 
3693  _OrthancPluginRetrieveDynamicString params;
3694  params.result = &result;
3695  params.argument = NULL;
3696 
3697  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3698  {
3699  /* Error */
3700  return NULL;
3701  }
3702  else
3703  {
3704  return result;
3705  }
3706  }
3707 
3708 
3709 
3710  typedef struct
3711  {
3712  OrthancPluginRestOutput* output;
3713  const char* subType;
3714  const char* contentType;
3715  } _OrthancPluginStartMultipartAnswer;
3716 
3731  OrthancPluginContext* context,
3732  OrthancPluginRestOutput* output,
3733  const char* subType,
3734  const char* contentType)
3735  {
3736  _OrthancPluginStartMultipartAnswer params;
3737  params.output = output;
3738  params.subType = subType;
3739  params.contentType = contentType;
3740  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3741  }
3742 
3743 
3760  OrthancPluginContext* context,
3761  OrthancPluginRestOutput* output,
3762  const void* answer,
3763  uint32_t answerSize)
3764  {
3765  _OrthancPluginAnswerBuffer params;
3766  params.output = output;
3767  params.answer = answer;
3768  params.answerSize = answerSize;
3769  params.mimeType = NULL;
3770  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3771  }
3772 
3773 
3774 
3775  typedef struct
3776  {
3777  OrthancPluginMemoryBuffer* target;
3778  const void* source;
3779  uint32_t size;
3780  OrthancPluginCompressionType compression;
3781  uint8_t uncompress;
3782  } _OrthancPluginBufferCompression;
3783 
3784 
3802  OrthancPluginContext* context,
3803  OrthancPluginMemoryBuffer* target,
3804  const void* source,
3805  uint32_t size,
3806  OrthancPluginCompressionType compression,
3807  uint8_t uncompress)
3808  {
3809  _OrthancPluginBufferCompression params;
3810  params.target = target;
3811  params.source = source;
3812  params.size = size;
3813  params.compression = compression;
3814  params.uncompress = uncompress;
3815 
3816  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3817  }
3818 
3819 
3820 
3821  typedef struct
3822  {
3823  OrthancPluginMemoryBuffer* target;
3824  const char* path;
3825  } _OrthancPluginReadFile;
3826 
3839  OrthancPluginContext* context,
3840  OrthancPluginMemoryBuffer* target,
3841  const char* path)
3842  {
3843  _OrthancPluginReadFile params;
3844  params.target = target;
3845  params.path = path;
3846  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3847  }
3848 
3849 
3850 
3851  typedef struct
3852  {
3853  const char* path;
3854  const void* data;
3855  uint32_t size;
3856  } _OrthancPluginWriteFile;
3857 
3870  OrthancPluginContext* context,
3871  const char* path,
3872  const void* data,
3873  uint32_t size)
3874  {
3875  _OrthancPluginWriteFile params;
3876  params.path = path;
3877  params.data = data;
3878  params.size = size;
3879  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3880  }
3881 
3882 
3883 
3884  typedef struct
3885  {
3886  const char** target;
3887  OrthancPluginErrorCode error;
3888  } _OrthancPluginGetErrorDescription;
3889 
3900  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3901  OrthancPluginContext* context,
3902  OrthancPluginErrorCode error)
3903  {
3904  const char* result = NULL;
3905 
3906  _OrthancPluginGetErrorDescription params;
3907  params.target = &result;
3908  params.error = error;
3909 
3910  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3911  result == NULL)
3912  {
3913  return "Unknown error code";
3914  }
3915  else
3916  {
3917  return result;
3918  }
3919  }
3920 
3921 
3922 
3923  typedef struct
3924  {
3925  OrthancPluginRestOutput* output;
3926  uint16_t status;
3927  const void* body;
3928  uint32_t bodySize;
3929  } _OrthancPluginSendHttpStatus;
3930 
3953  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3954  OrthancPluginContext* context,
3955  OrthancPluginRestOutput* output,
3956  uint16_t status,
3957  const void* body,
3958  uint32_t bodySize)
3959  {
3960  _OrthancPluginSendHttpStatus params;
3961  params.output = output;
3962  params.status = status;
3963  params.body = body;
3964  params.bodySize = bodySize;
3965  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3966  }
3967 
3968 
3969 
3970  typedef struct
3971  {
3972  const OrthancPluginImage* image;
3973  uint32_t* resultUint32;
3974  OrthancPluginPixelFormat* resultPixelFormat;
3975  void** resultBuffer;
3976  } _OrthancPluginGetImageInfo;
3977 
3978 
3990  OrthancPluginContext* context,
3991  const OrthancPluginImage* image)
3992  {
3993  OrthancPluginPixelFormat target;
3994 
3995  _OrthancPluginGetImageInfo params;
3996  memset(&params, 0, sizeof(params));
3997  params.image = image;
3998  params.resultPixelFormat = &target;
3999 
4000  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
4001  {
4003  }
4004  else
4005  {
4006  return (OrthancPluginPixelFormat) target;
4007  }
4008  }
4009 
4010 
4011 
4022  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
4023  OrthancPluginContext* context,
4024  const OrthancPluginImage* image)
4025  {
4026  uint32_t width;
4027 
4028  _OrthancPluginGetImageInfo params;
4029  memset(&params, 0, sizeof(params));
4030  params.image = image;
4031  params.resultUint32 = &width;
4032 
4033  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
4034  {
4035  return 0;
4036  }
4037  else
4038  {
4039  return width;
4040  }
4041  }
4042 
4043 
4044 
4055  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
4056  OrthancPluginContext* context,
4057  const OrthancPluginImage* image)
4058  {
4059  uint32_t height;
4060 
4061  _OrthancPluginGetImageInfo params;
4062  memset(&params, 0, sizeof(params));
4063  params.image = image;
4064  params.resultUint32 = &height;
4065 
4066  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
4067  {
4068  return 0;
4069  }
4070  else
4071  {
4072  return height;
4073  }
4074  }
4075 
4076 
4077 
4090  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
4091  OrthancPluginContext* context,
4092  const OrthancPluginImage* image)
4093  {
4094  uint32_t pitch;
4095 
4096  _OrthancPluginGetImageInfo params;
4097  memset(&params, 0, sizeof(params));
4098  params.image = image;
4099  params.resultUint32 = &pitch;
4100 
4101  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
4102  {
4103  return 0;
4104  }
4105  else
4106  {
4107  return pitch;
4108  }
4109  }
4110 
4111 
4112 
4124  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
4125  OrthancPluginContext* context,
4126  const OrthancPluginImage* image)
4127  {
4128  void* target = NULL;
4129 
4130  _OrthancPluginGetImageInfo params;
4131  memset(&params, 0, sizeof(params));
4132  params.resultBuffer = &target;
4133  params.image = image;
4134 
4135  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
4136  {
4137  return NULL;
4138  }
4139  else
4140  {
4141  return target;
4142  }
4143  }
4144 
4145 
4146  typedef struct
4147  {
4148  OrthancPluginImage** target;
4149  const void* data;
4150  uint32_t size;
4151  OrthancPluginImageFormat format;
4152  } _OrthancPluginUncompressImage;
4153 
4154 
4168  OrthancPluginContext* context,
4169  const void* data,
4170  uint32_t size,
4171  OrthancPluginImageFormat format)
4172  {
4173  OrthancPluginImage* target = NULL;
4174 
4175  _OrthancPluginUncompressImage params;
4176  memset(&params, 0, sizeof(params));
4177  params.target = &target;
4178  params.data = data;
4179  params.size = size;
4180  params.format = format;
4181 
4182  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
4183  {
4184  return NULL;
4185  }
4186  else
4187  {
4188  return target;
4189  }
4190  }
4191 
4192 
4193 
4194 
4195  typedef struct
4196  {
4197  OrthancPluginImage* image;
4198  } _OrthancPluginFreeImage;
4199 
4209  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
4210  OrthancPluginContext* context,
4211  OrthancPluginImage* image)
4212  {
4213  _OrthancPluginFreeImage params;
4214  params.image = image;
4215 
4216  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
4217  }
4218 
4219 
4220 
4221 
4222  typedef struct
4223  {
4224  OrthancPluginMemoryBuffer* target;
4225  OrthancPluginImageFormat imageFormat;
4226  OrthancPluginPixelFormat pixelFormat;
4227  uint32_t width;
4228  uint32_t height;
4229  uint32_t pitch;
4230  const void* buffer;
4231  uint8_t quality;
4232  } _OrthancPluginCompressImage;
4233 
4234 
4255  OrthancPluginContext* context,
4256  OrthancPluginMemoryBuffer* target,
4257  OrthancPluginPixelFormat format,
4258  uint32_t width,
4259  uint32_t height,
4260  uint32_t pitch,
4261  const void* buffer)
4262  {
4263  _OrthancPluginCompressImage params;
4264  memset(&params, 0, sizeof(params));
4265  params.target = target;
4266  params.imageFormat = OrthancPluginImageFormat_Png;
4267  params.pixelFormat = format;
4268  params.width = width;
4269  params.height = height;
4270  params.pitch = pitch;
4271  params.buffer = buffer;
4272  params.quality = 0; /* Unused for PNG */
4273 
4274  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4275  }
4276 
4277 
4300  OrthancPluginContext* context,
4301  OrthancPluginMemoryBuffer* target,
4302  OrthancPluginPixelFormat format,
4303  uint32_t width,
4304  uint32_t height,
4305  uint32_t pitch,
4306  const void* buffer,
4307  uint8_t quality)
4308  {
4309  _OrthancPluginCompressImage params;
4310  memset(&params, 0, sizeof(params));
4311  params.target = target;
4312  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4313  params.pixelFormat = format;
4314  params.width = width;
4315  params.height = height;
4316  params.pitch = pitch;
4317  params.buffer = buffer;
4318  params.quality = quality;
4319 
4320  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4321  }
4322 
4323 
4324 
4346  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
4347  OrthancPluginContext* context,
4348  OrthancPluginRestOutput* output,
4349  OrthancPluginPixelFormat format,
4350  uint32_t width,
4351  uint32_t height,
4352  uint32_t pitch,
4353  const void* buffer,
4354  uint8_t quality)
4355  {
4356  _OrthancPluginCompressAndAnswerImage params;
4357  params.output = output;
4358  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4359  params.pixelFormat = format;
4360  params.width = width;
4361  params.height = height;
4362  params.pitch = pitch;
4363  params.buffer = buffer;
4364  params.quality = quality;
4365  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4366  }
4367 
4368 
4369 
4370 
4371  typedef struct
4372  {
4373  OrthancPluginMemoryBuffer* target;
4374  OrthancPluginHttpMethod method;
4375  const char* url;
4376  const char* username;
4377  const char* password;
4378  const void* body;
4379  uint32_t bodySize;
4380  } _OrthancPluginCallHttpClient;
4381 
4382 
4400  OrthancPluginContext* context,
4401  OrthancPluginMemoryBuffer* target,
4402  const char* url,
4403  const char* username,
4404  const char* password)
4405  {
4406  _OrthancPluginCallHttpClient params;
4407  memset(&params, 0, sizeof(params));
4408 
4409  params.target = target;
4410  params.method = OrthancPluginHttpMethod_Get;
4411  params.url = url;
4412  params.username = username;
4413  params.password = password;
4414 
4415  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4416  }
4417 
4418 
4438  OrthancPluginContext* context,
4439  OrthancPluginMemoryBuffer* target,
4440  const char* url,
4441  const void* body,
4442  uint32_t bodySize,
4443  const char* username,
4444  const char* password)
4445  {
4446  _OrthancPluginCallHttpClient params;
4447  memset(&params, 0, sizeof(params));
4448 
4449  params.target = target;
4450  params.method = OrthancPluginHttpMethod_Post;
4451  params.url = url;
4452  params.body = body;
4453  params.bodySize = bodySize;
4454  params.username = username;
4455  params.password = password;
4456 
4457  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4458  }
4459 
4460 
4480  OrthancPluginContext* context,
4481  OrthancPluginMemoryBuffer* target,
4482  const char* url,
4483  const void* body,
4484  uint32_t bodySize,
4485  const char* username,
4486  const char* password)
4487  {
4488  _OrthancPluginCallHttpClient params;
4489  memset(&params, 0, sizeof(params));
4490 
4491  params.target = target;
4492  params.method = OrthancPluginHttpMethod_Put;
4493  params.url = url;
4494  params.body = body;
4495  params.bodySize = bodySize;
4496  params.username = username;
4497  params.password = password;
4498 
4499  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4500  }
4501 
4502 
4518  OrthancPluginContext* context,
4519  const char* url,
4520  const char* username,
4521  const char* password)
4522  {
4523  _OrthancPluginCallHttpClient params;
4524  memset(&params, 0, sizeof(params));
4525 
4526  params.method = OrthancPluginHttpMethod_Delete;
4527  params.url = url;
4528  params.username = username;
4529  params.password = password;
4530 
4531  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4532  }
4533 
4534 
4535 
4536  typedef struct
4537  {
4538  OrthancPluginImage** target;
4539  const OrthancPluginImage* source;
4540  OrthancPluginPixelFormat targetFormat;
4541  } _OrthancPluginConvertPixelFormat;
4542 
4543 
4556  OrthancPluginContext* context,
4557  const OrthancPluginImage* source,
4558  OrthancPluginPixelFormat targetFormat)
4559  {
4560  OrthancPluginImage* target = NULL;
4561 
4562  _OrthancPluginConvertPixelFormat params;
4563  params.target = &target;
4564  params.source = source;
4565  params.targetFormat = targetFormat;
4566 
4567  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4568  {
4569  return NULL;
4570  }
4571  else
4572  {
4573  return target;
4574  }
4575  }
4576 
4577 
4578 
4590  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4591  OrthancPluginContext* context)
4592  {
4593  uint32_t count = 0;
4594 
4595  _OrthancPluginReturnSingleValue params;
4596  memset(&params, 0, sizeof(params));
4597  params.resultUint32 = &count;
4598 
4599  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4600  {
4601  /* Error */
4602  return 0;
4603  }
4604  else
4605  {
4606  return count;
4607  }
4608  }
4609 
4610 
4611 
4612 
4613  typedef struct
4614  {
4615  uint32_t fontIndex; /* in */
4616  const char** name; /* out */
4617  uint32_t* size; /* out */
4618  } _OrthancPluginGetFontInfo;
4619 
4630  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4631  OrthancPluginContext* context,
4632  uint32_t fontIndex)
4633  {
4634  const char* result = NULL;
4635 
4636  _OrthancPluginGetFontInfo params;
4637  memset(&params, 0, sizeof(params));
4638  params.name = &result;
4639  params.fontIndex = fontIndex;
4640 
4641  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4642  {
4643  return NULL;
4644  }
4645  else
4646  {
4647  return result;
4648  }
4649  }
4650 
4651 
4662  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4663  OrthancPluginContext* context,
4664  uint32_t fontIndex)
4665  {
4666  uint32_t result;
4667 
4668  _OrthancPluginGetFontInfo params;
4669  memset(&params, 0, sizeof(params));
4670  params.size = &result;
4671  params.fontIndex = fontIndex;
4672 
4673  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4674  {
4675  return 0;
4676  }
4677  else
4678  {
4679  return result;
4680  }
4681  }
4682 
4683 
4684 
4685  typedef struct
4686  {
4687  OrthancPluginImage* image;
4688  uint32_t fontIndex;
4689  const char* utf8Text;
4690  int32_t x;
4691  int32_t y;
4692  uint8_t r;
4693  uint8_t g;
4694  uint8_t b;
4695  } _OrthancPluginDrawText;
4696 
4697 
4716  OrthancPluginContext* context,
4717  OrthancPluginImage* image,
4718  uint32_t fontIndex,
4719  const char* utf8Text,
4720  int32_t x,
4721  int32_t y,
4722  uint8_t r,
4723  uint8_t g,
4724  uint8_t b)
4725  {
4726  _OrthancPluginDrawText params;
4727  memset(&params, 0, sizeof(params));
4728  params.image = image;
4729  params.fontIndex = fontIndex;
4730  params.utf8Text = utf8Text;
4731  params.x = x;
4732  params.y = y;
4733  params.r = r;
4734  params.g = g;
4735  params.b = b;
4736 
4737  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4738  }
4739 
4740 
4741 
4742  typedef struct
4743  {
4744  OrthancPluginStorageArea* storageArea;
4745  const char* uuid;
4746  const void* content;
4747  uint64_t size;
4749  } _OrthancPluginStorageAreaCreate;
4750 
4751 
4770  OrthancPluginContext* context,
4771  OrthancPluginStorageArea* storageArea,
4772  const char* uuid,
4773  const void* content,
4774  uint64_t size,
4776  {
4777  _OrthancPluginStorageAreaCreate params;
4778  params.storageArea = storageArea;
4779  params.uuid = uuid;
4780  params.content = content;
4781  params.size = size;
4782  params.type = type;
4783 
4784  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4785  }
4786 
4787 
4788  typedef struct
4789  {
4790  OrthancPluginMemoryBuffer* target;
4791  OrthancPluginStorageArea* storageArea;
4792  const char* uuid;
4794  } _OrthancPluginStorageAreaRead;
4795 
4796 
4814  OrthancPluginContext* context,
4815  OrthancPluginMemoryBuffer* target,
4816  OrthancPluginStorageArea* storageArea,
4817  const char* uuid,
4819  {
4820  _OrthancPluginStorageAreaRead params;
4821  params.target = target;
4822  params.storageArea = storageArea;
4823  params.uuid = uuid;
4824  params.type = type;
4825 
4826  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4827  }
4828 
4829 
4830  typedef struct
4831  {
4832  OrthancPluginStorageArea* storageArea;
4833  const char* uuid;
4835  } _OrthancPluginStorageAreaRemove;
4836 
4853  OrthancPluginContext* context,
4854  OrthancPluginStorageArea* storageArea,
4855  const char* uuid,
4857  {
4858  _OrthancPluginStorageAreaRemove params;
4859  params.storageArea = storageArea;
4860  params.uuid = uuid;
4861  params.type = type;
4862 
4863  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4864  }
4865 
4866 
4867 
4868  typedef struct
4869  {
4870  OrthancPluginErrorCode* target;
4871  int32_t code;
4872  uint16_t httpStatus;
4873  const char* message;
4874  } _OrthancPluginRegisterErrorCode;
4875 
4892  OrthancPluginContext* context,
4893  int32_t code,
4894  uint16_t httpStatus,
4895  const char* message)
4896  {
4897  OrthancPluginErrorCode target;
4898 
4899  _OrthancPluginRegisterErrorCode params;
4900  params.target = &target;
4901  params.code = code;
4902  params.httpStatus = httpStatus;
4903  params.message = message;
4904 
4905  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4906  {
4907  return target;
4908  }
4909  else
4910  {
4911  /* There was an error while assigned the error. Use a generic code. */
4913  }
4914  }
4915 
4916 
4917 
4918  typedef struct
4919  {
4920  uint16_t group;
4921  uint16_t element;
4923  const char* name;
4924  uint32_t minMultiplicity;
4925  uint32_t maxMultiplicity;
4926  } _OrthancPluginRegisterDictionaryTag;
4927 
4948  OrthancPluginContext* context,
4949  uint16_t group,
4950  uint16_t element,
4952  const char* name,
4953  uint32_t minMultiplicity,
4954  uint32_t maxMultiplicity)
4955  {
4956  _OrthancPluginRegisterDictionaryTag params;
4957  params.group = group;
4958  params.element = element;
4959  params.vr = vr;
4960  params.name = name;
4961  params.minMultiplicity = minMultiplicity;
4962  params.maxMultiplicity = maxMultiplicity;
4963 
4964  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4965  }
4966 
4967 
4968 
4969  typedef struct
4970  {
4971  uint16_t group;
4972  uint16_t element;
4974  const char* name;
4975  uint32_t minMultiplicity;
4976  uint32_t maxMultiplicity;
4977  const char* privateCreator;
4978  } _OrthancPluginRegisterPrivateDictionaryTag;
4979 
5001  OrthancPluginContext* context,
5002  uint16_t group,
5003  uint16_t element,
5005  const char* name,
5006  uint32_t minMultiplicity,
5007  uint32_t maxMultiplicity,
5008  const char* privateCreator)
5009  {
5010  _OrthancPluginRegisterPrivateDictionaryTag params;
5011  params.group = group;
5012  params.element = element;
5013  params.vr = vr;
5014  params.name = name;
5015  params.minMultiplicity = minMultiplicity;
5016  params.maxMultiplicity = maxMultiplicity;
5017  params.privateCreator = privateCreator;
5018 
5019  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
5020  }
5021 
5022 
5023 
5024  typedef struct
5025  {
5026  OrthancPluginStorageArea* storageArea;
5028  } _OrthancPluginReconstructMainDicomTags;
5029 
5045  OrthancPluginContext* context,
5046  OrthancPluginStorageArea* storageArea,
5048  {
5049  _OrthancPluginReconstructMainDicomTags params;
5050  params.level = level;
5051  params.storageArea = storageArea;
5052 
5053  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
5054  }
5055 
5056 
5057  typedef struct
5058  {
5059  char** result;
5060  const char* instanceId;
5061  const void* buffer;
5062  uint32_t size;
5065  uint32_t maxStringLength;
5066  } _OrthancPluginDicomToJson;
5067 
5068 
5088  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
5089  OrthancPluginContext* context,
5090  const void* buffer,
5091  uint32_t size,
5094  uint32_t maxStringLength)
5095  {
5096  char* result;
5097 
5098  _OrthancPluginDicomToJson params;
5099  memset(&params, 0, sizeof(params));
5100  params.result = &result;
5101  params.buffer = buffer;
5102  params.size = size;
5103  params.format = format;
5104  params.flags = flags;
5105  params.maxStringLength = maxStringLength;
5106 
5107  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
5108  {
5109  /* Error */
5110  return NULL;
5111  }
5112  else
5113  {
5114  return result;
5115  }
5116  }
5117 
5118 
5137  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
5138  OrthancPluginContext* context,
5139  const char* instanceId,
5142  uint32_t maxStringLength)
5143  {
5144  char* result;
5145 
5146  _OrthancPluginDicomToJson params;
5147  memset(&params, 0, sizeof(params));
5148  params.result = &result;
5149  params.instanceId = instanceId;
5150  params.format = format;
5151  params.flags = flags;
5152  params.maxStringLength = maxStringLength;
5153 
5154  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
5155  {
5156  /* Error */
5157  return NULL;
5158  }
5159  else
5160  {
5161  return result;
5162  }
5163  }
5164 
5165 
5166  typedef struct
5167  {
5168  OrthancPluginMemoryBuffer* target;
5169  const char* uri;
5170  uint32_t headersCount;
5171  const char* const* headersKeys;
5172  const char* const* headersValues;
5173  int32_t afterPlugins;
5174  } _OrthancPluginRestApiGet2;
5175 
5196  OrthancPluginContext* context,
5197  OrthancPluginMemoryBuffer* target,
5198  const char* uri,
5199  uint32_t headersCount,
5200  const char* const* headersKeys,
5201  const char* const* headersValues,
5202  int32_t afterPlugins)
5203  {
5204  _OrthancPluginRestApiGet2 params;
5205  params.target = target;
5206  params.uri = uri;
5207  params.headersCount = headersCount;
5208  params.headersKeys = headersKeys;
5209  params.headersValues = headersValues;
5210  params.afterPlugins = afterPlugins;
5211 
5212  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
5213  }
5214 
5215 
5216 
5217  typedef struct
5218  {
5220  } _OrthancPluginWorklistCallback;
5221 
5234  OrthancPluginContext* context,
5236  {
5237  _OrthancPluginWorklistCallback params;
5238  params.callback = callback;
5239 
5240  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
5241  }
5242 
5243 
5244 
5245  typedef struct
5246  {
5248  const OrthancPluginWorklistQuery* query;
5249  const void* dicom;
5250  uint32_t size;
5251  } _OrthancPluginWorklistAnswersOperation;
5252 
5270  OrthancPluginContext* context,
5272  const OrthancPluginWorklistQuery* query,
5273  const void* dicom,
5274  uint32_t size)
5275  {
5276  _OrthancPluginWorklistAnswersOperation params;
5277  params.answers = answers;
5278  params.query = query;
5279  params.dicom = dicom;
5280  params.size = size;
5281 
5282  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
5283  }
5284 
5285 
5300  OrthancPluginContext* context,
5302  {
5303  _OrthancPluginWorklistAnswersOperation params;
5304  params.answers = answers;
5305  params.query = NULL;
5306  params.dicom = NULL;
5307  params.size = 0;
5308 
5309  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5310  }
5311 
5312 
5313  typedef struct
5314  {
5315  const OrthancPluginWorklistQuery* query;
5316  const void* dicom;
5317  uint32_t size;
5318  int32_t* isMatch;
5319  OrthancPluginMemoryBuffer* target;
5320  } _OrthancPluginWorklistQueryOperation;
5321 
5337  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5338  OrthancPluginContext* context,
5339  const OrthancPluginWorklistQuery* query,
5340  const void* dicom,
5341  uint32_t size)
5342  {
5343  int32_t isMatch = 0;
5344 
5345  _OrthancPluginWorklistQueryOperation params;
5346  params.query = query;
5347  params.dicom = dicom;
5348  params.size = size;
5349  params.isMatch = &isMatch;
5350  params.target = NULL;
5351 
5352  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5353  {
5354  return isMatch;
5355  }
5356  else
5357  {
5358  /* Error: Assume non-match */
5359  return 0;
5360  }
5361  }
5362 
5363 
5377  OrthancPluginContext* context,
5378  OrthancPluginMemoryBuffer* target,
5379  const OrthancPluginWorklistQuery* query)
5380  {
5381  _OrthancPluginWorklistQueryOperation params;
5382  params.query = query;
5383  params.dicom = NULL;
5384  params.size = 0;
5385  params.isMatch = NULL;
5386  params.target = target;
5387 
5388  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5389  }
5390 
5391 
5403  OrthancPluginContext* context,
5404  const OrthancPluginDicomInstance* instance)
5405  {
5407 
5408  _OrthancPluginAccessDicomInstance params;
5409  memset(&params, 0, sizeof(params));
5410  params.resultOrigin = &origin;
5411  params.instance = instance;
5412 
5413  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5414  {
5415  /* Error */
5417  }
5418  else
5419  {
5420  return origin;
5421  }
5422  }
5423 
5424 
5425  typedef struct
5426  {
5427  OrthancPluginMemoryBuffer* target;
5428  const char* json;
5429  const OrthancPluginImage* pixelData;
5431  } _OrthancPluginCreateDicom;
5432 
5459  OrthancPluginContext* context,
5460  OrthancPluginMemoryBuffer* target,
5461  const char* json,
5462  const OrthancPluginImage* pixelData,
5464  {
5465  _OrthancPluginCreateDicom params;
5466  params.target = target;
5467  params.json = json;
5468  params.pixelData = pixelData;
5469  params.flags = flags;
5470 
5471  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5472  }
5473 
5474 
5475  typedef struct
5476  {
5478  } _OrthancPluginDecodeImageCallback;
5479 
5495  OrthancPluginContext* context,
5497  {
5498  _OrthancPluginDecodeImageCallback params;
5499  params.callback = callback;
5500 
5501  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5502  }
5503 
5504 
5505 
5506  typedef struct
5507  {
5508  OrthancPluginImage** target;
5509  OrthancPluginPixelFormat format;
5510  uint32_t width;
5511  uint32_t height;
5512  uint32_t pitch;
5513  void* buffer;
5514  const void* constBuffer;
5515  uint32_t bufferSize;
5516  uint32_t frameIndex;
5517  } _OrthancPluginCreateImage;
5518 
5519 
5533  OrthancPluginContext* context,
5534  OrthancPluginPixelFormat format,
5535  uint32_t width,
5536  uint32_t height)
5537  {
5538  OrthancPluginImage* target = NULL;
5539 
5540  _OrthancPluginCreateImage params;
5541  memset(&params, 0, sizeof(params));
5542  params.target = &target;
5543  params.format = format;
5544  params.width = width;
5545  params.height = height;
5546 
5547  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5548  {
5549  return NULL;
5550  }
5551  else
5552  {
5553  return target;
5554  }
5555  }
5556 
5557 
5576  OrthancPluginContext* context,
5577  OrthancPluginPixelFormat format,
5578  uint32_t width,
5579  uint32_t height,
5580  uint32_t pitch,
5581  void* buffer)
5582  {
5583  OrthancPluginImage* target = NULL;
5584 
5585  _OrthancPluginCreateImage params;
5586  memset(&params, 0, sizeof(params));
5587  params.target = &target;
5588  params.format = format;
5589  params.width = width;
5590  params.height = height;
5591  params.pitch = pitch;
5592  params.buffer = buffer;
5593 
5594  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5595  {
5596  return NULL;
5597  }
5598  else
5599  {
5600  return target;
5601  }
5602  }
5603 
5604 
5605 
5622  OrthancPluginContext* context,
5623  const void* buffer,
5624  uint32_t bufferSize,
5625  uint32_t frameIndex)
5626  {
5627  OrthancPluginImage* target = NULL;
5628 
5629  _OrthancPluginCreateImage params;
5630  memset(&params, 0, sizeof(params));
5631  params.target = &target;
5632  params.constBuffer = buffer;
5633  params.bufferSize = bufferSize;
5634  params.frameIndex = frameIndex;
5635 
5636  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5637  {
5638  return NULL;
5639  }
5640  else
5641  {
5642  return target;
5643  }
5644  }
5645 
5646 
5647 
5648  typedef struct
5649  {
5650  char** result;
5651  const void* buffer;
5652  uint32_t size;
5653  } _OrthancPluginComputeHash;
5654 
5667  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5668  OrthancPluginContext* context,
5669  const void* buffer,
5670  uint32_t size)
5671  {
5672  char* result;
5673 
5674  _OrthancPluginComputeHash params;
5675  params.result = &result;
5676  params.buffer = buffer;
5677  params.size = size;
5678 
5679  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5680  {
5681  /* Error */
5682  return NULL;
5683  }
5684  else
5685  {
5686  return result;
5687  }
5688  }
5689 
5690 
5703  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5704  OrthancPluginContext* context,
5705  const void* buffer,
5706  uint32_t size)
5707  {
5708  char* result;
5709 
5710  _OrthancPluginComputeHash params;
5711  params.result = &result;
5712  params.buffer = buffer;
5713  params.size = size;
5714 
5715  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5716  {
5717  /* Error */
5718  return NULL;
5719  }
5720  else
5721  {
5722  return result;
5723  }
5724  }
5725 
5726 
5727 
5728  typedef struct
5729  {
5731  const char* name;
5732  } _OrthancPluginLookupDictionary;
5733 
5750  OrthancPluginContext* context,
5752  const char* name)
5753  {
5754  _OrthancPluginLookupDictionary params;
5755  params.target = target;
5756  params.name = name;
5757  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5758  }
5759 
5760 
5761 
5762  typedef struct
5763  {
5764  OrthancPluginRestOutput* output;
5765  const void* answer;
5766  uint32_t answerSize;
5767  uint32_t headersCount;
5768  const char* const* headersKeys;
5769  const char* const* headersValues;
5770  } _OrthancPluginSendMultipartItem2;
5771 
5793  OrthancPluginContext* context,
5794  OrthancPluginRestOutput* output,
5795  const void* answer,
5796  uint32_t answerSize,
5797  uint32_t headersCount,
5798  const char* const* headersKeys,
5799  const char* const* headersValues)
5800  {
5801  _OrthancPluginSendMultipartItem2 params;
5802  params.output = output;
5803  params.answer = answer;
5804  params.answerSize = answerSize;
5805  params.headersCount = headersCount;
5806  params.headersKeys = headersKeys;
5807  params.headersValues = headersValues;
5808 
5809  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5810  }
5811 
5812 
5813  typedef struct
5814  {
5816  } _OrthancPluginIncomingHttpRequestFilter;
5817 
5831  OrthancPluginContext* context,
5833  {
5834  _OrthancPluginIncomingHttpRequestFilter params;
5835  params.callback = callback;
5836 
5837  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5838  }
5839 
5840 
5841 
5842  typedef struct
5843  {
5844  OrthancPluginMemoryBuffer* answerBody;
5845  OrthancPluginMemoryBuffer* answerHeaders;
5846  uint16_t* httpStatus;
5847  OrthancPluginHttpMethod method;
5848  const char* url;
5849  uint32_t headersCount;
5850  const char* const* headersKeys;
5851  const char* const* headersValues;
5852  const void* body;
5853  uint32_t bodySize;
5854  const char* username;
5855  const char* password;
5856  uint32_t timeout;
5857  const char* certificateFile;
5858  const char* certificateKeyFile;
5859  const char* certificateKeyPassword;
5860  uint8_t pkcs11;
5861  } _OrthancPluginCallHttpClient2;
5862 
5863 
5864 
5906  OrthancPluginContext* context,
5907  OrthancPluginMemoryBuffer* answerBody,
5908  OrthancPluginMemoryBuffer* answerHeaders,
5909  uint16_t* httpStatus,
5910  OrthancPluginHttpMethod method,
5911  const char* url,
5912  uint32_t headersCount,
5913  const char* const* headersKeys,
5914  const char* const* headersValues,
5915  const void* body,
5916  uint32_t bodySize,
5917  const char* username,
5918  const char* password,
5919  uint32_t timeout,
5920  const char* certificateFile,
5921  const char* certificateKeyFile,
5922  const char* certificateKeyPassword,
5923  uint8_t pkcs11)
5924  {
5925  _OrthancPluginCallHttpClient2 params;
5926  memset(&params, 0, sizeof(params));
5927 
5928  params.answerBody = answerBody;
5929  params.answerHeaders = answerHeaders;
5930  params.httpStatus = httpStatus;
5931  params.method = method;
5932  params.url = url;
5933  params.headersCount = headersCount;
5934  params.headersKeys = headersKeys;
5935  params.headersValues = headersValues;
5936  params.body = body;
5937  params.bodySize = bodySize;
5938  params.username = username;
5939  params.password = password;
5940  params.timeout = timeout;
5941  params.certificateFile = certificateFile;
5942  params.certificateKeyFile = certificateKeyFile;
5943  params.certificateKeyPassword = certificateKeyPassword;
5944  params.pkcs11 = pkcs11;
5945 
5946  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5947  }
5948 
5949 
5960  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5961  OrthancPluginContext* context)
5962  {
5963  char* result;
5964 
5965  _OrthancPluginRetrieveDynamicString params;
5966  params.result = &result;
5967  params.argument = NULL;
5968 
5969  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5970  {
5971  /* Error */
5972  return NULL;
5973  }
5974  else
5975  {
5976  return result;
5977  }
5978  }
5979 
5980 
5981 
5982 
5983  typedef struct
5984  {
5985  OrthancPluginFindCallback callback;
5986  } _OrthancPluginFindCallback;
5987 
6000  OrthancPluginContext* context,
6001  OrthancPluginFindCallback callback)
6002  {
6003  _OrthancPluginFindCallback params;
6004  params.callback = callback;
6005 
6006  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
6007  }
6008 
6009 
6010  typedef struct
6011  {
6012  OrthancPluginFindAnswers *answers;
6013  const OrthancPluginFindQuery *query;
6014  const void *dicom;
6015  uint32_t size;
6016  uint32_t index;
6017  uint32_t *resultUint32;
6018  uint16_t *resultGroup;
6019  uint16_t *resultElement;
6020  char **resultString;
6021  } _OrthancPluginFindOperation;
6022 
6039  OrthancPluginContext* context,
6040  OrthancPluginFindAnswers* answers,
6041  const void* dicom,
6042  uint32_t size)
6043  {
6044  _OrthancPluginFindOperation params;
6045  memset(&params, 0, sizeof(params));
6046  params.answers = answers;
6047  params.dicom = dicom;
6048  params.size = size;
6049 
6050  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
6051  }
6052 
6053 
6068  OrthancPluginContext* context,
6069  OrthancPluginFindAnswers* answers)
6070  {
6071  _OrthancPluginFindOperation params;
6072  memset(&params, 0, sizeof(params));
6073  params.answers = answers;
6074 
6075  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
6076  }
6077 
6078 
6079 
6091  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
6092  OrthancPluginContext* context,
6093  const OrthancPluginFindQuery* query)
6094  {
6095  uint32_t count = 0;
6096 
6097  _OrthancPluginFindOperation params;
6098  memset(&params, 0, sizeof(params));
6099  params.query = query;
6100  params.resultUint32 = &count;
6101 
6102  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
6103  {
6104  /* Error */
6105  return 0;
6106  }
6107  else
6108  {
6109  return count;
6110  }
6111  }
6112 
6113 
6129  OrthancPluginContext* context,
6130  uint16_t* group,
6131  uint16_t* element,
6132  const OrthancPluginFindQuery* query,
6133  uint32_t index)
6134  {
6135  _OrthancPluginFindOperation params;
6136  memset(&params, 0, sizeof(params));
6137  params.query = query;
6138  params.index = index;
6139  params.resultGroup = group;
6140  params.resultElement = element;
6141 
6142  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
6143  }
6144 
6145 
6159  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
6160  OrthancPluginContext* context,
6161  const OrthancPluginFindQuery* query,
6162  uint32_t index)
6163  {
6164  char* result;
6165 
6166  _OrthancPluginFindOperation params;
6167  memset(&params, 0, sizeof(params));
6168  params.query = query;
6169  params.index = index;
6170  params.resultString = &result;
6171 
6172  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
6173  {
6174  /* Error */
6175  return NULL;
6176  }
6177  else
6178  {
6179  return result;
6180  }
6181  }
6182 
6183 
6197  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
6198  OrthancPluginContext* context,
6199  const OrthancPluginFindQuery* query,
6200  uint32_t index)
6201  {
6202  char* result;
6203 
6204  _OrthancPluginFindOperation params;
6205  memset(&params, 0, sizeof(params));
6206  params.query = query;
6207  params.index = index;
6208  params.resultString = &result;
6209 
6210  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
6211  {
6212  /* Error */
6213  return NULL;
6214  }
6215  else
6216  {
6217  return result;
6218  }
6219  }
6220 
6221 
6222 
6223 
6224  typedef struct
6225  {
6226  OrthancPluginMoveCallback callback;
6227  OrthancPluginGetMoveSize getMoveSize;
6228  OrthancPluginApplyMove applyMove;
6229  OrthancPluginFreeMove freeMove;
6230  } _OrthancPluginMoveCallback;
6231 
6246  OrthancPluginContext* context,
6247  OrthancPluginMoveCallback callback,
6248  OrthancPluginGetMoveSize getMoveSize,
6249  OrthancPluginApplyMove applyMove,
6250  OrthancPluginFreeMove freeMove)
6251  {
6252  _OrthancPluginMoveCallback params;
6253  params.callback = callback;
6254  params.getMoveSize = getMoveSize;
6255  params.applyMove = applyMove;
6256  params.freeMove = freeMove;
6257 
6258  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
6259  }
6260 
6261 
6262 
6263  typedef struct
6264  {
6265  OrthancPluginFindMatcher** target;
6266  const void* query;
6267  uint32_t size;
6268  } _OrthancPluginCreateFindMatcher;
6269 
6270 
6285  OrthancPluginContext* context,
6286  const void* query,
6287  uint32_t size)
6288  {
6289  OrthancPluginFindMatcher* target = NULL;
6290 
6291  _OrthancPluginCreateFindMatcher params;
6292  memset(&params, 0, sizeof(params));
6293  params.target = &target;
6294  params.query = query;
6295  params.size = size;
6296 
6297  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
6298  {
6299  return NULL;
6300  }
6301  else
6302  {
6303  return target;
6304  }
6305  }
6306 
6307 
6308  typedef struct
6309  {
6310  OrthancPluginFindMatcher* matcher;
6311  } _OrthancPluginFreeFindMatcher;
6312 
6322  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6323  OrthancPluginContext* context,
6324  OrthancPluginFindMatcher* matcher)
6325  {
6326  _OrthancPluginFreeFindMatcher params;
6327  params.matcher = matcher;
6328 
6329  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6330  }
6331 
6332 
6333  typedef struct
6334  {
6335  const OrthancPluginFindMatcher* matcher;
6336  const void* dicom;
6337  uint32_t size;
6338  int32_t* isMatch;
6339  } _OrthancPluginFindMatcherIsMatch;
6340 
6355  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6356  OrthancPluginContext* context,
6357  const OrthancPluginFindMatcher* matcher,
6358  const void* dicom,
6359  uint32_t size)
6360  {
6361  int32_t isMatch = 0;
6362 
6363  _OrthancPluginFindMatcherIsMatch params;
6364  params.matcher = matcher;
6365  params.dicom = dicom;
6366  params.size = size;
6367  params.isMatch = &isMatch;
6368 
6369  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6370  {
6371  return isMatch;
6372  }
6373  else
6374  {
6375  /* Error: Assume non-match */
6376  return 0;
6377  }
6378  }
6379 
6380 
6381  typedef struct
6382  {
6384  } _OrthancPluginIncomingHttpRequestFilter2;
6385 
6398  OrthancPluginContext* context,
6400  {
6401  _OrthancPluginIncomingHttpRequestFilter2 params;
6402  params.callback = callback;
6403 
6404  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6405  }
6406 
6407 
6408 
6409  typedef struct
6410  {
6411  OrthancPluginPeers** peers;
6412  } _OrthancPluginGetPeers;
6413 
6426  OrthancPluginContext* context)
6427  {
6428  OrthancPluginPeers* peers = NULL;
6429 
6430  _OrthancPluginGetPeers params;
6431  memset(&params, 0, sizeof(params));
6432  params.peers = &peers;
6433 
6434  if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6435  {
6436  return NULL;
6437  }
6438  else
6439  {
6440  return peers;
6441  }
6442  }
6443 
6444 
6445  typedef struct
6446  {
6447  OrthancPluginPeers* peers;
6448  } _OrthancPluginFreePeers;
6449 
6459  ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6460  OrthancPluginContext* context,
6461  OrthancPluginPeers* peers)
6462  {
6463  _OrthancPluginFreePeers params;
6464  params.peers = peers;
6465 
6466  context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6467  }
6468 
6469 
6470  typedef struct
6471  {
6472  uint32_t* target;
6473  const OrthancPluginPeers* peers;
6474  } _OrthancPluginGetPeersCount;
6475 
6489  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6490  OrthancPluginContext* context,
6491  const OrthancPluginPeers* peers)
6492  {
6493  uint32_t target = 0;
6494 
6495  _OrthancPluginGetPeersCount params;
6496  memset(&params, 0, sizeof(params));
6497  params.target = &target;
6498  params.peers = peers;
6499 
6500  if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6501  {
6502  /* Error */
6503  return 0;
6504  }
6505  else
6506  {
6507  return target;
6508  }
6509  }
6510 
6511 
6512  typedef struct
6513  {
6514  const char** target;
6515  const OrthancPluginPeers* peers;
6516  uint32_t peerIndex;
6517  const char* userProperty;
6518  } _OrthancPluginGetPeerProperty;
6519 
6537  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6538  OrthancPluginContext* context,
6539  const OrthancPluginPeers* peers,
6540  uint32_t peerIndex)
6541  {
6542  const char* target = NULL;
6543 
6544  _OrthancPluginGetPeerProperty params;
6545  memset(&params, 0, sizeof(params));
6546  params.target = &target;
6547  params.peers = peers;
6548  params.peerIndex = peerIndex;
6549  params.userProperty = NULL;
6550 
6551  if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6552  {
6553  /* Error */
6554  return NULL;
6555  }
6556  else
6557  {
6558  return target;
6559  }
6560  }
6561 
6562 
6578  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6579  OrthancPluginContext* context,
6580  const OrthancPluginPeers* peers,
6581  uint32_t peerIndex)
6582  {
6583  const char* target = NULL;
6584 
6585  _OrthancPluginGetPeerProperty params;
6586  memset(&params, 0, sizeof(params));
6587  params.target = &target;
6588  params.peers = peers;
6589  params.peerIndex = peerIndex;
6590  params.userProperty = NULL;
6591 
6592  if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6593  {
6594  /* Error */
6595  return NULL;
6596  }
6597  else
6598  {
6599  return target;
6600  }
6601  }
6602 
6603 
6604 
6624  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6625  OrthancPluginContext* context,
6626  const OrthancPluginPeers* peers,
6627  uint32_t peerIndex,
6628  const char* userProperty)
6629  {
6630  const char* target = NULL;
6631 
6632  _OrthancPluginGetPeerProperty params;
6633  memset(&params, 0, sizeof(params));
6634  params.target = &target;
6635  params.peers = peers;
6636  params.peerIndex = peerIndex;
6637  params.userProperty = userProperty;
6638 
6639  if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6640  {
6641  /* No such user property */
6642  return NULL;
6643  }
6644  else
6645  {
6646  return target;
6647  }
6648  }
6649 
6650 
6651 
6652  typedef struct
6653  {
6654  OrthancPluginMemoryBuffer* answerBody;
6655  OrthancPluginMemoryBuffer* answerHeaders;
6656  uint16_t* httpStatus;
6657  const OrthancPluginPeers* peers;
6658  uint32_t peerIndex;
6659  OrthancPluginHttpMethod method;
6660  const char* uri;
6661  uint32_t additionalHeadersCount;
6662  const char* const* additionalHeadersKeys;
6663  const char* const* additionalHeadersValues;
6664  const void* body;
6665  uint32_t bodySize;
6666  uint32_t timeout;
6667  } _OrthancPluginCallPeerApi;
6668 
6706  OrthancPluginContext* context,
6707  OrthancPluginMemoryBuffer* answerBody,
6708  OrthancPluginMemoryBuffer* answerHeaders,
6709  uint16_t* httpStatus,
6710  const OrthancPluginPeers* peers,
6711  uint32_t peerIndex,
6712  OrthancPluginHttpMethod method,
6713  const char* uri,
6714  uint32_t additionalHeadersCount,
6715  const char* const* additionalHeadersKeys,
6716  const char* const* additionalHeadersValues,
6717  const void* body,
6718  uint32_t bodySize,
6719  uint32_t timeout)
6720  {
6721  _OrthancPluginCallPeerApi params;
6722  memset(&params, 0, sizeof(params));
6723 
6724  params.answerBody = answerBody;
6725  params.answerHeaders = answerHeaders;
6726  params.httpStatus = httpStatus;
6727  params.peers = peers;
6728  params.peerIndex = peerIndex;
6729  params.method = method;
6730  params.uri = uri;
6731  params.additionalHeadersCount = additionalHeadersCount;
6732  params.additionalHeadersKeys = additionalHeadersKeys;
6733  params.additionalHeadersValues = additionalHeadersValues;
6734  params.body = body;
6735  params.bodySize = bodySize;
6736  params.timeout = timeout;
6737 
6738  return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6739  }
6740 
6741 
6742 
6743 
6744 
6745  typedef struct
6746  {
6747  OrthancPluginJob** target;
6748  void *job;
6749  OrthancPluginJobFinalize finalize;
6750  const char *type;
6751  OrthancPluginJobGetProgress getProgress;
6752  OrthancPluginJobGetContent getContent;
6753  OrthancPluginJobGetSerialized getSerialized;
6754  OrthancPluginJobStep step;
6755  OrthancPluginJobStop stop;
6756  OrthancPluginJobReset reset;
6757  } _OrthancPluginCreateJob;
6758 
6792  OrthancPluginContext *context,
6793  void *job,
6794  OrthancPluginJobFinalize finalize,
6795  const char *type,
6796  OrthancPluginJobGetProgress getProgress,
6797  OrthancPluginJobGetContent getContent,
6798  OrthancPluginJobGetSerialized getSerialized,
6799  OrthancPluginJobStep step,
6800  OrthancPluginJobStop stop,
6801  OrthancPluginJobReset reset)
6802  {
6803  OrthancPluginJob* target = NULL;
6804 
6805  _OrthancPluginCreateJob params;
6806  memset(&params, 0, sizeof(params));
6807 
6808  params.target = &target;
6809  params.job = job;
6810  params.finalize = finalize;
6811  params.type = type;
6812  params.getProgress = getProgress;
6813  params.getContent = getContent;
6814  params.getSerialized = getSerialized;
6815  params.step = step;
6816  params.stop = stop;
6817  params.reset = reset;
6818 
6819  if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6820  target == NULL)
6821  {
6822  /* Error */
6823  return NULL;
6824  }
6825  else
6826  {
6827  return target;
6828  }
6829  }
6830 
6831 
6832  typedef struct
6833  {
6834  OrthancPluginJob** target;
6835  void *job;
6836  OrthancPluginJobFinalize finalize;
6837  const char *type;
6838  OrthancPluginJobGetProgress getProgress;
6839  OrthancPluginJobGetContent2 getContent;
6840  OrthancPluginJobGetSerialized2 getSerialized;
6841  OrthancPluginJobStep step;
6842  OrthancPluginJobStop stop;
6843  OrthancPluginJobReset reset;
6844  } _OrthancPluginCreateJob2;
6845 
6878  OrthancPluginContext *context,
6879  void *job,
6880  OrthancPluginJobFinalize finalize,
6881  const char *type,
6882  OrthancPluginJobGetProgress getProgress,
6883  OrthancPluginJobGetContent2 getContent,
6884  OrthancPluginJobGetSerialized2 getSerialized,
6885  OrthancPluginJobStep step,
6886  OrthancPluginJobStop stop,
6887  OrthancPluginJobReset reset)
6888  {
6889  OrthancPluginJob* target = NULL;
6890 
6891  _OrthancPluginCreateJob2 params;
6892  memset(&params, 0, sizeof(params));
6893 
6894  params.target = &target;
6895  params.job = job;
6896  params.finalize = finalize;
6897  params.type = type;
6898  params.getProgress = getProgress;
6899  params.getContent = getContent;
6900  params.getSerialized = getSerialized;
6901  params.step = step;
6902  params.stop = stop;
6903  params.reset = reset;
6904 
6905  if (context->InvokeService(context, _OrthancPluginService_CreateJob2, &params) != OrthancPluginErrorCode_Success ||
6906  target == NULL)
6907  {
6908  /* Error */
6909  return NULL;
6910  }
6911  else
6912  {
6913  return target;
6914  }
6915  }
6916 
6917 
6918  typedef struct
6919  {
6920  OrthancPluginJob* job;
6921  } _OrthancPluginFreeJob;
6922 
6932  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6933  OrthancPluginContext* context,
6934  OrthancPluginJob* job)
6935  {
6936  _OrthancPluginFreeJob params;
6937  params.job = job;
6938 
6939  context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6940  }
6941 
6942 
6943 
6944  typedef struct
6945  {
6946  char** resultId;
6947  OrthancPluginJob *job;
6948  int32_t priority;
6949  } _OrthancPluginSubmitJob;
6950 
6964  ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6965  OrthancPluginContext *context,
6966  OrthancPluginJob *job,
6967  int32_t priority)
6968  {
6969  char* resultId = NULL;
6970 
6971  _OrthancPluginSubmitJob params;
6972  memset(&params, 0, sizeof(params));
6973 
6974  params.resultId = &resultId;
6975  params.job = job;
6976  params.priority = priority;
6977 
6978  if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6979  resultId == NULL)
6980  {
6981  /* Error */
6982  return NULL;
6983  }
6984  else
6985  {
6986  return resultId;
6987  }
6988  }
6989 
6990 
6991 
6992  typedef struct
6993  {
6994  OrthancPluginJobsUnserializer unserializer;
6995  } _OrthancPluginJobsUnserializer;
6996 
7009  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
7010  OrthancPluginContext* context,
7011  OrthancPluginJobsUnserializer unserializer)
7012  {
7013  _OrthancPluginJobsUnserializer params;
7014  params.unserializer = unserializer;
7015 
7016  context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
7017  }
7018 
7019 
7020 
7021  typedef struct
7022  {
7023  OrthancPluginRestOutput* output;
7024  const char* details;
7025  uint8_t log;
7026  } _OrthancPluginSetHttpErrorDetails;
7027 
7045  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
7046  OrthancPluginContext* context,
7047  OrthancPluginRestOutput* output,
7048  const char* details,
7049  uint8_t log)
7050  {
7051  _OrthancPluginSetHttpErrorDetails params;
7052  params.output = output;
7053  params.details = details;
7054  params.log = log;
7055  context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
7056  }
7057 
7058 
7059 
7060  typedef struct
7061  {
7062  const char** result;
7063  const char* argument;
7064  } _OrthancPluginRetrieveStaticString;
7065 
7077  ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
7078  OrthancPluginContext* context,
7079  const char* path)
7080  {
7081  const char* result = NULL;
7082 
7083  _OrthancPluginRetrieveStaticString params;
7084  params.result = &result;
7085  params.argument = path;
7086 
7087  if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
7088  {
7089  /* Error */
7090  return NULL;
7091  }
7092  else
7093  {
7094  return result;
7095  }
7096  }
7097 
7098 
7099 
7100  typedef struct
7101  {
7102  const char* name;
7103  float value;
7105  } _OrthancPluginSetMetricsValue;
7106 
7123  ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
7124  OrthancPluginContext* context,
7125  const char* name,
7126  float value,
7128  {
7129  _OrthancPluginSetMetricsValue params;
7130  params.name = name;
7131  params.value = value;
7132  params.type = type;
7133  context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
7134  }
7135 
7136 
7137 
7138  typedef struct
7139  {
7141  } _OrthancPluginRegisterRefreshMetricsCallback;
7142 
7155  OrthancPluginContext* context,
7157  {
7158  _OrthancPluginRegisterRefreshMetricsCallback params;
7159  params.callback = callback;
7160  context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
7161  }
7162 
7163 
7164 
7165 
7166  typedef struct
7167  {
7168  char** target;
7169  const void* dicom;
7170  uint32_t dicomSize;
7172  } _OrthancPluginEncodeDicomWeb;
7173 
7190  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
7191  OrthancPluginContext* context,
7192  const void* dicom,
7193  uint32_t dicomSize,
7195  {
7196  char* target = NULL;
7197 
7198  _OrthancPluginEncodeDicomWeb params;
7199  params.target = &target;
7200  params.dicom = dicom;
7201  params.dicomSize = dicomSize;
7202  params.callback = callback;
7203 
7204  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
7205  {
7206  /* Error */
7207  return NULL;
7208  }
7209  else
7210  {
7211  return target;
7212  }
7213  }
7214 
7215 
7232  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
7233  OrthancPluginContext* context,
7234  const void* dicom,
7235  uint32_t dicomSize,
7237  {
7238  char* target = NULL;
7239 
7240  _OrthancPluginEncodeDicomWeb params;
7241  params.target = &target;
7242  params.dicom = dicom;
7243  params.dicomSize = dicomSize;
7244  params.callback = callback;
7245 
7246  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
7247  {
7248  /* Error */
7249  return NULL;
7250  }
7251  else
7252  {
7253  return target;
7254  }
7255  }
7256 
7257 
7258 
7259  typedef struct
7260  {
7261  char** target;
7262  const void* dicom;
7263  uint32_t dicomSize;
7265  void* payload;
7266  } _OrthancPluginEncodeDicomWeb2;
7267 
7284  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson2(
7285  OrthancPluginContext* context,
7286  const void* dicom,
7287  uint32_t dicomSize,
7289  void* payload)
7290  {
7291  char* target = NULL;
7292 
7293  _OrthancPluginEncodeDicomWeb2 params;
7294  params.target = &target;
7295  params.dicom = dicom;
7296  params.dicomSize = dicomSize;
7297  params.callback = callback;
7298  params.payload = payload;
7299 
7300  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson2, &params) != OrthancPluginErrorCode_Success)
7301  {
7302  /* Error */
7303  return NULL;
7304  }
7305  else
7306  {
7307  return target;
7308  }
7309  }
7310 
7311 
7328  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml2(
7329  OrthancPluginContext* context,
7330  const void* dicom,
7331  uint32_t dicomSize,
7333  void* payload)
7334  {
7335  char* target = NULL;
7336 
7337  _OrthancPluginEncodeDicomWeb2 params;
7338  params.target = &target;
7339  params.dicom = dicom;
7340  params.dicomSize = dicomSize;
7341  params.callback = callback;
7342  params.payload = payload;
7343 
7344  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml2, &params) != OrthancPluginErrorCode_Success)
7345  {
7346  /* Error */
7347  return NULL;
7348  }
7349  else
7350  {
7351  return target;
7352  }
7353  }
7354 
7355 
7356 
7373  void* answer,
7374  const char* key,
7375  const char* value);
7376 
7377 
7394  void* answer,
7395  const void* data,
7396  uint32_t size);
7397 
7398 
7413  typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
7414 
7415 
7431 
7432 
7446  typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
7447 
7448 
7462  typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
7463 
7464 
7465  typedef struct
7466  {
7467  void* answer;
7470  uint16_t* httpStatus;
7471  OrthancPluginHttpMethod method;
7472  const char* url;
7473  uint32_t headersCount;
7474  const char* const* headersKeys;
7475  const char* const* headersValues;
7476  void* request;
7481  const char* username;
7482  const char* password;
7483  uint32_t timeout;
7484  const char* certificateFile;
7485  const char* certificateKeyFile;
7486  const char* certificateKeyPassword;
7487  uint8_t pkcs11;
7488  } _OrthancPluginChunkedHttpClient;
7489 
7490 
7542  OrthancPluginContext* context,
7543  void* answer,
7546  uint16_t* httpStatus,
7547  OrthancPluginHttpMethod method,
7548  const char* url,
7549  uint32_t headersCount,
7550  const char* const* headersKeys,
7551  const char* const* headersValues,
7552  void* request,
7557  const char* username,
7558  const char* password,
7559  uint32_t timeout,
7560  const char* certificateFile,
7561  const char* certificateKeyFile,
7562  const char* certificateKeyPassword,
7563  uint8_t pkcs11)
7564  {
7565  _OrthancPluginChunkedHttpClient params;
7566  memset(&params, 0, sizeof(params));
7567 
7568  /* In common with OrthancPluginHttpClient() */
7569  params.httpStatus = httpStatus;
7570  params.method = method;
7571  params.url = url;
7572  params.headersCount = headersCount;
7573  params.headersKeys = headersKeys;
7574  params.headersValues = headersValues;
7575  params.username = username;
7576  params.password = password;
7577  params.timeout = timeout;
7578  params.certificateFile = certificateFile;
7579  params.certificateKeyFile = certificateKeyFile;
7580  params.certificateKeyPassword = certificateKeyPassword;
7581  params.pkcs11 = pkcs11;
7582 
7583  /* For chunked body/answer */
7584  params.answer = answer;
7585  params.answerAddChunk = answerAddChunk;
7586  params.answerAddHeader = answerAddHeader;
7587  params.request = request;
7588  params.requestIsDone = requestIsDone;
7589  params.requestChunkData = requestChunkData;
7590  params.requestChunkSize = requestChunkSize;
7591  params.requestNext = requestNext;
7592 
7593  return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7594  }
7595 
7596 
7597 
7602  typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7603 
7604 
7605 
7623  const char* url,
7624  const OrthancPluginHttpRequest* request);
7625 
7626 
7642  const void* data,
7643  uint32_t size);
7644 
7645 
7662  OrthancPluginRestOutput* output);
7663 
7664 
7680 
7681  typedef struct
7682  {
7683  const char* pathRegularExpression;
7684  OrthancPluginRestCallback getHandler;
7686  OrthancPluginRestCallback deleteHandler;
7691  } _OrthancPluginChunkedRestCallback;
7692 
7693 
7723  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterChunkedRestCallback(
7724  OrthancPluginContext* context,
7725  const char* pathRegularExpression,
7726  OrthancPluginRestCallback getHandler,
7728  OrthancPluginRestCallback deleteHandler,
7733  {
7734  _OrthancPluginChunkedRestCallback params;
7735  params.pathRegularExpression = pathRegularExpression;
7736  params.getHandler = getHandler;
7737  params.postHandler = postHandler;
7738  params.deleteHandler = deleteHandler;
7739  params.putHandler = putHandler;
7740  params.addChunk = addChunk;
7741  params.execute = execute;
7742  params.finalize = finalize;
7743 
7744  context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
7745  }
7746 
7747 
7748 
7749 
7750 
7751  typedef struct
7752  {
7753  char** result;
7754  uint16_t group;
7755  uint16_t element;
7756  const char* privateCreator;
7757  } _OrthancPluginGetTagName;
7758 
7774  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
7775  OrthancPluginContext* context,
7776  uint16_t group,
7777  uint16_t element,
7778  const char* privateCreator)
7779  {
7780  char* result;
7781 
7782  _OrthancPluginGetTagName params;
7783  params.result = &result;
7784  params.group = group;
7785  params.element = element;
7786  params.privateCreator = privateCreator;
7787 
7788  if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
7789  {
7790  /* Error */
7791  return NULL;
7792  }
7793  else
7794  {
7795  return result;
7796  }
7797  }
7798 
7799 
7800 
7830  void** handler /* out */,
7831  const char* jobId,
7832  const char* transactionUid,
7833  const char* const* sopClassUids,
7834  const char* const* sopInstanceUids,
7835  uint32_t countInstances,
7836  const char* remoteAet,
7837  const char* calledAet);
7838 
7839 
7851  typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
7852 
7853 
7874  void* handler,
7875  const char* sopClassUid,
7876  const char* sopInstanceUid);
7877 
7878 
7879  typedef struct
7880  {
7884  } _OrthancPluginRegisterStorageCommitmentScpCallback;
7885 
7900  OrthancPluginContext* context,
7904  {
7905  _OrthancPluginRegisterStorageCommitmentScpCallback params;
7906  params.factory = factory;
7907  params.destructor = destructor;
7908  params.lookup = lookup;
7909  return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
7910  }
7911 
7912 
7913 
7940  const OrthancPluginDicomInstance* instance);
7941 
7942 
7943  typedef struct
7944  {
7946  } _OrthancPluginIncomingDicomInstanceFilter;
7947 
7961  OrthancPluginContext* context,
7963  {
7964  _OrthancPluginIncomingDicomInstanceFilter params;
7965  params.callback = callback;
7966 
7967  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, &params);
7968  }
7969 
7970 
8002  uint16_t* dimseStatus /* out */,
8003  const OrthancPluginDicomInstance* instance);
8004 
8005 
8006  typedef struct
8007  {
8009  } _OrthancPluginIncomingCStoreInstanceFilter;
8010 
8024  OrthancPluginContext* context,
8026  {
8027  _OrthancPluginIncomingCStoreInstanceFilter params;
8028  params.callback = callback;
8029 
8030  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingCStoreInstanceFilter, &params);
8031  }
8032 
8069  OrthancPluginMemoryBuffer64* modifiedDicomBuffer,
8070  const void* receivedDicomBuffer,
8071  uint64_t receivedDicomBufferSize,
8073 
8074 
8075  typedef struct
8076  {
8078  } _OrthancPluginReceivedInstanceCallback;
8079 
8101  OrthancPluginContext* context,
8103  {
8104  _OrthancPluginReceivedInstanceCallback params;
8105  params.callback = callback;
8106 
8107  return context->InvokeService(context, _OrthancPluginService_RegisterReceivedInstanceCallback, &params);
8108  }
8109 
8123  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceTransferSyntaxUid(
8124  OrthancPluginContext* context,
8125  const OrthancPluginDicomInstance* instance)
8126  {
8127  char* result;
8128 
8129  _OrthancPluginAccessDicomInstance params;
8130  memset(&params, 0, sizeof(params));
8131  params.resultStringToFree = &result;
8132  params.instance = instance;
8133 
8134  if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, &params) != OrthancPluginErrorCode_Success)
8135  {
8136  /* Error */
8137  return NULL;
8138  }
8139  else
8140  {
8141  return result;
8142  }
8143  }
8144 
8145 
8158  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData(
8159  OrthancPluginContext* context,
8160  const OrthancPluginDicomInstance* instance)
8161  {
8162  int64_t hasPixelData;
8163 
8164  _OrthancPluginAccessDicomInstance params;
8165  memset(&params, 0, sizeof(params));
8166  params.resultInt64 = &hasPixelData;
8167  params.instance = instance;
8168 
8169  if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, &params) != OrthancPluginErrorCode_Success ||
8170  hasPixelData < 0 ||
8171  hasPixelData > 1)
8172  {
8173  /* Error */
8174  return -1;
8175  }
8176  else
8177  {
8178  return (hasPixelData != 0);
8179  }
8180  }
8181 
8182 
8183 
8184 
8185 
8186 
8187  typedef struct
8188  {
8189  OrthancPluginDicomInstance** target;
8190  const void* buffer;
8191  uint32_t size;
8192  const char* transferSyntax;
8193  } _OrthancPluginCreateDicomInstance;
8194 
8209  OrthancPluginContext* context,
8210  const void* buffer,
8211  uint32_t size)
8212  {
8213  OrthancPluginDicomInstance* target = NULL;
8214 
8215  _OrthancPluginCreateDicomInstance params;
8216  params.target = &target;
8217  params.buffer = buffer;
8218  params.size = size;
8219 
8220  if (context->InvokeService(context, _OrthancPluginService_CreateDicomInstance, &params) != OrthancPluginErrorCode_Success)
8221  {
8222  /* Error */
8223  return NULL;
8224  }
8225  else
8226  {
8227  return target;
8228  }
8229  }
8230 
8231  typedef struct
8232  {
8234  } _OrthancPluginFreeDicomInstance;
8235 
8246  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeDicomInstance(
8247  OrthancPluginContext* context,
8249  {
8250  _OrthancPluginFreeDicomInstance params;
8251  params.dicom = dicom;
8252 
8253  context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, &params);
8254  }
8255 
8256 
8257  typedef struct
8258  {
8259  uint32_t* targetUint32;
8260  OrthancPluginMemoryBuffer* targetBuffer;
8261  OrthancPluginImage** targetImage;
8262  char** targetStringToFree;
8263  const OrthancPluginDicomInstance* instance;
8264  uint32_t frameIndex;
8267  uint32_t maxStringLength;
8268  OrthancPluginDicomWebBinaryCallback2 dicomWebCallback;
8269  void* dicomWebPayload;
8270  } _OrthancPluginAccessDicomInstance2;
8271 
8283  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetInstanceFramesCount(
8284  OrthancPluginContext* context,
8285  const OrthancPluginDicomInstance* instance)
8286  {
8287  uint32_t count;
8288 
8289  _OrthancPluginAccessDicomInstance2 params;
8290  memset(&params, 0, sizeof(params));
8291  params.targetUint32 = &count;
8292  params.instance = instance;
8293 
8294  if (context->InvokeService(context, _OrthancPluginService_GetInstanceFramesCount, &params) != OrthancPluginErrorCode_Success)
8295  {
8296  /* Error */
8297  return 0;
8298  }
8299  else
8300  {
8301  return count;
8302  }
8303  }
8304 
8305 
8324  OrthancPluginContext* context,
8325  OrthancPluginMemoryBuffer* target,
8326  const OrthancPluginDicomInstance* instance,
8327  uint32_t frameIndex)
8328  {
8329  _OrthancPluginAccessDicomInstance2 params;
8330  memset(&params, 0, sizeof(params));
8331  params.targetBuffer = target;
8332  params.instance = instance;
8333  params.frameIndex = frameIndex;
8334 
8335  return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, &params);
8336  }
8337 
8338 
8352  OrthancPluginContext* context,
8353  const OrthancPluginDicomInstance* instance,
8354  uint32_t frameIndex)
8355  {
8356  OrthancPluginImage* target = NULL;
8357 
8358  _OrthancPluginAccessDicomInstance2 params;
8359  memset(&params, 0, sizeof(params));
8360  params.targetImage = &target;
8361  params.instance = instance;
8362  params.frameIndex = frameIndex;
8363 
8364  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDecodedFrame, &params) != OrthancPluginErrorCode_Success)
8365  {
8366  return NULL;
8367  }
8368  else
8369  {
8370  return target;
8371  }
8372  }
8373 
8374 
8391  OrthancPluginContext* context,
8392  const void* buffer,
8393  uint32_t size,
8394  const char* transferSyntax)
8395  {
8396  OrthancPluginDicomInstance* target = NULL;
8397 
8398  _OrthancPluginCreateDicomInstance params;
8399  params.target = &target;
8400  params.buffer = buffer;
8401  params.size = size;
8402  params.transferSyntax = transferSyntax;
8403 
8404  if (context->InvokeService(context, _OrthancPluginService_TranscodeDicomInstance, &params) != OrthancPluginErrorCode_Success)
8405  {
8406  /* Error */
8407  return NULL;
8408  }
8409  else
8410  {
8411  return target;
8412  }
8413  }
8414 
8429  OrthancPluginContext* context,
8430  OrthancPluginMemoryBuffer* target,
8431  const OrthancPluginDicomInstance* instance)
8432  {
8433  _OrthancPluginAccessDicomInstance2 params;
8434  memset(&params, 0, sizeof(params));
8435  params.targetBuffer = target;
8436  params.instance = instance;
8437 
8438  return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, &params);
8439  }
8440 
8441 
8460  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceAdvancedJson(
8461  OrthancPluginContext* context,
8462  const OrthancPluginDicomInstance* instance,
8465  uint32_t maxStringLength)
8466  {
8467  char* result = NULL;
8468 
8469  _OrthancPluginAccessDicomInstance2 params;
8470  memset(&params, 0, sizeof(params));
8471  params.targetStringToFree = &result;
8472  params.instance = instance;
8473  params.format = format;
8474  params.flags = flags;
8475  params.maxStringLength = maxStringLength;
8476 
8477  if (context->InvokeService(context, _OrthancPluginService_GetInstanceAdvancedJson, &params) != OrthancPluginErrorCode_Success)
8478  {
8479  /* Error */
8480  return NULL;
8481  }
8482  else
8483  {
8484  return result;
8485  }
8486  }
8487 
8488 
8503  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebJson(
8504  OrthancPluginContext* context,
8505  const OrthancPluginDicomInstance* instance,
8507  void* payload)
8508  {
8509  char* target = NULL;
8510 
8511  _OrthancPluginAccessDicomInstance2 params;
8512  params.targetStringToFree = &target;
8513  params.instance = instance;
8514  params.dicomWebCallback = callback;
8515  params.dicomWebPayload = payload;
8516 
8517  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebJson, &params) != OrthancPluginErrorCode_Success)
8518  {
8519  /* Error */
8520  return NULL;
8521  }
8522  else
8523  {
8524  return target;
8525  }
8526  }
8527 
8528 
8543  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebXml(
8544  OrthancPluginContext* context,
8545  const OrthancPluginDicomInstance* instance,
8547  void* payload)
8548  {
8549  char* target = NULL;
8550 
8551  _OrthancPluginAccessDicomInstance2 params;
8552  params.targetStringToFree = &target;
8553  params.instance = instance;
8554  params.dicomWebCallback = callback;
8555  params.dicomWebPayload = payload;
8556 
8557  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebXml, &params) != OrthancPluginErrorCode_Success)
8558  {
8559  /* Error */
8560  return NULL;
8561  }
8562  else
8563  {
8564  return target;
8565  }
8566  }
8567 
8568 
8569 
8589  OrthancPluginMemoryBuffer* transcoded /* out */,
8590  const void* buffer,
8591  uint64_t size,
8592  const char* const* allowedSyntaxes,
8593  uint32_t countSyntaxes,
8594  uint8_t allowNewSopInstanceUid);
8595 
8596 
8597  typedef struct
8598  {
8600  } _OrthancPluginTranscoderCallback;
8601 
8616  OrthancPluginContext* context,
8618  {
8619  _OrthancPluginTranscoderCallback params;
8620  params.callback = callback;
8621 
8622  return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, &params);
8623  }
8624 
8625 
8626 
8627  typedef struct
8628  {
8629  OrthancPluginMemoryBuffer* target;
8630  uint32_t size;
8631  } _OrthancPluginCreateMemoryBuffer;
8632 
8651  OrthancPluginContext* context,
8652  OrthancPluginMemoryBuffer* target,
8653  uint32_t size)
8654  {
8655  _OrthancPluginCreateMemoryBuffer params;
8656  params.target = target;
8657  params.size = size;
8658 
8659  return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, &params);
8660  }
8661 
8662 
8689  OrthancPluginContext* context)
8690  {
8691  char* result;
8692 
8693  _OrthancPluginRetrieveDynamicString params;
8694  params.result = &result;
8695  params.argument = NULL;
8696 
8697  if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
8698  &params) != OrthancPluginErrorCode_Success)
8699  {
8700  /* Error */
8701  return NULL;
8702  }
8703  else
8704  {
8705  return result;
8706  }
8707  }
8708 
8709 
8710 
8711  typedef struct
8712  {
8714  uint64_t size;
8715  } _OrthancPluginCreateMemoryBuffer64;
8716 
8735  OrthancPluginContext* context,
8737  uint64_t size)
8738  {
8739  _OrthancPluginCreateMemoryBuffer64 params;
8740  params.target = target;
8741  params.size = size;
8742 
8743  return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer64, &params);
8744  }
8745 
8746 
8747  typedef struct
8748  {
8753  } _OrthancPluginRegisterStorageArea2;
8754 
8771  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea2(
8772  OrthancPluginContext* context,
8777  {
8778  _OrthancPluginRegisterStorageArea2 params;
8779  params.create = create;
8780  params.readWhole = readWhole;
8781  params.readRange = readRange;
8782  params.remove = remove;
8783  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea2, &params);
8784  }
8785 
8786 
8787 
8788  typedef struct
8789  {
8790  _OrthancPluginCreateDicom createDicom;
8791  const char* privateCreator;
8792  } _OrthancPluginCreateDicom2;
8793 
8819  OrthancPluginContext* context,
8820  OrthancPluginMemoryBuffer* target,
8821  const char* json,
8822  const OrthancPluginImage* pixelData,
8824  const char* privateCreator)
8825  {
8826  _OrthancPluginCreateDicom2 params;
8827  params.createDicom.target = target;
8828  params.createDicom.json = json;
8829  params.createDicom.pixelData = pixelData;
8830  params.createDicom.flags = flags;
8831  params.privateCreator = privateCreator;
8832 
8833  return context->InvokeService(context, _OrthancPluginService_CreateDicom2, &params);
8834  }
8835 
8836 
8837 
8838 
8839 
8840 
8841  typedef struct
8842  {
8843  OrthancPluginMemoryBuffer* answerBody;
8844  OrthancPluginMemoryBuffer* answerHeaders;
8845  uint16_t* httpStatus;
8846  OrthancPluginHttpMethod method;
8847  const char* uri;
8848  uint32_t headersCount;
8849  const char* const* headersKeys;
8850  const char* const* headersValues;
8851  const void* body;
8852  uint32_t bodySize;
8853  uint8_t afterPlugins;
8854  } _OrthancPluginCallRestApi;
8855 
8887  OrthancPluginContext* context,
8888  OrthancPluginMemoryBuffer* answerBody,
8889  OrthancPluginMemoryBuffer* answerHeaders,
8890  uint16_t* httpStatus,
8891  OrthancPluginHttpMethod method,
8892  const char* uri,
8893  uint32_t headersCount,
8894  const char* const* headersKeys,
8895  const char* const* headersValues,
8896  const void* body,
8897  uint32_t bodySize,
8898  uint8_t afterPlugins)
8899  {
8900  _OrthancPluginCallRestApi params;
8901  memset(&params, 0, sizeof(params));
8902 
8903  params.answerBody = answerBody;
8904  params.answerHeaders = answerHeaders;
8905  params.httpStatus = httpStatus;
8906  params.method = method;
8907  params.uri = uri;
8908  params.headersCount = headersCount;
8909  params.headersKeys = headersKeys;
8910  params.headersValues = headersValues;
8911  params.body = body;
8912  params.bodySize = bodySize;
8913  params.afterPlugins = afterPlugins;
8914 
8915  return context->InvokeService(context, _OrthancPluginService_CallRestApi, &params);
8916  }
8917 
8918 
8919 
8924  typedef struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection;
8925 
8926 
8944  OrthancPluginWebDavCollection* collection,
8945  const char* name,
8946  uint64_t size,
8947  const char* mimeType,
8948  const char* dateTime);
8949 
8950 
8965  OrthancPluginWebDavCollection* collection,
8966  const char* name,
8967  const char* dateTime);
8968 
8969 
8992  OrthancPluginWebDavCollection* collection,
8993  const void* data,
8994  uint64_t size,
8995  const char* mimeType,
8996  const char* dateTime);
8997 
8998 
9013  uint8_t* isExisting, /* out */
9014  uint32_t pathSize,
9015  const char* const* pathItems,
9016  void* payload);
9017 
9018 
9038  uint8_t* isExisting, /* out */
9039  OrthancPluginWebDavCollection* collection,
9041  OrthancPluginWebDavAddFolder addFolder,
9042  uint32_t pathSize,
9043  const char* const* pathItems,
9044  void* payload);
9045 
9046 
9064  OrthancPluginWebDavCollection* collection,
9065  OrthancPluginWebDavRetrieveFile retrieveFile,
9066  uint32_t pathSize,
9067  const char* const* pathItems,
9068  void* payload);
9069 
9070 
9087  uint8_t* isReadOnly, /* out */
9088  uint32_t pathSize,
9089  const char* const* pathItems,
9090  const void* data,
9091  uint64_t size,
9092  void* payload);
9093 
9094 
9109  uint8_t* isReadOnly, /* out */
9110  uint32_t pathSize,
9111  const char* const* pathItems,
9112  void* payload);
9113 
9114 
9129  uint8_t* isReadOnly, /* out */
9130  uint32_t pathSize,
9131  const char* const* pathItems,
9132  void* payload);
9133 
9134 
9135  typedef struct
9136  {
9137  const char* uri;
9144  void* payload;
9145  } _OrthancPluginRegisterWebDavCollection;
9146 
9168  OrthancPluginContext* context,
9169  const char* uri,
9176  void* payload)
9177  {
9178  _OrthancPluginRegisterWebDavCollection params;
9179  params.uri = uri;
9180  params.isExistingFolder = isExistingFolder;
9181  params.listFolder = listFolder;
9182  params.retrieveFile = retrieveFile;
9183  params.storeFile = storeFile;
9184  params.createFolder = createFolder;
9185  params.deleteItem = deleteItem;
9186  params.payload = payload;
9187 
9188  return context->InvokeService(context, _OrthancPluginService_RegisterWebDavCollection, &params);
9189  }
9190 
9191 
9200  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetDatabaseServerIdentifier(
9201  OrthancPluginContext* context)
9202  {
9203  const char* result;
9204 
9205  _OrthancPluginRetrieveStaticString params;
9206  params.result = &result;
9207  params.argument = NULL;
9208 
9209  if (context->InvokeService(context, _OrthancPluginService_GetDatabaseServerIdentifier, &params) != OrthancPluginErrorCode_Success)
9210  {
9211  /* Error */
9212  return NULL;
9213  }
9214  else
9215  {
9216  return result;
9217  }
9218  }
9219 
9220 
9228  OrthancPluginMemoryBuffer64* response,
9229  void* backend,
9230  const void* request,
9231  uint64_t requestSize);
9232 
9238  typedef void (*OrthancPluginFinalizeDatabaseBackendV4) (void* backend);
9239 
9240  typedef struct
9241  {
9242  void* backend;
9243  uint32_t maxDatabaseRetries;
9246  } _OrthancPluginRegisterDatabaseBackendV4;
9247 
9266  OrthancPluginContext* context,
9267  void* backend,
9268  uint32_t maxDatabaseRetries,
9271  {
9272  _OrthancPluginRegisterDatabaseBackendV4 params;
9273  params.backend = backend;
9274  params.maxDatabaseRetries = maxDatabaseRetries;
9275  params.operations = operations;
9276  params.finalize = finalize;
9277 
9278  return context->InvokeService(context, _OrthancPluginService_RegisterDatabaseBackendV4, &params);
9279  }
9280 
9281 
9282  typedef struct
9283  {
9284  OrthancPluginDicomInstance** target;
9285  const char* instanceId;
9287  } _OrthancPluginLoadDicomInstance;
9288 
9303  OrthancPluginContext* context,
9304  const char* instanceId,
9306  {
9307  OrthancPluginDicomInstance* target = NULL;
9308 
9309  _OrthancPluginLoadDicomInstance params;
9310  params.target = &target;
9311  params.instanceId = instanceId;
9312  params.mode = mode;
9313 
9314  if (context->InvokeService(context, _OrthancPluginService_LoadDicomInstance, &params) != OrthancPluginErrorCode_Success)
9315  {
9316  /* Error */
9317  return NULL;
9318  }
9319  else
9320  {
9321  return target;
9322  }
9323  }
9324 
9325 
9326  typedef struct
9327  {
9328  const char* name;
9329  int64_t value;
9331  } _OrthancPluginSetMetricsIntegerValue;
9332 
9348  ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsIntegerValue(
9349  OrthancPluginContext* context,
9350  const char* name,
9351  int64_t value,
9353  {
9354  _OrthancPluginSetMetricsIntegerValue params;
9355  params.name = name;
9356  params.value = value;
9357  params.type = type;
9358  context->InvokeService(context, _OrthancPluginService_SetMetricsIntegerValue, &params);
9359  }
9360 
9361 
9376  OrthancPluginContext* context,
9377  const char* threadName)
9378  {
9379  return context->InvokeService(context, _OrthancPluginService_SetCurrentThreadName, threadName);
9380  }
9381 
9382 #ifdef __cplusplus
9383 }
9384 #endif
9385 
9386 
OrthancPluginErrorCode OrthancPluginRegisterDatabaseBackendV4(OrthancPluginContext *context, void *backend, uint32_t maxDatabaseRetries, OrthancPluginCallDatabaseBackendV4 operations, OrthancPluginFinalizeDatabaseBackendV4 finalize)
Register a custom database back-end.
Definition: OrthancCPlugin.h:9265
OrthancPluginErrorCode(* OrthancPluginCallDatabaseBackendV4)(OrthancPluginMemoryBuffer64 *response, void *backend, const void *request, uint64_t requestSize)
Signature of a callback function that is triggered when the Orthanc core requests an operation from t...
Definition: OrthancCPlugin.h:9227
OrthancPluginReceivedInstanceAction(* OrthancPluginReceivedInstanceCallback)(OrthancPluginMemoryBuffer64 *modifiedDicomBuffer, const void *receivedDicomBuffer, uint64_t receivedDicomBufferSize, OrthancPluginInstanceOrigin origin)
Callback to keep/discard/modify a DICOM instance received by Orthanc from any source (C-STORE or REST...
Definition: OrthancCPlugin.h:8068
OrthancPluginErrorCode(* OrthancPluginWebDavAddFile)(OrthancPluginWebDavCollection *collection, const char *name, uint64_t size, const char *mimeType, const char *dateTime)
Declare a file while returning the content of a folder.
Definition: OrthancCPlugin.h:8943
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:3268
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:2233
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:1274
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5494
OrthancPluginChangeType
Definition: OrthancCPlugin.h:738
OrthancPluginErrorCode(* OrthancPluginStorageReadWhole)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type)
Callback for reading a whole file from the storage area.
Definition: OrthancCPlugin.h:1340
OrthancPluginErrorCode OrthancPluginRegisterIncomingCStoreInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingCStoreInstanceFilter callback)
Register a callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition: OrthancCPlugin.h:8023
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:1252
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:7154
OrthancPluginErrorCode(* OrthancPluginWebDavCreateFolderCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback to create a folder.
Definition: OrthancCPlugin.h:9108
struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection
Opaque structure that represents a WebDAV collection.
Definition: OrthancCPlugin.h:8924
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:1810
OrthancPluginErrorCode(* OrthancPluginWebDavRetrieveFileCallback)(OrthancPluginWebDavCollection *collection, OrthancPluginWebDavRetrieveFile retrieveFile, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback for retrieving the content of a file.
Definition: OrthancCPlugin.h:9063
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition: OrthancCPlugin.h:7939
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4852
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:8588
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6397
OrthancPluginErrorCode(* OrthancPluginWebDavRetrieveFile)(OrthancPluginWebDavCollection *collection, const void *data, uint64_t size, const char *mimeType, const char *dateTime)
Retrieve the content of a file.
Definition: OrthancCPlugin.h:8991
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1320
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:2155
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3656
OrthancPluginErrorCode OrthancPluginRegisterReceivedInstanceCallback(OrthancPluginContext *context, OrthancPluginReceivedInstanceCallback callback)
Register a callback to keep/discard/modify a DICOM instance received by Orthanc from any source (C-ST...
Definition: OrthancCPlugin.h:8100
int32_t OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:2036
OrthancPluginErrorCode(* OrthancPluginWebDavListFolderCallback)(uint8_t *isExisting, OrthancPluginWebDavCollection *collection, OrthancPluginWebDavAddFile addFile, OrthancPluginWebDavAddFolder addFolder, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback for listing the content of a folder.
Definition: OrthancCPlugin.h:9037
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:1123
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3411
void OrthancPluginRegisterStorageArea2(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageReadWhole readWhole, OrthancPluginStorageReadRange readRange, OrthancPluginStorageRemove remove)
Register a custom storage area, with support for range request.
Definition: OrthancCPlugin.h:8771
OrthancPluginErrorCode(* OrthancPluginWebDavAddFolder)(OrthancPluginWebDavCollection *collection, const char *name, const char *dateTime)
Declare a subfolder while returning the content of a folder.
Definition: OrthancCPlugin.h:8964
OrthancPluginErrorCode OrthancPluginRegisterWebDavCollection(OrthancPluginContext *context, const char *uri, OrthancPluginWebDavIsExistingFolderCallback isExistingFolder, OrthancPluginWebDavListFolderCallback listFolder, OrthancPluginWebDavRetrieveFileCallback retrieveFile, OrthancPluginWebDavStoreFileCallback storeFile, OrthancPluginWebDavCreateFolderCallback createFolder, OrthancPluginWebDavDeleteItemCallback deleteItem, void *payload)
Register a WebDAV virtual filesystem.
Definition: OrthancCPlugin.h:9167
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:1466
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1220
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1782
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition: OrthancCPlugin.h:8615
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:1231
OrthancPluginErrorCode(* OrthancPluginWebDavStoreFileCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, const void *data, uint64_t size, void *payload)
Callback to store a file.
Definition: OrthancCPlugin.h:9086
OrthancPluginErrorCode(* OrthancPluginWebDavDeleteItemCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback to remove a file or a folder.
Definition: OrthancCPlugin.h:9128
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:5044
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1381
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1293
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:1848
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:1241
void(* OrthancPluginFinalizeDatabaseBackendV4)(void *backend)
Signature of a callback function that is triggered when the database plugin must be finalized.
Definition: OrthancCPlugin.h:9238
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition: OrthancCPlugin.h:7602
OrthancPluginErrorCode(* OrthancPluginWebDavIsExistingFolderCallback)(uint8_t *isExisting, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback for testing the existence of a folder.
Definition: OrthancCPlugin.h:9012
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:1431
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1763
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:7009
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1264
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:2195
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4813
int32_t OrthancPluginCheckVersionAdvanced(OrthancPluginContext *context, int32_t expectedMajor, int32_t expectedMinor, int32_t expectedRevision)
Check that the version of the hosting Orthanc is above a given version.
Definition: OrthancCPlugin.h:1929
OrthancPluginErrorCode(* OrthancPluginStorageReadRange)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type, uint64_t rangeStart)
Callback for reading a range of a file from the storage area.
Definition: OrthancCPlugin.h:1363
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:7723
int32_t(* OrthancPluginIncomingCStoreInstanceFilter)(uint16_t *dimseStatus, const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition: OrthancCPlugin.h:8001
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition: OrthancCPlugin.h:7960
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5830
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:4769
@ OrthancPluginChangeType_OrthancStopped
Definition: OrthancCPlugin.h:750
@ OrthancPluginChangeType_OrthancStarted
Definition: OrthancCPlugin.h:749
@ OrthancPluginChangeType_Deleted
Definition: OrthancCPlugin.h:740
@ OrthancPluginChangeType_JobFailure
Definition: OrthancCPlugin.h:757
@ OrthancPluginChangeType_NewInstance
Definition: OrthancCPlugin.h:742
@ OrthancPluginChangeType_NewPatient
Definition: OrthancCPlugin.h:743
@ OrthancPluginChangeType_JobSubmitted
Definition: OrthancCPlugin.h:755
@ OrthancPluginChangeType_NewSeries
Definition: OrthancCPlugin.h:744
@ OrthancPluginChangeType_StablePatient
Definition: OrthancCPlugin.h:746
@ OrthancPluginChangeType_UpdatedPeers
Definition: OrthancCPlugin.h:753
@ OrthancPluginChangeType_StableStudy
Definition: OrthancCPlugin.h:748
@ OrthancPluginChangeType_CompletedSeries
Definition: OrthancCPlugin.h:739
@ OrthancPluginChangeType_NewChildInstance
Definition: OrthancCPlugin.h:741
@ OrthancPluginChangeType_UpdatedAttachment
Definition: OrthancCPlugin.h:751
@ OrthancPluginChangeType_UpdatedMetadata
Definition: OrthancCPlugin.h:752
@ OrthancPluginChangeType_StableSeries
Definition: OrthancCPlugin.h:747
@ OrthancPluginChangeType_UpdatedModalities
Definition: OrthancCPlugin.h:754
@ OrthancPluginChangeType_JobSuccess
Definition: OrthancCPlugin.h:756
@ OrthancPluginChangeType_NewStudy
Definition: OrthancCPlugin.h:745
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:6091
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1171
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1576
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:6067
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:6159
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7851
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:1400
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:6245
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:7829
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5999
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5376
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:7872
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:5337
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:6038
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:1536
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:7899
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1179
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1163
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1493
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1561
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:5233
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5299
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:6197
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:6128
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1590
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1155
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:5269
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:8158
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:8543
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition: OrthancCPlugin.h:1131
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition: OrthancCPlugin.h:8123
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:8323
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:8460
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:3065
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition: OrthancCPlugin.h:8208
int32_t OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:3178
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition: OrthancCPlugin.h:8283
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:8351
OrthancPluginDicomInstance * OrthancPluginLoadDicomInstance(OrthancPluginContext *context, const char *instanceId, OrthancPluginLoadDicomInstanceMode mode)
Load a DICOM instance from the Orthanc server.
Definition: OrthancCPlugin.h:9302
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5402
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:3032
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:8503
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:3139
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:3101
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:3219
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition: OrthancCPlugin.h:8246
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition: OrthancCPlugin.h:8428
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition: OrthancCPlugin.h:8390
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2999
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:614
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:4715
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:4299
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:4090
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4555
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3989
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4590
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:4055
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:4209
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:4254
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5532
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:4167
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4630
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:4124
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:5575
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:783
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:1147
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:768
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:4022
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:3801
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5621
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4662
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1139
@ OrthancPluginPixelFormat_RGBA32
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:653
@ OrthancPluginPixelFormat_RGB48
Color image in RGB48 format.
Definition: OrthancCPlugin.h:663
@ OrthancPluginPixelFormat_Grayscale8
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:621
@ OrthancPluginPixelFormat_SignedGrayscale16
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:637
@ OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:679
@ OrthancPluginPixelFormat_RGB24
Color image in RGB24 format.
Definition: OrthancCPlugin.h:645
@ OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:687
@ OrthancPluginPixelFormat_Unknown
Definition: OrthancCPlugin.h:655
@ OrthancPluginPixelFormat_Grayscale64
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:695
@ OrthancPluginPixelFormat_Grayscale32
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:671
@ OrthancPluginPixelFormat_Grayscale16
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:629
@ OrthancPluginImageFormat_Png
Definition: OrthancCPlugin.h:784
@ OrthancPluginImageFormat_Jpeg
Definition: OrthancCPlugin.h:785
@ OrthancPluginImageFormat_Dicom
Definition: OrthancCPlugin.h:786
@ OrthancPluginCompressionType_Gzip
Definition: OrthancCPlugin.h:771
@ OrthancPluginCompressionType_ZlibWithSize
Definition: OrthancCPlugin.h:770
@ OrthancPluginCompressionType_Zlib
Definition: OrthancCPlugin.h:769
@ OrthancPluginCompressionType_GzipWithSize
Definition: OrthancCPlugin.h:772
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:2463
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:2498
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:2611
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2712
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3559
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3520
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:2575
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2782
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2747
char * OrthancPluginGenerateRestApiAuthorizationToken(OrthancPluginContext *context)
Generate a token to grant full access to the REST API of Orthanc.
Definition: OrthancCPlugin.h:8688
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2396
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2817
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:2426
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2677
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2527
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2550
OrthancPluginErrorCode OrthancPluginCallRestApi(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, OrthancPluginHttpMethod method, const char *uri, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, const void *body, uint32_t bodySize, uint8_t afterPlugins)
Call the REST API of Orthanc with full flexibility.
Definition: OrthancCPlugin.h:8886
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:5195
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2363
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:2322
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2885
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:7045
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2908
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:2265
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2862
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2963
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2938
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2645
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:4346
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:3759
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:5792
void OrthancPluginSendHttpStatus(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status, const void *body, uint32_t bodySize)
Send a HTTP status, with a custom body.
Definition: OrthancCPlugin.h:3953
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3730
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1730
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderExecute)(OrthancPluginServerChunkedRequestReader *reader, OrthancPluginRestOutput *output)
Callback invoked whenever the request body is entirely received.
Definition: OrthancCPlugin.h:7660
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:5905
struct _OrthancPluginJob_t OrthancPluginJob
Opaque structure to a job to be executed by Orthanc.
Definition: OrthancCPlugin.h:1203
OrthancPluginErrorCode OrthancPluginCreateDicom2(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *json, const OrthancPluginImage *pixelData, OrthancPluginCreateDicomFlags flags, const char *privateCreator)
Create a DICOM instance from a JSON string and an image, with a private creator.
Definition: OrthancCPlugin.h:8818
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:2119
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderFactory)(OrthancPluginServerChunkedRequestReader **reader, const char *url, const OrthancPluginHttpRequest *request)
Callback to create a reader to handle incoming chunked HTTP transfers.
Definition: OrthancCPlugin.h:7621
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:6322
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6459
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:5000
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:887
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:4947
OrthancPluginResourceType
Definition: OrthancCPlugin.h:721
void OrthancPluginSetMetricsIntegerValue(OrthancPluginContext *context, const char *name, int64_t value, OrthancPluginMetricsType type)
Set the value of an integer metrics.
Definition: OrthancCPlugin.h:9348
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3869
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3590
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:201
struct _OrthancPluginPeers_t OrthancPluginPeers
Opaque structure to the set of remote Orthanc Peers that are known to the local Orthanc server.
Definition: OrthancCPlugin.h:1195
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:4437
uint32_t(* OrthancPluginChunkedClientRequestGetChunkSize)(void *request)
Callback to read the size of the current request chunk during a chunked transfer.
Definition: OrthancCPlugin.h:7462
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4891
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, uint32_t size)
Create a 32-bit memory buffer.
Definition: OrthancCPlugin.h:8650
OrthancPluginDicomWebBinaryMode
Definition: OrthancCPlugin.h:976
char * OrthancPluginEncodeDicomWebJson2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7284
OrthancPluginErrorCode(* OrthancPluginJobGetContent2)(OrthancPluginMemoryBuffer *target, void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1650
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1670
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:5137
OrthancPluginErrorCode(* OrthancPluginChunkedClientRequestNext)(void *request)
Callback to advance in the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7430
struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode
Opaque structure that represents a node in a JSON or XML document used in DICOMweb.
Definition: OrthancCPlugin.h:1212
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1616
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:851
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:933
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:872
void(* OrthancPluginServerChunkedRequestReaderFinalize)(OrthancPluginServerChunkedRequestReader *reader)
Callback invoked to release the resources associated with an incoming HTTP chunked transfer.
Definition: OrthancCPlugin.h:7678
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:6355
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:3486
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:2103
OrthancPluginConstraintType
Definition: OrthancCPlugin.h:902
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3838
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1706
void OrthancPluginSetMetricsValue(OrthancPluginContext *context, const char *name, float value, OrthancPluginMetricsType type)
Set the value of a floating-point metrics.
Definition: OrthancCPlugin.h:7123
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:7640
OrthancPluginReceivedInstanceAction
Definition: OrthancCPlugin.h:1037
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:7541
int32_t(* OrthancPluginJobGetSerialized2)(OrthancPluginMemoryBuffer *target, void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1690
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:7077
void OrthancPluginFreeMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:2071
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:4479
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6537
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3624
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3900
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:5458
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5960
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6932
OrthancPluginStorageCommitmentFailureReason
Definition: OrthancCPlugin.h:989
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:7393
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6578
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6425
OrthancPluginMetricsType
Definition: OrthancCPlugin.h:959
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int32_t priority)
Submit a new job to the jobs engine of Orthanc.
Definition: OrthancCPlugin.h:6964
char * OrthancPluginEncodeDicomWebXml2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7328
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7232
const char * OrthancPluginGetDatabaseServerIdentifier(OrthancPluginContext *context)
Gets the DatabaseServerIdentifier.
Definition: OrthancCPlugin.h:9200
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4517
uint8_t(* OrthancPluginChunkedClientRequestIsDone)(void *request)
Callback to know whether the request body is entirely read during a chunked transfer.
Definition: OrthancCPlugin.h:7413
char * OrthancPluginGetTagName(OrthancPluginContext *context, uint16_t group, uint16_t element, const char *privateCreator)
Returns the symbolic name of a DICOM tag.
Definition: OrthancCPlugin.h:7774
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5667
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:5088
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:2055
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *target, uint64_t size)
Create a 64-bit memory buffer.
Definition: OrthancCPlugin.h:8734
OrthancPluginLoadDicomInstanceMode
Definition: OrthancCPlugin.h:1051
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:7372
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6489
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:797
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:3365
const void *(* OrthancPluginChunkedClientRequestGetChunkData)(void *request)
Callback to read the current chunk of the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7446
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:4399
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:947
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:3330
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:6284
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:836
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:2087
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:328
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3689
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:3442
OrthancPluginJob * OrthancPluginCreateJob2(OrthancPluginContext *context, void *job, OrthancPluginJobFinalize finalize, const char *type, OrthancPluginJobGetProgress getProgress, OrthancPluginJobGetContent2 getContent, OrthancPluginJobGetSerialized2 getSerialized, OrthancPluginJobStep step, OrthancPluginJobStop stop, OrthancPluginJobReset reset)
Create a custom job.
Definition: OrthancCPlugin.h:6877
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:6791
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:6705
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:1187
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:6624
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5749
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5703
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:917
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1603
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1899
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1632
OrthancPluginErrorCode OrthancPluginSetCurrentThreadName(OrthancPluginContext *context, const char *threadName)
Set the name of the current thread.
Definition: OrthancCPlugin.h:9375
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7190
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:3300
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1747
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginContentType
Definition: OrthancCPlugin.h:706
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:3464
@ OrthancPluginIdentifierConstraint_Wildcard
Definition: OrthancCPlugin.h:891
@ OrthancPluginIdentifierConstraint_Equal
Definition: OrthancCPlugin.h:888
@ OrthancPluginIdentifierConstraint_SmallerOrEqual
Definition: OrthancCPlugin.h:889
@ OrthancPluginIdentifierConstraint_GreaterOrEqual
Definition: OrthancCPlugin.h:890
@ OrthancPluginResourceType_Instance
Definition: OrthancCPlugin.h:725
@ OrthancPluginResourceType_None
Definition: OrthancCPlugin.h:726
@ OrthancPluginResourceType_Series
Definition: OrthancCPlugin.h:724
@ OrthancPluginResourceType_Study
Definition: OrthancCPlugin.h:723
@ OrthancPluginResourceType_Patient
Definition: OrthancCPlugin.h:722
@ OrthancPluginErrorCode_CreateDicomBadParent
Definition: OrthancCPlugin.h:290
@ OrthancPluginErrorCode_MainDicomTagsMultiplyDefined
Definition: OrthancCPlugin.h:247
@ OrthancPluginErrorCode_SQLiteFlush
Definition: OrthancCPlugin.h:258
@ OrthancPluginErrorCode_IncompatibleDatabaseVersion
Definition: OrthancCPlugin.h:221
@ OrthancPluginErrorCode_BadSequenceOfCalls
Definition: OrthancCPlugin.h:209
@ OrthancPluginErrorCode_SharedLibrary
Definition: OrthancCPlugin.h:228
@ OrthancPluginErrorCode_NullPointer
Definition: OrthancCPlugin.h:238
@ OrthancPluginErrorCode_NotLuaPredicate
Definition: OrthancCPlugin.h:300
@ OrthancPluginErrorCode_LuaAlreadyExecuted
Definition: OrthancCPlugin.h:298
@ OrthancPluginErrorCode_NotAcceptable
Definition: OrthancCPlugin.h:237
@ OrthancPluginErrorCode_FullStorage
Definition: OrthancCPlugin.h:222
@ OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered
Definition: OrthancCPlugin.h:303
@ OrthancPluginErrorCode_InexistentFile
Definition: OrthancCPlugin.h:216
@ OrthancPluginErrorCode_CreateDicomParentEncoding
Definition: OrthancCPlugin.h:292
@ OrthancPluginErrorCode_CannotOrderSlices
Definition: OrthancCPlugin.h:306
@ OrthancPluginErrorCode_InternalError
Definition: OrthancCPlugin.h:202
@ OrthancPluginErrorCode_DiscontinuedAbi
Definition: OrthancCPlugin.h:243
@ OrthancPluginErrorCode_NoCFindHandler
Definition: OrthancCPlugin.h:276
@ OrthancPluginErrorCode_SQLiteCommitWithoutTransaction
Definition: OrthancCPlugin.h:256
@ OrthancPluginErrorCode_DatabasePlugin
Definition: OrthancCPlugin.h:234
@ OrthancPluginErrorCode_SQLiteStatementAlreadyUsed
Definition: OrthancCPlugin.h:253
@ OrthancPluginErrorCode_SQLiteCannotRun
Definition: OrthancCPlugin.h:259
@ OrthancPluginErrorCode_UnknownPluginService
Definition: OrthancCPlugin.h:229
@ OrthancPluginErrorCode_JsonToLuaTable
Definition: OrthancCPlugin.h:295
@ OrthancPluginErrorCode_CreateDicomOverrideTag
Definition: OrthancCPlugin.h:286
@ OrthancPluginErrorCode_SQLiteBindOutOfRange
Definition: OrthancCPlugin.h:261
@ OrthancPluginErrorCode_ParameterOutOfRange
Definition: OrthancCPlugin.h:206
@ OrthancPluginErrorCode_SQLiteRegisterFunction
Definition: OrthancCPlugin.h:257
@ OrthancPluginErrorCode_SQLiteTransactionBegin
Definition: OrthancCPlugin.h:265
@ OrthancPluginErrorCode_CreateDicomNoPayload
Definition: OrthancCPlugin.h:288
@ OrthancPluginErrorCode_Unauthorized
Definition: OrthancCPlugin.h:232
@ OrthancPluginErrorCode_RegularFileExpected
Definition: OrthancCPlugin.h:272
@ OrthancPluginErrorCode_DicomPortInUse
Definition: OrthancCPlugin.h:270
@ OrthancPluginErrorCode_BadApplicationEntityTitle
Definition: OrthancCPlugin.h:275
@ OrthancPluginErrorCode_NoCStoreHandler
Definition: OrthancCPlugin.h:278
@ OrthancPluginErrorCode_PathToExecutable
Definition: OrthancCPlugin.h:273
@ OrthancPluginErrorCode_NoSopClassOrInstance
Definition: OrthancCPlugin.h:280
@ OrthancPluginErrorCode_BadFont
Definition: OrthancCPlugin.h:233
@ OrthancPluginErrorCode_DatabaseUnavailable
Definition: OrthancCPlugin.h:239
@ OrthancPluginErrorCode_CannotCreateLua
Definition: OrthancCPlugin.h:296
@ OrthancPluginErrorCode_SQLiteExecute
Definition: OrthancCPlugin.h:254
@ OrthancPluginErrorCode_UriSyntax
Definition: OrthancCPlugin.h:215
@ OrthancPluginErrorCode_DirectoryOverFile
Definition: OrthancCPlugin.h:266
@ OrthancPluginErrorCode_Revision
Definition: OrthancCPlugin.h:246
@ OrthancPluginErrorCode_InexistentTag
Definition: OrthancCPlugin.h:224
@ OrthancPluginErrorCode_IncompatibleImageFormat
Definition: OrthancCPlugin.h:226
@ OrthancPluginErrorCode_UnsupportedMediaType
Definition: OrthancCPlugin.h:311
@ OrthancPluginErrorCode_DicomFindUnavailable
Definition: OrthancCPlugin.h:282
@ OrthancPluginErrorCode_SQLiteCannotStep
Definition: OrthancCPlugin.h:260
@ OrthancPluginErrorCode_CreateDicomParentIsInstance
Definition: OrthancCPlugin.h:291
@ OrthancPluginErrorCode_DuplicateResource
Definition: OrthancCPlugin.h:249
@ OrthancPluginErrorCode_StorageAreaAlreadyRegistered
Definition: OrthancCPlugin.h:302
@ OrthancPluginErrorCode_LuaReturnsNoString
Definition: OrthancCPlugin.h:301
@ OrthancPluginErrorCode_UnknownResource
Definition: OrthancCPlugin.h:220
@ OrthancPluginErrorCode_CreateDicomNotString
Definition: OrthancCPlugin.h:285
@ OrthancPluginErrorCode_HttpPortInUse
Definition: OrthancCPlugin.h:269
@ OrthancPluginErrorCode_SslDisabled
Definition: OrthancCPlugin.h:305
@ OrthancPluginErrorCode_UnknownModality
Definition: OrthancCPlugin.h:293
@ OrthancPluginErrorCode_BadHttpStatusInRest
Definition: OrthancCPlugin.h:271
@ OrthancPluginErrorCode_BadGeometry
Definition: OrthancCPlugin.h:241
@ OrthancPluginErrorCode_AlreadyExistingTag
Definition: OrthancCPlugin.h:308
@ OrthancPluginErrorCode_FileStorageCannotWrite
Definition: OrthancCPlugin.h:267
@ OrthancPluginErrorCode_CreateDicomUseDataUriScheme
Definition: OrthancCPlugin.h:289
@ OrthancPluginErrorCode_DirectoryExpected
Definition: OrthancCPlugin.h:268
@ OrthancPluginErrorCode_NoCMoveHandler
Definition: OrthancCPlugin.h:277
@ OrthancPluginErrorCode_SQLitePrepareStatement
Definition: OrthancCPlugin.h:262
@ OrthancPluginErrorCode_CorruptedFile
Definition: OrthancCPlugin.h:223
@ OrthancPluginErrorCode_StorageAreaPlugin
Definition: OrthancCPlugin.h:235
@ OrthancPluginErrorCode_BadJobOrdering
Definition: OrthancCPlugin.h:294
@ OrthancPluginErrorCode_DatabaseCannotSerialize
Definition: OrthancCPlugin.h:245
@ OrthancPluginErrorCode_CanceledJob
Definition: OrthancCPlugin.h:240
@ OrthancPluginErrorCode_BadRange
Definition: OrthancCPlugin.h:244
@ OrthancPluginErrorCode_NotImplemented
Definition: OrthancCPlugin.h:205
@ OrthancPluginErrorCode_SslInitialization
Definition: OrthancCPlugin.h:242
@ OrthancPluginErrorCode_IncompatibleImageSize
Definition: OrthancCPlugin.h:227
@ OrthancPluginErrorCode_BadFileFormat
Definition: OrthancCPlugin.h:218
@ OrthancPluginErrorCode_BadRequest
Definition: OrthancCPlugin.h:211
@ OrthancPluginErrorCode_SystemCommand
Definition: OrthancCPlugin.h:213
@ OrthancPluginErrorCode_NoStorageCommitmentHandler
Definition: OrthancCPlugin.h:309
@ OrthancPluginErrorCode_SQLiteAlreadyOpened
Definition: OrthancCPlugin.h:251
@ OrthancPluginErrorCode_Plugin
Definition: OrthancCPlugin.h:204
@ OrthancPluginErrorCode_CannotExecuteLua
Definition: OrthancCPlugin.h:297
@ OrthancPluginErrorCode_SQLiteRollbackWithoutTransaction
Definition: OrthancCPlugin.h:255
@ OrthancPluginErrorCode_UnknownDicomTag
Definition: OrthancCPlugin.h:230
@ OrthancPluginErrorCode_ForbiddenAccess
Definition: OrthancCPlugin.h:248
@ OrthancPluginErrorCode_NoPresentationContext
Definition: OrthancCPlugin.h:281
@ OrthancPluginErrorCode_EmptyRequest
Definition: OrthancCPlugin.h:236
@ OrthancPluginErrorCode_DatabaseNotInitialized
Definition: OrthancCPlugin.h:304
@ OrthancPluginErrorCode_DicomMoveUnavailable
Definition: OrthancCPlugin.h:283
@ OrthancPluginErrorCode_SQLiteTransactionCommit
Definition: OrthancCPlugin.h:264
@ OrthancPluginErrorCode_BadJson
Definition: OrthancCPlugin.h:231
@ OrthancPluginErrorCode_Success
Definition: OrthancCPlugin.h:203
@ OrthancPluginErrorCode_NetworkProtocol
Definition: OrthancCPlugin.h:212
@ OrthancPluginErrorCode_NoApplicationEntityFilter
Definition: OrthancCPlugin.h:279
@ OrthancPluginErrorCode_InexistentItem
Definition: OrthancCPlugin.h:210
@ OrthancPluginErrorCode_Timeout
Definition: OrthancCPlugin.h:219
@ OrthancPluginErrorCode_LuaBadOutput
Definition: OrthancCPlugin.h:299
@ OrthancPluginErrorCode_SQLiteTransactionAlreadyStarted
Definition: OrthancCPlugin.h:263
@ OrthancPluginErrorCode_NoCGetHandler
Definition: OrthancCPlugin.h:310
@ OrthancPluginErrorCode_SQLiteNotOpened
Definition: OrthancCPlugin.h:250
@ OrthancPluginErrorCode_ReadOnly
Definition: OrthancCPlugin.h:225
@ OrthancPluginErrorCode_CannotStoreInstance
Definition: OrthancCPlugin.h:284
@ OrthancPluginErrorCode_CannotWriteFile
Definition: OrthancCPlugin.h:217
@ OrthancPluginErrorCode_BadParameterType
Definition: OrthancCPlugin.h:208
@ OrthancPluginErrorCode_NotEnoughMemory
Definition: OrthancCPlugin.h:207
@ OrthancPluginErrorCode_CreateDicomUseContent
Definition: OrthancCPlugin.h:287
@ OrthancPluginErrorCode_Database
Definition: OrthancCPlugin.h:214
@ OrthancPluginErrorCode_SQLiteCannotOpen
Definition: OrthancCPlugin.h:252
@ OrthancPluginErrorCode_MakeDirectory
Definition: OrthancCPlugin.h:274
@ OrthancPluginErrorCode_NoWorklistHandler
Definition: OrthancCPlugin.h:307
@ OrthancPluginDicomWebBinaryMode_InlineBinary
Definition: OrthancCPlugin.h:978
@ OrthancPluginDicomWebBinaryMode_BulkDataUri
Definition: OrthancCPlugin.h:979
@ OrthancPluginDicomWebBinaryMode_Ignore
Definition: OrthancCPlugin.h:977
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii
Definition: OrthancCPlugin.h:857
@ OrthancPluginDicomToJsonFlags_IncludeBinary
Definition: OrthancCPlugin.h:853
@ OrthancPluginDicomToJsonFlags_IncludePixelData
Definition: OrthancCPlugin.h:856
@ OrthancPluginDicomToJsonFlags_IncludeUnknownTags
Definition: OrthancCPlugin.h:855
@ OrthancPluginDicomToJsonFlags_SkipGroupLengths
Definition: OrthancCPlugin.h:860
@ OrthancPluginDicomToJsonFlags_None
Definition: OrthancCPlugin.h:852
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
Definition: OrthancCPlugin.h:858
@ OrthancPluginDicomToJsonFlags_StopAfterPixelData
Definition: OrthancCPlugin.h:859
@ OrthancPluginDicomToJsonFlags_IncludePrivateTags
Definition: OrthancCPlugin.h:854
@ OrthancPluginJobStepStatus_Continue
Definition: OrthancCPlugin.h:936
@ OrthancPluginJobStepStatus_Success
Definition: OrthancCPlugin.h:934
@ OrthancPluginJobStepStatus_Failure
Definition: OrthancCPlugin.h:935
@ OrthancPluginCreateDicomFlags_DecodeDataUriScheme
Definition: OrthancCPlugin.h:874
@ OrthancPluginCreateDicomFlags_None
Definition: OrthancCPlugin.h:873
@ OrthancPluginCreateDicomFlags_GenerateIdentifiers
Definition: OrthancCPlugin.h:875
@ OrthancPluginConstraintType_SmallerOrEqual
Definition: OrthancCPlugin.h:904
@ OrthancPluginConstraintType_List
Definition: OrthancCPlugin.h:907
@ OrthancPluginConstraintType_GreaterOrEqual
Definition: OrthancCPlugin.h:905
@ OrthancPluginConstraintType_Equal
Definition: OrthancCPlugin.h:903
@ OrthancPluginConstraintType_Wildcard
Definition: OrthancCPlugin.h:906
@ OrthancPluginReceivedInstanceAction_KeepAsIs
Definition: OrthancCPlugin.h:1038
@ OrthancPluginReceivedInstanceAction_Discard
Definition: OrthancCPlugin.h:1040
@ OrthancPluginReceivedInstanceAction_Modify
Definition: OrthancCPlugin.h:1039
@ OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
Definition: OrthancCPlugin.h:1016
@ OrthancPluginStorageCommitmentFailureReason_Success
Definition: OrthancCPlugin.h:993
@ OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
Definition: OrthancCPlugin.h:1029
@ OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
Definition: OrthancCPlugin.h:1023
@ OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
Definition: OrthancCPlugin.h:1010
@ OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
Definition: OrthancCPlugin.h:1004
@ OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
Definition: OrthancCPlugin.h:998
@ OrthancPluginMetricsType_Default
Definition: OrthancCPlugin.h:960
@ OrthancPluginMetricsType_Timer
Definition: OrthancCPlugin.h:967
@ OrthancPluginLoadDicomInstanceMode_UntilPixelData
Definition: OrthancCPlugin.h:1061
@ OrthancPluginLoadDicomInstanceMode_WholeDicom
Definition: OrthancCPlugin.h:1055
@ OrthancPluginLoadDicomInstanceMode_EmptyPixelData
Definition: OrthancCPlugin.h:1068
@ OrthancPluginValueRepresentation_PN
Definition: OrthancCPlugin.h:813
@ OrthancPluginValueRepresentation_UL
Definition: OrthancCPlugin.h:821
@ OrthancPluginValueRepresentation_UN
Definition: OrthancCPlugin.h:822
@ OrthancPluginValueRepresentation_DA
Definition: OrthancCPlugin.h:802
@ OrthancPluginValueRepresentation_OF
Definition: OrthancCPlugin.h:811
@ OrthancPluginValueRepresentation_OW
Definition: OrthancCPlugin.h:812
@ OrthancPluginValueRepresentation_CS
Definition: OrthancCPlugin.h:801
@ OrthancPluginValueRepresentation_US
Definition: OrthancCPlugin.h:823
@ OrthancPluginValueRepresentation_SH
Definition: OrthancCPlugin.h:814
@ OrthancPluginValueRepresentation_FL
Definition: OrthancCPlugin.h:806
@ OrthancPluginValueRepresentation_DT
Definition: OrthancCPlugin.h:804
@ OrthancPluginValueRepresentation_TM
Definition: OrthancCPlugin.h:819
@ OrthancPluginValueRepresentation_SQ
Definition: OrthancCPlugin.h:816
@ OrthancPluginValueRepresentation_DS
Definition: OrthancCPlugin.h:803
@ OrthancPluginValueRepresentation_OB
Definition: OrthancCPlugin.h:810
@ OrthancPluginValueRepresentation_SL
Definition: OrthancCPlugin.h:815
@ OrthancPluginValueRepresentation_ST
Definition: OrthancCPlugin.h:818
@ OrthancPluginValueRepresentation_IS
Definition: OrthancCPlugin.h:807
@ OrthancPluginValueRepresentation_LT
Definition: OrthancCPlugin.h:809
@ OrthancPluginValueRepresentation_SS
Definition: OrthancCPlugin.h:817
@ OrthancPluginValueRepresentation_UT
Definition: OrthancCPlugin.h:824
@ OrthancPluginValueRepresentation_LO
Definition: OrthancCPlugin.h:808
@ OrthancPluginValueRepresentation_AE
Definition: OrthancCPlugin.h:798
@ OrthancPluginValueRepresentation_FD
Definition: OrthancCPlugin.h:805
@ OrthancPluginValueRepresentation_UI
Definition: OrthancCPlugin.h:820
@ OrthancPluginValueRepresentation_AS
Definition: OrthancCPlugin.h:799
@ OrthancPluginValueRepresentation_AT
Definition: OrthancCPlugin.h:800
@ OrthancPluginJobStopReason_Failure
Definition: OrthancCPlugin.h:950
@ OrthancPluginJobStopReason_Success
Definition: OrthancCPlugin.h:948
@ OrthancPluginJobStopReason_Canceled
Definition: OrthancCPlugin.h:951
@ OrthancPluginJobStopReason_Paused
Definition: OrthancCPlugin.h:949
@ OrthancPluginDicomToJsonFormat_Full
Definition: OrthancCPlugin.h:837
@ OrthancPluginDicomToJsonFormat_Human
Definition: OrthancCPlugin.h:839
@ OrthancPluginDicomToJsonFormat_Short
Definition: OrthancCPlugin.h:838
@ OrthancPluginHttpMethod_Delete
Definition: OrthancCPlugin.h:332
@ OrthancPluginHttpMethod_Post
Definition: OrthancCPlugin.h:330
@ OrthancPluginHttpMethod_Put
Definition: OrthancCPlugin.h:331
@ OrthancPluginHttpMethod_Get
Definition: OrthancCPlugin.h:329
@ OrthancPluginInstanceOrigin_Unknown
Definition: OrthancCPlugin.h:918
@ OrthancPluginInstanceOrigin_RestApi
Definition: OrthancCPlugin.h:920
@ OrthancPluginInstanceOrigin_Lua
Definition: OrthancCPlugin.h:922
@ OrthancPluginInstanceOrigin_WebDav
Definition: OrthancCPlugin.h:923
@ OrthancPluginInstanceOrigin_DicomProtocol
Definition: OrthancCPlugin.h:919
@ OrthancPluginInstanceOrigin_Plugin
Definition: OrthancCPlugin.h:921
@ OrthancPluginContentType_Dicom
Definition: OrthancCPlugin.h:708
@ OrthancPluginContentType_DicomAsJson
Definition: OrthancCPlugin.h:709
@ OrthancPluginContentType_Unknown
Definition: OrthancCPlugin.h:707
@ OrthancPluginContentType_DicomUntilPixelData
Definition: OrthancCPlugin.h:710
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1881
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1885
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1886
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1884
uint16_t element
Definition: OrthancCPlugin.h:1883
uint16_t group
Definition: OrthancCPlugin.h:1882
The parameters of a REST request.
Definition: OrthancCPlugin.h:343
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:372
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:357
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:382
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:352
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:397
const void * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:377
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:367
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:392
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:347
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:362
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:402
A 64-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1104
uint64_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1113
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1108
A 32-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1082
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1091
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1086