Orthanc Plugin SDK  1.8.2
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1 
104 #pragma once
105 
106 
107 #include <stdio.h>
108 #include <string.h>
109 
110 #ifdef WIN32
111 # define ORTHANC_PLUGINS_API __declspec(dllexport)
112 #elif __GNUC__ >= 4
113 # define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default")))
114 #else
115 # define ORTHANC_PLUGINS_API
116 #endif
117 
118 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
119 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 8
120 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 1
121 
122 
123 #if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
124 #define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
125  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
126  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
127  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
128  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
129  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
130 #endif
131 
132 
133 
134 /********************************************************************
135  ** Check that function inlining is properly supported. The use of
136  ** inlining is required, to avoid the duplication of object code
137  ** between two compilation modules that would use the Orthanc Plugin
138  ** API.
139  ********************************************************************/
140 
141 /* If the auto-detection of the "inline" keyword below does not work
142  automatically and that your compiler is known to properly support
143  inlining, uncomment the following #define and adapt the definition
144  of "static inline". */
145 
146 /* #define ORTHANC_PLUGIN_INLINE static inline */
147 
148 #ifndef ORTHANC_PLUGIN_INLINE
149 # if __STDC_VERSION__ >= 199901L
150 /* This is C99 or above: http://predef.sourceforge.net/prestd.html */
151 # define ORTHANC_PLUGIN_INLINE static inline
152 # elif defined(__cplusplus)
153 /* This is C++ */
154 # define ORTHANC_PLUGIN_INLINE static inline
155 # elif defined(__GNUC__)
156 /* This is GCC running in C89 mode */
157 # define ORTHANC_PLUGIN_INLINE static __inline
158 # elif defined(_MSC_VER)
159 /* This is Visual Studio running in C89 mode */
160 # define ORTHANC_PLUGIN_INLINE static __inline
161 # else
162 # error Your compiler is not known to support the "inline" keyword
163 # endif
164 #endif
165 
166 
167 
168 /********************************************************************
169  ** Inclusion of standard libraries.
170  ********************************************************************/
171 
177 #include <stdint.h>
178 
179 #include <stdlib.h>
180 
181 
182 
183 /********************************************************************
184  ** Definition of the Orthanc Plugin API.
185  ********************************************************************/
186 
189 #ifdef __cplusplus
190 extern "C"
191 {
192 #endif
193 
197  typedef enum
198  {
303 
304  _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
306 
307 
312  ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
313 
314 
318  typedef enum
319  {
325  _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
327 
328 
333  typedef struct
334  {
339 
343  uint32_t groupsCount;
344 
348  const char* const* groups;
349 
353  uint32_t getCount;
354 
358  const char* const* getKeys;
359 
363  const char* const* getValues;
364 
368  const void* body;
369 
373  uint32_t bodySize;
374 
375 
376  /* --------------------------------------------------
377  New in version 0.8.1
378  -------------------------------------------------- */
379 
383  uint32_t headersCount;
384 
388  const char* const* headersKeys;
389 
393  const char* const* headersValues;
394 
396 
397 
398  typedef enum
399  {
400  /* Generic services */
401  _OrthancPluginService_LogInfo = 1,
402  _OrthancPluginService_LogWarning = 2,
403  _OrthancPluginService_LogError = 3,
404  _OrthancPluginService_GetOrthancPath = 4,
405  _OrthancPluginService_GetOrthancDirectory = 5,
406  _OrthancPluginService_GetConfigurationPath = 6,
407  _OrthancPluginService_SetPluginProperty = 7,
408  _OrthancPluginService_GetGlobalProperty = 8,
409  _OrthancPluginService_SetGlobalProperty = 9,
410  _OrthancPluginService_GetCommandLineArgumentsCount = 10,
411  _OrthancPluginService_GetCommandLineArgument = 11,
412  _OrthancPluginService_GetExpectedDatabaseVersion = 12,
413  _OrthancPluginService_GetConfiguration = 13,
414  _OrthancPluginService_BufferCompression = 14,
415  _OrthancPluginService_ReadFile = 15,
416  _OrthancPluginService_WriteFile = 16,
417  _OrthancPluginService_GetErrorDescription = 17,
418  _OrthancPluginService_CallHttpClient = 18,
419  _OrthancPluginService_RegisterErrorCode = 19,
420  _OrthancPluginService_RegisterDictionaryTag = 20,
421  _OrthancPluginService_DicomBufferToJson = 21,
422  _OrthancPluginService_DicomInstanceToJson = 22,
423  _OrthancPluginService_CreateDicom = 23,
424  _OrthancPluginService_ComputeMd5 = 24,
425  _OrthancPluginService_ComputeSha1 = 25,
426  _OrthancPluginService_LookupDictionary = 26,
427  _OrthancPluginService_CallHttpClient2 = 27,
428  _OrthancPluginService_GenerateUuid = 28,
429  _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
430  _OrthancPluginService_AutodetectMimeType = 30,
431  _OrthancPluginService_SetMetricsValue = 31,
432  _OrthancPluginService_EncodeDicomWebJson = 32,
433  _OrthancPluginService_EncodeDicomWebXml = 33,
434  _OrthancPluginService_ChunkedHttpClient = 34, /* New in Orthanc 1.5.7 */
435  _OrthancPluginService_GetTagName = 35, /* New in Orthanc 1.5.7 */
436  _OrthancPluginService_EncodeDicomWebJson2 = 36, /* New in Orthanc 1.7.0 */
437  _OrthancPluginService_EncodeDicomWebXml2 = 37, /* New in Orthanc 1.7.0 */
438  _OrthancPluginService_CreateMemoryBuffer = 38, /* New in Orthanc 1.7.0 */
439  _OrthancPluginService_GenerateRestApiAuthorizationToken = 39, /* New in Orthanc 1.8.1 */
440 
441  /* Registration of callbacks */
442  _OrthancPluginService_RegisterRestCallback = 1000,
443  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
444  _OrthancPluginService_RegisterStorageArea = 1002,
445  _OrthancPluginService_RegisterOnChangeCallback = 1003,
446  _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
447  _OrthancPluginService_RegisterWorklistCallback = 1005,
448  _OrthancPluginService_RegisterDecodeImageCallback = 1006,
449  _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
450  _OrthancPluginService_RegisterFindCallback = 1008,
451  _OrthancPluginService_RegisterMoveCallback = 1009,
452  _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
453  _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
454  _OrthancPluginService_RegisterChunkedRestCallback = 1012, /* New in Orthanc 1.5.7 */
455  _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
456  _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
457  _OrthancPluginService_RegisterTranscoderCallback = 1015, /* New in Orthanc 1.7.0 */
458 
459  /* Sending answers to REST calls */
460  _OrthancPluginService_AnswerBuffer = 2000,
461  _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
462  _OrthancPluginService_Redirect = 2002,
463  _OrthancPluginService_SendHttpStatusCode = 2003,
464  _OrthancPluginService_SendUnauthorized = 2004,
465  _OrthancPluginService_SendMethodNotAllowed = 2005,
466  _OrthancPluginService_SetCookie = 2006,
467  _OrthancPluginService_SetHttpHeader = 2007,
468  _OrthancPluginService_StartMultipartAnswer = 2008,
469  _OrthancPluginService_SendMultipartItem = 2009,
470  _OrthancPluginService_SendHttpStatus = 2010,
471  _OrthancPluginService_CompressAndAnswerImage = 2011,
472  _OrthancPluginService_SendMultipartItem2 = 2012,
473  _OrthancPluginService_SetHttpErrorDetails = 2013,
474 
475  /* Access to the Orthanc database and API */
476  _OrthancPluginService_GetDicomForInstance = 3000,
477  _OrthancPluginService_RestApiGet = 3001,
478  _OrthancPluginService_RestApiPost = 3002,
479  _OrthancPluginService_RestApiDelete = 3003,
480  _OrthancPluginService_RestApiPut = 3004,
481  _OrthancPluginService_LookupPatient = 3005,
482  _OrthancPluginService_LookupStudy = 3006,
483  _OrthancPluginService_LookupSeries = 3007,
484  _OrthancPluginService_LookupInstance = 3008,
485  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
486  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
487  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
488  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
489  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
490  _OrthancPluginService_ReconstructMainDicomTags = 3014,
491  _OrthancPluginService_RestApiGet2 = 3015,
492 
493  /* Access to DICOM instances */
494  _OrthancPluginService_GetInstanceRemoteAet = 4000,
495  _OrthancPluginService_GetInstanceSize = 4001,
496  _OrthancPluginService_GetInstanceData = 4002,
497  _OrthancPluginService_GetInstanceJson = 4003,
498  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
499  _OrthancPluginService_HasInstanceMetadata = 4005,
500  _OrthancPluginService_GetInstanceMetadata = 4006,
501  _OrthancPluginService_GetInstanceOrigin = 4007,
502  _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
503  _OrthancPluginService_HasInstancePixelData = 4009,
504  _OrthancPluginService_CreateDicomInstance = 4010, /* New in Orthanc 1.7.0 */
505  _OrthancPluginService_FreeDicomInstance = 4011, /* New in Orthanc 1.7.0 */
506  _OrthancPluginService_GetInstanceFramesCount = 4012, /* New in Orthanc 1.7.0 */
507  _OrthancPluginService_GetInstanceRawFrame = 4013, /* New in Orthanc 1.7.0 */
508  _OrthancPluginService_GetInstanceDecodedFrame = 4014, /* New in Orthanc 1.7.0 */
509  _OrthancPluginService_TranscodeDicomInstance = 4015, /* New in Orthanc 1.7.0 */
510  _OrthancPluginService_SerializeDicomInstance = 4016, /* New in Orthanc 1.7.0 */
511  _OrthancPluginService_GetInstanceAdvancedJson = 4017, /* New in Orthanc 1.7.0 */
512  _OrthancPluginService_GetInstanceDicomWebJson = 4018, /* New in Orthanc 1.7.0 */
513  _OrthancPluginService_GetInstanceDicomWebXml = 4019, /* New in Orthanc 1.7.0 */
514 
515  /* Services for plugins implementing a database back-end */
516  _OrthancPluginService_RegisterDatabaseBackend = 5000,
517  _OrthancPluginService_DatabaseAnswer = 5001,
518  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
519  _OrthancPluginService_StorageAreaCreate = 5003,
520  _OrthancPluginService_StorageAreaRead = 5004,
521  _OrthancPluginService_StorageAreaRemove = 5005,
522 
523  /* Primitives for handling images */
524  _OrthancPluginService_GetImagePixelFormat = 6000,
525  _OrthancPluginService_GetImageWidth = 6001,
526  _OrthancPluginService_GetImageHeight = 6002,
527  _OrthancPluginService_GetImagePitch = 6003,
528  _OrthancPluginService_GetImageBuffer = 6004,
529  _OrthancPluginService_UncompressImage = 6005,
530  _OrthancPluginService_FreeImage = 6006,
531  _OrthancPluginService_CompressImage = 6007,
532  _OrthancPluginService_ConvertPixelFormat = 6008,
533  _OrthancPluginService_GetFontsCount = 6009,
534  _OrthancPluginService_GetFontInfo = 6010,
535  _OrthancPluginService_DrawText = 6011,
536  _OrthancPluginService_CreateImage = 6012,
537  _OrthancPluginService_CreateImageAccessor = 6013,
538  _OrthancPluginService_DecodeDicomImage = 6014,
539 
540  /* Primitives for handling C-Find, C-Move and worklists */
541  _OrthancPluginService_WorklistAddAnswer = 7000,
542  _OrthancPluginService_WorklistMarkIncomplete = 7001,
543  _OrthancPluginService_WorklistIsMatch = 7002,
544  _OrthancPluginService_WorklistGetDicomQuery = 7003,
545  _OrthancPluginService_FindAddAnswer = 7004,
546  _OrthancPluginService_FindMarkIncomplete = 7005,
547  _OrthancPluginService_GetFindQuerySize = 7006,
548  _OrthancPluginService_GetFindQueryTag = 7007,
549  _OrthancPluginService_GetFindQueryTagName = 7008,
550  _OrthancPluginService_GetFindQueryValue = 7009,
551  _OrthancPluginService_CreateFindMatcher = 7010,
552  _OrthancPluginService_FreeFindMatcher = 7011,
553  _OrthancPluginService_FindMatcherIsMatch = 7012,
554 
555  /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
556  _OrthancPluginService_GetPeers = 8000,
557  _OrthancPluginService_FreePeers = 8001,
558  _OrthancPluginService_GetPeersCount = 8003,
559  _OrthancPluginService_GetPeerName = 8004,
560  _OrthancPluginService_GetPeerUrl = 8005,
561  _OrthancPluginService_CallPeerApi = 8006,
562  _OrthancPluginService_GetPeerUserProperty = 8007,
563 
564  /* Primitives for handling jobs (new in 1.4.2) */
565  _OrthancPluginService_CreateJob = 9000,
566  _OrthancPluginService_FreeJob = 9001,
567  _OrthancPluginService_SubmitJob = 9002,
568  _OrthancPluginService_RegisterJobsUnserializer = 9003,
569 
570  _OrthancPluginService_INTERNAL = 0x7fffffff
571  } _OrthancPluginService;
572 
573 
574  typedef enum
575  {
576  _OrthancPluginProperty_Description = 1,
577  _OrthancPluginProperty_RootUri = 2,
578  _OrthancPluginProperty_OrthancExplorer = 3,
579 
580  _OrthancPluginProperty_INTERNAL = 0x7fffffff
581  } _OrthancPluginProperty;
582 
583 
584 
589  typedef enum
590  {
598 
606 
614 
622 
630 
640 
648 
656 
664 
672 
673  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
675 
676 
677 
681  typedef enum
682  {
687  _OrthancPluginContentType_INTERNAL = 0x7fffffff
689 
690 
691 
695  typedef enum
696  {
703  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
705 
706 
707 
712  typedef enum
713  {
734  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
736 
737 
742  typedef enum
743  {
749  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
751 
752 
757  typedef enum
758  {
763  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
765 
766 
771  typedef enum
772  {
801  _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
803 
804 
810  typedef enum
811  {
816  _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
818 
819 
825  typedef enum
826  {
827  OrthancPluginDicomToJsonFlags_None = 0,
835  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
837 
838 
844  typedef enum
845  {
846  OrthancPluginCreateDicomFlags_None = 0,
850  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
852 
853 
859  typedef enum
860  {
866  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
868 
869 
874  typedef enum
875  {
882  _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
884 
885 
889  typedef enum
890  {
898  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
900 
901 
905  typedef enum
906  {
911 
912 
919  typedef enum
920  {
926 
927 
931  typedef enum
932  {
942 
943 
948  typedef enum
949  {
954 
955 
961  typedef enum
962  {
990 
991 
992 
1000  typedef struct
1001  {
1005  void* data;
1006 
1010  uint32_t size;
1012 
1013 
1014 
1015 
1020  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
1021 
1022 
1023 
1028  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
1029 
1030 
1031 
1036  typedef struct _OrthancPluginImage_t OrthancPluginImage;
1037 
1038 
1039 
1044  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
1045 
1046 
1047 
1052  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
1053 
1054 
1055 
1060  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
1061 
1062 
1063 
1068  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1069 
1070 
1071 
1076  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1077 
1078 
1079 
1084  typedef struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher;
1085 
1086 
1087 
1092  typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1093 
1094 
1095 
1100  typedef struct _OrthancPluginJob_t OrthancPluginJob;
1101 
1102 
1103 
1109  typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1110 
1111 
1112 
1118  OrthancPluginRestOutput* output,
1119  const char* url,
1120  const OrthancPluginHttpRequest* request);
1121 
1122 
1123 
1129  const OrthancPluginDicomInstance* instance,
1130  const char* instanceId);
1131 
1132 
1133 
1139  OrthancPluginChangeType changeType,
1140  OrthancPluginResourceType resourceType,
1141  const char* resourceId);
1142 
1143 
1144 
1150  OrthancPluginImage** target,
1151  const void* dicom,
1152  const uint32_t size,
1153  uint32_t frameIndex);
1154 
1155 
1156 
1161  typedef void (*OrthancPluginFree) (void* buffer);
1162 
1163 
1164 
1174  const char* bulkDataUri);
1175 
1176 
1177 
1191  const char* uuid,
1192  const void* content,
1193  int64_t size,
1195 
1196 
1197 
1217  void** content,
1218  int64_t* size,
1219  const char* uuid,
1221 
1222 
1223 
1235  const char* uuid,
1237 
1238 
1239 
1255  const OrthancPluginWorklistQuery* query,
1256  const char* issuerAet,
1257  const char* calledAet);
1258 
1259 
1260 
1285  OrthancPluginHttpMethod method,
1286  const char* uri,
1287  const char* ip,
1288  uint32_t headersCount,
1289  const char* const* headersKeys,
1290  const char* const* headersValues);
1291 
1292 
1293 
1320  OrthancPluginHttpMethod method,
1321  const char* uri,
1322  const char* ip,
1323  uint32_t headersCount,
1324  const char* const* headersKeys,
1325  const char* const* headersValues,
1326  uint32_t getArgumentsCount,
1327  const char* const* getArgumentsKeys,
1328  const char* const* getArgumentsValues);
1329 
1330 
1331 
1347  OrthancPluginFindAnswers* answers,
1348  const OrthancPluginFindQuery* query,
1349  const char* issuerAet,
1350  const char* calledAet);
1351 
1352 
1353 
1389  typedef void* (*OrthancPluginMoveCallback) (
1390  OrthancPluginResourceType resourceType,
1391  const char* patientId,
1392  const char* accessionNumber,
1393  const char* studyInstanceUid,
1394  const char* seriesInstanceUid,
1395  const char* sopInstanceUid,
1396  const char* originatorAet,
1397  const char* sourceAet,
1398  const char* targetAet,
1399  uint16_t originatorId);
1400 
1401 
1414  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1415 
1416 
1429  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1430 
1431 
1443  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1444 
1445 
1456  typedef void (*OrthancPluginJobFinalize) (void* job);
1457 
1458 
1469  typedef float (*OrthancPluginJobGetProgress) (void* job);
1470 
1471 
1484  typedef const char* (*OrthancPluginJobGetContent) (void* job);
1485 
1486 
1502  typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1503 
1504 
1518 
1519 
1543 
1544 
1559 
1560 
1574  typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1575  const char* serialized);
1576 
1577 
1578 
1593 
1594 
1595 
1623  uint32_t levelDepth,
1624  const uint16_t* levelTagGroup,
1625  const uint16_t* levelTagElement,
1626  const uint32_t* levelIndex,
1627  uint16_t tagGroup,
1628  uint16_t tagElement,
1630 
1631 
1632 
1661  uint32_t levelDepth,
1662  const uint16_t* levelTagGroup,
1663  const uint16_t* levelTagElement,
1664  const uint32_t* levelIndex,
1665  uint16_t tagGroup,
1666  uint16_t tagElement,
1668  void* payload);
1669 
1670 
1671 
1675  typedef struct _OrthancPluginContext_t
1676  {
1677  void* pluginsManager;
1678  const char* orthancVersion;
1679  OrthancPluginFree Free;
1680  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1681  _OrthancPluginService service,
1682  const void* params);
1684 
1685 
1686 
1690  typedef struct
1691  {
1692  uint16_t group;
1693  uint16_t element;
1695  uint32_t minMultiplicity;
1696  uint32_t maxMultiplicity;
1698 
1699 
1700 
1709  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1710  OrthancPluginContext* context,
1711  char* str)
1712  {
1713  if (str != NULL)
1714  {
1715  context->Free(str);
1716  }
1717  }
1718 
1719 
1739  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1740  OrthancPluginContext* context,
1741  int expectedMajor,
1742  int expectedMinor,
1743  int expectedRevision)
1744  {
1745  int major, minor, revision;
1746 
1747  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1748  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1749  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1750  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1751  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1752  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1753  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1754  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1755  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1756  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1757  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1758  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1759  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1760  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1761  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1762  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1763  sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1764  sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
1765  sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
1766  sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
1767  sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason))
1768  {
1769  /* Mismatch in the size of the enumerations */
1770  return 0;
1771  }
1772 
1773  /* Assume compatibility with the mainline */
1774  if (!strcmp(context->orthancVersion, "mainline"))
1775  {
1776  return 1;
1777  }
1778 
1779  /* Parse the version of the Orthanc core */
1780  if (
1781 #ifdef _MSC_VER
1782  sscanf_s
1783 #else
1784  sscanf
1785 #endif
1786  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1787  {
1788  return 0;
1789  }
1790 
1791  /* Check the major number of the version */
1792 
1793  if (major > expectedMajor)
1794  {
1795  return 1;
1796  }
1797 
1798  if (major < expectedMajor)
1799  {
1800  return 0;
1801  }
1802 
1803  /* Check the minor number of the version */
1804 
1805  if (minor > expectedMinor)
1806  {
1807  return 1;
1808  }
1809 
1810  if (minor < expectedMinor)
1811  {
1812  return 0;
1813  }
1814 
1815  /* Check the revision number of the version */
1816 
1817  if (revision >= expectedRevision)
1818  {
1819  return 1;
1820  }
1821  else
1822  {
1823  return 0;
1824  }
1825  }
1826 
1827 
1844  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1845  OrthancPluginContext* context)
1846  {
1848  context,
1849  ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1850  ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1851  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1852  }
1853 
1854 
1863  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1864  OrthancPluginContext* context,
1865  OrthancPluginMemoryBuffer* buffer)
1866  {
1867  context->Free(buffer->data);
1868  }
1869 
1870 
1879  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1880  OrthancPluginContext* context,
1881  const char* message)
1882  {
1883  context->InvokeService(context, _OrthancPluginService_LogError, message);
1884  }
1885 
1886 
1895  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
1896  OrthancPluginContext* context,
1897  const char* message)
1898  {
1899  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1900  }
1901 
1902 
1911  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
1912  OrthancPluginContext* context,
1913  const char* message)
1914  {
1915  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
1916  }
1917 
1918 
1919 
1920  typedef struct
1921  {
1922  const char* pathRegularExpression;
1923  OrthancPluginRestCallback callback;
1924  } _OrthancPluginRestCallback;
1925 
1947  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
1948  OrthancPluginContext* context,
1949  const char* pathRegularExpression,
1950  OrthancPluginRestCallback callback)
1951  {
1952  _OrthancPluginRestCallback params;
1953  params.pathRegularExpression = pathRegularExpression;
1954  params.callback = callback;
1955  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
1956  }
1957 
1958 
1959 
1987  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
1988  OrthancPluginContext* context,
1989  const char* pathRegularExpression,
1990  OrthancPluginRestCallback callback)
1991  {
1992  _OrthancPluginRestCallback params;
1993  params.pathRegularExpression = pathRegularExpression;
1994  params.callback = callback;
1995  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
1996  }
1997 
1998 
1999 
2000  typedef struct
2001  {
2003  } _OrthancPluginOnStoredInstanceCallback;
2004 
2026  OrthancPluginContext* context,
2028  {
2029  _OrthancPluginOnStoredInstanceCallback params;
2030  params.callback = callback;
2031 
2032  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
2033  }
2034 
2035 
2036 
2037  typedef struct
2038  {
2039  OrthancPluginRestOutput* output;
2040  const void* answer;
2041  uint32_t answerSize;
2042  const char* mimeType;
2043  } _OrthancPluginAnswerBuffer;
2044 
2057  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
2058  OrthancPluginContext* context,
2059  OrthancPluginRestOutput* output,
2060  const void* answer,
2061  uint32_t answerSize,
2062  const char* mimeType)
2063  {
2064  _OrthancPluginAnswerBuffer params;
2065  params.output = output;
2066  params.answer = answer;
2067  params.answerSize = answerSize;
2068  params.mimeType = mimeType;
2069  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
2070  }
2071 
2072 
2073  typedef struct
2074  {
2075  OrthancPluginRestOutput* output;
2076  OrthancPluginPixelFormat format;
2077  uint32_t width;
2078  uint32_t height;
2079  uint32_t pitch;
2080  const void* buffer;
2081  } _OrthancPluginCompressAndAnswerPngImage;
2082 
2083  typedef struct
2084  {
2085  OrthancPluginRestOutput* output;
2086  OrthancPluginImageFormat imageFormat;
2087  OrthancPluginPixelFormat pixelFormat;
2088  uint32_t width;
2089  uint32_t height;
2090  uint32_t pitch;
2091  const void* buffer;
2092  uint8_t quality;
2093  } _OrthancPluginCompressAndAnswerImage;
2094 
2095 
2114  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2115  OrthancPluginContext* context,
2116  OrthancPluginRestOutput* output,
2117  OrthancPluginPixelFormat format,
2118  uint32_t width,
2119  uint32_t height,
2120  uint32_t pitch,
2121  const void* buffer)
2122  {
2123  _OrthancPluginCompressAndAnswerImage params;
2124  params.output = output;
2125  params.imageFormat = OrthancPluginImageFormat_Png;
2126  params.pixelFormat = format;
2127  params.width = width;
2128  params.height = height;
2129  params.pitch = pitch;
2130  params.buffer = buffer;
2131  params.quality = 0; /* No quality for PNG */
2132  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2133  }
2134 
2135 
2136 
2137  typedef struct
2138  {
2139  OrthancPluginMemoryBuffer* target;
2140  const char* instanceId;
2141  } _OrthancPluginGetDicomForInstance;
2142 
2156  OrthancPluginContext* context,
2157  OrthancPluginMemoryBuffer* target,
2158  const char* instanceId)
2159  {
2160  _OrthancPluginGetDicomForInstance params;
2161  params.target = target;
2162  params.instanceId = instanceId;
2163  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2164  }
2165 
2166 
2167 
2168  typedef struct
2169  {
2170  OrthancPluginMemoryBuffer* target;
2171  const char* uri;
2172  } _OrthancPluginRestApiGet;
2173 
2189  OrthancPluginContext* context,
2190  OrthancPluginMemoryBuffer* target,
2191  const char* uri)
2192  {
2193  _OrthancPluginRestApiGet params;
2194  params.target = target;
2195  params.uri = uri;
2196  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2197  }
2198 
2199 
2200 
2219  OrthancPluginContext* context,
2220  OrthancPluginMemoryBuffer* target,
2221  const char* uri)
2222  {
2223  _OrthancPluginRestApiGet params;
2224  params.target = target;
2225  params.uri = uri;
2226  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2227  }
2228 
2229 
2230 
2231  typedef struct
2232  {
2233  OrthancPluginMemoryBuffer* target;
2234  const char* uri;
2235  const void* body;
2236  uint32_t bodySize;
2237  } _OrthancPluginRestApiPostPut;
2238 
2256  OrthancPluginContext* context,
2257  OrthancPluginMemoryBuffer* target,
2258  const char* uri,
2259  const void* body,
2260  uint32_t bodySize)
2261  {
2262  _OrthancPluginRestApiPostPut params;
2263  params.target = target;
2264  params.uri = uri;
2265  params.body = body;
2266  params.bodySize = bodySize;
2267  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2268  }
2269 
2270 
2291  OrthancPluginContext* context,
2292  OrthancPluginMemoryBuffer* target,
2293  const char* uri,
2294  const void* body,
2295  uint32_t bodySize)
2296  {
2297  _OrthancPluginRestApiPostPut params;
2298  params.target = target;
2299  params.uri = uri;
2300  params.body = body;
2301  params.bodySize = bodySize;
2302  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2303  }
2304 
2305 
2306 
2320  OrthancPluginContext* context,
2321  const char* uri)
2322  {
2323  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2324  }
2325 
2326 
2343  OrthancPluginContext* context,
2344  const char* uri)
2345  {
2346  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2347  }
2348 
2349 
2350 
2368  OrthancPluginContext* context,
2369  OrthancPluginMemoryBuffer* target,
2370  const char* uri,
2371  const void* body,
2372  uint32_t bodySize)
2373  {
2374  _OrthancPluginRestApiPostPut params;
2375  params.target = target;
2376  params.uri = uri;
2377  params.body = body;
2378  params.bodySize = bodySize;
2379  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2380  }
2381 
2382 
2383 
2404  OrthancPluginContext* context,
2405  OrthancPluginMemoryBuffer* target,
2406  const char* uri,
2407  const void* body,
2408  uint32_t bodySize)
2409  {
2410  _OrthancPluginRestApiPostPut params;
2411  params.target = target;
2412  params.uri = uri;
2413  params.body = body;
2414  params.bodySize = bodySize;
2415  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2416  }
2417 
2418 
2419 
2420  typedef struct
2421  {
2422  OrthancPluginRestOutput* output;
2423  const char* argument;
2424  } _OrthancPluginOutputPlusArgument;
2425 
2437  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2438  OrthancPluginContext* context,
2439  OrthancPluginRestOutput* output,
2440  const char* redirection)
2441  {
2442  _OrthancPluginOutputPlusArgument params;
2443  params.output = output;
2444  params.argument = redirection;
2445  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2446  }
2447 
2448 
2449 
2450  typedef struct
2451  {
2452  char** result;
2453  const char* argument;
2454  } _OrthancPluginRetrieveDynamicString;
2455 
2469  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2470  OrthancPluginContext* context,
2471  const char* patientID)
2472  {
2473  char* result;
2474 
2475  _OrthancPluginRetrieveDynamicString params;
2476  params.result = &result;
2477  params.argument = patientID;
2478 
2479  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2480  {
2481  /* Error */
2482  return NULL;
2483  }
2484  else
2485  {
2486  return result;
2487  }
2488  }
2489 
2490 
2504  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2505  OrthancPluginContext* context,
2506  const char* studyUID)
2507  {
2508  char* result;
2509 
2510  _OrthancPluginRetrieveDynamicString params;
2511  params.result = &result;
2512  params.argument = studyUID;
2513 
2514  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2515  {
2516  /* Error */
2517  return NULL;
2518  }
2519  else
2520  {
2521  return result;
2522  }
2523  }
2524 
2525 
2539  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
2540  OrthancPluginContext* context,
2541  const char* accessionNumber)
2542  {
2543  char* result;
2544 
2545  _OrthancPluginRetrieveDynamicString params;
2546  params.result = &result;
2547  params.argument = accessionNumber;
2548 
2549  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2550  {
2551  /* Error */
2552  return NULL;
2553  }
2554  else
2555  {
2556  return result;
2557  }
2558  }
2559 
2560 
2574  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2575  OrthancPluginContext* context,
2576  const char* seriesUID)
2577  {
2578  char* result;
2579 
2580  _OrthancPluginRetrieveDynamicString params;
2581  params.result = &result;
2582  params.argument = seriesUID;
2583 
2584  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2585  {
2586  /* Error */
2587  return NULL;
2588  }
2589  else
2590  {
2591  return result;
2592  }
2593  }
2594 
2595 
2609  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2610  OrthancPluginContext* context,
2611  const char* sopInstanceUID)
2612  {
2613  char* result;
2614 
2615  _OrthancPluginRetrieveDynamicString params;
2616  params.result = &result;
2617  params.argument = sopInstanceUID;
2618 
2619  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2620  {
2621  /* Error */
2622  return NULL;
2623  }
2624  else
2625  {
2626  return result;
2627  }
2628  }
2629 
2630 
2631 
2632  typedef struct
2633  {
2634  OrthancPluginRestOutput* output;
2635  uint16_t status;
2636  } _OrthancPluginSendHttpStatusCode;
2637 
2654  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2655  OrthancPluginContext* context,
2656  OrthancPluginRestOutput* output,
2657  uint16_t status)
2658  {
2659  _OrthancPluginSendHttpStatusCode params;
2660  params.output = output;
2661  params.status = status;
2662  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2663  }
2664 
2665 
2677  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2678  OrthancPluginContext* context,
2679  OrthancPluginRestOutput* output,
2680  const char* realm)
2681  {
2682  _OrthancPluginOutputPlusArgument params;
2683  params.output = output;
2684  params.argument = realm;
2685  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2686  }
2687 
2688 
2700  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2701  OrthancPluginContext* context,
2702  OrthancPluginRestOutput* output,
2703  const char* allowedMethods)
2704  {
2705  _OrthancPluginOutputPlusArgument params;
2706  params.output = output;
2707  params.argument = allowedMethods;
2708  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2709  }
2710 
2711 
2712  typedef struct
2713  {
2714  OrthancPluginRestOutput* output;
2715  const char* key;
2716  const char* value;
2717  } _OrthancPluginSetHttpHeader;
2718 
2730  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2731  OrthancPluginContext* context,
2732  OrthancPluginRestOutput* output,
2733  const char* cookie,
2734  const char* value)
2735  {
2736  _OrthancPluginSetHttpHeader params;
2737  params.output = output;
2738  params.key = cookie;
2739  params.value = value;
2740  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2741  }
2742 
2743 
2755  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2756  OrthancPluginContext* context,
2757  OrthancPluginRestOutput* output,
2758  const char* key,
2759  const char* value)
2760  {
2761  _OrthancPluginSetHttpHeader params;
2762  params.output = output;
2763  params.key = key;
2764  params.value = value;
2765  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2766  }
2767 
2768 
2769  typedef struct
2770  {
2771  char** resultStringToFree;
2772  const char** resultString;
2773  int64_t* resultInt64;
2774  const char* key;
2775  const OrthancPluginDicomInstance* instance;
2776  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2777  } _OrthancPluginAccessDicomInstance;
2778 
2779 
2791  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2792  OrthancPluginContext* context,
2793  const OrthancPluginDicomInstance* instance)
2794  {
2795  const char* result;
2796 
2797  _OrthancPluginAccessDicomInstance params;
2798  memset(&params, 0, sizeof(params));
2799  params.resultString = &result;
2800  params.instance = instance;
2801 
2802  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2803  {
2804  /* Error */
2805  return NULL;
2806  }
2807  else
2808  {
2809  return result;
2810  }
2811  }
2812 
2813 
2824  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2825  OrthancPluginContext* context,
2826  const OrthancPluginDicomInstance* instance)
2827  {
2828  int64_t size;
2829 
2830  _OrthancPluginAccessDicomInstance params;
2831  memset(&params, 0, sizeof(params));
2832  params.resultInt64 = &size;
2833  params.instance = instance;
2834 
2835  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2836  {
2837  /* Error */
2838  return -1;
2839  }
2840  else
2841  {
2842  return size;
2843  }
2844  }
2845 
2846 
2857  ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData(
2858  OrthancPluginContext* context,
2859  const OrthancPluginDicomInstance* instance)
2860  {
2861  const char* result;
2862 
2863  _OrthancPluginAccessDicomInstance params;
2864  memset(&params, 0, sizeof(params));
2865  params.resultString = &result;
2866  params.instance = instance;
2867 
2868  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2869  {
2870  /* Error */
2871  return NULL;
2872  }
2873  else
2874  {
2875  return result;
2876  }
2877  }
2878 
2879 
2893  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
2894  OrthancPluginContext* context,
2895  const OrthancPluginDicomInstance* instance)
2896  {
2897  char* result;
2898 
2899  _OrthancPluginAccessDicomInstance params;
2900  memset(&params, 0, sizeof(params));
2901  params.resultStringToFree = &result;
2902  params.instance = instance;
2903 
2904  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
2905  {
2906  /* Error */
2907  return NULL;
2908  }
2909  else
2910  {
2911  return result;
2912  }
2913  }
2914 
2915 
2931  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
2932  OrthancPluginContext* context,
2933  const OrthancPluginDicomInstance* instance)
2934  {
2935  char* result;
2936 
2937  _OrthancPluginAccessDicomInstance params;
2938  memset(&params, 0, sizeof(params));
2939  params.resultStringToFree = &result;
2940  params.instance = instance;
2941 
2942  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
2943  {
2944  /* Error */
2945  return NULL;
2946  }
2947  else
2948  {
2949  return result;
2950  }
2951  }
2952 
2953 
2970  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
2971  OrthancPluginContext* context,
2972  const OrthancPluginDicomInstance* instance,
2973  const char* metadata)
2974  {
2975  int64_t result;
2976 
2977  _OrthancPluginAccessDicomInstance params;
2978  memset(&params, 0, sizeof(params));
2979  params.resultInt64 = &result;
2980  params.instance = instance;
2981  params.key = metadata;
2982 
2983  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2984  {
2985  /* Error */
2986  return -1;
2987  }
2988  else
2989  {
2990  return (result != 0);
2991  }
2992  }
2993 
2994 
3011  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
3012  OrthancPluginContext* context,
3013  const OrthancPluginDicomInstance* instance,
3014  const char* metadata)
3015  {
3016  const char* result;
3017 
3018  _OrthancPluginAccessDicomInstance params;
3019  memset(&params, 0, sizeof(params));
3020  params.resultString = &result;
3021  params.instance = instance;
3022  params.key = metadata;
3023 
3024  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3025  {
3026  /* Error */
3027  return NULL;
3028  }
3029  else
3030  {
3031  return result;
3032  }
3033  }
3034 
3035 
3036 
3037  typedef struct
3038  {
3042  OrthancPluginFree free;
3043  } _OrthancPluginRegisterStorageArea;
3044 
3059  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
3060  OrthancPluginContext* context,
3064  {
3065  _OrthancPluginRegisterStorageArea params;
3066  params.create = create;
3067  params.read = read;
3068  params.remove = remove;
3069 
3070 #ifdef __cplusplus
3071  params.free = ::free;
3072 #else
3073  params.free = free;
3074 #endif
3075 
3076  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3077  }
3078 
3079 
3080 
3091  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3092  {
3093  char* result;
3094 
3095  _OrthancPluginRetrieveDynamicString params;
3096  params.result = &result;
3097  params.argument = NULL;
3098 
3099  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3100  {
3101  /* Error */
3102  return NULL;
3103  }
3104  else
3105  {
3106  return result;
3107  }
3108  }
3109 
3110 
3121  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3122  {
3123  char* result;
3124 
3125  _OrthancPluginRetrieveDynamicString params;
3126  params.result = &result;
3127  params.argument = NULL;
3128 
3129  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3130  {
3131  /* Error */
3132  return NULL;
3133  }
3134  else
3135  {
3136  return result;
3137  }
3138  }
3139 
3140 
3156  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3157  {
3158  char* result;
3159 
3160  _OrthancPluginRetrieveDynamicString params;
3161  params.result = &result;
3162  params.argument = NULL;
3163 
3164  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3165  {
3166  /* Error */
3167  return NULL;
3168  }
3169  else
3170  {
3171  return result;
3172  }
3173  }
3174 
3175 
3176 
3177  typedef struct
3178  {
3180  } _OrthancPluginOnChangeCallback;
3181 
3202  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3203  OrthancPluginContext* context,
3205  {
3206  _OrthancPluginOnChangeCallback params;
3207  params.callback = callback;
3208 
3209  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3210  }
3211 
3212 
3213 
3214  typedef struct
3215  {
3216  const char* plugin;
3217  _OrthancPluginProperty property;
3218  const char* value;
3219  } _OrthancPluginSetPluginProperty;
3220 
3221 
3233  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3234  OrthancPluginContext* context,
3235  const char* uri)
3236  {
3237  _OrthancPluginSetPluginProperty params;
3238  params.plugin = OrthancPluginGetName();
3239  params.property = _OrthancPluginProperty_RootUri;
3240  params.value = uri;
3241 
3242  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3243  }
3244 
3245 
3255  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3256  OrthancPluginContext* context,
3257  const char* description)
3258  {
3259  _OrthancPluginSetPluginProperty params;
3260  params.plugin = OrthancPluginGetName();
3261  params.property = _OrthancPluginProperty_Description;
3262  params.value = description;
3263 
3264  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3265  }
3266 
3267 
3277  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3278  OrthancPluginContext* context,
3279  const char* javascript)
3280  {
3281  _OrthancPluginSetPluginProperty params;
3282  params.plugin = OrthancPluginGetName();
3283  params.property = _OrthancPluginProperty_OrthancExplorer;
3284  params.value = javascript;
3285 
3286  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3287  }
3288 
3289 
3290  typedef struct
3291  {
3292  char** result;
3293  int32_t property;
3294  const char* value;
3295  } _OrthancPluginGlobalProperty;
3296 
3297 
3311  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3312  OrthancPluginContext* context,
3313  int32_t property,
3314  const char* defaultValue)
3315  {
3316  char* result;
3317 
3318  _OrthancPluginGlobalProperty params;
3319  params.result = &result;
3320  params.property = property;
3321  params.value = defaultValue;
3322 
3323  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3324  {
3325  /* Error */
3326  return NULL;
3327  }
3328  else
3329  {
3330  return result;
3331  }
3332  }
3333 
3334 
3351  OrthancPluginContext* context,
3352  int32_t property,
3353  const char* value)
3354  {
3355  _OrthancPluginGlobalProperty params;
3356  params.result = NULL;
3357  params.property = property;
3358  params.value = value;
3359 
3360  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3361  }
3362 
3363 
3364 
3365  typedef struct
3366  {
3367  int32_t *resultInt32;
3368  uint32_t *resultUint32;
3369  int64_t *resultInt64;
3370  uint64_t *resultUint64;
3371  } _OrthancPluginReturnSingleValue;
3372 
3381  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3382  OrthancPluginContext* context)
3383  {
3384  uint32_t count = 0;
3385 
3386  _OrthancPluginReturnSingleValue params;
3387  memset(&params, 0, sizeof(params));
3388  params.resultUint32 = &count;
3389 
3390  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3391  {
3392  /* Error */
3393  return 0;
3394  }
3395  else
3396  {
3397  return count;
3398  }
3399  }
3400 
3401 
3402 
3415  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3416  OrthancPluginContext* context,
3417  uint32_t argument)
3418  {
3419  char* result;
3420 
3421  _OrthancPluginGlobalProperty params;
3422  params.result = &result;
3423  params.property = (int32_t) argument;
3424  params.value = NULL;
3425 
3426  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3427  {
3428  /* Error */
3429  return NULL;
3430  }
3431  else
3432  {
3433  return result;
3434  }
3435  }
3436 
3437 
3447  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3448  OrthancPluginContext* context)
3449  {
3450  uint32_t count = 0;
3451 
3452  _OrthancPluginReturnSingleValue params;
3453  memset(&params, 0, sizeof(params));
3454  params.resultUint32 = &count;
3455 
3456  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3457  {
3458  /* Error */
3459  return 0;
3460  }
3461  else
3462  {
3463  return count;
3464  }
3465  }
3466 
3467 
3468 
3480  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3481  {
3482  char* result;
3483 
3484  _OrthancPluginRetrieveDynamicString params;
3485  params.result = &result;
3486  params.argument = NULL;
3487 
3488  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3489  {
3490  /* Error */
3491  return NULL;
3492  }
3493  else
3494  {
3495  return result;
3496  }
3497  }
3498 
3499 
3500 
3501  typedef struct
3502  {
3503  OrthancPluginRestOutput* output;
3504  const char* subType;
3505  const char* contentType;
3506  } _OrthancPluginStartMultipartAnswer;
3507 
3522  OrthancPluginContext* context,
3523  OrthancPluginRestOutput* output,
3524  const char* subType,
3525  const char* contentType)
3526  {
3527  _OrthancPluginStartMultipartAnswer params;
3528  params.output = output;
3529  params.subType = subType;
3530  params.contentType = contentType;
3531  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3532  }
3533 
3534 
3551  OrthancPluginContext* context,
3552  OrthancPluginRestOutput* output,
3553  const void* answer,
3554  uint32_t answerSize)
3555  {
3556  _OrthancPluginAnswerBuffer params;
3557  params.output = output;
3558  params.answer = answer;
3559  params.answerSize = answerSize;
3560  params.mimeType = NULL;
3561  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3562  }
3563 
3564 
3565 
3566  typedef struct
3567  {
3568  OrthancPluginMemoryBuffer* target;
3569  const void* source;
3570  uint32_t size;
3571  OrthancPluginCompressionType compression;
3572  uint8_t uncompress;
3573  } _OrthancPluginBufferCompression;
3574 
3575 
3593  OrthancPluginContext* context,
3594  OrthancPluginMemoryBuffer* target,
3595  const void* source,
3596  uint32_t size,
3597  OrthancPluginCompressionType compression,
3598  uint8_t uncompress)
3599  {
3600  _OrthancPluginBufferCompression params;
3601  params.target = target;
3602  params.source = source;
3603  params.size = size;
3604  params.compression = compression;
3605  params.uncompress = uncompress;
3606 
3607  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3608  }
3609 
3610 
3611 
3612  typedef struct
3613  {
3614  OrthancPluginMemoryBuffer* target;
3615  const char* path;
3616  } _OrthancPluginReadFile;
3617 
3630  OrthancPluginContext* context,
3631  OrthancPluginMemoryBuffer* target,
3632  const char* path)
3633  {
3634  _OrthancPluginReadFile params;
3635  params.target = target;
3636  params.path = path;
3637  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3638  }
3639 
3640 
3641 
3642  typedef struct
3643  {
3644  const char* path;
3645  const void* data;
3646  uint32_t size;
3647  } _OrthancPluginWriteFile;
3648 
3661  OrthancPluginContext* context,
3662  const char* path,
3663  const void* data,
3664  uint32_t size)
3665  {
3666  _OrthancPluginWriteFile params;
3667  params.path = path;
3668  params.data = data;
3669  params.size = size;
3670  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3671  }
3672 
3673 
3674 
3675  typedef struct
3676  {
3677  const char** target;
3678  OrthancPluginErrorCode error;
3679  } _OrthancPluginGetErrorDescription;
3680 
3691  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3692  OrthancPluginContext* context,
3693  OrthancPluginErrorCode error)
3694  {
3695  const char* result = NULL;
3696 
3697  _OrthancPluginGetErrorDescription params;
3698  params.target = &result;
3699  params.error = error;
3700 
3701  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3702  result == NULL)
3703  {
3704  return "Unknown error code";
3705  }
3706  else
3707  {
3708  return result;
3709  }
3710  }
3711 
3712 
3713 
3714  typedef struct
3715  {
3716  OrthancPluginRestOutput* output;
3717  uint16_t status;
3718  const char* body;
3719  uint32_t bodySize;
3720  } _OrthancPluginSendHttpStatus;
3721 
3744  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3745  OrthancPluginContext* context,
3746  OrthancPluginRestOutput* output,
3747  uint16_t status,
3748  const char* body,
3749  uint32_t bodySize)
3750  {
3751  _OrthancPluginSendHttpStatus params;
3752  params.output = output;
3753  params.status = status;
3754  params.body = body;
3755  params.bodySize = bodySize;
3756  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3757  }
3758 
3759 
3760 
3761  typedef struct
3762  {
3763  const OrthancPluginImage* image;
3764  uint32_t* resultUint32;
3765  OrthancPluginPixelFormat* resultPixelFormat;
3766  void** resultBuffer;
3767  } _OrthancPluginGetImageInfo;
3768 
3769 
3781  OrthancPluginContext* context,
3782  const OrthancPluginImage* image)
3783  {
3784  OrthancPluginPixelFormat target;
3785 
3786  _OrthancPluginGetImageInfo params;
3787  memset(&params, 0, sizeof(params));
3788  params.image = image;
3789  params.resultPixelFormat = &target;
3790 
3791  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3792  {
3794  }
3795  else
3796  {
3797  return (OrthancPluginPixelFormat) target;
3798  }
3799  }
3800 
3801 
3802 
3813  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3814  OrthancPluginContext* context,
3815  const OrthancPluginImage* image)
3816  {
3817  uint32_t width;
3818 
3819  _OrthancPluginGetImageInfo params;
3820  memset(&params, 0, sizeof(params));
3821  params.image = image;
3822  params.resultUint32 = &width;
3823 
3824  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3825  {
3826  return 0;
3827  }
3828  else
3829  {
3830  return width;
3831  }
3832  }
3833 
3834 
3835 
3846  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3847  OrthancPluginContext* context,
3848  const OrthancPluginImage* image)
3849  {
3850  uint32_t height;
3851 
3852  _OrthancPluginGetImageInfo params;
3853  memset(&params, 0, sizeof(params));
3854  params.image = image;
3855  params.resultUint32 = &height;
3856 
3857  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3858  {
3859  return 0;
3860  }
3861  else
3862  {
3863  return height;
3864  }
3865  }
3866 
3867 
3868 
3881  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3882  OrthancPluginContext* context,
3883  const OrthancPluginImage* image)
3884  {
3885  uint32_t pitch;
3886 
3887  _OrthancPluginGetImageInfo params;
3888  memset(&params, 0, sizeof(params));
3889  params.image = image;
3890  params.resultUint32 = &pitch;
3891 
3892  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
3893  {
3894  return 0;
3895  }
3896  else
3897  {
3898  return pitch;
3899  }
3900  }
3901 
3902 
3903 
3915  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
3916  OrthancPluginContext* context,
3917  const OrthancPluginImage* image)
3918  {
3919  void* target = NULL;
3920 
3921  _OrthancPluginGetImageInfo params;
3922  memset(&params, 0, sizeof(params));
3923  params.resultBuffer = &target;
3924  params.image = image;
3925 
3926  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
3927  {
3928  return NULL;
3929  }
3930  else
3931  {
3932  return target;
3933  }
3934  }
3935 
3936 
3937  typedef struct
3938  {
3939  OrthancPluginImage** target;
3940  const void* data;
3941  uint32_t size;
3942  OrthancPluginImageFormat format;
3943  } _OrthancPluginUncompressImage;
3944 
3945 
3959  OrthancPluginContext* context,
3960  const void* data,
3961  uint32_t size,
3962  OrthancPluginImageFormat format)
3963  {
3964  OrthancPluginImage* target = NULL;
3965 
3966  _OrthancPluginUncompressImage params;
3967  memset(&params, 0, sizeof(params));
3968  params.target = &target;
3969  params.data = data;
3970  params.size = size;
3971  params.format = format;
3972 
3973  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
3974  {
3975  return NULL;
3976  }
3977  else
3978  {
3979  return target;
3980  }
3981  }
3982 
3983 
3984 
3985 
3986  typedef struct
3987  {
3988  OrthancPluginImage* image;
3989  } _OrthancPluginFreeImage;
3990 
4000  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
4001  OrthancPluginContext* context,
4002  OrthancPluginImage* image)
4003  {
4004  _OrthancPluginFreeImage params;
4005  params.image = image;
4006 
4007  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
4008  }
4009 
4010 
4011 
4012 
4013  typedef struct
4014  {
4015  OrthancPluginMemoryBuffer* target;
4016  OrthancPluginImageFormat imageFormat;
4017  OrthancPluginPixelFormat pixelFormat;
4018  uint32_t width;
4019  uint32_t height;
4020  uint32_t pitch;
4021  const void* buffer;
4022  uint8_t quality;
4023  } _OrthancPluginCompressImage;
4024 
4025 
4046  OrthancPluginContext* context,
4047  OrthancPluginMemoryBuffer* target,
4048  OrthancPluginPixelFormat format,
4049  uint32_t width,
4050  uint32_t height,
4051  uint32_t pitch,
4052  const void* buffer)
4053  {
4054  _OrthancPluginCompressImage params;
4055  memset(&params, 0, sizeof(params));
4056  params.target = target;
4057  params.imageFormat = OrthancPluginImageFormat_Png;
4058  params.pixelFormat = format;
4059  params.width = width;
4060  params.height = height;
4061  params.pitch = pitch;
4062  params.buffer = buffer;
4063  params.quality = 0; /* Unused for PNG */
4064 
4065  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4066  }
4067 
4068 
4091  OrthancPluginContext* context,
4092  OrthancPluginMemoryBuffer* target,
4093  OrthancPluginPixelFormat format,
4094  uint32_t width,
4095  uint32_t height,
4096  uint32_t pitch,
4097  const void* buffer,
4098  uint8_t quality)
4099  {
4100  _OrthancPluginCompressImage params;
4101  memset(&params, 0, sizeof(params));
4102  params.target = target;
4103  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4104  params.pixelFormat = format;
4105  params.width = width;
4106  params.height = height;
4107  params.pitch = pitch;
4108  params.buffer = buffer;
4109  params.quality = quality;
4110 
4111  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4112  }
4113 
4114 
4115 
4137  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
4138  OrthancPluginContext* context,
4139  OrthancPluginRestOutput* output,
4140  OrthancPluginPixelFormat format,
4141  uint32_t width,
4142  uint32_t height,
4143  uint32_t pitch,
4144  const void* buffer,
4145  uint8_t quality)
4146  {
4147  _OrthancPluginCompressAndAnswerImage params;
4148  params.output = output;
4149  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4150  params.pixelFormat = format;
4151  params.width = width;
4152  params.height = height;
4153  params.pitch = pitch;
4154  params.buffer = buffer;
4155  params.quality = quality;
4156  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4157  }
4158 
4159 
4160 
4161 
4162  typedef struct
4163  {
4164  OrthancPluginMemoryBuffer* target;
4165  OrthancPluginHttpMethod method;
4166  const char* url;
4167  const char* username;
4168  const char* password;
4169  const void* body;
4170  uint32_t bodySize;
4171  } _OrthancPluginCallHttpClient;
4172 
4173 
4191  OrthancPluginContext* context,
4192  OrthancPluginMemoryBuffer* target,
4193  const char* url,
4194  const char* username,
4195  const char* password)
4196  {
4197  _OrthancPluginCallHttpClient params;
4198  memset(&params, 0, sizeof(params));
4199 
4200  params.target = target;
4201  params.method = OrthancPluginHttpMethod_Get;
4202  params.url = url;
4203  params.username = username;
4204  params.password = password;
4205 
4206  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4207  }
4208 
4209 
4229  OrthancPluginContext* context,
4230  OrthancPluginMemoryBuffer* target,
4231  const char* url,
4232  const void* body,
4233  uint32_t bodySize,
4234  const char* username,
4235  const char* password)
4236  {
4237  _OrthancPluginCallHttpClient params;
4238  memset(&params, 0, sizeof(params));
4239 
4240  params.target = target;
4241  params.method = OrthancPluginHttpMethod_Post;
4242  params.url = url;
4243  params.body = body;
4244  params.bodySize = bodySize;
4245  params.username = username;
4246  params.password = password;
4247 
4248  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4249  }
4250 
4251 
4271  OrthancPluginContext* context,
4272  OrthancPluginMemoryBuffer* target,
4273  const char* url,
4274  const void* body,
4275  uint32_t bodySize,
4276  const char* username,
4277  const char* password)
4278  {
4279  _OrthancPluginCallHttpClient params;
4280  memset(&params, 0, sizeof(params));
4281 
4282  params.target = target;
4283  params.method = OrthancPluginHttpMethod_Put;
4284  params.url = url;
4285  params.body = body;
4286  params.bodySize = bodySize;
4287  params.username = username;
4288  params.password = password;
4289 
4290  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4291  }
4292 
4293 
4309  OrthancPluginContext* context,
4310  const char* url,
4311  const char* username,
4312  const char* password)
4313  {
4314  _OrthancPluginCallHttpClient params;
4315  memset(&params, 0, sizeof(params));
4316 
4317  params.method = OrthancPluginHttpMethod_Delete;
4318  params.url = url;
4319  params.username = username;
4320  params.password = password;
4321 
4322  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4323  }
4324 
4325 
4326 
4327  typedef struct
4328  {
4329  OrthancPluginImage** target;
4330  const OrthancPluginImage* source;
4331  OrthancPluginPixelFormat targetFormat;
4332  } _OrthancPluginConvertPixelFormat;
4333 
4334 
4347  OrthancPluginContext* context,
4348  const OrthancPluginImage* source,
4349  OrthancPluginPixelFormat targetFormat)
4350  {
4351  OrthancPluginImage* target = NULL;
4352 
4353  _OrthancPluginConvertPixelFormat params;
4354  params.target = &target;
4355  params.source = source;
4356  params.targetFormat = targetFormat;
4357 
4358  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4359  {
4360  return NULL;
4361  }
4362  else
4363  {
4364  return target;
4365  }
4366  }
4367 
4368 
4369 
4381  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4382  OrthancPluginContext* context)
4383  {
4384  uint32_t count = 0;
4385 
4386  _OrthancPluginReturnSingleValue params;
4387  memset(&params, 0, sizeof(params));
4388  params.resultUint32 = &count;
4389 
4390  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4391  {
4392  /* Error */
4393  return 0;
4394  }
4395  else
4396  {
4397  return count;
4398  }
4399  }
4400 
4401 
4402 
4403 
4404  typedef struct
4405  {
4406  uint32_t fontIndex; /* in */
4407  const char** name; /* out */
4408  uint32_t* size; /* out */
4409  } _OrthancPluginGetFontInfo;
4410 
4421  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4422  OrthancPluginContext* context,
4423  uint32_t fontIndex)
4424  {
4425  const char* result = NULL;
4426 
4427  _OrthancPluginGetFontInfo params;
4428  memset(&params, 0, sizeof(params));
4429  params.name = &result;
4430  params.fontIndex = fontIndex;
4431 
4432  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4433  {
4434  return NULL;
4435  }
4436  else
4437  {
4438  return result;
4439  }
4440  }
4441 
4442 
4453  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4454  OrthancPluginContext* context,
4455  uint32_t fontIndex)
4456  {
4457  uint32_t result;
4458 
4459  _OrthancPluginGetFontInfo params;
4460  memset(&params, 0, sizeof(params));
4461  params.size = &result;
4462  params.fontIndex = fontIndex;
4463 
4464  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4465  {
4466  return 0;
4467  }
4468  else
4469  {
4470  return result;
4471  }
4472  }
4473 
4474 
4475 
4476  typedef struct
4477  {
4478  OrthancPluginImage* image;
4479  uint32_t fontIndex;
4480  const char* utf8Text;
4481  int32_t x;
4482  int32_t y;
4483  uint8_t r;
4484  uint8_t g;
4485  uint8_t b;
4486  } _OrthancPluginDrawText;
4487 
4488 
4507  OrthancPluginContext* context,
4508  OrthancPluginImage* image,
4509  uint32_t fontIndex,
4510  const char* utf8Text,
4511  int32_t x,
4512  int32_t y,
4513  uint8_t r,
4514  uint8_t g,
4515  uint8_t b)
4516  {
4517  _OrthancPluginDrawText params;
4518  memset(&params, 0, sizeof(params));
4519  params.image = image;
4520  params.fontIndex = fontIndex;
4521  params.utf8Text = utf8Text;
4522  params.x = x;
4523  params.y = y;
4524  params.r = r;
4525  params.g = g;
4526  params.b = b;
4527 
4528  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4529  }
4530 
4531 
4532 
4533  typedef struct
4534  {
4535  OrthancPluginStorageArea* storageArea;
4536  const char* uuid;
4537  const void* content;
4538  uint64_t size;
4540  } _OrthancPluginStorageAreaCreate;
4541 
4542 
4559  OrthancPluginContext* context,
4560  OrthancPluginStorageArea* storageArea,
4561  const char* uuid,
4562  const void* content,
4563  uint64_t size,
4565  {
4566  _OrthancPluginStorageAreaCreate params;
4567  params.storageArea = storageArea;
4568  params.uuid = uuid;
4569  params.content = content;
4570  params.size = size;
4571  params.type = type;
4572 
4573  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4574  }
4575 
4576 
4577  typedef struct
4578  {
4579  OrthancPluginMemoryBuffer* target;
4580  OrthancPluginStorageArea* storageArea;
4581  const char* uuid;
4583  } _OrthancPluginStorageAreaRead;
4584 
4585 
4601  OrthancPluginContext* context,
4602  OrthancPluginMemoryBuffer* target,
4603  OrthancPluginStorageArea* storageArea,
4604  const char* uuid,
4606  {
4607  _OrthancPluginStorageAreaRead params;
4608  params.target = target;
4609  params.storageArea = storageArea;
4610  params.uuid = uuid;
4611  params.type = type;
4612 
4613  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4614  }
4615 
4616 
4617  typedef struct
4618  {
4619  OrthancPluginStorageArea* storageArea;
4620  const char* uuid;
4622  } _OrthancPluginStorageAreaRemove;
4623 
4638  OrthancPluginContext* context,
4639  OrthancPluginStorageArea* storageArea,
4640  const char* uuid,
4642  {
4643  _OrthancPluginStorageAreaRemove params;
4644  params.storageArea = storageArea;
4645  params.uuid = uuid;
4646  params.type = type;
4647 
4648  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4649  }
4650 
4651 
4652 
4653  typedef struct
4654  {
4655  OrthancPluginErrorCode* target;
4656  int32_t code;
4657  uint16_t httpStatus;
4658  const char* message;
4659  } _OrthancPluginRegisterErrorCode;
4660 
4677  OrthancPluginContext* context,
4678  int32_t code,
4679  uint16_t httpStatus,
4680  const char* message)
4681  {
4682  OrthancPluginErrorCode target;
4683 
4684  _OrthancPluginRegisterErrorCode params;
4685  params.target = &target;
4686  params.code = code;
4687  params.httpStatus = httpStatus;
4688  params.message = message;
4689 
4690  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4691  {
4692  return target;
4693  }
4694  else
4695  {
4696  /* There was an error while assigned the error. Use a generic code. */
4698  }
4699  }
4700 
4701 
4702 
4703  typedef struct
4704  {
4705  uint16_t group;
4706  uint16_t element;
4708  const char* name;
4709  uint32_t minMultiplicity;
4710  uint32_t maxMultiplicity;
4711  } _OrthancPluginRegisterDictionaryTag;
4712 
4733  OrthancPluginContext* context,
4734  uint16_t group,
4735  uint16_t element,
4737  const char* name,
4738  uint32_t minMultiplicity,
4739  uint32_t maxMultiplicity)
4740  {
4741  _OrthancPluginRegisterDictionaryTag params;
4742  params.group = group;
4743  params.element = element;
4744  params.vr = vr;
4745  params.name = name;
4746  params.minMultiplicity = minMultiplicity;
4747  params.maxMultiplicity = maxMultiplicity;
4748 
4749  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4750  }
4751 
4752 
4753 
4754  typedef struct
4755  {
4756  uint16_t group;
4757  uint16_t element;
4759  const char* name;
4760  uint32_t minMultiplicity;
4761  uint32_t maxMultiplicity;
4762  const char* privateCreator;
4763  } _OrthancPluginRegisterPrivateDictionaryTag;
4764 
4786  OrthancPluginContext* context,
4787  uint16_t group,
4788  uint16_t element,
4790  const char* name,
4791  uint32_t minMultiplicity,
4792  uint32_t maxMultiplicity,
4793  const char* privateCreator)
4794  {
4795  _OrthancPluginRegisterPrivateDictionaryTag params;
4796  params.group = group;
4797  params.element = element;
4798  params.vr = vr;
4799  params.name = name;
4800  params.minMultiplicity = minMultiplicity;
4801  params.maxMultiplicity = maxMultiplicity;
4802  params.privateCreator = privateCreator;
4803 
4804  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4805  }
4806 
4807 
4808 
4809  typedef struct
4810  {
4811  OrthancPluginStorageArea* storageArea;
4813  } _OrthancPluginReconstructMainDicomTags;
4814 
4830  OrthancPluginContext* context,
4831  OrthancPluginStorageArea* storageArea,
4833  {
4834  _OrthancPluginReconstructMainDicomTags params;
4835  params.level = level;
4836  params.storageArea = storageArea;
4837 
4838  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
4839  }
4840 
4841 
4842  typedef struct
4843  {
4844  char** result;
4845  const char* instanceId;
4846  const void* buffer;
4847  uint32_t size;
4850  uint32_t maxStringLength;
4851  } _OrthancPluginDicomToJson;
4852 
4853 
4873  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4874  OrthancPluginContext* context,
4875  const void* buffer,
4876  uint32_t size,
4879  uint32_t maxStringLength)
4880  {
4881  char* result;
4882 
4883  _OrthancPluginDicomToJson params;
4884  memset(&params, 0, sizeof(params));
4885  params.result = &result;
4886  params.buffer = buffer;
4887  params.size = size;
4888  params.format = format;
4889  params.flags = flags;
4890  params.maxStringLength = maxStringLength;
4891 
4892  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
4893  {
4894  /* Error */
4895  return NULL;
4896  }
4897  else
4898  {
4899  return result;
4900  }
4901  }
4902 
4903 
4922  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
4923  OrthancPluginContext* context,
4924  const char* instanceId,
4927  uint32_t maxStringLength)
4928  {
4929  char* result;
4930 
4931  _OrthancPluginDicomToJson params;
4932  memset(&params, 0, sizeof(params));
4933  params.result = &result;
4934  params.instanceId = instanceId;
4935  params.format = format;
4936  params.flags = flags;
4937  params.maxStringLength = maxStringLength;
4938 
4939  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
4940  {
4941  /* Error */
4942  return NULL;
4943  }
4944  else
4945  {
4946  return result;
4947  }
4948  }
4949 
4950 
4951  typedef struct
4952  {
4953  OrthancPluginMemoryBuffer* target;
4954  const char* uri;
4955  uint32_t headersCount;
4956  const char* const* headersKeys;
4957  const char* const* headersValues;
4958  int32_t afterPlugins;
4959  } _OrthancPluginRestApiGet2;
4960 
4981  OrthancPluginContext* context,
4982  OrthancPluginMemoryBuffer* target,
4983  const char* uri,
4984  uint32_t headersCount,
4985  const char* const* headersKeys,
4986  const char* const* headersValues,
4987  int32_t afterPlugins)
4988  {
4989  _OrthancPluginRestApiGet2 params;
4990  params.target = target;
4991  params.uri = uri;
4992  params.headersCount = headersCount;
4993  params.headersKeys = headersKeys;
4994  params.headersValues = headersValues;
4995  params.afterPlugins = afterPlugins;
4996 
4997  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
4998  }
4999 
5000 
5001 
5002  typedef struct
5003  {
5005  } _OrthancPluginWorklistCallback;
5006 
5019  OrthancPluginContext* context,
5021  {
5022  _OrthancPluginWorklistCallback params;
5023  params.callback = callback;
5024 
5025  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
5026  }
5027 
5028 
5029 
5030  typedef struct
5031  {
5033  const OrthancPluginWorklistQuery* query;
5034  const void* dicom;
5035  uint32_t size;
5036  } _OrthancPluginWorklistAnswersOperation;
5037 
5055  OrthancPluginContext* context,
5057  const OrthancPluginWorklistQuery* query,
5058  const void* dicom,
5059  uint32_t size)
5060  {
5061  _OrthancPluginWorklistAnswersOperation params;
5062  params.answers = answers;
5063  params.query = query;
5064  params.dicom = dicom;
5065  params.size = size;
5066 
5067  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
5068  }
5069 
5070 
5085  OrthancPluginContext* context,
5087  {
5088  _OrthancPluginWorklistAnswersOperation params;
5089  params.answers = answers;
5090  params.query = NULL;
5091  params.dicom = NULL;
5092  params.size = 0;
5093 
5094  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5095  }
5096 
5097 
5098  typedef struct
5099  {
5100  const OrthancPluginWorklistQuery* query;
5101  const void* dicom;
5102  uint32_t size;
5103  int32_t* isMatch;
5104  OrthancPluginMemoryBuffer* target;
5105  } _OrthancPluginWorklistQueryOperation;
5106 
5122  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5123  OrthancPluginContext* context,
5124  const OrthancPluginWorklistQuery* query,
5125  const void* dicom,
5126  uint32_t size)
5127  {
5128  int32_t isMatch = 0;
5129 
5130  _OrthancPluginWorklistQueryOperation params;
5131  params.query = query;
5132  params.dicom = dicom;
5133  params.size = size;
5134  params.isMatch = &isMatch;
5135  params.target = NULL;
5136 
5137  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5138  {
5139  return isMatch;
5140  }
5141  else
5142  {
5143  /* Error: Assume non-match */
5144  return 0;
5145  }
5146  }
5147 
5148 
5162  OrthancPluginContext* context,
5163  OrthancPluginMemoryBuffer* target,
5164  const OrthancPluginWorklistQuery* query)
5165  {
5166  _OrthancPluginWorklistQueryOperation params;
5167  params.query = query;
5168  params.dicom = NULL;
5169  params.size = 0;
5170  params.isMatch = NULL;
5171  params.target = target;
5172 
5173  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5174  }
5175 
5176 
5188  OrthancPluginContext* context,
5189  const OrthancPluginDicomInstance* instance)
5190  {
5192 
5193  _OrthancPluginAccessDicomInstance params;
5194  memset(&params, 0, sizeof(params));
5195  params.resultOrigin = &origin;
5196  params.instance = instance;
5197 
5198  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5199  {
5200  /* Error */
5202  }
5203  else
5204  {
5205  return origin;
5206  }
5207  }
5208 
5209 
5210  typedef struct
5211  {
5212  OrthancPluginMemoryBuffer* target;
5213  const char* json;
5214  const OrthancPluginImage* pixelData;
5216  } _OrthancPluginCreateDicom;
5217 
5237  OrthancPluginContext* context,
5238  OrthancPluginMemoryBuffer* target,
5239  const char* json,
5240  const OrthancPluginImage* pixelData,
5242  {
5243  _OrthancPluginCreateDicom params;
5244  params.target = target;
5245  params.json = json;
5246  params.pixelData = pixelData;
5247  params.flags = flags;
5248 
5249  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5250  }
5251 
5252 
5253  typedef struct
5254  {
5256  } _OrthancPluginDecodeImageCallback;
5257 
5273  OrthancPluginContext* context,
5275  {
5276  _OrthancPluginDecodeImageCallback params;
5277  params.callback = callback;
5278 
5279  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5280  }
5281 
5282 
5283 
5284  typedef struct
5285  {
5286  OrthancPluginImage** target;
5287  OrthancPluginPixelFormat format;
5288  uint32_t width;
5289  uint32_t height;
5290  uint32_t pitch;
5291  void* buffer;
5292  const void* constBuffer;
5293  uint32_t bufferSize;
5294  uint32_t frameIndex;
5295  } _OrthancPluginCreateImage;
5296 
5297 
5311  OrthancPluginContext* context,
5312  OrthancPluginPixelFormat format,
5313  uint32_t width,
5314  uint32_t height)
5315  {
5316  OrthancPluginImage* target = NULL;
5317 
5318  _OrthancPluginCreateImage params;
5319  memset(&params, 0, sizeof(params));
5320  params.target = &target;
5321  params.format = format;
5322  params.width = width;
5323  params.height = height;
5324 
5325  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5326  {
5327  return NULL;
5328  }
5329  else
5330  {
5331  return target;
5332  }
5333  }
5334 
5335 
5354  OrthancPluginContext* context,
5355  OrthancPluginPixelFormat format,
5356  uint32_t width,
5357  uint32_t height,
5358  uint32_t pitch,
5359  void* buffer)
5360  {
5361  OrthancPluginImage* target = NULL;
5362 
5363  _OrthancPluginCreateImage params;
5364  memset(&params, 0, sizeof(params));
5365  params.target = &target;
5366  params.format = format;
5367  params.width = width;
5368  params.height = height;
5369  params.pitch = pitch;
5370  params.buffer = buffer;
5371 
5372  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5373  {
5374  return NULL;
5375  }
5376  else
5377  {
5378  return target;
5379  }
5380  }
5381 
5382 
5383 
5400  OrthancPluginContext* context,
5401  const void* buffer,
5402  uint32_t bufferSize,
5403  uint32_t frameIndex)
5404  {
5405  OrthancPluginImage* target = NULL;
5406 
5407  _OrthancPluginCreateImage params;
5408  memset(&params, 0, sizeof(params));
5409  params.target = &target;
5410  params.constBuffer = buffer;
5411  params.bufferSize = bufferSize;
5412  params.frameIndex = frameIndex;
5413 
5414  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5415  {
5416  return NULL;
5417  }
5418  else
5419  {
5420  return target;
5421  }
5422  }
5423 
5424 
5425 
5426  typedef struct
5427  {
5428  char** result;
5429  const void* buffer;
5430  uint32_t size;
5431  } _OrthancPluginComputeHash;
5432 
5445  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5446  OrthancPluginContext* context,
5447  const void* buffer,
5448  uint32_t size)
5449  {
5450  char* result;
5451 
5452  _OrthancPluginComputeHash params;
5453  params.result = &result;
5454  params.buffer = buffer;
5455  params.size = size;
5456 
5457  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5458  {
5459  /* Error */
5460  return NULL;
5461  }
5462  else
5463  {
5464  return result;
5465  }
5466  }
5467 
5468 
5481  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5482  OrthancPluginContext* context,
5483  const void* buffer,
5484  uint32_t size)
5485  {
5486  char* result;
5487 
5488  _OrthancPluginComputeHash params;
5489  params.result = &result;
5490  params.buffer = buffer;
5491  params.size = size;
5492 
5493  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5494  {
5495  /* Error */
5496  return NULL;
5497  }
5498  else
5499  {
5500  return result;
5501  }
5502  }
5503 
5504 
5505 
5506  typedef struct
5507  {
5509  const char* name;
5510  } _OrthancPluginLookupDictionary;
5511 
5528  OrthancPluginContext* context,
5530  const char* name)
5531  {
5532  _OrthancPluginLookupDictionary params;
5533  params.target = target;
5534  params.name = name;
5535  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5536  }
5537 
5538 
5539 
5540  typedef struct
5541  {
5542  OrthancPluginRestOutput* output;
5543  const void* answer;
5544  uint32_t answerSize;
5545  uint32_t headersCount;
5546  const char* const* headersKeys;
5547  const char* const* headersValues;
5548  } _OrthancPluginSendMultipartItem2;
5549 
5571  OrthancPluginContext* context,
5572  OrthancPluginRestOutput* output,
5573  const void* answer,
5574  uint32_t answerSize,
5575  uint32_t headersCount,
5576  const char* const* headersKeys,
5577  const char* const* headersValues)
5578  {
5579  _OrthancPluginSendMultipartItem2 params;
5580  params.output = output;
5581  params.answer = answer;
5582  params.answerSize = answerSize;
5583  params.headersCount = headersCount;
5584  params.headersKeys = headersKeys;
5585  params.headersValues = headersValues;
5586 
5587  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5588  }
5589 
5590 
5591  typedef struct
5592  {
5594  } _OrthancPluginIncomingHttpRequestFilter;
5595 
5609  OrthancPluginContext* context,
5611  {
5612  _OrthancPluginIncomingHttpRequestFilter params;
5613  params.callback = callback;
5614 
5615  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5616  }
5617 
5618 
5619 
5620  typedef struct
5621  {
5622  OrthancPluginMemoryBuffer* answerBody;
5623  OrthancPluginMemoryBuffer* answerHeaders;
5624  uint16_t* httpStatus;
5625  OrthancPluginHttpMethod method;
5626  const char* url;
5627  uint32_t headersCount;
5628  const char* const* headersKeys;
5629  const char* const* headersValues;
5630  const void* body;
5631  uint32_t bodySize;
5632  const char* username;
5633  const char* password;
5634  uint32_t timeout;
5635  const char* certificateFile;
5636  const char* certificateKeyFile;
5637  const char* certificateKeyPassword;
5638  uint8_t pkcs11;
5639  } _OrthancPluginCallHttpClient2;
5640 
5641 
5642 
5683  OrthancPluginContext* context,
5684  OrthancPluginMemoryBuffer* answerBody,
5685  OrthancPluginMemoryBuffer* answerHeaders,
5686  uint16_t* httpStatus,
5687  OrthancPluginHttpMethod method,
5688  const char* url,
5689  uint32_t headersCount,
5690  const char* const* headersKeys,
5691  const char* const* headersValues,
5692  const void* body,
5693  uint32_t bodySize,
5694  const char* username,
5695  const char* password,
5696  uint32_t timeout,
5697  const char* certificateFile,
5698  const char* certificateKeyFile,
5699  const char* certificateKeyPassword,
5700  uint8_t pkcs11)
5701  {
5702  _OrthancPluginCallHttpClient2 params;
5703  memset(&params, 0, sizeof(params));
5704 
5705  params.answerBody = answerBody;
5706  params.answerHeaders = answerHeaders;
5707  params.httpStatus = httpStatus;
5708  params.method = method;
5709  params.url = url;
5710  params.headersCount = headersCount;
5711  params.headersKeys = headersKeys;
5712  params.headersValues = headersValues;
5713  params.body = body;
5714  params.bodySize = bodySize;
5715  params.username = username;
5716  params.password = password;
5717  params.timeout = timeout;
5718  params.certificateFile = certificateFile;
5719  params.certificateKeyFile = certificateKeyFile;
5720  params.certificateKeyPassword = certificateKeyPassword;
5721  params.pkcs11 = pkcs11;
5722 
5723  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5724  }
5725 
5726 
5737  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5738  OrthancPluginContext* context)
5739  {
5740  char* result;
5741 
5742  _OrthancPluginRetrieveDynamicString params;
5743  params.result = &result;
5744  params.argument = NULL;
5745 
5746  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5747  {
5748  /* Error */
5749  return NULL;
5750  }
5751  else
5752  {
5753  return result;
5754  }
5755  }
5756 
5757 
5758 
5759 
5760  typedef struct
5761  {
5762  OrthancPluginFindCallback callback;
5763  } _OrthancPluginFindCallback;
5764 
5777  OrthancPluginContext* context,
5778  OrthancPluginFindCallback callback)
5779  {
5780  _OrthancPluginFindCallback params;
5781  params.callback = callback;
5782 
5783  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5784  }
5785 
5786 
5787  typedef struct
5788  {
5789  OrthancPluginFindAnswers *answers;
5790  const OrthancPluginFindQuery *query;
5791  const void *dicom;
5792  uint32_t size;
5793  uint32_t index;
5794  uint32_t *resultUint32;
5795  uint16_t *resultGroup;
5796  uint16_t *resultElement;
5797  char **resultString;
5798  } _OrthancPluginFindOperation;
5799 
5816  OrthancPluginContext* context,
5817  OrthancPluginFindAnswers* answers,
5818  const void* dicom,
5819  uint32_t size)
5820  {
5821  _OrthancPluginFindOperation params;
5822  memset(&params, 0, sizeof(params));
5823  params.answers = answers;
5824  params.dicom = dicom;
5825  params.size = size;
5826 
5827  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
5828  }
5829 
5830 
5845  OrthancPluginContext* context,
5846  OrthancPluginFindAnswers* answers)
5847  {
5848  _OrthancPluginFindOperation params;
5849  memset(&params, 0, sizeof(params));
5850  params.answers = answers;
5851 
5852  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
5853  }
5854 
5855 
5856 
5868  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
5869  OrthancPluginContext* context,
5870  const OrthancPluginFindQuery* query)
5871  {
5872  uint32_t count = 0;
5873 
5874  _OrthancPluginFindOperation params;
5875  memset(&params, 0, sizeof(params));
5876  params.query = query;
5877  params.resultUint32 = &count;
5878 
5879  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
5880  {
5881  /* Error */
5882  return 0;
5883  }
5884  else
5885  {
5886  return count;
5887  }
5888  }
5889 
5890 
5906  OrthancPluginContext* context,
5907  uint16_t* group,
5908  uint16_t* element,
5909  const OrthancPluginFindQuery* query,
5910  uint32_t index)
5911  {
5912  _OrthancPluginFindOperation params;
5913  memset(&params, 0, sizeof(params));
5914  params.query = query;
5915  params.index = index;
5916  params.resultGroup = group;
5917  params.resultElement = element;
5918 
5919  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
5920  }
5921 
5922 
5936  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
5937  OrthancPluginContext* context,
5938  const OrthancPluginFindQuery* query,
5939  uint32_t index)
5940  {
5941  char* result;
5942 
5943  _OrthancPluginFindOperation params;
5944  memset(&params, 0, sizeof(params));
5945  params.query = query;
5946  params.index = index;
5947  params.resultString = &result;
5948 
5949  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
5950  {
5951  /* Error */
5952  return NULL;
5953  }
5954  else
5955  {
5956  return result;
5957  }
5958  }
5959 
5960 
5974  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
5975  OrthancPluginContext* context,
5976  const OrthancPluginFindQuery* query,
5977  uint32_t index)
5978  {
5979  char* result;
5980 
5981  _OrthancPluginFindOperation params;
5982  memset(&params, 0, sizeof(params));
5983  params.query = query;
5984  params.index = index;
5985  params.resultString = &result;
5986 
5987  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
5988  {
5989  /* Error */
5990  return NULL;
5991  }
5992  else
5993  {
5994  return result;
5995  }
5996  }
5997 
5998 
5999 
6000 
6001  typedef struct
6002  {
6003  OrthancPluginMoveCallback callback;
6004  OrthancPluginGetMoveSize getMoveSize;
6005  OrthancPluginApplyMove applyMove;
6006  OrthancPluginFreeMove freeMove;
6007  } _OrthancPluginMoveCallback;
6008 
6023  OrthancPluginContext* context,
6024  OrthancPluginMoveCallback callback,
6025  OrthancPluginGetMoveSize getMoveSize,
6026  OrthancPluginApplyMove applyMove,
6027  OrthancPluginFreeMove freeMove)
6028  {
6029  _OrthancPluginMoveCallback params;
6030  params.callback = callback;
6031  params.getMoveSize = getMoveSize;
6032  params.applyMove = applyMove;
6033  params.freeMove = freeMove;
6034 
6035  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
6036  }
6037 
6038 
6039 
6040  typedef struct
6041  {
6042  OrthancPluginFindMatcher** target;
6043  const void* query;
6044  uint32_t size;
6045  } _OrthancPluginCreateFindMatcher;
6046 
6047 
6062  OrthancPluginContext* context,
6063  const void* query,
6064  uint32_t size)
6065  {
6066  OrthancPluginFindMatcher* target = NULL;
6067 
6068  _OrthancPluginCreateFindMatcher params;
6069  memset(&params, 0, sizeof(params));
6070  params.target = &target;
6071  params.query = query;
6072  params.size = size;
6073 
6074  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
6075  {
6076  return NULL;
6077  }
6078  else
6079  {
6080  return target;
6081  }
6082  }
6083 
6084 
6085  typedef struct
6086  {
6087  OrthancPluginFindMatcher* matcher;
6088  } _OrthancPluginFreeFindMatcher;
6089 
6099  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6100  OrthancPluginContext* context,
6101  OrthancPluginFindMatcher* matcher)
6102  {
6103  _OrthancPluginFreeFindMatcher params;
6104  params.matcher = matcher;
6105 
6106  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6107  }
6108 
6109 
6110  typedef struct
6111  {
6112  const OrthancPluginFindMatcher* matcher;
6113  const void* dicom;
6114  uint32_t size;
6115  int32_t* isMatch;
6116  } _OrthancPluginFindMatcherIsMatch;
6117 
6132  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6133  OrthancPluginContext* context,
6134  const OrthancPluginFindMatcher* matcher,
6135  const void* dicom,
6136  uint32_t size)
6137  {
6138  int32_t isMatch = 0;
6139 
6140  _OrthancPluginFindMatcherIsMatch params;
6141  params.matcher = matcher;
6142  params.dicom = dicom;
6143  params.size = size;
6144  params.isMatch = &isMatch;
6145 
6146  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6147  {
6148  return isMatch;
6149  }
6150  else
6151  {
6152  /* Error: Assume non-match */
6153  return 0;
6154  }
6155  }
6156 
6157 
6158  typedef struct
6159  {
6161  } _OrthancPluginIncomingHttpRequestFilter2;
6162 
6175  OrthancPluginContext* context,
6177  {
6178  _OrthancPluginIncomingHttpRequestFilter2 params;
6179  params.callback = callback;
6180 
6181  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6182  }
6183 
6184 
6185 
6186  typedef struct
6187  {
6188  OrthancPluginPeers** peers;
6189  } _OrthancPluginGetPeers;
6190 
6203  OrthancPluginContext* context)
6204  {
6205  OrthancPluginPeers* peers = NULL;
6206 
6207  _OrthancPluginGetPeers params;
6208  memset(&params, 0, sizeof(params));
6209  params.peers = &peers;
6210 
6211  if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6212  {
6213  return NULL;
6214  }
6215  else
6216  {
6217  return peers;
6218  }
6219  }
6220 
6221 
6222  typedef struct
6223  {
6224  OrthancPluginPeers* peers;
6225  } _OrthancPluginFreePeers;
6226 
6236  ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6237  OrthancPluginContext* context,
6238  OrthancPluginPeers* peers)
6239  {
6240  _OrthancPluginFreePeers params;
6241  params.peers = peers;
6242 
6243  context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6244  }
6245 
6246 
6247  typedef struct
6248  {
6249  uint32_t* target;
6250  const OrthancPluginPeers* peers;
6251  } _OrthancPluginGetPeersCount;
6252 
6266  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6267  OrthancPluginContext* context,
6268  const OrthancPluginPeers* peers)
6269  {
6270  uint32_t target = 0;
6271 
6272  _OrthancPluginGetPeersCount params;
6273  memset(&params, 0, sizeof(params));
6274  params.target = &target;
6275  params.peers = peers;
6276 
6277  if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6278  {
6279  /* Error */
6280  return 0;
6281  }
6282  else
6283  {
6284  return target;
6285  }
6286  }
6287 
6288 
6289  typedef struct
6290  {
6291  const char** target;
6292  const OrthancPluginPeers* peers;
6293  uint32_t peerIndex;
6294  const char* userProperty;
6295  } _OrthancPluginGetPeerProperty;
6296 
6314  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6315  OrthancPluginContext* context,
6316  const OrthancPluginPeers* peers,
6317  uint32_t peerIndex)
6318  {
6319  const char* target = NULL;
6320 
6321  _OrthancPluginGetPeerProperty params;
6322  memset(&params, 0, sizeof(params));
6323  params.target = &target;
6324  params.peers = peers;
6325  params.peerIndex = peerIndex;
6326  params.userProperty = NULL;
6327 
6328  if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6329  {
6330  /* Error */
6331  return NULL;
6332  }
6333  else
6334  {
6335  return target;
6336  }
6337  }
6338 
6339 
6355  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6356  OrthancPluginContext* context,
6357  const OrthancPluginPeers* peers,
6358  uint32_t peerIndex)
6359  {
6360  const char* target = NULL;
6361 
6362  _OrthancPluginGetPeerProperty params;
6363  memset(&params, 0, sizeof(params));
6364  params.target = &target;
6365  params.peers = peers;
6366  params.peerIndex = peerIndex;
6367  params.userProperty = NULL;
6368 
6369  if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6370  {
6371  /* Error */
6372  return NULL;
6373  }
6374  else
6375  {
6376  return target;
6377  }
6378  }
6379 
6380 
6381 
6401  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6402  OrthancPluginContext* context,
6403  const OrthancPluginPeers* peers,
6404  uint32_t peerIndex,
6405  const char* userProperty)
6406  {
6407  const char* target = NULL;
6408 
6409  _OrthancPluginGetPeerProperty params;
6410  memset(&params, 0, sizeof(params));
6411  params.target = &target;
6412  params.peers = peers;
6413  params.peerIndex = peerIndex;
6414  params.userProperty = userProperty;
6415 
6416  if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6417  {
6418  /* No such user property */
6419  return NULL;
6420  }
6421  else
6422  {
6423  return target;
6424  }
6425  }
6426 
6427 
6428 
6429  typedef struct
6430  {
6431  OrthancPluginMemoryBuffer* answerBody;
6432  OrthancPluginMemoryBuffer* answerHeaders;
6433  uint16_t* httpStatus;
6434  const OrthancPluginPeers* peers;
6435  uint32_t peerIndex;
6436  OrthancPluginHttpMethod method;
6437  const char* uri;
6438  uint32_t additionalHeadersCount;
6439  const char* const* additionalHeadersKeys;
6440  const char* const* additionalHeadersValues;
6441  const void* body;
6442  uint32_t bodySize;
6443  uint32_t timeout;
6444  } _OrthancPluginCallPeerApi;
6445 
6482  OrthancPluginContext* context,
6483  OrthancPluginMemoryBuffer* answerBody,
6484  OrthancPluginMemoryBuffer* answerHeaders,
6485  uint16_t* httpStatus,
6486  const OrthancPluginPeers* peers,
6487  uint32_t peerIndex,
6488  OrthancPluginHttpMethod method,
6489  const char* uri,
6490  uint32_t additionalHeadersCount,
6491  const char* const* additionalHeadersKeys,
6492  const char* const* additionalHeadersValues,
6493  const void* body,
6494  uint32_t bodySize,
6495  uint32_t timeout)
6496  {
6497  _OrthancPluginCallPeerApi params;
6498  memset(&params, 0, sizeof(params));
6499 
6500  params.answerBody = answerBody;
6501  params.answerHeaders = answerHeaders;
6502  params.httpStatus = httpStatus;
6503  params.peers = peers;
6504  params.peerIndex = peerIndex;
6505  params.method = method;
6506  params.uri = uri;
6507  params.additionalHeadersCount = additionalHeadersCount;
6508  params.additionalHeadersKeys = additionalHeadersKeys;
6509  params.additionalHeadersValues = additionalHeadersValues;
6510  params.body = body;
6511  params.bodySize = bodySize;
6512  params.timeout = timeout;
6513 
6514  return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6515  }
6516 
6517 
6518 
6519 
6520 
6521  typedef struct
6522  {
6523  OrthancPluginJob** target;
6524  void *job;
6525  OrthancPluginJobFinalize finalize;
6526  const char *type;
6527  OrthancPluginJobGetProgress getProgress;
6528  OrthancPluginJobGetContent getContent;
6529  OrthancPluginJobGetSerialized getSerialized;
6530  OrthancPluginJobStep step;
6531  OrthancPluginJobStop stop;
6532  OrthancPluginJobReset reset;
6533  } _OrthancPluginCreateJob;
6534 
6567  OrthancPluginContext *context,
6568  void *job,
6569  OrthancPluginJobFinalize finalize,
6570  const char *type,
6571  OrthancPluginJobGetProgress getProgress,
6572  OrthancPluginJobGetContent getContent,
6573  OrthancPluginJobGetSerialized getSerialized,
6574  OrthancPluginJobStep step,
6575  OrthancPluginJobStop stop,
6576  OrthancPluginJobReset reset)
6577  {
6578  OrthancPluginJob* target = NULL;
6579 
6580  _OrthancPluginCreateJob params;
6581  memset(&params, 0, sizeof(params));
6582 
6583  params.target = &target;
6584  params.job = job;
6585  params.finalize = finalize;
6586  params.type = type;
6587  params.getProgress = getProgress;
6588  params.getContent = getContent;
6589  params.getSerialized = getSerialized;
6590  params.step = step;
6591  params.stop = stop;
6592  params.reset = reset;
6593 
6594  if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6595  target == NULL)
6596  {
6597  /* Error */
6598  return NULL;
6599  }
6600  else
6601  {
6602  return target;
6603  }
6604  }
6605 
6606 
6607  typedef struct
6608  {
6609  OrthancPluginJob* job;
6610  } _OrthancPluginFreeJob;
6611 
6621  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6622  OrthancPluginContext* context,
6623  OrthancPluginJob* job)
6624  {
6625  _OrthancPluginFreeJob params;
6626  params.job = job;
6627 
6628  context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6629  }
6630 
6631 
6632 
6633  typedef struct
6634  {
6635  char** resultId;
6636  OrthancPluginJob *job;
6637  int priority;
6638  } _OrthancPluginSubmitJob;
6639 
6653  ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6654  OrthancPluginContext *context,
6655  OrthancPluginJob *job,
6656  int priority)
6657  {
6658  char* resultId = NULL;
6659 
6660  _OrthancPluginSubmitJob params;
6661  memset(&params, 0, sizeof(params));
6662 
6663  params.resultId = &resultId;
6664  params.job = job;
6665  params.priority = priority;
6666 
6667  if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6668  resultId == NULL)
6669  {
6670  /* Error */
6671  return NULL;
6672  }
6673  else
6674  {
6675  return resultId;
6676  }
6677  }
6678 
6679 
6680 
6681  typedef struct
6682  {
6683  OrthancPluginJobsUnserializer unserializer;
6684  } _OrthancPluginJobsUnserializer;
6685 
6698  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6699  OrthancPluginContext* context,
6700  OrthancPluginJobsUnserializer unserializer)
6701  {
6702  _OrthancPluginJobsUnserializer params;
6703  params.unserializer = unserializer;
6704 
6705  context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6706  }
6707 
6708 
6709 
6710  typedef struct
6711  {
6712  OrthancPluginRestOutput* output;
6713  const char* details;
6714  uint8_t log;
6715  } _OrthancPluginSetHttpErrorDetails;
6716 
6734  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
6735  OrthancPluginContext* context,
6736  OrthancPluginRestOutput* output,
6737  const char* details,
6738  uint8_t log)
6739  {
6740  _OrthancPluginSetHttpErrorDetails params;
6741  params.output = output;
6742  params.details = details;
6743  params.log = log;
6744  context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
6745  }
6746 
6747 
6748 
6749  typedef struct
6750  {
6751  const char** result;
6752  const char* argument;
6753  } _OrthancPluginRetrieveStaticString;
6754 
6766  ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
6767  OrthancPluginContext* context,
6768  const char* path)
6769  {
6770  const char* result = NULL;
6771 
6772  _OrthancPluginRetrieveStaticString params;
6773  params.result = &result;
6774  params.argument = path;
6775 
6776  if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
6777  {
6778  /* Error */
6779  return NULL;
6780  }
6781  else
6782  {
6783  return result;
6784  }
6785  }
6786 
6787 
6788 
6789  typedef struct
6790  {
6791  const char* name;
6792  float value;
6794  } _OrthancPluginSetMetricsValue;
6795 
6810  ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
6811  OrthancPluginContext* context,
6812  const char* name,
6813  float value,
6815  {
6816  _OrthancPluginSetMetricsValue params;
6817  params.name = name;
6818  params.value = value;
6819  params.type = type;
6820  context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
6821  }
6822 
6823 
6824 
6825  typedef struct
6826  {
6828  } _OrthancPluginRegisterRefreshMetricsCallback;
6829 
6841  OrthancPluginContext* context,
6843  {
6844  _OrthancPluginRegisterRefreshMetricsCallback params;
6845  params.callback = callback;
6846  context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
6847  }
6848 
6849 
6850 
6851 
6852  typedef struct
6853  {
6854  char** target;
6855  const void* dicom;
6856  uint32_t dicomSize;
6858  } _OrthancPluginEncodeDicomWeb;
6859 
6876  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
6877  OrthancPluginContext* context,
6878  const void* dicom,
6879  uint32_t dicomSize,
6881  {
6882  char* target = NULL;
6883 
6884  _OrthancPluginEncodeDicomWeb params;
6885  params.target = &target;
6886  params.dicom = dicom;
6887  params.dicomSize = dicomSize;
6888  params.callback = callback;
6889 
6890  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
6891  {
6892  /* Error */
6893  return NULL;
6894  }
6895  else
6896  {
6897  return target;
6898  }
6899  }
6900 
6901 
6918  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
6919  OrthancPluginContext* context,
6920  const void* dicom,
6921  uint32_t dicomSize,
6923  {
6924  char* target = NULL;
6925 
6926  _OrthancPluginEncodeDicomWeb params;
6927  params.target = &target;
6928  params.dicom = dicom;
6929  params.dicomSize = dicomSize;
6930  params.callback = callback;
6931 
6932  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
6933  {
6934  /* Error */
6935  return NULL;
6936  }
6937  else
6938  {
6939  return target;
6940  }
6941  }
6942 
6943 
6944 
6945  typedef struct
6946  {
6947  char** target;
6948  const void* dicom;
6949  uint32_t dicomSize;
6951  void* payload;
6952  } _OrthancPluginEncodeDicomWeb2;
6953 
6970  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson2(
6971  OrthancPluginContext* context,
6972  const void* dicom,
6973  uint32_t dicomSize,
6975  void* payload)
6976  {
6977  char* target = NULL;
6978 
6979  _OrthancPluginEncodeDicomWeb2 params;
6980  params.target = &target;
6981  params.dicom = dicom;
6982  params.dicomSize = dicomSize;
6983  params.callback = callback;
6984  params.payload = payload;
6985 
6986  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson2, &params) != OrthancPluginErrorCode_Success)
6987  {
6988  /* Error */
6989  return NULL;
6990  }
6991  else
6992  {
6993  return target;
6994  }
6995  }
6996 
6997 
7014  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml2(
7015  OrthancPluginContext* context,
7016  const void* dicom,
7017  uint32_t dicomSize,
7019  void* payload)
7020  {
7021  char* target = NULL;
7022 
7023  _OrthancPluginEncodeDicomWeb2 params;
7024  params.target = &target;
7025  params.dicom = dicom;
7026  params.dicomSize = dicomSize;
7027  params.callback = callback;
7028  params.payload = payload;
7029 
7030  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml2, &params) != OrthancPluginErrorCode_Success)
7031  {
7032  /* Error */
7033  return NULL;
7034  }
7035  else
7036  {
7037  return target;
7038  }
7039  }
7040 
7041 
7042 
7059  void* answer,
7060  const char* key,
7061  const char* value);
7062 
7063 
7080  void* answer,
7081  const void* data,
7082  uint32_t size);
7083 
7084 
7099  typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
7100 
7101 
7117 
7118 
7132  typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
7133 
7134 
7148  typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
7149 
7150 
7151  typedef struct
7152  {
7153  void* answer;
7156  uint16_t* httpStatus;
7157  OrthancPluginHttpMethod method;
7158  const char* url;
7159  uint32_t headersCount;
7160  const char* const* headersKeys;
7161  const char* const* headersValues;
7162  void* request;
7167  const char* username;
7168  const char* password;
7169  uint32_t timeout;
7170  const char* certificateFile;
7171  const char* certificateKeyFile;
7172  const char* certificateKeyPassword;
7173  uint8_t pkcs11;
7174  } _OrthancPluginChunkedHttpClient;
7175 
7176 
7228  OrthancPluginContext* context,
7229  void* answer,
7232  uint16_t* httpStatus,
7233  OrthancPluginHttpMethod method,
7234  const char* url,
7235  uint32_t headersCount,
7236  const char* const* headersKeys,
7237  const char* const* headersValues,
7238  void* request,
7243  const char* username,
7244  const char* password,
7245  uint32_t timeout,
7246  const char* certificateFile,
7247  const char* certificateKeyFile,
7248  const char* certificateKeyPassword,
7249  uint8_t pkcs11)
7250  {
7251  _OrthancPluginChunkedHttpClient params;
7252  memset(&params, 0, sizeof(params));
7253 
7254  /* In common with OrthancPluginHttpClient() */
7255  params.httpStatus = httpStatus;
7256  params.method = method;
7257  params.url = url;
7258  params.headersCount = headersCount;
7259  params.headersKeys = headersKeys;
7260  params.headersValues = headersValues;
7261  params.username = username;
7262  params.password = password;
7263  params.timeout = timeout;
7264  params.certificateFile = certificateFile;
7265  params.certificateKeyFile = certificateKeyFile;
7266  params.certificateKeyPassword = certificateKeyPassword;
7267  params.pkcs11 = pkcs11;
7268 
7269  /* For chunked body/answer */
7270  params.answer = answer;
7271  params.answerAddChunk = answerAddChunk;
7272  params.answerAddHeader = answerAddHeader;
7273  params.request = request;
7274  params.requestIsDone = requestIsDone;
7275  params.requestChunkData = requestChunkData;
7276  params.requestChunkSize = requestChunkSize;
7277  params.requestNext = requestNext;
7278 
7279  return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7280  }
7281 
7282 
7283 
7288  typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7289 
7290 
7291 
7309  const char* url,
7310  const OrthancPluginHttpRequest* request);
7311 
7312 
7328  const void* data,
7329  uint32_t size);
7330 
7331 
7348  OrthancPluginRestOutput* output);
7349 
7350 
7366 
7367  typedef struct
7368  {
7369  const char* pathRegularExpression;
7370  OrthancPluginRestCallback getHandler;
7372  OrthancPluginRestCallback deleteHandler;
7377  } _OrthancPluginChunkedRestCallback;
7378 
7379 
7409  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterChunkedRestCallback(
7410  OrthancPluginContext* context,
7411  const char* pathRegularExpression,
7412  OrthancPluginRestCallback getHandler,
7414  OrthancPluginRestCallback deleteHandler,
7419  {
7420  _OrthancPluginChunkedRestCallback params;
7421  params.pathRegularExpression = pathRegularExpression;
7422  params.getHandler = getHandler;
7423  params.postHandler = postHandler;
7424  params.deleteHandler = deleteHandler;
7425  params.putHandler = putHandler;
7426  params.addChunk = addChunk;
7427  params.execute = execute;
7428  params.finalize = finalize;
7429 
7430  context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
7431  }
7432 
7433 
7434 
7435 
7436 
7437  typedef struct
7438  {
7439  char** result;
7440  uint16_t group;
7441  uint16_t element;
7442  const char* privateCreator;
7443  } _OrthancPluginGetTagName;
7444 
7460  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
7461  OrthancPluginContext* context,
7462  uint16_t group,
7463  uint16_t element,
7464  const char* privateCreator)
7465  {
7466  char* result;
7467 
7468  _OrthancPluginGetTagName params;
7469  params.result = &result;
7470  params.group = group;
7471  params.element = element;
7472  params.privateCreator = privateCreator;
7473 
7474  if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
7475  {
7476  /* Error */
7477  return NULL;
7478  }
7479  else
7480  {
7481  return result;
7482  }
7483  }
7484 
7485 
7486 
7516  void** handler /* out */,
7517  const char* jobId,
7518  const char* transactionUid,
7519  const char* const* sopClassUids,
7520  const char* const* sopInstanceUids,
7521  uint32_t countInstances,
7522  const char* remoteAet,
7523  const char* calledAet);
7524 
7525 
7537  typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
7538 
7539 
7560  void* handler,
7561  const char* sopClassUid,
7562  const char* sopInstanceUid);
7563 
7564 
7565  typedef struct
7566  {
7570  } _OrthancPluginRegisterStorageCommitmentScpCallback;
7571 
7586  OrthancPluginContext* context,
7590  {
7591  _OrthancPluginRegisterStorageCommitmentScpCallback params;
7592  params.factory = factory;
7593  params.destructor = destructor;
7594  params.lookup = lookup;
7595  return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
7596  }
7597 
7598 
7599 
7616  const OrthancPluginDicomInstance* instance);
7617 
7618 
7619  typedef struct
7620  {
7622  } _OrthancPluginIncomingDicomInstanceFilter;
7623 
7647  OrthancPluginContext* context,
7649  {
7650  _OrthancPluginIncomingDicomInstanceFilter params;
7651  params.callback = callback;
7652 
7653  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, &params);
7654  }
7655 
7656 
7670  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceTransferSyntaxUid(
7671  OrthancPluginContext* context,
7672  const OrthancPluginDicomInstance* instance)
7673  {
7674  char* result;
7675 
7676  _OrthancPluginAccessDicomInstance params;
7677  memset(&params, 0, sizeof(params));
7678  params.resultStringToFree = &result;
7679  params.instance = instance;
7680 
7681  if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, &params) != OrthancPluginErrorCode_Success)
7682  {
7683  /* Error */
7684  return NULL;
7685  }
7686  else
7687  {
7688  return result;
7689  }
7690  }
7691 
7692 
7705  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData(
7706  OrthancPluginContext* context,
7707  const OrthancPluginDicomInstance* instance)
7708  {
7709  int64_t hasPixelData;
7710 
7711  _OrthancPluginAccessDicomInstance params;
7712  memset(&params, 0, sizeof(params));
7713  params.resultInt64 = &hasPixelData;
7714  params.instance = instance;
7715 
7716  if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, &params) != OrthancPluginErrorCode_Success ||
7717  hasPixelData < 0 ||
7718  hasPixelData > 1)
7719  {
7720  /* Error */
7721  return -1;
7722  }
7723  else
7724  {
7725  return (hasPixelData != 0);
7726  }
7727  }
7728 
7729 
7730 
7731 
7732 
7733 
7734  typedef struct
7735  {
7736  OrthancPluginDicomInstance** target;
7737  const void* buffer;
7738  uint32_t size;
7739  const char* transferSyntax;
7740  } _OrthancPluginCreateDicomInstance;
7741 
7756  OrthancPluginContext* context,
7757  const void* buffer,
7758  uint32_t size)
7759  {
7760  OrthancPluginDicomInstance* target = NULL;
7761 
7762  _OrthancPluginCreateDicomInstance params;
7763  params.target = &target;
7764  params.buffer = buffer;
7765  params.size = size;
7766 
7767  if (context->InvokeService(context, _OrthancPluginService_CreateDicomInstance, &params) != OrthancPluginErrorCode_Success)
7768  {
7769  /* Error */
7770  return NULL;
7771  }
7772  else
7773  {
7774  return target;
7775  }
7776  }
7777 
7778  typedef struct
7779  {
7781  } _OrthancPluginFreeDicomInstance;
7782 
7793  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeDicomInstance(
7794  OrthancPluginContext* context,
7796  {
7797  _OrthancPluginFreeDicomInstance params;
7798  params.dicom = dicom;
7799 
7800  context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, &params);
7801  }
7802 
7803 
7804  typedef struct
7805  {
7806  uint32_t* targetUint32;
7807  OrthancPluginMemoryBuffer* targetBuffer;
7808  OrthancPluginImage** targetImage;
7809  char** targetStringToFree;
7810  const OrthancPluginDicomInstance* instance;
7811  uint32_t frameIndex;
7814  uint32_t maxStringLength;
7815  OrthancPluginDicomWebBinaryCallback2 dicomWebCallback;
7816  void* dicomWebPayload;
7817  } _OrthancPluginAccessDicomInstance2;
7818 
7830  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetInstanceFramesCount(
7831  OrthancPluginContext* context,
7832  const OrthancPluginDicomInstance* instance)
7833  {
7834  uint32_t count;
7835 
7836  _OrthancPluginAccessDicomInstance2 params;
7837  memset(&params, 0, sizeof(params));
7838  params.targetUint32 = &count;
7839  params.instance = instance;
7840 
7841  if (context->InvokeService(context, _OrthancPluginService_GetInstanceFramesCount, &params) != OrthancPluginErrorCode_Success)
7842  {
7843  /* Error */
7844  return 0;
7845  }
7846  else
7847  {
7848  return count;
7849  }
7850  }
7851 
7852 
7871  OrthancPluginContext* context,
7872  OrthancPluginMemoryBuffer* target,
7873  const OrthancPluginDicomInstance* instance,
7874  uint32_t frameIndex)
7875  {
7876  _OrthancPluginAccessDicomInstance2 params;
7877  memset(&params, 0, sizeof(params));
7878  params.targetBuffer = target;
7879  params.instance = instance;
7880  params.frameIndex = frameIndex;
7881 
7882  return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, &params);
7883  }
7884 
7885 
7899  OrthancPluginContext* context,
7900  const OrthancPluginDicomInstance* instance,
7901  uint32_t frameIndex)
7902  {
7903  OrthancPluginImage* target = NULL;
7904 
7905  _OrthancPluginAccessDicomInstance2 params;
7906  memset(&params, 0, sizeof(params));
7907  params.targetImage = &target;
7908  params.instance = instance;
7909  params.frameIndex = frameIndex;
7910 
7911  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDecodedFrame, &params) != OrthancPluginErrorCode_Success)
7912  {
7913  return NULL;
7914  }
7915  else
7916  {
7917  return target;
7918  }
7919  }
7920 
7921 
7938  OrthancPluginContext* context,
7939  const void* buffer,
7940  uint32_t size,
7941  const char* transferSyntax)
7942  {
7943  OrthancPluginDicomInstance* target = NULL;
7944 
7945  _OrthancPluginCreateDicomInstance params;
7946  params.target = &target;
7947  params.buffer = buffer;
7948  params.size = size;
7949  params.transferSyntax = transferSyntax;
7950 
7951  if (context->InvokeService(context, _OrthancPluginService_TranscodeDicomInstance, &params) != OrthancPluginErrorCode_Success)
7952  {
7953  /* Error */
7954  return NULL;
7955  }
7956  else
7957  {
7958  return target;
7959  }
7960  }
7961 
7976  OrthancPluginContext* context,
7977  OrthancPluginMemoryBuffer* target,
7978  const OrthancPluginDicomInstance* instance)
7979  {
7980  _OrthancPluginAccessDicomInstance2 params;
7981  memset(&params, 0, sizeof(params));
7982  params.targetBuffer = target;
7983  params.instance = instance;
7984 
7985  return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, &params);
7986  }
7987 
7988 
8007  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceAdvancedJson(
8008  OrthancPluginContext* context,
8009  const OrthancPluginDicomInstance* instance,
8012  uint32_t maxStringLength)
8013  {
8014  char* result = NULL;
8015 
8016  _OrthancPluginAccessDicomInstance2 params;
8017  memset(&params, 0, sizeof(params));
8018  params.targetStringToFree = &result;
8019  params.instance = instance;
8020  params.format = format;
8021  params.flags = flags;
8022  params.maxStringLength = maxStringLength;
8023 
8024  if (context->InvokeService(context, _OrthancPluginService_GetInstanceAdvancedJson, &params) != OrthancPluginErrorCode_Success)
8025  {
8026  /* Error */
8027  return NULL;
8028  }
8029  else
8030  {
8031  return result;
8032  }
8033  }
8034 
8035 
8050  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebJson(
8051  OrthancPluginContext* context,
8052  const OrthancPluginDicomInstance* instance,
8054  void* payload)
8055  {
8056  char* target = NULL;
8057 
8058  _OrthancPluginAccessDicomInstance2 params;
8059  params.targetStringToFree = &target;
8060  params.instance = instance;
8061  params.dicomWebCallback = callback;
8062  params.dicomWebPayload = payload;
8063 
8064  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebJson, &params) != OrthancPluginErrorCode_Success)
8065  {
8066  /* Error */
8067  return NULL;
8068  }
8069  else
8070  {
8071  return target;
8072  }
8073  }
8074 
8075 
8090  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebXml(
8091  OrthancPluginContext* context,
8092  const OrthancPluginDicomInstance* instance,
8094  void* payload)
8095  {
8096  char* target = NULL;
8097 
8098  _OrthancPluginAccessDicomInstance2 params;
8099  params.targetStringToFree = &target;
8100  params.instance = instance;
8101  params.dicomWebCallback = callback;
8102  params.dicomWebPayload = payload;
8103 
8104  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebXml, &params) != OrthancPluginErrorCode_Success)
8105  {
8106  /* Error */
8107  return NULL;
8108  }
8109  else
8110  {
8111  return target;
8112  }
8113  }
8114 
8115 
8116 
8136  OrthancPluginMemoryBuffer* transcoded /* out */,
8137  const void* buffer,
8138  uint64_t size,
8139  const char* const* allowedSyntaxes,
8140  uint32_t countSyntaxes,
8141  uint8_t allowNewSopInstanceUid);
8142 
8143 
8144  typedef struct
8145  {
8147  } _OrthancPluginTranscoderCallback;
8148 
8163  OrthancPluginContext* context,
8165  {
8166  _OrthancPluginTranscoderCallback params;
8167  params.callback = callback;
8168 
8169  return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, &params);
8170  }
8171 
8172 
8173 
8174  typedef struct
8175  {
8176  OrthancPluginMemoryBuffer* target;
8177  uint32_t size;
8178  } _OrthancPluginCreateMemoryBuffer;
8179 
8198  OrthancPluginContext* context,
8199  OrthancPluginMemoryBuffer* target,
8200  uint32_t size)
8201  {
8202  _OrthancPluginCreateMemoryBuffer params;
8203  params.target = target;
8204  params.size = size;
8205 
8206  return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, &params);
8207  }
8208 
8209 
8236  OrthancPluginContext* context)
8237  {
8238  char* result;
8239 
8240  _OrthancPluginRetrieveDynamicString params;
8241  params.result = &result;
8242  params.argument = NULL;
8243 
8244  if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
8245  &params) != OrthancPluginErrorCode_Success)
8246  {
8247  /* Error */
8248  return NULL;
8249  }
8250  else
8251  {
8252  return result;
8253  }
8254  }
8255 #ifdef __cplusplus
8256 }
8257 #endif
8258 
8259 
OrthancPluginJobGetProgress
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1469
OrthancPluginMetricsType_Default
@ OrthancPluginMetricsType_Default
Definition: OrthancCPlugin.h:933
OrthancPluginChangeType_NewPatient
@ OrthancPluginChangeType_NewPatient
Definition: OrthancCPlugin.h:718
OrthancPluginErrorCode_SQLiteStatementAlreadyUsed
@ OrthancPluginErrorCode_SQLiteStatementAlreadyUsed
Definition: OrthancCPlugin.h:244
OrthancPluginConvertPixelFormat
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4346
OrthancPluginGetMoveSize
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1414
OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
Definition: OrthancCPlugin.h:833
OrthancPluginErrorCode_CannotExecuteLua
@ OrthancPluginErrorCode_CannotExecuteLua
Definition: OrthancCPlugin.h:288
OrthancPluginCheckVersion
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1844
OrthancPluginChangeType_JobFailure
@ OrthancPluginChangeType_JobFailure
Definition: OrthancCPlugin.h:732
OrthancPluginErrorCode_NoWorklistHandler
@ OrthancPluginErrorCode_NoWorklistHandler
Definition: OrthancCPlugin.h:298
OrthancPluginCompressionType_Gzip
@ OrthancPluginCompressionType_Gzip
Definition: OrthancCPlugin.h:746
OrthancPluginExtendOrthancExplorer
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:3277
OrthancPluginHttpClient
OrthancPluginErrorCode OrthancPluginHttpClient(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, OrthancPluginHttpMethod method, const char *url, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, const void *body, uint32_t bodySize, const char *username, const char *password, uint32_t timeout, const char *certificateFile, const char *certificateKeyFile, const char *certificateKeyPassword, uint8_t pkcs11)
Issue a HTTP call with full flexibility.
Definition: OrthancCPlugin.h:5682
OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii
Definition: OrthancCPlugin.h:832
OrthancPluginErrorCode_SQLiteBindOutOfRange
@ OrthancPluginErrorCode_SQLiteBindOutOfRange
Definition: OrthancCPlugin.h:252
OrthancPluginRegisterOnStoredInstanceCallback
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:2025
OrthancPluginValueRepresentation_AS
@ OrthancPluginValueRepresentation_AS
Definition: OrthancCPlugin.h:774
OrthancPluginValueRepresentation_UT
@ OrthancPluginValueRepresentation_UT
Definition: OrthancCPlugin.h:799
OrthancPluginErrorCode_SystemCommand
@ OrthancPluginErrorCode_SystemCommand
Definition: OrthancCPlugin.h:210
OrthancPluginContext
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginErrorCode_NotEnoughMemory
@ OrthancPluginErrorCode_NotEnoughMemory
Definition: OrthancCPlugin.h:204
OrthancPluginChangeType_UpdatedAttachment
@ OrthancPluginChangeType_UpdatedAttachment
Definition: OrthancCPlugin.h:726
OrthancPluginSendHttpStatus
void OrthancPluginSendHttpStatus(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status, const char *body, uint32_t bodySize)
Send a HTTP status, with a custom body.
Definition: OrthancCPlugin.h:3744
OrthancPluginInstanceOrigin_Plugin
@ OrthancPluginInstanceOrigin_Plugin
Definition: OrthancCPlugin.h:894
OrthancPluginFindAddAnswer
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5815
OrthancPluginGetOrthancDirectory
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:3121
OrthancPluginDicomToJsonFlags_IncludePrivateTags
@ OrthancPluginDicomToJsonFlags_IncludePrivateTags
Definition: OrthancCPlugin.h:829
OrthancPluginAnswerBuffer
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:2057
OrthancPluginPixelFormat_RGBA32
@ OrthancPluginPixelFormat_RGBA32
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:629
OrthancPluginChangeType_StableStudy
@ OrthancPluginChangeType_StableStudy
Definition: OrthancCPlugin.h:723
OrthancPluginRestApiDelete
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2319
OrthancPluginValueRepresentation_FD
@ OrthancPluginValueRepresentation_FD
Definition: OrthancCPlugin.h:780
OrthancPluginCreateDicomInstance
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition: OrthancCPlugin.h:7755
OrthancPluginRestApiPutAfterPlugins
OrthancPluginErrorCode OrthancPluginRestApiPutAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a PUT call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2403
OrthancPluginErrorCode_Unauthorized
@ OrthancPluginErrorCode_Unauthorized
Definition: OrthancCPlugin.h:229
OrthancPluginServerChunkedRequestReaderFactory
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderFactory)(OrthancPluginServerChunkedRequestReader **reader, const char *url, const OrthancPluginHttpRequest *request)
Callback to create a reader to handle incoming chunked HTTP transfers.
Definition: OrthancCPlugin.h:7307
OrthancPluginErrorCode_CreateDicomNoPayload
@ OrthancPluginErrorCode_CreateDicomNoPayload
Definition: OrthancCPlugin.h:279
OrthancPluginErrorCode_InexistentTag
@ OrthancPluginErrorCode_InexistentTag
Definition: OrthancCPlugin.h:221
OrthancPluginComputeSha1
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5481
OrthancPluginErrorCode_CreateDicomUseContent
@ OrthancPluginErrorCode_CreateDicomUseContent
Definition: OrthancCPlugin.h:278
OrthancPluginPixelFormat_BGRA32
@ OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:663
OrthancPluginErrorCode_Timeout
@ OrthancPluginErrorCode_Timeout
Definition: OrthancCPlugin.h:216
OrthancPluginResourceType_Patient
@ OrthancPluginResourceType_Patient
Definition: OrthancCPlugin.h:697
OrthancPluginErrorCode_JsonToLuaTable
@ OrthancPluginErrorCode_JsonToLuaTable
Definition: OrthancCPlugin.h:286
OrthancPluginErrorCode_LuaReturnsNoString
@ OrthancPluginErrorCode_LuaReturnsNoString
Definition: OrthancCPlugin.h:292
OrthancPluginPixelFormat_Float32
@ OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:655
OrthancPluginDictionaryEntry::group
uint16_t group
Definition: OrthancCPlugin.h:1692
OrthancPluginCreateDicomFlags_DecodeDataUriScheme
@ OrthancPluginCreateDicomFlags_DecodeDataUriScheme
Definition: OrthancCPlugin.h:847
OrthancPluginCreateImage
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5310
OrthancPluginLookupSeries
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2574
OrthancPluginServerChunkedRequestReaderAddChunk
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderAddChunk)(OrthancPluginServerChunkedRequestReader *reader, const void *data, uint32_t size)
Callback invoked whenever a new data chunk is available during a chunked transfer.
Definition: OrthancCPlugin.h:7326
OrthancPluginIncomingDicomInstanceFilter
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition: OrthancCPlugin.h:7615
OrthancPluginChangeType_OrthancStopped
@ OrthancPluginChangeType_OrthancStopped
Definition: OrthancCPlugin.h:725
OrthancPluginErrorCode_LuaAlreadyExecuted
@ OrthancPluginErrorCode_LuaAlreadyExecuted
Definition: OrthancCPlugin.h:289
OrthancPluginGetInstanceRemoteAet
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2791
OrthancPluginDicomToJsonFlags
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:826
OrthancPluginErrorCode_SQLiteCannotStep
@ OrthancPluginErrorCode_SQLiteCannotStep
Definition: OrthancCPlugin.h:251
OrthancPluginCompressAndAnswerJpegImage
void OrthancPluginCompressAndAnswerJpegImage(OrthancPluginContext *context, OrthancPluginRestOutput *output, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, const void *buffer, uint8_t quality)
Answer to a REST request with a JPEG image.
Definition: OrthancCPlugin.h:4137
OrthancPluginGetPeerUrl
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6355
OrthancPluginErrorCode_NoCGetHandler
@ OrthancPluginErrorCode_NoCGetHandler
Definition: OrthancCPlugin.h:301
OrthancPluginValueRepresentation_ST
@ OrthancPluginValueRepresentation_ST
Definition: OrthancCPlugin.h:793
OrthancPluginImageFormat
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:758
OrthancPluginConstraintType_Wildcard
@ OrthancPluginConstraintType_Wildcard
Definition: OrthancCPlugin.h:879
OrthancPluginStorageAreaRead
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4600
OrthancPluginRegisterDecodeImageCallback
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5272
OrthancPluginRestApiPostAfterPlugins
OrthancPluginErrorCode OrthancPluginRestApiPostAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a POST call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2290
OrthancPluginErrorCode_SQLiteCannotOpen
@ OrthancPluginErrorCode_SQLiteCannotOpen
Definition: OrthancCPlugin.h:243
OrthancPluginChangeType_CompletedSeries
@ OrthancPluginChangeType_CompletedSeries
Definition: OrthancCPlugin.h:714
OrthancPluginErrorCode_SQLiteFlush
@ OrthancPluginErrorCode_SQLiteFlush
Definition: OrthancCPlugin.h:249
OrthancPluginErrorCode_SQLiteExecute
@ OrthancPluginErrorCode_SQLiteExecute
Definition: OrthancCPlugin.h:245
OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
@ OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
Definition: OrthancCPlugin.h:969
OrthancPluginHttpRequest
The parameters of a REST request.
Definition: OrthancCPlugin.h:334
OrthancPluginInstanceOrigin_Unknown
@ OrthancPluginInstanceOrigin_Unknown
Definition: OrthancCPlugin.h:891
OrthancPluginValueRepresentation_DA
@ OrthancPluginValueRepresentation_DA
Definition: OrthancCPlugin.h:777
OrthancPluginIdentifierConstraint_SmallerOrEqual
@ OrthancPluginIdentifierConstraint_SmallerOrEqual
Definition: OrthancCPlugin.h:862
OrthancPluginGetImageWidth
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3813
OrthancPluginChangeType_JobSuccess
@ OrthancPluginChangeType_JobSuccess
Definition: OrthancCPlugin.h:731
OrthancPluginConstraintType
OrthancPluginConstraintType
Definition: OrthancCPlugin.h:875
OrthancPluginHasInstanceMetadata
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:2970
OrthancPluginGetPeerName
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6314
OrthancPluginErrorCode_InternalError
@ OrthancPluginErrorCode_InternalError
Definition: OrthancCPlugin.h:199
OrthancPluginDicomWebBinaryCallback2
void(* OrthancPluginDicomWebBinaryCallback2)(OrthancPluginDicomWebNode *node, OrthancPluginDicomWebSetBinaryNode setter, uint32_t levelDepth, const uint16_t *levelTagGroup, const uint16_t *levelTagElement, const uint32_t *levelIndex, uint16_t tagGroup, uint16_t tagElement, OrthancPluginValueRepresentation vr, void *payload)
Callback executed to encode a binary tag in DICOMweb.
Definition: OrthancCPlugin.h:1658
OrthancPluginChangeType_NewChildInstance
@ OrthancPluginChangeType_NewChildInstance
Definition: OrthancCPlugin.h:716
OrthancPluginWorklistCallback
OrthancPluginErrorCode(* OrthancPluginWorklistCallback)(OrthancPluginWorklistAnswers *answers, const OrthancPluginWorklistQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle the C-Find SCP requests for worklists.
Definition: OrthancCPlugin.h:1253
OrthancPluginChangeType_UpdatedPeers
@ OrthancPluginChangeType_UpdatedPeers
Definition: OrthancCPlugin.h:728
OrthancPluginGenerateRestApiAuthorizationToken
char * OrthancPluginGenerateRestApiAuthorizationToken(OrthancPluginContext *context)
Generate a token to grant full access to the REST API of Orthanc.
Definition: OrthancCPlugin.h:8235
OrthancPluginGetImagePitch
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3881
OrthancPluginFindMatcher
struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher
Opaque structure to an object that can be used to check whether a DICOM instance matches a C-Find que...
Definition: OrthancCPlugin.h:1084
OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
@ OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
Definition: OrthancCPlugin.h:977
OrthancPluginErrorCode_BadApplicationEntityTitle
@ OrthancPluginErrorCode_BadApplicationEntityTitle
Definition: OrthancCPlugin.h:266
OrthancPluginGetInstanceMetadata
const char * OrthancPluginGetInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Get the value of some metadata associated with a given DICOM instance.
Definition: OrthancCPlugin.h:3011
OrthancPluginErrorCode_NoCMoveHandler
@ OrthancPluginErrorCode_NoCMoveHandler
Definition: OrthancCPlugin.h:268
OrthancPluginErrorCode_SQLiteCannotRun
@ OrthancPluginErrorCode_SQLiteCannotRun
Definition: OrthancCPlugin.h:250
OrthancPluginDicomToJsonFlags_IncludeBinary
@ OrthancPluginDicomToJsonFlags_IncludeBinary
Definition: OrthancCPlugin.h:828
OrthancPluginRegisterStorageCommitmentScpCallback
OrthancPluginErrorCode OrthancPluginRegisterStorageCommitmentScpCallback(OrthancPluginContext *context, OrthancPluginStorageCommitmentFactory factory, OrthancPluginStorageCommitmentDestructor destructor, OrthancPluginStorageCommitmentLookup lookup)
Register a callback to handle incoming requests to the storage commitment SCP.
Definition: OrthancCPlugin.h:7585
OrthancPluginJobStopReason_Failure
@ OrthancPluginJobStopReason_Failure
Definition: OrthancCPlugin.h:923
OrthancPluginGetInstanceFramesCount
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition: OrthancCPlugin.h:7830
OrthancPluginHttpRequest::groups
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:348
OrthancPluginCreateDicomFlags_GenerateIdentifiers
@ OrthancPluginCreateDicomFlags_GenerateIdentifiers
Definition: OrthancCPlugin.h:848
OrthancPluginErrorCode_SQLitePrepareStatement
@ OrthancPluginErrorCode_SQLitePrepareStatement
Definition: OrthancCPlugin.h:253
OrthancPluginRestCallback
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1117
OrthancPluginHttpRequest::bodySize
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:373
OrthancPluginReconstructMainDicomTags
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4829
OrthancPluginGetTagName
char * OrthancPluginGetTagName(OrthancPluginContext *context, uint16_t group, uint16_t element, const char *privateCreator)
Returns the symbolic name of a DICOM tag.
Definition: OrthancCPlugin.h:7460
OrthancPluginGetFindQueryTag
OrthancPluginErrorCode OrthancPluginGetFindQueryTag(OrthancPluginContext *context, uint16_t *group, uint16_t *element, const OrthancPluginFindQuery *query, uint32_t index)
Get one tag in a C-Find query.
Definition: OrthancCPlugin.h:5905
OrthancPluginLookupDictionary
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5527
OrthancPluginDicomBufferToJson
char * OrthancPluginDicomBufferToJson(OrthancPluginContext *context, const void *buffer, uint32_t size, OrthancPluginDicomToJsonFormat format, OrthancPluginDicomToJsonFlags flags, uint32_t maxStringLength)
Format a DICOM memory buffer as a JSON string.
Definition: OrthancCPlugin.h:4873
OrthancPluginGetConfigurationPath
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:3156
OrthancPluginHttpDelete
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4308
OrthancPluginCompressionType
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:743
OrthancPluginJobStep
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1517
OrthancPluginDictionaryEntry::minMultiplicity
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1695
OrthancPluginErrorCode_InexistentFile
@ OrthancPluginErrorCode_InexistentFile
Definition: OrthancCPlugin.h:213
OrthancPluginErrorCode_ParameterOutOfRange
@ OrthancPluginErrorCode_ParameterOutOfRange
Definition: OrthancCPlugin.h:203
OrthancPluginContentType_Dicom
@ OrthancPluginContentType_Dicom
Definition: OrthancCPlugin.h:684
OrthancPluginErrorCode_UnknownResource
@ OrthancPluginErrorCode_UnknownResource
Definition: OrthancCPlugin.h:217
OrthancPluginErrorCode_DirectoryExpected
@ OrthancPluginErrorCode_DirectoryExpected
Definition: OrthancCPlugin.h:259
OrthancPluginResourceType_Instance
@ OrthancPluginResourceType_Instance
Definition: OrthancCPlugin.h:700
OrthancPluginRegisterIncomingHttpRequestFilter
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5608
OrthancPluginEncodeDicomWebXml2
char * OrthancPluginEncodeDicomWebXml2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7014
OrthancPluginErrorCode_Success
@ OrthancPluginErrorCode_Success
Definition: OrthancCPlugin.h:200
OrthancPluginCompressPngImage
OrthancPluginErrorCode OrthancPluginCompressPngImage(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, const void *buffer)
Encode a PNG image.
Definition: OrthancCPlugin.h:4045
OrthancPluginErrorCode_MakeDirectory
@ OrthancPluginErrorCode_MakeDirectory
Definition: OrthancCPlugin.h:265
OrthancPluginErrorCode_UnsupportedMediaType
@ OrthancPluginErrorCode_UnsupportedMediaType
Definition: OrthancCPlugin.h:302
OrthancPluginChangeType_NewInstance
@ OrthancPluginChangeType_NewInstance
Definition: OrthancCPlugin.h:717
OrthancPluginDrawText
OrthancPluginErrorCode OrthancPluginDrawText(OrthancPluginContext *context, OrthancPluginImage *image, uint32_t fontIndex, const char *utf8Text, int32_t x, int32_t y, uint8_t r, uint8_t g, uint8_t b)
Draw text on an image.
Definition: OrthancCPlugin.h:4506
OrthancPluginResourceType_None
@ OrthancPluginResourceType_None
Definition: OrthancCPlugin.h:701
OrthancPluginSetMetricsValue
void OrthancPluginSetMetricsValue(OrthancPluginContext *context, const char *name, float value, OrthancPluginMetricsType type)
Set the value of a metrics.
Definition: OrthancCPlugin.h:6810
OrthancPluginErrorCode_CannotStoreInstance
@ OrthancPluginErrorCode_CannotStoreInstance
Definition: OrthancCPlugin.h:275
OrthancPluginHttpMethod_Get
@ OrthancPluginHttpMethod_Get
Definition: OrthancCPlugin.h:320
OrthancPluginGetInstanceTransferSyntaxUid
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition: OrthancCPlugin.h:7670
OrthancPluginCreateDicomFlags
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:845
OrthancPluginWorklistAddAnswer
OrthancPluginErrorCode OrthancPluginWorklistAddAnswer(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Add one answer to some modality worklist request.
Definition: OrthancCPlugin.h:5054
OrthancPluginPixelFormat_Grayscale8
@ OrthancPluginPixelFormat_Grayscale8
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:597
OrthancPluginStorageArea
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:1044
OrthancPluginSendHttpStatusCode
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2654
OrthancPluginIdentifierConstraint
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:860
OrthancPluginRestApiDeleteAfterPlugins
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2342
OrthancPluginPeers
struct _OrthancPluginPeers_t OrthancPluginPeers
Opaque structure to the set of remote Orthanc Peers that are known to the local Orthanc server.
Definition: OrthancCPlugin.h:1092
OrthancPluginRefreshMetricsCallback
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1592
OrthancPluginDicomWebBinaryMode_BulkDataUri
@ OrthancPluginDicomWebBinaryMode_BulkDataUri
Definition: OrthancCPlugin.h:952
OrthancPluginPixelFormat_Unknown
@ OrthancPluginPixelFormat_Unknown
Definition: OrthancCPlugin.h:631
OrthancPluginValueRepresentation_LO
@ OrthancPluginValueRepresentation_LO
Definition: OrthancCPlugin.h:783
OrthancPluginRegisterIncomingHttpRequestFilter2
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6174
OrthancPluginValueRepresentation_AE
@ OrthancPluginValueRepresentation_AE
Definition: OrthancCPlugin.h:773
OrthancPluginGetInstanceDecodedFrame
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:7898
OrthancPluginRestApiGet2
OrthancPluginErrorCode OrthancPluginRestApiGet2(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, int32_t afterPlugins)
Make a GET call to the Orthanc REST API, with custom HTTP headers.
Definition: OrthancCPlugin.h:4980
OrthancPluginResourceType
OrthancPluginResourceType
Definition: OrthancCPlugin.h:696
OrthancPluginCreateFindMatcher
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:6061
OrthancPluginErrorCode_NoSopClassOrInstance
@ OrthancPluginErrorCode_NoSopClassOrInstance
Definition: OrthancCPlugin.h:271
OrthancPluginJobStop
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1541
OrthancPluginValueRepresentation_AT
@ OrthancPluginValueRepresentation_AT
Definition: OrthancCPlugin.h:775
OrthancPluginReadFile
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3629
OrthancPluginCallPeerApi
OrthancPluginErrorCode OrthancPluginCallPeerApi(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, const OrthancPluginPeers *peers, uint32_t peerIndex, OrthancPluginHttpMethod method, const char *uri, uint32_t additionalHeadersCount, const char *const *additionalHeadersKeys, const char *const *additionalHeadersValues, const void *body, uint32_t bodySize, uint32_t timeout)
Call the REST API of an Orthanc peer.
Definition: OrthancCPlugin.h:6481
OrthancPluginOnChangeCallback
OrthancPluginErrorCode(* OrthancPluginOnChangeCallback)(OrthancPluginChangeType changeType, OrthancPluginResourceType resourceType, const char *resourceId)
Signature of a callback function that is triggered when a change happens to some DICOM resource.
Definition: OrthancCPlugin.h:1138
OrthancPluginInstanceOrigin_RestApi
@ OrthancPluginInstanceOrigin_RestApi
Definition: OrthancCPlugin.h:893
OrthancPluginChunkedClientRequestIsDone
uint8_t(* OrthancPluginChunkedClientRequestIsDone)(void *request)
Callback to know whether the request body is entirely read during a chunked transfer.
Definition: OrthancCPlugin.h:7099
OrthancPluginErrorCode_NoApplicationEntityFilter
@ OrthancPluginErrorCode_NoApplicationEntityFilter
Definition: OrthancCPlugin.h:270
OrthancPluginLookupStudyWithAccessionNumber
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2539
OrthancPluginCompressionType_ZlibWithSize
@ OrthancPluginCompressionType_ZlibWithSize
Definition: OrthancCPlugin.h:745
OrthancPluginGetCommandLineArgumentsCount
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3381
OrthancPluginErrorCode_ReadOnly
@ OrthancPluginErrorCode_ReadOnly
Definition: OrthancCPlugin.h:222
OrthancPluginErrorCode_SQLiteTransactionAlreadyStarted
@ OrthancPluginErrorCode_SQLiteTransactionAlreadyStarted
Definition: OrthancCPlugin.h:254
OrthancPluginFreeDicomInstance
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition: OrthancCPlugin.h:7793
OrthancPluginValueRepresentation_TM
@ OrthancPluginValueRepresentation_TM
Definition: OrthancCPlugin.h:794
OrthancPluginErrorCode_StorageAreaPlugin
@ OrthancPluginErrorCode_StorageAreaPlugin
Definition: OrthancCPlugin.h:232
OrthancPluginWorklistQuery
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1052
OrthancPluginHasInstancePixelData
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:7705
OrthancPluginGetInstanceDicomWebXml
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:8090
OrthancPluginGetInstanceSize
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2824
OrthancPluginEncodeDicomWebXml
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:6918
OrthancPluginImageFormat_Jpeg
@ OrthancPluginImageFormat_Jpeg
Definition: OrthancCPlugin.h:760
OrthancPluginErrorCode_BadRequest
@ OrthancPluginErrorCode_BadRequest
Definition: OrthancCPlugin.h:208
OrthancPluginDicomWebSetBinaryNode
void(* OrthancPluginDicomWebSetBinaryNode)(OrthancPluginDicomWebNode *node, OrthancPluginDicomWebBinaryMode mode, const char *bulkDataUri)
Signature of a function to set the content of a node encoding a binary DICOM tag, into a JSON or XML ...
Definition: OrthancCPlugin.h:1171
OrthancPluginCreateMemoryBuffer
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, uint32_t size)
Create a memory buffer.
Definition: OrthancCPlugin.h:8197
OrthancPluginOnStoredInstanceCallback
OrthancPluginErrorCode(* OrthancPluginOnStoredInstanceCallback)(const OrthancPluginDicomInstance *instance, const char *instanceId)
Signature of a callback function that is triggered when Orthanc stores a new DICOM instance.
Definition: OrthancCPlugin.h:1128
OrthancPluginRestApiGet
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2188
OrthancPluginConstraintType_SmallerOrEqual
@ OrthancPluginConstraintType_SmallerOrEqual
Definition: OrthancCPlugin.h:877
OrthancPluginRestOutput
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:1020
OrthancPluginServerChunkedRequestReaderFinalize
void(* OrthancPluginServerChunkedRequestReaderFinalize)(OrthancPluginServerChunkedRequestReader *reader)
Callback invoked to release the resources associated with an incoming HTTP chunked transfer.
Definition: OrthancCPlugin.h:7364
OrthancPluginCompressionType_Zlib
@ OrthancPluginCompressionType_Zlib
Definition: OrthancCPlugin.h:744
OrthancPluginErrorCode_NoCStoreHandler
@ OrthancPluginErrorCode_NoCStoreHandler
Definition: OrthancCPlugin.h:269
OrthancPluginErrorCode_CreateDicomParentEncoding
@ OrthancPluginErrorCode_CreateDicomParentEncoding
Definition: OrthancCPlugin.h:283
OrthancPluginDicomToJsonFormat_Short
@ OrthancPluginDicomToJsonFormat_Short
Definition: OrthancCPlugin.h:813
OrthancPluginLogError
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:1879
OrthancPluginPixelFormat_RGB48
@ OrthancPluginPixelFormat_RGB48
Color image in RGB48 format.
Definition: OrthancCPlugin.h:639
OrthancPluginCompressAndAnswerPngImage
void OrthancPluginCompressAndAnswerPngImage(OrthancPluginContext *context, OrthancPluginRestOutput *output, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, const void *buffer)
Answer to a REST request with a PNG image.
Definition: OrthancCPlugin.h:2114
OrthancPluginValueRepresentation_SL
@ OrthancPluginValueRepresentation_SL
Definition: OrthancCPlugin.h:790
OrthancPluginErrorCode_DicomFindUnavailable
@ OrthancPluginErrorCode_DicomFindUnavailable
Definition: OrthancCPlugin.h:273
OrthancPluginErrorCode_InexistentItem
@ OrthancPluginErrorCode_InexistentItem
Definition: OrthancCPlugin.h:207
OrthancPluginGetInstanceSimplifiedJson
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:2931
OrthancPluginJobStopReason_Canceled
@ OrthancPluginJobStopReason_Canceled
Definition: OrthancCPlugin.h:924
OrthancPluginErrorCode_SslInitialization
@ OrthancPluginErrorCode_SslInitialization
Definition: OrthancCPlugin.h:239
OrthancPluginDicomToJsonFormat
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:811
OrthancPluginErrorCode_IncompatibleDatabaseVersion
@ OrthancPluginErrorCode_IncompatibleDatabaseVersion
Definition: OrthancCPlugin.h:218
OrthancPluginErrorCode_AlreadyExistingTag
@ OrthancPluginErrorCode_AlreadyExistingTag
Definition: OrthancCPlugin.h:299
OrthancPluginErrorCode_CreateDicomNotString
@ OrthancPluginErrorCode_CreateDicomNotString
Definition: OrthancCPlugin.h:276
OrthancPluginErrorCode_BadFont
@ OrthancPluginErrorCode_BadFont
Definition: OrthancCPlugin.h:230
OrthancPluginConstraintType_Equal
@ OrthancPluginConstraintType_Equal
Definition: OrthancCPlugin.h:876
OrthancPluginErrorCode_IncompatibleImageSize
@ OrthancPluginErrorCode_IncompatibleImageSize
Definition: OrthancCPlugin.h:224
OrthancPluginErrorCode_SQLiteTransactionCommit
@ OrthancPluginErrorCode_SQLiteTransactionCommit
Definition: OrthancCPlugin.h:255
OrthancPluginHttpMethod_Post
@ OrthancPluginHttpMethod_Post
Definition: OrthancCPlugin.h:321
OrthancPluginErrorCode_UnknownPluginService
@ OrthancPluginErrorCode_UnknownPluginService
Definition: OrthancCPlugin.h:226
OrthancPluginErrorCode_CorruptedFile
@ OrthancPluginErrorCode_CorruptedFile
Definition: OrthancCPlugin.h:220
OrthancPluginDicomWebBinaryMode_InlineBinary
@ OrthancPluginDicomWebBinaryMode_InlineBinary
Definition: OrthancCPlugin.h:951
OrthancPluginIncomingHttpRequestFilter
int32_t(* OrthancPluginIncomingHttpRequestFilter)(OrthancPluginHttpMethod method, const char *uri, const char *ip, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues)
Callback to filter incoming HTTP requests received by Orthanc.
Definition: OrthancCPlugin.h:1284
OrthancPluginChangeType_StableSeries
@ OrthancPluginChangeType_StableSeries
Definition: OrthancCPlugin.h:722
OrthancPluginGetOrthancPath
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:3091
OrthancPluginGetInstanceOrigin
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5187
OrthancPluginStorageCreate
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1190
OrthancPluginContentType
OrthancPluginContentType
Definition: OrthancCPlugin.h:682
OrthancPluginGenerateUuid
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5737
OrthancPluginValueRepresentation_LT
@ OrthancPluginValueRepresentation_LT
Definition: OrthancCPlugin.h:784
OrthancPluginFreeMemoryBuffer
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1863
OrthancPluginMetricsType_Timer
@ OrthancPluginMetricsType_Timer
Definition: OrthancCPlugin.h:940
OrthancPluginHttpRequest::headersCount
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:383
OrthancPluginServerChunkedRequestReaderExecute
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderExecute)(OrthancPluginServerChunkedRequestReader *reader, OrthancPluginRestOutput *output)
Callback invoked whenever the request body is entirely received.
Definition: OrthancCPlugin.h:7346
OrthancPluginInstanceOrigin_Lua
@ OrthancPluginInstanceOrigin_Lua
Definition: OrthancCPlugin.h:895
OrthancPluginSerializeDicomInstance
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition: OrthancCPlugin.h:7975
OrthancPluginSetRootUri
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:3233
OrthancPluginCompressionType_GzipWithSize
@ OrthancPluginCompressionType_GzipWithSize
Definition: OrthancCPlugin.h:747
OrthancPluginStartMultipartAnswer
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3521
OrthancPluginErrorCode_CannotOrderSlices
@ OrthancPluginErrorCode_CannotOrderSlices
Definition: OrthancCPlugin.h:297
OrthancPluginGetImageBuffer
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:3915
OrthancPluginStorageRemove
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1234
OrthancPluginErrorCode_SQLiteTransactionBegin
@ OrthancPluginErrorCode_SQLiteTransactionBegin
Definition: OrthancCPlugin.h:256
OrthancPluginErrorCode_BadJobOrdering
@ OrthancPluginErrorCode_BadJobOrdering
Definition: OrthancCPlugin.h:285
OrthancPluginHttpRequest::headersValues
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:393
OrthancPluginValueRepresentation_DS
@ OrthancPluginValueRepresentation_DS
Definition: OrthancCPlugin.h:778
OrthancPluginChunkedClientRequestGetChunkData
const void *(* OrthancPluginChunkedClientRequestGetChunkData)(void *request)
Callback to read the current chunk of the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7132
OrthancPluginInstanceOrigin
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:890
OrthancPluginRestApiPut
OrthancPluginErrorCode OrthancPluginRestApiPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a PUT call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2367
OrthancPluginErrorCode_CreateDicomOverrideTag
@ OrthancPluginErrorCode_CreateDicomOverrideTag
Definition: OrthancCPlugin.h:277
OrthancPluginTranscodeDicomInstance
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition: OrthancCPlugin.h:7937
OrthancPluginDicomWebBinaryMode_Ignore
@ OrthancPluginDicomWebBinaryMode_Ignore
Definition: OrthancCPlugin.h:950
OrthancPluginGetFontsCount
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4381
OrthancPluginRegisterIncomingDicomInstanceFilter
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition: OrthancCPlugin.h:7646
OrthancPluginChangeType_StablePatient
@ OrthancPluginChangeType_StablePatient
Definition: OrthancCPlugin.h:721
OrthancPluginSendMultipartItem
OrthancPluginErrorCode OrthancPluginSendMultipartItem(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize)
Send an item as a part of some HTTP multipart answer.
Definition: OrthancCPlugin.h:3550
OrthancPluginGetExpectedDatabaseVersion
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3447
OrthancPluginRegisterOnChangeCallback
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3202
OrthancPluginChangeType_OrthancStarted
@ OrthancPluginChangeType_OrthancStarted
Definition: OrthancCPlugin.h:724
OrthancPluginFreeJob
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6621
OrthancPluginChangeType_NewSeries
@ OrthancPluginChangeType_NewSeries
Definition: OrthancCPlugin.h:719
OrthancPluginDicomToJsonFormat_Human
@ OrthancPluginDicomToJsonFormat_Human
Definition: OrthancCPlugin.h:814
OrthancPluginChunkedClientAnswerAddChunk
OrthancPluginErrorCode(* OrthancPluginChunkedClientAnswerAddChunk)(void *answer, const void *data, uint32_t size)
Callback executed when an answer chunk is received during a chunked transfer.
Definition: OrthancCPlugin.h:7079
OrthancPluginServerChunkedRequestReader
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition: OrthancCPlugin.h:7288
OrthancPluginIdentifierConstraint_GreaterOrEqual
@ OrthancPluginIdentifierConstraint_GreaterOrEqual
Definition: OrthancCPlugin.h:863
OrthancPluginValueRepresentation
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:772
OrthancPluginErrorCode_CannotWriteFile
@ OrthancPluginErrorCode_CannotWriteFile
Definition: OrthancCPlugin.h:214
OrthancPluginDictionaryEntry::maxMultiplicity
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1696
OrthancPluginIdentifierConstraint_Equal
@ OrthancPluginIdentifierConstraint_Equal
Definition: OrthancCPlugin.h:861
OrthancPluginErrorCode_Database
@ OrthancPluginErrorCode_Database
Definition: OrthancCPlugin.h:211
OrthancPluginErrorCode_DirectoryOverFile
@ OrthancPluginErrorCode_DirectoryOverFile
Definition: OrthancCPlugin.h:257
OrthancPluginRegisterWorklistCallback
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:5018
OrthancPluginCreateDicom
OrthancPluginErrorCode OrthancPluginCreateDicom(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *json, const OrthancPluginImage *pixelData, OrthancPluginCreateDicomFlags flags)
Create a DICOM instance from a JSON string and an image.
Definition: OrthancCPlugin.h:5236
OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered
@ OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered
Definition: OrthancCPlugin.h:294
OrthancPluginGetFontSize
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4453
OrthancPluginGetErrorDescription
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3691
OrthancPluginErrorCode_DatabaseUnavailable
@ OrthancPluginErrorCode_DatabaseUnavailable
Definition: OrthancCPlugin.h:236
OrthancPluginSetGlobalProperty
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3350
OrthancPluginDecodeImageCallback
OrthancPluginErrorCode(* OrthancPluginDecodeImageCallback)(OrthancPluginImage **target, const void *dicom, const uint32_t size, uint32_t frameIndex)
Signature of a callback function to decode a DICOM instance as an image.
Definition: OrthancCPlugin.h:1149
OrthancPluginRegisterRestCallback
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:1947
OrthancPluginChangeType_Deleted
@ OrthancPluginChangeType_Deleted
Definition: OrthancCPlugin.h:715
OrthancPluginMoveCallback
void *(* OrthancPluginMoveCallback)(OrthancPluginResourceType resourceType, const char *patientId, const char *accessionNumber, const char *studyInstanceUid, const char *seriesInstanceUid, const char *sopInstanceUid, const char *originatorAet, const char *sourceAet, const char *targetAet, uint16_t originatorId)
Callback to handle incoming C-Move SCP requests.
Definition: OrthancCPlugin.h:1389
OrthancPluginImageFormat_Dicom
@ OrthancPluginImageFormat_Dicom
Definition: OrthancCPlugin.h:761
OrthancPluginGetGlobalProperty
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3311
OrthancPluginValueRepresentation_SH
@ OrthancPluginValueRepresentation_SH
Definition: OrthancCPlugin.h:789
OrthancPluginGetImageHeight
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:3846
OrthancPluginValueRepresentation_OB
@ OrthancPluginValueRepresentation_OB
Definition: OrthancCPlugin.h:785
OrthancPluginValueRepresentation_DT
@ OrthancPluginValueRepresentation_DT
Definition: OrthancCPlugin.h:779
OrthancPluginValueRepresentation_UL
@ OrthancPluginValueRepresentation_UL
Definition: OrthancCPlugin.h:796
OrthancPluginPixelFormat_RGB24
@ OrthancPluginPixelFormat_RGB24
Color image in RGB24 format.
Definition: OrthancCPlugin.h:621
OrthancPluginValueRepresentation_SQ
@ OrthancPluginValueRepresentation_SQ
Definition: OrthancCPlugin.h:791
OrthancPluginJobGetSerialized
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1502
OrthancPluginFindAnswers
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1076
OrthancPluginRegisterErrorCode
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4676
OrthancPluginComputeMd5
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5445
OrthancPluginErrorCode_SQLiteRegisterFunction
@ OrthancPluginErrorCode_SQLiteRegisterFunction
Definition: OrthancCPlugin.h:248
OrthancPluginErrorCode_NoStorageCommitmentHandler
@ OrthancPluginErrorCode_NoStorageCommitmentHandler
Definition: OrthancCPlugin.h:300
OrthancPluginValueRepresentation_CS
@ OrthancPluginValueRepresentation_CS
Definition: OrthancCPlugin.h:776
OrthancPluginMemoryBuffer::data
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1005
OrthancPluginPixelFormat_SignedGrayscale16
@ OrthancPluginPixelFormat_SignedGrayscale16
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:613
OrthancPluginFreeFindMatcher
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:6099
OrthancPluginCompressJpegImage
OrthancPluginErrorCode OrthancPluginCompressJpegImage(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, const void *buffer, uint8_t quality)
Encode a JPEG image.
Definition: OrthancCPlugin.h:4090
OrthancPluginGetInstanceJson
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2893
OrthancPluginInstanceOrigin_WebDav
@ OrthancPluginInstanceOrigin_WebDav
Definition: OrthancCPlugin.h:896
OrthancPluginHttpMethod_Put
@ OrthancPluginHttpMethod_Put
Definition: OrthancCPlugin.h:322
OrthancPluginStorageAreaCreate
OrthancPluginErrorCode OrthancPluginStorageAreaCreate(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, const void *content, uint64_t size, OrthancPluginContentType type)
Create a file inside the storage area.
Definition: OrthancCPlugin.h:4558
OrthancPluginHttpRequest::body
const void * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:368
OrthancPluginStorageCommitmentLookup
OrthancPluginErrorCode(* OrthancPluginStorageCommitmentLookup)(OrthancPluginStorageCommitmentFailureReason *target, void *handler, const char *sopClassUid, const char *sopInstanceUid)
Callback to get the status of one DICOM instance in the storage commitment SCP.
Definition: OrthancCPlugin.h:7558
OrthancPluginRegisterChunkedRestCallback
void OrthancPluginRegisterChunkedRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback getHandler, OrthancPluginServerChunkedRequestReaderFactory postHandler, OrthancPluginRestCallback deleteHandler, OrthancPluginServerChunkedRequestReaderFactory putHandler, OrthancPluginServerChunkedRequestReaderAddChunk addChunk, OrthancPluginServerChunkedRequestReaderExecute execute, OrthancPluginServerChunkedRequestReaderFinalize finalize)
Register a REST callback to handle chunked HTTP transfers.
Definition: OrthancCPlugin.h:7409
OrthancPluginErrorCode_NotImplemented
@ OrthancPluginErrorCode_NotImplemented
Definition: OrthancCPlugin.h:202
OrthancPluginDicomToJsonFlags_IncludePixelData
@ OrthancPluginDicomToJsonFlags_IncludePixelData
Definition: OrthancCPlugin.h:831
OrthancPluginRegisterMoveCallback
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:6022
OrthancPluginRegisterJobsUnserializer
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6698
OrthancPluginErrorCode_UnknownModality
@ OrthancPluginErrorCode_UnknownModality
Definition: OrthancCPlugin.h:284
OrthancPluginErrorCode_CreateDicomBadParent
@ OrthancPluginErrorCode_CreateDicomBadParent
Definition: OrthancCPlugin.h:281
OrthancPluginHttpPost
OrthancPluginErrorCode OrthancPluginHttpPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const void *body, uint32_t bodySize, const char *username, const char *password)
Issue a HTTP POST call.
Definition: OrthancCPlugin.h:4228
OrthancPluginHttpPut
OrthancPluginErrorCode OrthancPluginHttpPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const void *body, uint32_t bodySize, const char *username, const char *password)
Issue a HTTP PUT call.
Definition: OrthancCPlugin.h:4270
OrthancPluginDicomInstanceToJson
char * OrthancPluginDicomInstanceToJson(OrthancPluginContext *context, const char *instanceId, OrthancPluginDicomToJsonFormat format, OrthancPluginDicomToJsonFlags flags, uint32_t maxStringLength)
Format a DICOM instance as a JSON string.
Definition: OrthancCPlugin.h:4922
OrthancPluginChangeType_UpdatedModalities
@ OrthancPluginChangeType_UpdatedModalities
Definition: OrthancCPlugin.h:729
OrthancPluginValueRepresentation_UN
@ OrthancPluginValueRepresentation_UN
Definition: OrthancCPlugin.h:797
OrthancPluginSetDescription
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:3255
OrthancPluginDicomWebBinaryMode
OrthancPluginDicomWebBinaryMode
Definition: OrthancCPlugin.h:949
OrthancPluginIdentifierConstraint_Wildcard
@ OrthancPluginIdentifierConstraint_Wildcard
Definition: OrthancCPlugin.h:864
OrthancPluginPixelFormat_Grayscale64
@ OrthancPluginPixelFormat_Grayscale64
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:671
OrthancPluginConstraintType_GreaterOrEqual
@ OrthancPluginConstraintType_GreaterOrEqual
Definition: OrthancCPlugin.h:878
OrthancPluginErrorCode_NoCFindHandler
@ OrthancPluginErrorCode_NoCFindHandler
Definition: OrthancCPlugin.h:267
OrthancPluginValueRepresentation_IS
@ OrthancPluginValueRepresentation_IS
Definition: OrthancCPlugin.h:782
OrthancPluginErrorCode_BadGeometry
@ OrthancPluginErrorCode_BadGeometry
Definition: OrthancCPlugin.h:238
OrthancPluginLogWarning
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:1895
OrthancPluginValueRepresentation_UI
@ OrthancPluginValueRepresentation_UI
Definition: OrthancCPlugin.h:795
OrthancPluginGetImagePixelFormat
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3780
OrthancPluginStorageCommitmentFailureReason_Success
@ OrthancPluginStorageCommitmentFailureReason_Success
Definition: OrthancCPlugin.h:963
OrthancPluginErrorCode_CreateDicomParentIsInstance
@ OrthancPluginErrorCode_CreateDicomParentIsInstance
Definition: OrthancCPlugin.h:282
OrthancPluginFree
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1161
OrthancPluginRedirect
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2437
OrthancPluginValueRepresentation_SS
@ OrthancPluginValueRepresentation_SS
Definition: OrthancCPlugin.h:792
OrthancPluginJobReset
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1558
OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
@ OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
Definition: OrthancCPlugin.h:981
OrthancPluginGetFindQueryTagName
char * OrthancPluginGetFindQueryTagName(OrthancPluginContext *context, const OrthancPluginFindQuery *query, uint32_t index)
Get the symbolic name of one tag in a C-Find query.
Definition: OrthancCPlugin.h:5936
OrthancPluginCreateJob
OrthancPluginJob * OrthancPluginCreateJob(OrthancPluginContext *context, void *job, OrthancPluginJobFinalize finalize, const char *type, OrthancPluginJobGetProgress getProgress, OrthancPluginJobGetContent getContent, OrthancPluginJobGetSerialized getSerialized, OrthancPluginJobStep step, OrthancPluginJobStop stop, OrthancPluginJobReset reset)
Create a custom job.
Definition: OrthancCPlugin.h:6566
OrthancPluginWorklistMarkIncomplete
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5084
OrthancPluginEncodeDicomWebJson
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:6876
OrthancPluginHttpRequest::method
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:338
OrthancPluginErrorCode_SQLiteCommitWithoutTransaction
@ OrthancPluginErrorCode_SQLiteCommitWithoutTransaction
Definition: OrthancCPlugin.h:247
OrthancPluginValueRepresentation_PN
@ OrthancPluginValueRepresentation_PN
Definition: OrthancCPlugin.h:788
OrthancPluginErrorCode
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:198
OrthancPluginErrorCode_DiscontinuedAbi
@ OrthancPluginErrorCode_DiscontinuedAbi
Definition: OrthancCPlugin.h:240
OrthancPluginHttpRequest::getValues
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:363
OrthancPluginErrorCode_Plugin
@ OrthancPluginErrorCode_Plugin
Definition: OrthancCPlugin.h:201
OrthancPluginErrorCode_UriSyntax
@ OrthancPluginErrorCode_UriSyntax
Definition: OrthancCPlugin.h:212
OrthancPluginHttpRequest::headersKeys
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:388
OrthancPluginStorageRead
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1216
OrthancPluginJobsUnserializer
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1574
OrthancPluginChangeType_UpdatedMetadata
@ OrthancPluginChangeType_UpdatedMetadata
Definition: OrthancCPlugin.h:727
OrthancPluginChangeType_JobSubmitted
@ OrthancPluginChangeType_JobSubmitted
Definition: OrthancCPlugin.h:730
OrthancPluginMemoryBuffer
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1001
OrthancPluginJobGetContent
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1484
OrthancPluginValueRepresentation_FL
@ OrthancPluginValueRepresentation_FL
Definition: OrthancCPlugin.h:781
OrthancPluginFreePeers
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6236
OrthancPluginWorklistAnswers
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1060
OrthancPluginRegisterFindCallback
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5776
OrthancPluginDictionaryEntry::vr
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1694
OrthancPluginImage
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1036
OrthancPluginConstraintType_List
@ OrthancPluginConstraintType_List
Definition: OrthancCPlugin.h:880
OrthancPluginJob
struct _OrthancPluginJob_t OrthancPluginJob
Opaque structure to a job to be executed by Orthanc.
Definition: OrthancCPlugin.h:1100
OrthancPluginErrorCode_BadSequenceOfCalls
@ OrthancPluginErrorCode_BadSequenceOfCalls
Definition: OrthancCPlugin.h:206
OrthancPluginContentType_Unknown
@ OrthancPluginContentType_Unknown
Definition: OrthancCPlugin.h:683
OrthancPluginIncomingHttpRequestFilter2
int32_t(* OrthancPluginIncomingHttpRequestFilter2)(OrthancPluginHttpMethod method, const char *uri, const char *ip, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, uint32_t getArgumentsCount, const char *const *getArgumentsKeys, const char *const *getArgumentsValues)
Callback to filter incoming HTTP requests received by Orthanc.
Definition: OrthancCPlugin.h:1319
OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
@ OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
Definition: OrthancCPlugin.h:986
OrthancPluginHttpMethod
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:319
OrthancPluginFindCallback
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1346
OrthancPluginFreeImage
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:4000
OrthancPluginHttpRequest::groupsCount
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:343
OrthancPluginDicomWebNode
struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode
Opaque structure that represents a node in a JSON or XML document used in DICOMweb.
Definition: OrthancCPlugin.h:1109
OrthancPluginAutodetectMimeType
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:6766
OrthancPluginErrorCode_DicomMoveUnavailable
@ OrthancPluginErrorCode_DicomMoveUnavailable
Definition: OrthancCPlugin.h:274
OrthancPluginErrorCode_DicomPortInUse
@ OrthancPluginErrorCode_DicomPortInUse
Definition: OrthancCPlugin.h:261
OrthancPluginFreeMove
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1443
OrthancPluginGetFontName
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4421
OrthancPluginSetCookie
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2730
OrthancPluginJobFinalize
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1456
OrthancPluginApplyMove
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1429
OrthancPluginErrorCode_EmptyRequest
@ OrthancPluginErrorCode_EmptyRequest
Definition: OrthancCPlugin.h:233
OrthancPluginErrorCode_CanceledJob
@ OrthancPluginErrorCode_CanceledJob
Definition: OrthancCPlugin.h:237
OrthancPluginJobStepStatus_Failure
@ OrthancPluginJobStepStatus_Failure
Definition: OrthancCPlugin.h:908
OrthancPluginGetInstanceRawFrame
OrthancPluginErrorCode OrthancPluginGetInstanceRawFrame(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Get the raw content of a frame in a DICOM instance.
Definition: OrthancCPlugin.h:7870
OrthancPluginPixelFormat_Grayscale32
@ OrthancPluginPixelFormat_Grayscale32
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:647
OrthancPluginGetPeers
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6202
OrthancPluginErrorCode_NoPresentationContext
@ OrthancPluginErrorCode_NoPresentationContext
Definition: OrthancCPlugin.h:272
OrthancPluginErrorCode_NetworkProtocol
@ OrthancPluginErrorCode_NetworkProtocol
Definition: OrthancCPlugin.h:209
OrthancPluginSubmitJob
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int priority)
Submit a new job to the jobs engine of Orthanc.
Definition: OrthancCPlugin.h:6653
OrthancPluginDicomToJsonFormat_Full
@ OrthancPluginDicomToJsonFormat_Full
Definition: OrthancCPlugin.h:812
OrthancPluginRegisterRefreshMetricsCallback
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:6840
OrthancPluginGetInstanceAdvancedJson
char * OrthancPluginGetInstanceAdvancedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomToJsonFormat format, OrthancPluginDicomToJsonFlags flags, uint32_t maxStringLength)
Format a DICOM memory buffer as a JSON string.
Definition: OrthancCPlugin.h:8007
OrthancPluginHttpMethod_Delete
@ OrthancPluginHttpMethod_Delete
Definition: OrthancCPlugin.h:323
OrthancPluginHttpRequest::getCount
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:353
OrthancPluginErrorCode_UnknownDicomTag
@ OrthancPluginErrorCode_UnknownDicomTag
Definition: OrthancCPlugin.h:227
OrthancPluginInstanceOrigin_DicomProtocol
@ OrthancPluginInstanceOrigin_DicomProtocol
Definition: OrthancCPlugin.h:892
OrthancPluginResourceType_Series
@ OrthancPluginResourceType_Series
Definition: OrthancCPlugin.h:699
OrthancPluginErrorCode_IncompatibleImageFormat
@ OrthancPluginErrorCode_IncompatibleImageFormat
Definition: OrthancCPlugin.h:223
OrthancPluginChangeType_NewStudy
@ OrthancPluginChangeType_NewStudy
Definition: OrthancCPlugin.h:720
OrthancPluginErrorCode_FullStorage
@ OrthancPluginErrorCode_FullStorage
Definition: OrthancCPlugin.h:219
OrthancPluginDictionaryEntry
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1691
OrthancPluginCreateImageAccessor
OrthancPluginImage * OrthancPluginCreateImageAccessor(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, void *buffer)
Create an image pointing to a memory buffer.
Definition: OrthancCPlugin.h:5353
OrthancPluginJobStopReason_Paused
@ OrthancPluginJobStopReason_Paused
Definition: OrthancCPlugin.h:922
OrthancPluginGetPeerUserProperty
const char * OrthancPluginGetPeerUserProperty(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex, const char *userProperty)
Get some user-defined property of an Orthanc peer.
Definition: OrthancCPlugin.h:6401
OrthancPluginLookupPatient
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2469
OrthancPluginJobStopReason_Success
@ OrthancPluginJobStopReason_Success
Definition: OrthancCPlugin.h:921
OrthancPluginErrorCode_SQLiteAlreadyOpened
@ OrthancPluginErrorCode_SQLiteAlreadyOpened
Definition: OrthancCPlugin.h:242
OrthancPluginFreeString
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1709
OrthancPluginWriteFile
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3660
OrthancPluginGetCommandLineArgument
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3415
OrthancPluginJobStepStatus_Continue
@ OrthancPluginJobStepStatus_Continue
Definition: OrthancCPlugin.h:909
OrthancPluginErrorCode_RegularFileExpected
@ OrthancPluginErrorCode_RegularFileExpected
Definition: OrthancCPlugin.h:263
OrthancPluginLookupInstance
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2609
OrthancPluginChunkedHttpClient
OrthancPluginErrorCode OrthancPluginChunkedHttpClient(OrthancPluginContext *context, void *answer, OrthancPluginChunkedClientAnswerAddChunk answerAddChunk, OrthancPluginChunkedClientAnswerAddHeader answerAddHeader, uint16_t *httpStatus, OrthancPluginHttpMethod method, const char *url, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, void *request, OrthancPluginChunkedClientRequestIsDone requestIsDone, OrthancPluginChunkedClientRequestGetChunkData requestChunkData, OrthancPluginChunkedClientRequestGetChunkSize requestChunkSize, OrthancPluginChunkedClientRequestNext requestNext, const char *username, const char *password, uint32_t timeout, const char *certificateFile, const char *certificateKeyFile, const char *certificateKeyPassword, uint8_t pkcs11)
Issue a HTTP call, using chunked HTTP transfers.
Definition: OrthancCPlugin.h:7227
OrthancPluginErrorCode_SslDisabled
@ OrthancPluginErrorCode_SslDisabled
Definition: OrthancCPlugin.h:296
OrthancPluginErrorCode_CreateDicomUseDataUriScheme
@ OrthancPluginErrorCode_CreateDicomUseDataUriScheme
Definition: OrthancCPlugin.h:280
OrthancPluginChangeType
OrthancPluginChangeType
Definition: OrthancCPlugin.h:713
OrthancPluginErrorCode_CannotCreateLua
@ OrthancPluginErrorCode_CannotCreateLua
Definition: OrthancCPlugin.h:287
OrthancPluginErrorCode_BadHttpStatusInRest
@ OrthancPluginErrorCode_BadHttpStatusInRest
Definition: OrthancCPlugin.h:262
OrthancPluginErrorCode_StorageAreaAlreadyRegistered
@ OrthancPluginErrorCode_StorageAreaAlreadyRegistered
Definition: OrthancCPlugin.h:293
OrthancPluginJobStepStatus
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:906
OrthancPluginUncompressImage
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:3958
OrthancPluginRegisterRestCallbackNoLock
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:1987
OrthancPluginCheckVersionAdvanced
int OrthancPluginCheckVersionAdvanced(OrthancPluginContext *context, int expectedMajor, int expectedMinor, int expectedRevision)
Check that the version of the hosting Orthanc is above a given version.
Definition: OrthancCPlugin.h:1739
OrthancPluginValueRepresentation_US
@ OrthancPluginValueRepresentation_US
Definition: OrthancCPlugin.h:798
OrthancPluginWorklistIsMatch
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:5122
OrthancPluginErrorCode_DatabaseNotInitialized
@ OrthancPluginErrorCode_DatabaseNotInitialized
Definition: OrthancCPlugin.h:295
OrthancPluginSendMultipartItem2
OrthancPluginErrorCode OrthancPluginSendMultipartItem2(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues)
Send an item as a part of some HTTP multipart answer, with custom headers.
Definition: OrthancCPlugin.h:5570
OrthancPluginDicomToJsonFlags_IncludeUnknownTags
@ OrthancPluginDicomToJsonFlags_IncludeUnknownTags
Definition: OrthancCPlugin.h:830
OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
@ OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
Definition: OrthancCPlugin.h:973
OrthancPluginMemoryBuffer::size
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1010
OrthancPluginJobStopReason
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:920
OrthancPluginRegisterPrivateDictionaryTag
OrthancPluginErrorCode OrthancPluginRegisterPrivateDictionaryTag(OrthancPluginContext *context, uint16_t group, uint16_t element, OrthancPluginValueRepresentation vr, const char *name, uint32_t minMultiplicity, uint32_t maxMultiplicity, const char *privateCreator)
Register a new private tag into the DICOM dictionary.
Definition: OrthancCPlugin.h:4785
OrthancPluginEncodeDicomWebJson2
char * OrthancPluginEncodeDicomWebJson2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:6970
OrthancPluginStorageAreaRemove
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4637
OrthancPluginGetPeersCount
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6266
OrthancPluginGetFindQuerySize
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5868
OrthancPluginLogInfo
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:1911
OrthancPluginErrorCode_SQLiteRollbackWithoutTransaction
@ OrthancPluginErrorCode_SQLiteRollbackWithoutTransaction
Definition: OrthancCPlugin.h:246
OrthancPluginFindMarkIncomplete
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:5844
OrthancPluginFindQuery
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1068
OrthancPluginHttpGet
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:4190
OrthancPluginGetInstanceData
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2857
OrthancPluginGetInstanceDicomWebJson
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:8050
OrthancPluginErrorCode_BadFileFormat
@ OrthancPluginErrorCode_BadFileFormat
Definition: OrthancCPlugin.h:215
OrthancPluginErrorCode_BadJson
@ OrthancPluginErrorCode_BadJson
Definition: OrthancCPlugin.h:228
OrthancPluginHttpRequest::getKeys
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:358
OrthancPluginChunkedClientRequestGetChunkSize
uint32_t(* OrthancPluginChunkedClientRequestGetChunkSize)(void *request)
Callback to read the size of the current request chunk during a chunked transfer.
Definition: OrthancCPlugin.h:7148
OrthancPluginResourceType_Study
@ OrthancPluginResourceType_Study
Definition: OrthancCPlugin.h:698
OrthancPluginStorageCommitmentFailureReason
OrthancPluginStorageCommitmentFailureReason
Definition: OrthancCPlugin.h:962
OrthancPluginContentType_DicomAsJson
@ OrthancPluginContentType_DicomAsJson
Definition: OrthancCPlugin.h:685
OrthancPluginDicomWebBinaryCallback
void(* OrthancPluginDicomWebBinaryCallback)(OrthancPluginDicomWebNode *node, OrthancPluginDicomWebSetBinaryNode setter, uint32_t levelDepth, const uint16_t *levelTagGroup, const uint16_t *levelTagElement, const uint32_t *levelIndex, uint16_t tagGroup, uint16_t tagElement, OrthancPluginValueRepresentation vr)
Callback executed to encode a binary tag in DICOMweb.
Definition: OrthancCPlugin.h:1620
OrthancPluginErrorCode_HttpPortInUse
@ OrthancPluginErrorCode_HttpPortInUse
Definition: OrthancCPlugin.h:260
OrthancPluginErrorCode_PathToExecutable
@ OrthancPluginErrorCode_PathToExecutable
Definition: OrthancCPlugin.h:264
OrthancPluginMetricsType
OrthancPluginMetricsType
Definition: OrthancCPlugin.h:932
OrthancPluginBufferCompression
OrthancPluginErrorCode OrthancPluginBufferCompression(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const void *source, uint32_t size, OrthancPluginCompressionType compression, uint8_t uncompress)
Compress or decompress a buffer.
Definition: OrthancCPlugin.h:3592
OrthancPluginGetDicomForInstance
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2155
OrthancPluginWorklistGetDicomQuery
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5161
OrthancPluginErrorCode_NullPointer
@ OrthancPluginErrorCode_NullPointer
Definition: OrthancCPlugin.h:235
OrthancPluginSetHttpErrorDetails
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:6734
OrthancPluginErrorCode_SharedLibrary
@ OrthancPluginErrorCode_SharedLibrary
Definition: OrthancCPlugin.h:225
OrthancPluginChunkedClientAnswerAddHeader
OrthancPluginErrorCode(* OrthancPluginChunkedClientAnswerAddHeader)(void *answer, const char *key, const char *value)
Callback executed when a HTTP header is received during a chunked transfer.
Definition: OrthancCPlugin.h:7058
OrthancPluginErrorCode_FileStorageCannotWrite
@ OrthancPluginErrorCode_FileStorageCannotWrite
Definition: OrthancCPlugin.h:258
OrthancPluginFindMatcherIsMatch
int32_t OrthancPluginFindMatcherIsMatch(OrthancPluginContext *context, const OrthancPluginFindMatcher *matcher, const void *dicom, uint32_t size)
Test whether a DICOM instance matches a C-Find query.
Definition: OrthancCPlugin.h:6132
OrthancPluginValueRepresentation_OW
@ OrthancPluginValueRepresentation_OW
Definition: OrthancCPlugin.h:787
OrthancPluginValueRepresentation_OF
@ OrthancPluginValueRepresentation_OF
Definition: OrthancCPlugin.h:786
OrthancPluginChunkedClientRequestNext
OrthancPluginErrorCode(* OrthancPluginChunkedClientRequestNext)(void *request)
Callback to advance in the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7116
OrthancPluginErrorCode_SQLiteNotOpened
@ OrthancPluginErrorCode_SQLiteNotOpened
Definition: OrthancCPlugin.h:241
OrthancPluginRestApiPost
OrthancPluginErrorCode OrthancPluginRestApiPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a POST call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2255
OrthancPluginRegisterStorageArea
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:3059
OrthancPluginTranscoderCallback
OrthancPluginErrorCode(* OrthancPluginTranscoderCallback)(OrthancPluginMemoryBuffer *transcoded, const void *buffer, uint64_t size, const char *const *allowedSyntaxes, uint32_t countSyntaxes, uint8_t allowNewSopInstanceUid)
Signature of a callback function to transcode a DICOM instance.
Definition: OrthancCPlugin.h:8135
OrthancPluginStorageCommitmentFactory
OrthancPluginErrorCode(* OrthancPluginStorageCommitmentFactory)(void **handler, const char *jobId, const char *transactionUid, const char *const *sopClassUids, const char *const *sopInstanceUids, uint32_t countInstances, const char *remoteAet, const char *calledAet)
Callback executed by the storage commitment SCP.
Definition: OrthancCPlugin.h:7515
OrthancPluginJobStepStatus_Success
@ OrthancPluginJobStepStatus_Success
Definition: OrthancCPlugin.h:907
OrthancPluginErrorCode_BadParameterType
@ OrthancPluginErrorCode_BadParameterType
Definition: OrthancCPlugin.h:205
OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
@ OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
Definition: OrthancCPlugin.h:966
OrthancPluginRestApiGetAfterPlugins
OrthancPluginErrorCode OrthancPluginRestApiGetAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2218
OrthancPluginRegisterTranscoderCallback
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition: OrthancCPlugin.h:8162
OrthancPluginGetFindQueryValue
char * OrthancPluginGetFindQueryValue(OrthancPluginContext *context, const OrthancPluginFindQuery *query, uint32_t index)
Get the value associated with one tag in a C-Find query.
Definition: OrthancCPlugin.h:5974
OrthancPluginImageFormat_Png
@ OrthancPluginImageFormat_Png
Definition: OrthancCPlugin.h:759
OrthancPluginPixelFormat
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:590
OrthancPluginErrorCode_LuaBadOutput
@ OrthancPluginErrorCode_LuaBadOutput
Definition: OrthancCPlugin.h:290
OrthancPluginSendUnauthorized
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2677
OrthancPluginDicomInstance
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition: OrthancCPlugin.h:1028
OrthancPluginErrorCode_DatabasePlugin
@ OrthancPluginErrorCode_DatabasePlugin
Definition: OrthancCPlugin.h:231
OrthancPluginPixelFormat_Grayscale16
@ OrthancPluginPixelFormat_Grayscale16
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:605
OrthancPluginSendMethodNotAllowed
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2700
OrthancPluginStorageCommitmentDestructor
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7537
OrthancPluginSetHttpHeader
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2755
OrthancPluginRegisterDictionaryTag
OrthancPluginErrorCode OrthancPluginRegisterDictionaryTag(OrthancPluginContext *context, uint16_t group, uint16_t element, OrthancPluginValueRepresentation vr, const char *name, uint32_t minMultiplicity, uint32_t maxMultiplicity)
Register a new tag into the DICOM dictionary.
Definition: OrthancCPlugin.h:4732
OrthancPluginErrorCode_NotLuaPredicate
@ OrthancPluginErrorCode_NotLuaPredicate
Definition: OrthancCPlugin.h:291
OrthancPluginLookupStudy
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2504
OrthancPluginDictionaryEntry::element
uint16_t element
Definition: OrthancCPlugin.h:1693
OrthancPluginErrorCode_NotAcceptable
@ OrthancPluginErrorCode_NotAcceptable
Definition: OrthancCPlugin.h:234
OrthancPluginDecodeDicomImage
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5399
OrthancPluginGetConfiguration
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3480