Orthanc Plugin SDK  1.8.1
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 
1281  OrthancPluginHttpMethod method,
1282  const char* uri,
1283  const char* ip,
1284  uint32_t headersCount,
1285  const char* const* headersKeys,
1286  const char* const* headersValues);
1287 
1288 
1289 
1312  OrthancPluginHttpMethod method,
1313  const char* uri,
1314  const char* ip,
1315  uint32_t headersCount,
1316  const char* const* headersKeys,
1317  const char* const* headersValues,
1318  uint32_t getArgumentsCount,
1319  const char* const* getArgumentsKeys,
1320  const char* const* getArgumentsValues);
1321 
1322 
1323 
1339  OrthancPluginFindAnswers* answers,
1340  const OrthancPluginFindQuery* query,
1341  const char* issuerAet,
1342  const char* calledAet);
1343 
1344 
1345 
1381  typedef void* (*OrthancPluginMoveCallback) (
1382  OrthancPluginResourceType resourceType,
1383  const char* patientId,
1384  const char* accessionNumber,
1385  const char* studyInstanceUid,
1386  const char* seriesInstanceUid,
1387  const char* sopInstanceUid,
1388  const char* originatorAet,
1389  const char* sourceAet,
1390  const char* targetAet,
1391  uint16_t originatorId);
1392 
1393 
1406  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1407 
1408 
1421  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1422 
1423 
1435  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1436 
1437 
1448  typedef void (*OrthancPluginJobFinalize) (void* job);
1449 
1450 
1461  typedef float (*OrthancPluginJobGetProgress) (void* job);
1462 
1463 
1476  typedef const char* (*OrthancPluginJobGetContent) (void* job);
1477 
1478 
1494  typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1495 
1496 
1510 
1511 
1535 
1536 
1551 
1552 
1566  typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1567  const char* serialized);
1568 
1569 
1570 
1585 
1586 
1587 
1615  uint32_t levelDepth,
1616  const uint16_t* levelTagGroup,
1617  const uint16_t* levelTagElement,
1618  const uint32_t* levelIndex,
1619  uint16_t tagGroup,
1620  uint16_t tagElement,
1622 
1623 
1624 
1653  uint32_t levelDepth,
1654  const uint16_t* levelTagGroup,
1655  const uint16_t* levelTagElement,
1656  const uint32_t* levelIndex,
1657  uint16_t tagGroup,
1658  uint16_t tagElement,
1660  void* payload);
1661 
1662 
1663 
1667  typedef struct _OrthancPluginContext_t
1668  {
1669  void* pluginsManager;
1670  const char* orthancVersion;
1671  OrthancPluginFree Free;
1672  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1673  _OrthancPluginService service,
1674  const void* params);
1676 
1677 
1678 
1682  typedef struct
1683  {
1684  uint16_t group;
1685  uint16_t element;
1687  uint32_t minMultiplicity;
1688  uint32_t maxMultiplicity;
1690 
1691 
1692 
1701  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1702  OrthancPluginContext* context,
1703  char* str)
1704  {
1705  if (str != NULL)
1706  {
1707  context->Free(str);
1708  }
1709  }
1710 
1711 
1731  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1732  OrthancPluginContext* context,
1733  int expectedMajor,
1734  int expectedMinor,
1735  int expectedRevision)
1736  {
1737  int major, minor, revision;
1738 
1739  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1740  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1741  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1742  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1743  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1744  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1745  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1746  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1747  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1748  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1749  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1750  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1751  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1752  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1753  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1754  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1755  sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1756  sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
1757  sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
1758  sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
1759  sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason))
1760  {
1761  /* Mismatch in the size of the enumerations */
1762  return 0;
1763  }
1764 
1765  /* Assume compatibility with the mainline */
1766  if (!strcmp(context->orthancVersion, "mainline"))
1767  {
1768  return 1;
1769  }
1770 
1771  /* Parse the version of the Orthanc core */
1772  if (
1773 #ifdef _MSC_VER
1774  sscanf_s
1775 #else
1776  sscanf
1777 #endif
1778  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1779  {
1780  return 0;
1781  }
1782 
1783  /* Check the major number of the version */
1784 
1785  if (major > expectedMajor)
1786  {
1787  return 1;
1788  }
1789 
1790  if (major < expectedMajor)
1791  {
1792  return 0;
1793  }
1794 
1795  /* Check the minor number of the version */
1796 
1797  if (minor > expectedMinor)
1798  {
1799  return 1;
1800  }
1801 
1802  if (minor < expectedMinor)
1803  {
1804  return 0;
1805  }
1806 
1807  /* Check the revision number of the version */
1808 
1809  if (revision >= expectedRevision)
1810  {
1811  return 1;
1812  }
1813  else
1814  {
1815  return 0;
1816  }
1817  }
1818 
1819 
1836  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1837  OrthancPluginContext* context)
1838  {
1840  context,
1841  ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1842  ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1843  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1844  }
1845 
1846 
1855  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1856  OrthancPluginContext* context,
1857  OrthancPluginMemoryBuffer* buffer)
1858  {
1859  context->Free(buffer->data);
1860  }
1861 
1862 
1871  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1872  OrthancPluginContext* context,
1873  const char* message)
1874  {
1875  context->InvokeService(context, _OrthancPluginService_LogError, message);
1876  }
1877 
1878 
1887  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
1888  OrthancPluginContext* context,
1889  const char* message)
1890  {
1891  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1892  }
1893 
1894 
1903  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
1904  OrthancPluginContext* context,
1905  const char* message)
1906  {
1907  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
1908  }
1909 
1910 
1911 
1912  typedef struct
1913  {
1914  const char* pathRegularExpression;
1915  OrthancPluginRestCallback callback;
1916  } _OrthancPluginRestCallback;
1917 
1939  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
1940  OrthancPluginContext* context,
1941  const char* pathRegularExpression,
1942  OrthancPluginRestCallback callback)
1943  {
1944  _OrthancPluginRestCallback params;
1945  params.pathRegularExpression = pathRegularExpression;
1946  params.callback = callback;
1947  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
1948  }
1949 
1950 
1951 
1979  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
1980  OrthancPluginContext* context,
1981  const char* pathRegularExpression,
1982  OrthancPluginRestCallback callback)
1983  {
1984  _OrthancPluginRestCallback params;
1985  params.pathRegularExpression = pathRegularExpression;
1986  params.callback = callback;
1987  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
1988  }
1989 
1990 
1991 
1992  typedef struct
1993  {
1995  } _OrthancPluginOnStoredInstanceCallback;
1996 
2018  OrthancPluginContext* context,
2020  {
2021  _OrthancPluginOnStoredInstanceCallback params;
2022  params.callback = callback;
2023 
2024  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
2025  }
2026 
2027 
2028 
2029  typedef struct
2030  {
2031  OrthancPluginRestOutput* output;
2032  const void* answer;
2033  uint32_t answerSize;
2034  const char* mimeType;
2035  } _OrthancPluginAnswerBuffer;
2036 
2049  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
2050  OrthancPluginContext* context,
2051  OrthancPluginRestOutput* output,
2052  const void* answer,
2053  uint32_t answerSize,
2054  const char* mimeType)
2055  {
2056  _OrthancPluginAnswerBuffer params;
2057  params.output = output;
2058  params.answer = answer;
2059  params.answerSize = answerSize;
2060  params.mimeType = mimeType;
2061  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
2062  }
2063 
2064 
2065  typedef struct
2066  {
2067  OrthancPluginRestOutput* output;
2068  OrthancPluginPixelFormat format;
2069  uint32_t width;
2070  uint32_t height;
2071  uint32_t pitch;
2072  const void* buffer;
2073  } _OrthancPluginCompressAndAnswerPngImage;
2074 
2075  typedef struct
2076  {
2077  OrthancPluginRestOutput* output;
2078  OrthancPluginImageFormat imageFormat;
2079  OrthancPluginPixelFormat pixelFormat;
2080  uint32_t width;
2081  uint32_t height;
2082  uint32_t pitch;
2083  const void* buffer;
2084  uint8_t quality;
2085  } _OrthancPluginCompressAndAnswerImage;
2086 
2087 
2106  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2107  OrthancPluginContext* context,
2108  OrthancPluginRestOutput* output,
2109  OrthancPluginPixelFormat format,
2110  uint32_t width,
2111  uint32_t height,
2112  uint32_t pitch,
2113  const void* buffer)
2114  {
2115  _OrthancPluginCompressAndAnswerImage params;
2116  params.output = output;
2117  params.imageFormat = OrthancPluginImageFormat_Png;
2118  params.pixelFormat = format;
2119  params.width = width;
2120  params.height = height;
2121  params.pitch = pitch;
2122  params.buffer = buffer;
2123  params.quality = 0; /* No quality for PNG */
2124  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2125  }
2126 
2127 
2128 
2129  typedef struct
2130  {
2131  OrthancPluginMemoryBuffer* target;
2132  const char* instanceId;
2133  } _OrthancPluginGetDicomForInstance;
2134 
2148  OrthancPluginContext* context,
2149  OrthancPluginMemoryBuffer* target,
2150  const char* instanceId)
2151  {
2152  _OrthancPluginGetDicomForInstance params;
2153  params.target = target;
2154  params.instanceId = instanceId;
2155  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2156  }
2157 
2158 
2159 
2160  typedef struct
2161  {
2162  OrthancPluginMemoryBuffer* target;
2163  const char* uri;
2164  } _OrthancPluginRestApiGet;
2165 
2181  OrthancPluginContext* context,
2182  OrthancPluginMemoryBuffer* target,
2183  const char* uri)
2184  {
2185  _OrthancPluginRestApiGet params;
2186  params.target = target;
2187  params.uri = uri;
2188  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2189  }
2190 
2191 
2192 
2211  OrthancPluginContext* context,
2212  OrthancPluginMemoryBuffer* target,
2213  const char* uri)
2214  {
2215  _OrthancPluginRestApiGet params;
2216  params.target = target;
2217  params.uri = uri;
2218  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2219  }
2220 
2221 
2222 
2223  typedef struct
2224  {
2225  OrthancPluginMemoryBuffer* target;
2226  const char* uri;
2227  const void* body;
2228  uint32_t bodySize;
2229  } _OrthancPluginRestApiPostPut;
2230 
2248  OrthancPluginContext* context,
2249  OrthancPluginMemoryBuffer* target,
2250  const char* uri,
2251  const void* body,
2252  uint32_t bodySize)
2253  {
2254  _OrthancPluginRestApiPostPut params;
2255  params.target = target;
2256  params.uri = uri;
2257  params.body = body;
2258  params.bodySize = bodySize;
2259  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2260  }
2261 
2262 
2283  OrthancPluginContext* context,
2284  OrthancPluginMemoryBuffer* target,
2285  const char* uri,
2286  const void* body,
2287  uint32_t bodySize)
2288  {
2289  _OrthancPluginRestApiPostPut params;
2290  params.target = target;
2291  params.uri = uri;
2292  params.body = body;
2293  params.bodySize = bodySize;
2294  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2295  }
2296 
2297 
2298 
2312  OrthancPluginContext* context,
2313  const char* uri)
2314  {
2315  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2316  }
2317 
2318 
2335  OrthancPluginContext* context,
2336  const char* uri)
2337  {
2338  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2339  }
2340 
2341 
2342 
2360  OrthancPluginContext* context,
2361  OrthancPluginMemoryBuffer* target,
2362  const char* uri,
2363  const void* body,
2364  uint32_t bodySize)
2365  {
2366  _OrthancPluginRestApiPostPut params;
2367  params.target = target;
2368  params.uri = uri;
2369  params.body = body;
2370  params.bodySize = bodySize;
2371  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2372  }
2373 
2374 
2375 
2396  OrthancPluginContext* context,
2397  OrthancPluginMemoryBuffer* target,
2398  const char* uri,
2399  const void* body,
2400  uint32_t bodySize)
2401  {
2402  _OrthancPluginRestApiPostPut params;
2403  params.target = target;
2404  params.uri = uri;
2405  params.body = body;
2406  params.bodySize = bodySize;
2407  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2408  }
2409 
2410 
2411 
2412  typedef struct
2413  {
2414  OrthancPluginRestOutput* output;
2415  const char* argument;
2416  } _OrthancPluginOutputPlusArgument;
2417 
2429  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2430  OrthancPluginContext* context,
2431  OrthancPluginRestOutput* output,
2432  const char* redirection)
2433  {
2434  _OrthancPluginOutputPlusArgument params;
2435  params.output = output;
2436  params.argument = redirection;
2437  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2438  }
2439 
2440 
2441 
2442  typedef struct
2443  {
2444  char** result;
2445  const char* argument;
2446  } _OrthancPluginRetrieveDynamicString;
2447 
2461  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2462  OrthancPluginContext* context,
2463  const char* patientID)
2464  {
2465  char* result;
2466 
2467  _OrthancPluginRetrieveDynamicString params;
2468  params.result = &result;
2469  params.argument = patientID;
2470 
2471  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2472  {
2473  /* Error */
2474  return NULL;
2475  }
2476  else
2477  {
2478  return result;
2479  }
2480  }
2481 
2482 
2496  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2497  OrthancPluginContext* context,
2498  const char* studyUID)
2499  {
2500  char* result;
2501 
2502  _OrthancPluginRetrieveDynamicString params;
2503  params.result = &result;
2504  params.argument = studyUID;
2505 
2506  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2507  {
2508  /* Error */
2509  return NULL;
2510  }
2511  else
2512  {
2513  return result;
2514  }
2515  }
2516 
2517 
2531  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
2532  OrthancPluginContext* context,
2533  const char* accessionNumber)
2534  {
2535  char* result;
2536 
2537  _OrthancPluginRetrieveDynamicString params;
2538  params.result = &result;
2539  params.argument = accessionNumber;
2540 
2541  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2542  {
2543  /* Error */
2544  return NULL;
2545  }
2546  else
2547  {
2548  return result;
2549  }
2550  }
2551 
2552 
2566  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2567  OrthancPluginContext* context,
2568  const char* seriesUID)
2569  {
2570  char* result;
2571 
2572  _OrthancPluginRetrieveDynamicString params;
2573  params.result = &result;
2574  params.argument = seriesUID;
2575 
2576  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2577  {
2578  /* Error */
2579  return NULL;
2580  }
2581  else
2582  {
2583  return result;
2584  }
2585  }
2586 
2587 
2601  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2602  OrthancPluginContext* context,
2603  const char* sopInstanceUID)
2604  {
2605  char* result;
2606 
2607  _OrthancPluginRetrieveDynamicString params;
2608  params.result = &result;
2609  params.argument = sopInstanceUID;
2610 
2611  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2612  {
2613  /* Error */
2614  return NULL;
2615  }
2616  else
2617  {
2618  return result;
2619  }
2620  }
2621 
2622 
2623 
2624  typedef struct
2625  {
2626  OrthancPluginRestOutput* output;
2627  uint16_t status;
2628  } _OrthancPluginSendHttpStatusCode;
2629 
2646  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2647  OrthancPluginContext* context,
2648  OrthancPluginRestOutput* output,
2649  uint16_t status)
2650  {
2651  _OrthancPluginSendHttpStatusCode params;
2652  params.output = output;
2653  params.status = status;
2654  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2655  }
2656 
2657 
2669  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2670  OrthancPluginContext* context,
2671  OrthancPluginRestOutput* output,
2672  const char* realm)
2673  {
2674  _OrthancPluginOutputPlusArgument params;
2675  params.output = output;
2676  params.argument = realm;
2677  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2678  }
2679 
2680 
2692  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2693  OrthancPluginContext* context,
2694  OrthancPluginRestOutput* output,
2695  const char* allowedMethods)
2696  {
2697  _OrthancPluginOutputPlusArgument params;
2698  params.output = output;
2699  params.argument = allowedMethods;
2700  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2701  }
2702 
2703 
2704  typedef struct
2705  {
2706  OrthancPluginRestOutput* output;
2707  const char* key;
2708  const char* value;
2709  } _OrthancPluginSetHttpHeader;
2710 
2722  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2723  OrthancPluginContext* context,
2724  OrthancPluginRestOutput* output,
2725  const char* cookie,
2726  const char* value)
2727  {
2728  _OrthancPluginSetHttpHeader params;
2729  params.output = output;
2730  params.key = cookie;
2731  params.value = value;
2732  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2733  }
2734 
2735 
2747  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2748  OrthancPluginContext* context,
2749  OrthancPluginRestOutput* output,
2750  const char* key,
2751  const char* value)
2752  {
2753  _OrthancPluginSetHttpHeader params;
2754  params.output = output;
2755  params.key = key;
2756  params.value = value;
2757  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2758  }
2759 
2760 
2761  typedef struct
2762  {
2763  char** resultStringToFree;
2764  const char** resultString;
2765  int64_t* resultInt64;
2766  const char* key;
2767  const OrthancPluginDicomInstance* instance;
2768  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2769  } _OrthancPluginAccessDicomInstance;
2770 
2771 
2783  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2784  OrthancPluginContext* context,
2785  const OrthancPluginDicomInstance* instance)
2786  {
2787  const char* result;
2788 
2789  _OrthancPluginAccessDicomInstance params;
2790  memset(&params, 0, sizeof(params));
2791  params.resultString = &result;
2792  params.instance = instance;
2793 
2794  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2795  {
2796  /* Error */
2797  return NULL;
2798  }
2799  else
2800  {
2801  return result;
2802  }
2803  }
2804 
2805 
2816  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2817  OrthancPluginContext* context,
2818  const OrthancPluginDicomInstance* instance)
2819  {
2820  int64_t size;
2821 
2822  _OrthancPluginAccessDicomInstance params;
2823  memset(&params, 0, sizeof(params));
2824  params.resultInt64 = &size;
2825  params.instance = instance;
2826 
2827  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2828  {
2829  /* Error */
2830  return -1;
2831  }
2832  else
2833  {
2834  return size;
2835  }
2836  }
2837 
2838 
2849  ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData(
2850  OrthancPluginContext* context,
2851  const OrthancPluginDicomInstance* instance)
2852  {
2853  const char* result;
2854 
2855  _OrthancPluginAccessDicomInstance params;
2856  memset(&params, 0, sizeof(params));
2857  params.resultString = &result;
2858  params.instance = instance;
2859 
2860  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2861  {
2862  /* Error */
2863  return NULL;
2864  }
2865  else
2866  {
2867  return result;
2868  }
2869  }
2870 
2871 
2885  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
2886  OrthancPluginContext* context,
2887  const OrthancPluginDicomInstance* instance)
2888  {
2889  char* result;
2890 
2891  _OrthancPluginAccessDicomInstance params;
2892  memset(&params, 0, sizeof(params));
2893  params.resultStringToFree = &result;
2894  params.instance = instance;
2895 
2896  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
2897  {
2898  /* Error */
2899  return NULL;
2900  }
2901  else
2902  {
2903  return result;
2904  }
2905  }
2906 
2907 
2923  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
2924  OrthancPluginContext* context,
2925  const OrthancPluginDicomInstance* instance)
2926  {
2927  char* result;
2928 
2929  _OrthancPluginAccessDicomInstance params;
2930  memset(&params, 0, sizeof(params));
2931  params.resultStringToFree = &result;
2932  params.instance = instance;
2933 
2934  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
2935  {
2936  /* Error */
2937  return NULL;
2938  }
2939  else
2940  {
2941  return result;
2942  }
2943  }
2944 
2945 
2962  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
2963  OrthancPluginContext* context,
2964  const OrthancPluginDicomInstance* instance,
2965  const char* metadata)
2966  {
2967  int64_t result;
2968 
2969  _OrthancPluginAccessDicomInstance params;
2970  memset(&params, 0, sizeof(params));
2971  params.resultInt64 = &result;
2972  params.instance = instance;
2973  params.key = metadata;
2974 
2975  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2976  {
2977  /* Error */
2978  return -1;
2979  }
2980  else
2981  {
2982  return (result != 0);
2983  }
2984  }
2985 
2986 
3003  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
3004  OrthancPluginContext* context,
3005  const OrthancPluginDicomInstance* instance,
3006  const char* metadata)
3007  {
3008  const char* result;
3009 
3010  _OrthancPluginAccessDicomInstance params;
3011  memset(&params, 0, sizeof(params));
3012  params.resultString = &result;
3013  params.instance = instance;
3014  params.key = metadata;
3015 
3016  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3017  {
3018  /* Error */
3019  return NULL;
3020  }
3021  else
3022  {
3023  return result;
3024  }
3025  }
3026 
3027 
3028 
3029  typedef struct
3030  {
3034  OrthancPluginFree free;
3035  } _OrthancPluginRegisterStorageArea;
3036 
3051  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
3052  OrthancPluginContext* context,
3056  {
3057  _OrthancPluginRegisterStorageArea params;
3058  params.create = create;
3059  params.read = read;
3060  params.remove = remove;
3061 
3062 #ifdef __cplusplus
3063  params.free = ::free;
3064 #else
3065  params.free = free;
3066 #endif
3067 
3068  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3069  }
3070 
3071 
3072 
3083  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3084  {
3085  char* result;
3086 
3087  _OrthancPluginRetrieveDynamicString params;
3088  params.result = &result;
3089  params.argument = NULL;
3090 
3091  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3092  {
3093  /* Error */
3094  return NULL;
3095  }
3096  else
3097  {
3098  return result;
3099  }
3100  }
3101 
3102 
3113  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3114  {
3115  char* result;
3116 
3117  _OrthancPluginRetrieveDynamicString params;
3118  params.result = &result;
3119  params.argument = NULL;
3120 
3121  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3122  {
3123  /* Error */
3124  return NULL;
3125  }
3126  else
3127  {
3128  return result;
3129  }
3130  }
3131 
3132 
3148  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3149  {
3150  char* result;
3151 
3152  _OrthancPluginRetrieveDynamicString params;
3153  params.result = &result;
3154  params.argument = NULL;
3155 
3156  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3157  {
3158  /* Error */
3159  return NULL;
3160  }
3161  else
3162  {
3163  return result;
3164  }
3165  }
3166 
3167 
3168 
3169  typedef struct
3170  {
3172  } _OrthancPluginOnChangeCallback;
3173 
3194  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3195  OrthancPluginContext* context,
3197  {
3198  _OrthancPluginOnChangeCallback params;
3199  params.callback = callback;
3200 
3201  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3202  }
3203 
3204 
3205 
3206  typedef struct
3207  {
3208  const char* plugin;
3209  _OrthancPluginProperty property;
3210  const char* value;
3211  } _OrthancPluginSetPluginProperty;
3212 
3213 
3225  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3226  OrthancPluginContext* context,
3227  const char* uri)
3228  {
3229  _OrthancPluginSetPluginProperty params;
3230  params.plugin = OrthancPluginGetName();
3231  params.property = _OrthancPluginProperty_RootUri;
3232  params.value = uri;
3233 
3234  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3235  }
3236 
3237 
3247  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3248  OrthancPluginContext* context,
3249  const char* description)
3250  {
3251  _OrthancPluginSetPluginProperty params;
3252  params.plugin = OrthancPluginGetName();
3253  params.property = _OrthancPluginProperty_Description;
3254  params.value = description;
3255 
3256  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3257  }
3258 
3259 
3269  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3270  OrthancPluginContext* context,
3271  const char* javascript)
3272  {
3273  _OrthancPluginSetPluginProperty params;
3274  params.plugin = OrthancPluginGetName();
3275  params.property = _OrthancPluginProperty_OrthancExplorer;
3276  params.value = javascript;
3277 
3278  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3279  }
3280 
3281 
3282  typedef struct
3283  {
3284  char** result;
3285  int32_t property;
3286  const char* value;
3287  } _OrthancPluginGlobalProperty;
3288 
3289 
3303  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3304  OrthancPluginContext* context,
3305  int32_t property,
3306  const char* defaultValue)
3307  {
3308  char* result;
3309 
3310  _OrthancPluginGlobalProperty params;
3311  params.result = &result;
3312  params.property = property;
3313  params.value = defaultValue;
3314 
3315  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3316  {
3317  /* Error */
3318  return NULL;
3319  }
3320  else
3321  {
3322  return result;
3323  }
3324  }
3325 
3326 
3343  OrthancPluginContext* context,
3344  int32_t property,
3345  const char* value)
3346  {
3347  _OrthancPluginGlobalProperty params;
3348  params.result = NULL;
3349  params.property = property;
3350  params.value = value;
3351 
3352  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3353  }
3354 
3355 
3356 
3357  typedef struct
3358  {
3359  int32_t *resultInt32;
3360  uint32_t *resultUint32;
3361  int64_t *resultInt64;
3362  uint64_t *resultUint64;
3363  } _OrthancPluginReturnSingleValue;
3364 
3373  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3374  OrthancPluginContext* context)
3375  {
3376  uint32_t count = 0;
3377 
3378  _OrthancPluginReturnSingleValue params;
3379  memset(&params, 0, sizeof(params));
3380  params.resultUint32 = &count;
3381 
3382  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3383  {
3384  /* Error */
3385  return 0;
3386  }
3387  else
3388  {
3389  return count;
3390  }
3391  }
3392 
3393 
3394 
3407  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3408  OrthancPluginContext* context,
3409  uint32_t argument)
3410  {
3411  char* result;
3412 
3413  _OrthancPluginGlobalProperty params;
3414  params.result = &result;
3415  params.property = (int32_t) argument;
3416  params.value = NULL;
3417 
3418  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3419  {
3420  /* Error */
3421  return NULL;
3422  }
3423  else
3424  {
3425  return result;
3426  }
3427  }
3428 
3429 
3439  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3440  OrthancPluginContext* context)
3441  {
3442  uint32_t count = 0;
3443 
3444  _OrthancPluginReturnSingleValue params;
3445  memset(&params, 0, sizeof(params));
3446  params.resultUint32 = &count;
3447 
3448  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3449  {
3450  /* Error */
3451  return 0;
3452  }
3453  else
3454  {
3455  return count;
3456  }
3457  }
3458 
3459 
3460 
3472  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3473  {
3474  char* result;
3475 
3476  _OrthancPluginRetrieveDynamicString params;
3477  params.result = &result;
3478  params.argument = NULL;
3479 
3480  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3481  {
3482  /* Error */
3483  return NULL;
3484  }
3485  else
3486  {
3487  return result;
3488  }
3489  }
3490 
3491 
3492 
3493  typedef struct
3494  {
3495  OrthancPluginRestOutput* output;
3496  const char* subType;
3497  const char* contentType;
3498  } _OrthancPluginStartMultipartAnswer;
3499 
3514  OrthancPluginContext* context,
3515  OrthancPluginRestOutput* output,
3516  const char* subType,
3517  const char* contentType)
3518  {
3519  _OrthancPluginStartMultipartAnswer params;
3520  params.output = output;
3521  params.subType = subType;
3522  params.contentType = contentType;
3523  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3524  }
3525 
3526 
3543  OrthancPluginContext* context,
3544  OrthancPluginRestOutput* output,
3545  const void* answer,
3546  uint32_t answerSize)
3547  {
3548  _OrthancPluginAnswerBuffer params;
3549  params.output = output;
3550  params.answer = answer;
3551  params.answerSize = answerSize;
3552  params.mimeType = NULL;
3553  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3554  }
3555 
3556 
3557 
3558  typedef struct
3559  {
3560  OrthancPluginMemoryBuffer* target;
3561  const void* source;
3562  uint32_t size;
3563  OrthancPluginCompressionType compression;
3564  uint8_t uncompress;
3565  } _OrthancPluginBufferCompression;
3566 
3567 
3585  OrthancPluginContext* context,
3586  OrthancPluginMemoryBuffer* target,
3587  const void* source,
3588  uint32_t size,
3589  OrthancPluginCompressionType compression,
3590  uint8_t uncompress)
3591  {
3592  _OrthancPluginBufferCompression params;
3593  params.target = target;
3594  params.source = source;
3595  params.size = size;
3596  params.compression = compression;
3597  params.uncompress = uncompress;
3598 
3599  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3600  }
3601 
3602 
3603 
3604  typedef struct
3605  {
3606  OrthancPluginMemoryBuffer* target;
3607  const char* path;
3608  } _OrthancPluginReadFile;
3609 
3622  OrthancPluginContext* context,
3623  OrthancPluginMemoryBuffer* target,
3624  const char* path)
3625  {
3626  _OrthancPluginReadFile params;
3627  params.target = target;
3628  params.path = path;
3629  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3630  }
3631 
3632 
3633 
3634  typedef struct
3635  {
3636  const char* path;
3637  const void* data;
3638  uint32_t size;
3639  } _OrthancPluginWriteFile;
3640 
3653  OrthancPluginContext* context,
3654  const char* path,
3655  const void* data,
3656  uint32_t size)
3657  {
3658  _OrthancPluginWriteFile params;
3659  params.path = path;
3660  params.data = data;
3661  params.size = size;
3662  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3663  }
3664 
3665 
3666 
3667  typedef struct
3668  {
3669  const char** target;
3670  OrthancPluginErrorCode error;
3671  } _OrthancPluginGetErrorDescription;
3672 
3683  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3684  OrthancPluginContext* context,
3685  OrthancPluginErrorCode error)
3686  {
3687  const char* result = NULL;
3688 
3689  _OrthancPluginGetErrorDescription params;
3690  params.target = &result;
3691  params.error = error;
3692 
3693  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3694  result == NULL)
3695  {
3696  return "Unknown error code";
3697  }
3698  else
3699  {
3700  return result;
3701  }
3702  }
3703 
3704 
3705 
3706  typedef struct
3707  {
3708  OrthancPluginRestOutput* output;
3709  uint16_t status;
3710  const char* body;
3711  uint32_t bodySize;
3712  } _OrthancPluginSendHttpStatus;
3713 
3736  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3737  OrthancPluginContext* context,
3738  OrthancPluginRestOutput* output,
3739  uint16_t status,
3740  const char* body,
3741  uint32_t bodySize)
3742  {
3743  _OrthancPluginSendHttpStatus params;
3744  params.output = output;
3745  params.status = status;
3746  params.body = body;
3747  params.bodySize = bodySize;
3748  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3749  }
3750 
3751 
3752 
3753  typedef struct
3754  {
3755  const OrthancPluginImage* image;
3756  uint32_t* resultUint32;
3757  OrthancPluginPixelFormat* resultPixelFormat;
3758  void** resultBuffer;
3759  } _OrthancPluginGetImageInfo;
3760 
3761 
3773  OrthancPluginContext* context,
3774  const OrthancPluginImage* image)
3775  {
3776  OrthancPluginPixelFormat target;
3777 
3778  _OrthancPluginGetImageInfo params;
3779  memset(&params, 0, sizeof(params));
3780  params.image = image;
3781  params.resultPixelFormat = &target;
3782 
3783  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3784  {
3786  }
3787  else
3788  {
3789  return (OrthancPluginPixelFormat) target;
3790  }
3791  }
3792 
3793 
3794 
3805  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3806  OrthancPluginContext* context,
3807  const OrthancPluginImage* image)
3808  {
3809  uint32_t width;
3810 
3811  _OrthancPluginGetImageInfo params;
3812  memset(&params, 0, sizeof(params));
3813  params.image = image;
3814  params.resultUint32 = &width;
3815 
3816  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3817  {
3818  return 0;
3819  }
3820  else
3821  {
3822  return width;
3823  }
3824  }
3825 
3826 
3827 
3838  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3839  OrthancPluginContext* context,
3840  const OrthancPluginImage* image)
3841  {
3842  uint32_t height;
3843 
3844  _OrthancPluginGetImageInfo params;
3845  memset(&params, 0, sizeof(params));
3846  params.image = image;
3847  params.resultUint32 = &height;
3848 
3849  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3850  {
3851  return 0;
3852  }
3853  else
3854  {
3855  return height;
3856  }
3857  }
3858 
3859 
3860 
3873  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3874  OrthancPluginContext* context,
3875  const OrthancPluginImage* image)
3876  {
3877  uint32_t pitch;
3878 
3879  _OrthancPluginGetImageInfo params;
3880  memset(&params, 0, sizeof(params));
3881  params.image = image;
3882  params.resultUint32 = &pitch;
3883 
3884  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
3885  {
3886  return 0;
3887  }
3888  else
3889  {
3890  return pitch;
3891  }
3892  }
3893 
3894 
3895 
3907  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
3908  OrthancPluginContext* context,
3909  const OrthancPluginImage* image)
3910  {
3911  void* target = NULL;
3912 
3913  _OrthancPluginGetImageInfo params;
3914  memset(&params, 0, sizeof(params));
3915  params.resultBuffer = &target;
3916  params.image = image;
3917 
3918  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
3919  {
3920  return NULL;
3921  }
3922  else
3923  {
3924  return target;
3925  }
3926  }
3927 
3928 
3929  typedef struct
3930  {
3931  OrthancPluginImage** target;
3932  const void* data;
3933  uint32_t size;
3934  OrthancPluginImageFormat format;
3935  } _OrthancPluginUncompressImage;
3936 
3937 
3951  OrthancPluginContext* context,
3952  const void* data,
3953  uint32_t size,
3954  OrthancPluginImageFormat format)
3955  {
3956  OrthancPluginImage* target = NULL;
3957 
3958  _OrthancPluginUncompressImage params;
3959  memset(&params, 0, sizeof(params));
3960  params.target = &target;
3961  params.data = data;
3962  params.size = size;
3963  params.format = format;
3964 
3965  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
3966  {
3967  return NULL;
3968  }
3969  else
3970  {
3971  return target;
3972  }
3973  }
3974 
3975 
3976 
3977 
3978  typedef struct
3979  {
3980  OrthancPluginImage* image;
3981  } _OrthancPluginFreeImage;
3982 
3992  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
3993  OrthancPluginContext* context,
3994  OrthancPluginImage* image)
3995  {
3996  _OrthancPluginFreeImage params;
3997  params.image = image;
3998 
3999  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
4000  }
4001 
4002 
4003 
4004 
4005  typedef struct
4006  {
4007  OrthancPluginMemoryBuffer* target;
4008  OrthancPluginImageFormat imageFormat;
4009  OrthancPluginPixelFormat pixelFormat;
4010  uint32_t width;
4011  uint32_t height;
4012  uint32_t pitch;
4013  const void* buffer;
4014  uint8_t quality;
4015  } _OrthancPluginCompressImage;
4016 
4017 
4038  OrthancPluginContext* context,
4039  OrthancPluginMemoryBuffer* target,
4040  OrthancPluginPixelFormat format,
4041  uint32_t width,
4042  uint32_t height,
4043  uint32_t pitch,
4044  const void* buffer)
4045  {
4046  _OrthancPluginCompressImage params;
4047  memset(&params, 0, sizeof(params));
4048  params.target = target;
4049  params.imageFormat = OrthancPluginImageFormat_Png;
4050  params.pixelFormat = format;
4051  params.width = width;
4052  params.height = height;
4053  params.pitch = pitch;
4054  params.buffer = buffer;
4055  params.quality = 0; /* Unused for PNG */
4056 
4057  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4058  }
4059 
4060 
4083  OrthancPluginContext* context,
4084  OrthancPluginMemoryBuffer* target,
4085  OrthancPluginPixelFormat format,
4086  uint32_t width,
4087  uint32_t height,
4088  uint32_t pitch,
4089  const void* buffer,
4090  uint8_t quality)
4091  {
4092  _OrthancPluginCompressImage params;
4093  memset(&params, 0, sizeof(params));
4094  params.target = target;
4095  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4096  params.pixelFormat = format;
4097  params.width = width;
4098  params.height = height;
4099  params.pitch = pitch;
4100  params.buffer = buffer;
4101  params.quality = quality;
4102 
4103  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4104  }
4105 
4106 
4107 
4129  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
4130  OrthancPluginContext* context,
4131  OrthancPluginRestOutput* output,
4132  OrthancPluginPixelFormat format,
4133  uint32_t width,
4134  uint32_t height,
4135  uint32_t pitch,
4136  const void* buffer,
4137  uint8_t quality)
4138  {
4139  _OrthancPluginCompressAndAnswerImage params;
4140  params.output = output;
4141  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4142  params.pixelFormat = format;
4143  params.width = width;
4144  params.height = height;
4145  params.pitch = pitch;
4146  params.buffer = buffer;
4147  params.quality = quality;
4148  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4149  }
4150 
4151 
4152 
4153 
4154  typedef struct
4155  {
4156  OrthancPluginMemoryBuffer* target;
4157  OrthancPluginHttpMethod method;
4158  const char* url;
4159  const char* username;
4160  const char* password;
4161  const void* body;
4162  uint32_t bodySize;
4163  } _OrthancPluginCallHttpClient;
4164 
4165 
4183  OrthancPluginContext* context,
4184  OrthancPluginMemoryBuffer* target,
4185  const char* url,
4186  const char* username,
4187  const char* password)
4188  {
4189  _OrthancPluginCallHttpClient params;
4190  memset(&params, 0, sizeof(params));
4191 
4192  params.target = target;
4193  params.method = OrthancPluginHttpMethod_Get;
4194  params.url = url;
4195  params.username = username;
4196  params.password = password;
4197 
4198  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4199  }
4200 
4201 
4221  OrthancPluginContext* context,
4222  OrthancPluginMemoryBuffer* target,
4223  const char* url,
4224  const void* body,
4225  uint32_t bodySize,
4226  const char* username,
4227  const char* password)
4228  {
4229  _OrthancPluginCallHttpClient params;
4230  memset(&params, 0, sizeof(params));
4231 
4232  params.target = target;
4233  params.method = OrthancPluginHttpMethod_Post;
4234  params.url = url;
4235  params.body = body;
4236  params.bodySize = bodySize;
4237  params.username = username;
4238  params.password = password;
4239 
4240  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4241  }
4242 
4243 
4263  OrthancPluginContext* context,
4264  OrthancPluginMemoryBuffer* target,
4265  const char* url,
4266  const void* body,
4267  uint32_t bodySize,
4268  const char* username,
4269  const char* password)
4270  {
4271  _OrthancPluginCallHttpClient params;
4272  memset(&params, 0, sizeof(params));
4273 
4274  params.target = target;
4275  params.method = OrthancPluginHttpMethod_Put;
4276  params.url = url;
4277  params.body = body;
4278  params.bodySize = bodySize;
4279  params.username = username;
4280  params.password = password;
4281 
4282  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4283  }
4284 
4285 
4301  OrthancPluginContext* context,
4302  const char* url,
4303  const char* username,
4304  const char* password)
4305  {
4306  _OrthancPluginCallHttpClient params;
4307  memset(&params, 0, sizeof(params));
4308 
4309  params.method = OrthancPluginHttpMethod_Delete;
4310  params.url = url;
4311  params.username = username;
4312  params.password = password;
4313 
4314  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4315  }
4316 
4317 
4318 
4319  typedef struct
4320  {
4321  OrthancPluginImage** target;
4322  const OrthancPluginImage* source;
4323  OrthancPluginPixelFormat targetFormat;
4324  } _OrthancPluginConvertPixelFormat;
4325 
4326 
4339  OrthancPluginContext* context,
4340  const OrthancPluginImage* source,
4341  OrthancPluginPixelFormat targetFormat)
4342  {
4343  OrthancPluginImage* target = NULL;
4344 
4345  _OrthancPluginConvertPixelFormat params;
4346  params.target = &target;
4347  params.source = source;
4348  params.targetFormat = targetFormat;
4349 
4350  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4351  {
4352  return NULL;
4353  }
4354  else
4355  {
4356  return target;
4357  }
4358  }
4359 
4360 
4361 
4373  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4374  OrthancPluginContext* context)
4375  {
4376  uint32_t count = 0;
4377 
4378  _OrthancPluginReturnSingleValue params;
4379  memset(&params, 0, sizeof(params));
4380  params.resultUint32 = &count;
4381 
4382  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4383  {
4384  /* Error */
4385  return 0;
4386  }
4387  else
4388  {
4389  return count;
4390  }
4391  }
4392 
4393 
4394 
4395 
4396  typedef struct
4397  {
4398  uint32_t fontIndex; /* in */
4399  const char** name; /* out */
4400  uint32_t* size; /* out */
4401  } _OrthancPluginGetFontInfo;
4402 
4413  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4414  OrthancPluginContext* context,
4415  uint32_t fontIndex)
4416  {
4417  const char* result = NULL;
4418 
4419  _OrthancPluginGetFontInfo params;
4420  memset(&params, 0, sizeof(params));
4421  params.name = &result;
4422  params.fontIndex = fontIndex;
4423 
4424  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4425  {
4426  return NULL;
4427  }
4428  else
4429  {
4430  return result;
4431  }
4432  }
4433 
4434 
4445  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4446  OrthancPluginContext* context,
4447  uint32_t fontIndex)
4448  {
4449  uint32_t result;
4450 
4451  _OrthancPluginGetFontInfo params;
4452  memset(&params, 0, sizeof(params));
4453  params.size = &result;
4454  params.fontIndex = fontIndex;
4455 
4456  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4457  {
4458  return 0;
4459  }
4460  else
4461  {
4462  return result;
4463  }
4464  }
4465 
4466 
4467 
4468  typedef struct
4469  {
4470  OrthancPluginImage* image;
4471  uint32_t fontIndex;
4472  const char* utf8Text;
4473  int32_t x;
4474  int32_t y;
4475  uint8_t r;
4476  uint8_t g;
4477  uint8_t b;
4478  } _OrthancPluginDrawText;
4479 
4480 
4499  OrthancPluginContext* context,
4500  OrthancPluginImage* image,
4501  uint32_t fontIndex,
4502  const char* utf8Text,
4503  int32_t x,
4504  int32_t y,
4505  uint8_t r,
4506  uint8_t g,
4507  uint8_t b)
4508  {
4509  _OrthancPluginDrawText params;
4510  memset(&params, 0, sizeof(params));
4511  params.image = image;
4512  params.fontIndex = fontIndex;
4513  params.utf8Text = utf8Text;
4514  params.x = x;
4515  params.y = y;
4516  params.r = r;
4517  params.g = g;
4518  params.b = b;
4519 
4520  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4521  }
4522 
4523 
4524 
4525  typedef struct
4526  {
4527  OrthancPluginStorageArea* storageArea;
4528  const char* uuid;
4529  const void* content;
4530  uint64_t size;
4532  } _OrthancPluginStorageAreaCreate;
4533 
4534 
4551  OrthancPluginContext* context,
4552  OrthancPluginStorageArea* storageArea,
4553  const char* uuid,
4554  const void* content,
4555  uint64_t size,
4557  {
4558  _OrthancPluginStorageAreaCreate params;
4559  params.storageArea = storageArea;
4560  params.uuid = uuid;
4561  params.content = content;
4562  params.size = size;
4563  params.type = type;
4564 
4565  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4566  }
4567 
4568 
4569  typedef struct
4570  {
4571  OrthancPluginMemoryBuffer* target;
4572  OrthancPluginStorageArea* storageArea;
4573  const char* uuid;
4575  } _OrthancPluginStorageAreaRead;
4576 
4577 
4593  OrthancPluginContext* context,
4594  OrthancPluginMemoryBuffer* target,
4595  OrthancPluginStorageArea* storageArea,
4596  const char* uuid,
4598  {
4599  _OrthancPluginStorageAreaRead params;
4600  params.target = target;
4601  params.storageArea = storageArea;
4602  params.uuid = uuid;
4603  params.type = type;
4604 
4605  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4606  }
4607 
4608 
4609  typedef struct
4610  {
4611  OrthancPluginStorageArea* storageArea;
4612  const char* uuid;
4614  } _OrthancPluginStorageAreaRemove;
4615 
4630  OrthancPluginContext* context,
4631  OrthancPluginStorageArea* storageArea,
4632  const char* uuid,
4634  {
4635  _OrthancPluginStorageAreaRemove params;
4636  params.storageArea = storageArea;
4637  params.uuid = uuid;
4638  params.type = type;
4639 
4640  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4641  }
4642 
4643 
4644 
4645  typedef struct
4646  {
4647  OrthancPluginErrorCode* target;
4648  int32_t code;
4649  uint16_t httpStatus;
4650  const char* message;
4651  } _OrthancPluginRegisterErrorCode;
4652 
4669  OrthancPluginContext* context,
4670  int32_t code,
4671  uint16_t httpStatus,
4672  const char* message)
4673  {
4674  OrthancPluginErrorCode target;
4675 
4676  _OrthancPluginRegisterErrorCode params;
4677  params.target = &target;
4678  params.code = code;
4679  params.httpStatus = httpStatus;
4680  params.message = message;
4681 
4682  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4683  {
4684  return target;
4685  }
4686  else
4687  {
4688  /* There was an error while assigned the error. Use a generic code. */
4690  }
4691  }
4692 
4693 
4694 
4695  typedef struct
4696  {
4697  uint16_t group;
4698  uint16_t element;
4700  const char* name;
4701  uint32_t minMultiplicity;
4702  uint32_t maxMultiplicity;
4703  } _OrthancPluginRegisterDictionaryTag;
4704 
4725  OrthancPluginContext* context,
4726  uint16_t group,
4727  uint16_t element,
4729  const char* name,
4730  uint32_t minMultiplicity,
4731  uint32_t maxMultiplicity)
4732  {
4733  _OrthancPluginRegisterDictionaryTag params;
4734  params.group = group;
4735  params.element = element;
4736  params.vr = vr;
4737  params.name = name;
4738  params.minMultiplicity = minMultiplicity;
4739  params.maxMultiplicity = maxMultiplicity;
4740 
4741  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4742  }
4743 
4744 
4745 
4746  typedef struct
4747  {
4748  uint16_t group;
4749  uint16_t element;
4751  const char* name;
4752  uint32_t minMultiplicity;
4753  uint32_t maxMultiplicity;
4754  const char* privateCreator;
4755  } _OrthancPluginRegisterPrivateDictionaryTag;
4756 
4778  OrthancPluginContext* context,
4779  uint16_t group,
4780  uint16_t element,
4782  const char* name,
4783  uint32_t minMultiplicity,
4784  uint32_t maxMultiplicity,
4785  const char* privateCreator)
4786  {
4787  _OrthancPluginRegisterPrivateDictionaryTag params;
4788  params.group = group;
4789  params.element = element;
4790  params.vr = vr;
4791  params.name = name;
4792  params.minMultiplicity = minMultiplicity;
4793  params.maxMultiplicity = maxMultiplicity;
4794  params.privateCreator = privateCreator;
4795 
4796  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4797  }
4798 
4799 
4800 
4801  typedef struct
4802  {
4803  OrthancPluginStorageArea* storageArea;
4805  } _OrthancPluginReconstructMainDicomTags;
4806 
4822  OrthancPluginContext* context,
4823  OrthancPluginStorageArea* storageArea,
4825  {
4826  _OrthancPluginReconstructMainDicomTags params;
4827  params.level = level;
4828  params.storageArea = storageArea;
4829 
4830  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
4831  }
4832 
4833 
4834  typedef struct
4835  {
4836  char** result;
4837  const char* instanceId;
4838  const void* buffer;
4839  uint32_t size;
4842  uint32_t maxStringLength;
4843  } _OrthancPluginDicomToJson;
4844 
4845 
4865  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4866  OrthancPluginContext* context,
4867  const void* buffer,
4868  uint32_t size,
4871  uint32_t maxStringLength)
4872  {
4873  char* result;
4874 
4875  _OrthancPluginDicomToJson params;
4876  memset(&params, 0, sizeof(params));
4877  params.result = &result;
4878  params.buffer = buffer;
4879  params.size = size;
4880  params.format = format;
4881  params.flags = flags;
4882  params.maxStringLength = maxStringLength;
4883 
4884  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
4885  {
4886  /* Error */
4887  return NULL;
4888  }
4889  else
4890  {
4891  return result;
4892  }
4893  }
4894 
4895 
4914  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
4915  OrthancPluginContext* context,
4916  const char* instanceId,
4919  uint32_t maxStringLength)
4920  {
4921  char* result;
4922 
4923  _OrthancPluginDicomToJson params;
4924  memset(&params, 0, sizeof(params));
4925  params.result = &result;
4926  params.instanceId = instanceId;
4927  params.format = format;
4928  params.flags = flags;
4929  params.maxStringLength = maxStringLength;
4930 
4931  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
4932  {
4933  /* Error */
4934  return NULL;
4935  }
4936  else
4937  {
4938  return result;
4939  }
4940  }
4941 
4942 
4943  typedef struct
4944  {
4945  OrthancPluginMemoryBuffer* target;
4946  const char* uri;
4947  uint32_t headersCount;
4948  const char* const* headersKeys;
4949  const char* const* headersValues;
4950  int32_t afterPlugins;
4951  } _OrthancPluginRestApiGet2;
4952 
4973  OrthancPluginContext* context,
4974  OrthancPluginMemoryBuffer* target,
4975  const char* uri,
4976  uint32_t headersCount,
4977  const char* const* headersKeys,
4978  const char* const* headersValues,
4979  int32_t afterPlugins)
4980  {
4981  _OrthancPluginRestApiGet2 params;
4982  params.target = target;
4983  params.uri = uri;
4984  params.headersCount = headersCount;
4985  params.headersKeys = headersKeys;
4986  params.headersValues = headersValues;
4987  params.afterPlugins = afterPlugins;
4988 
4989  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
4990  }
4991 
4992 
4993 
4994  typedef struct
4995  {
4997  } _OrthancPluginWorklistCallback;
4998 
5011  OrthancPluginContext* context,
5013  {
5014  _OrthancPluginWorklistCallback params;
5015  params.callback = callback;
5016 
5017  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
5018  }
5019 
5020 
5021 
5022  typedef struct
5023  {
5025  const OrthancPluginWorklistQuery* query;
5026  const void* dicom;
5027  uint32_t size;
5028  } _OrthancPluginWorklistAnswersOperation;
5029 
5047  OrthancPluginContext* context,
5049  const OrthancPluginWorklistQuery* query,
5050  const void* dicom,
5051  uint32_t size)
5052  {
5053  _OrthancPluginWorklistAnswersOperation params;
5054  params.answers = answers;
5055  params.query = query;
5056  params.dicom = dicom;
5057  params.size = size;
5058 
5059  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
5060  }
5061 
5062 
5077  OrthancPluginContext* context,
5079  {
5080  _OrthancPluginWorklistAnswersOperation params;
5081  params.answers = answers;
5082  params.query = NULL;
5083  params.dicom = NULL;
5084  params.size = 0;
5085 
5086  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5087  }
5088 
5089 
5090  typedef struct
5091  {
5092  const OrthancPluginWorklistQuery* query;
5093  const void* dicom;
5094  uint32_t size;
5095  int32_t* isMatch;
5096  OrthancPluginMemoryBuffer* target;
5097  } _OrthancPluginWorklistQueryOperation;
5098 
5114  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5115  OrthancPluginContext* context,
5116  const OrthancPluginWorklistQuery* query,
5117  const void* dicom,
5118  uint32_t size)
5119  {
5120  int32_t isMatch = 0;
5121 
5122  _OrthancPluginWorklistQueryOperation params;
5123  params.query = query;
5124  params.dicom = dicom;
5125  params.size = size;
5126  params.isMatch = &isMatch;
5127  params.target = NULL;
5128 
5129  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5130  {
5131  return isMatch;
5132  }
5133  else
5134  {
5135  /* Error: Assume non-match */
5136  return 0;
5137  }
5138  }
5139 
5140 
5154  OrthancPluginContext* context,
5155  OrthancPluginMemoryBuffer* target,
5156  const OrthancPluginWorklistQuery* query)
5157  {
5158  _OrthancPluginWorklistQueryOperation params;
5159  params.query = query;
5160  params.dicom = NULL;
5161  params.size = 0;
5162  params.isMatch = NULL;
5163  params.target = target;
5164 
5165  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5166  }
5167 
5168 
5180  OrthancPluginContext* context,
5181  const OrthancPluginDicomInstance* instance)
5182  {
5184 
5185  _OrthancPluginAccessDicomInstance params;
5186  memset(&params, 0, sizeof(params));
5187  params.resultOrigin = &origin;
5188  params.instance = instance;
5189 
5190  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5191  {
5192  /* Error */
5194  }
5195  else
5196  {
5197  return origin;
5198  }
5199  }
5200 
5201 
5202  typedef struct
5203  {
5204  OrthancPluginMemoryBuffer* target;
5205  const char* json;
5206  const OrthancPluginImage* pixelData;
5208  } _OrthancPluginCreateDicom;
5209 
5229  OrthancPluginContext* context,
5230  OrthancPluginMemoryBuffer* target,
5231  const char* json,
5232  const OrthancPluginImage* pixelData,
5234  {
5235  _OrthancPluginCreateDicom params;
5236  params.target = target;
5237  params.json = json;
5238  params.pixelData = pixelData;
5239  params.flags = flags;
5240 
5241  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5242  }
5243 
5244 
5245  typedef struct
5246  {
5248  } _OrthancPluginDecodeImageCallback;
5249 
5265  OrthancPluginContext* context,
5267  {
5268  _OrthancPluginDecodeImageCallback params;
5269  params.callback = callback;
5270 
5271  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5272  }
5273 
5274 
5275 
5276  typedef struct
5277  {
5278  OrthancPluginImage** target;
5279  OrthancPluginPixelFormat format;
5280  uint32_t width;
5281  uint32_t height;
5282  uint32_t pitch;
5283  void* buffer;
5284  const void* constBuffer;
5285  uint32_t bufferSize;
5286  uint32_t frameIndex;
5287  } _OrthancPluginCreateImage;
5288 
5289 
5303  OrthancPluginContext* context,
5304  OrthancPluginPixelFormat format,
5305  uint32_t width,
5306  uint32_t height)
5307  {
5308  OrthancPluginImage* target = NULL;
5309 
5310  _OrthancPluginCreateImage params;
5311  memset(&params, 0, sizeof(params));
5312  params.target = &target;
5313  params.format = format;
5314  params.width = width;
5315  params.height = height;
5316 
5317  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5318  {
5319  return NULL;
5320  }
5321  else
5322  {
5323  return target;
5324  }
5325  }
5326 
5327 
5346  OrthancPluginContext* context,
5347  OrthancPluginPixelFormat format,
5348  uint32_t width,
5349  uint32_t height,
5350  uint32_t pitch,
5351  void* buffer)
5352  {
5353  OrthancPluginImage* target = NULL;
5354 
5355  _OrthancPluginCreateImage params;
5356  memset(&params, 0, sizeof(params));
5357  params.target = &target;
5358  params.format = format;
5359  params.width = width;
5360  params.height = height;
5361  params.pitch = pitch;
5362  params.buffer = buffer;
5363 
5364  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5365  {
5366  return NULL;
5367  }
5368  else
5369  {
5370  return target;
5371  }
5372  }
5373 
5374 
5375 
5392  OrthancPluginContext* context,
5393  const void* buffer,
5394  uint32_t bufferSize,
5395  uint32_t frameIndex)
5396  {
5397  OrthancPluginImage* target = NULL;
5398 
5399  _OrthancPluginCreateImage params;
5400  memset(&params, 0, sizeof(params));
5401  params.target = &target;
5402  params.constBuffer = buffer;
5403  params.bufferSize = bufferSize;
5404  params.frameIndex = frameIndex;
5405 
5406  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5407  {
5408  return NULL;
5409  }
5410  else
5411  {
5412  return target;
5413  }
5414  }
5415 
5416 
5417 
5418  typedef struct
5419  {
5420  char** result;
5421  const void* buffer;
5422  uint32_t size;
5423  } _OrthancPluginComputeHash;
5424 
5437  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5438  OrthancPluginContext* context,
5439  const void* buffer,
5440  uint32_t size)
5441  {
5442  char* result;
5443 
5444  _OrthancPluginComputeHash params;
5445  params.result = &result;
5446  params.buffer = buffer;
5447  params.size = size;
5448 
5449  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5450  {
5451  /* Error */
5452  return NULL;
5453  }
5454  else
5455  {
5456  return result;
5457  }
5458  }
5459 
5460 
5473  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5474  OrthancPluginContext* context,
5475  const void* buffer,
5476  uint32_t size)
5477  {
5478  char* result;
5479 
5480  _OrthancPluginComputeHash params;
5481  params.result = &result;
5482  params.buffer = buffer;
5483  params.size = size;
5484 
5485  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5486  {
5487  /* Error */
5488  return NULL;
5489  }
5490  else
5491  {
5492  return result;
5493  }
5494  }
5495 
5496 
5497 
5498  typedef struct
5499  {
5501  const char* name;
5502  } _OrthancPluginLookupDictionary;
5503 
5520  OrthancPluginContext* context,
5522  const char* name)
5523  {
5524  _OrthancPluginLookupDictionary params;
5525  params.target = target;
5526  params.name = name;
5527  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5528  }
5529 
5530 
5531 
5532  typedef struct
5533  {
5534  OrthancPluginRestOutput* output;
5535  const void* answer;
5536  uint32_t answerSize;
5537  uint32_t headersCount;
5538  const char* const* headersKeys;
5539  const char* const* headersValues;
5540  } _OrthancPluginSendMultipartItem2;
5541 
5563  OrthancPluginContext* context,
5564  OrthancPluginRestOutput* output,
5565  const void* answer,
5566  uint32_t answerSize,
5567  uint32_t headersCount,
5568  const char* const* headersKeys,
5569  const char* const* headersValues)
5570  {
5571  _OrthancPluginSendMultipartItem2 params;
5572  params.output = output;
5573  params.answer = answer;
5574  params.answerSize = answerSize;
5575  params.headersCount = headersCount;
5576  params.headersKeys = headersKeys;
5577  params.headersValues = headersValues;
5578 
5579  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5580  }
5581 
5582 
5583  typedef struct
5584  {
5586  } _OrthancPluginIncomingHttpRequestFilter;
5587 
5601  OrthancPluginContext* context,
5603  {
5604  _OrthancPluginIncomingHttpRequestFilter params;
5605  params.callback = callback;
5606 
5607  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5608  }
5609 
5610 
5611 
5612  typedef struct
5613  {
5614  OrthancPluginMemoryBuffer* answerBody;
5615  OrthancPluginMemoryBuffer* answerHeaders;
5616  uint16_t* httpStatus;
5617  OrthancPluginHttpMethod method;
5618  const char* url;
5619  uint32_t headersCount;
5620  const char* const* headersKeys;
5621  const char* const* headersValues;
5622  const void* body;
5623  uint32_t bodySize;
5624  const char* username;
5625  const char* password;
5626  uint32_t timeout;
5627  const char* certificateFile;
5628  const char* certificateKeyFile;
5629  const char* certificateKeyPassword;
5630  uint8_t pkcs11;
5631  } _OrthancPluginCallHttpClient2;
5632 
5633 
5634 
5675  OrthancPluginContext* context,
5676  OrthancPluginMemoryBuffer* answerBody,
5677  OrthancPluginMemoryBuffer* answerHeaders,
5678  uint16_t* httpStatus,
5679  OrthancPluginHttpMethod method,
5680  const char* url,
5681  uint32_t headersCount,
5682  const char* const* headersKeys,
5683  const char* const* headersValues,
5684  const void* body,
5685  uint32_t bodySize,
5686  const char* username,
5687  const char* password,
5688  uint32_t timeout,
5689  const char* certificateFile,
5690  const char* certificateKeyFile,
5691  const char* certificateKeyPassword,
5692  uint8_t pkcs11)
5693  {
5694  _OrthancPluginCallHttpClient2 params;
5695  memset(&params, 0, sizeof(params));
5696 
5697  params.answerBody = answerBody;
5698  params.answerHeaders = answerHeaders;
5699  params.httpStatus = httpStatus;
5700  params.method = method;
5701  params.url = url;
5702  params.headersCount = headersCount;
5703  params.headersKeys = headersKeys;
5704  params.headersValues = headersValues;
5705  params.body = body;
5706  params.bodySize = bodySize;
5707  params.username = username;
5708  params.password = password;
5709  params.timeout = timeout;
5710  params.certificateFile = certificateFile;
5711  params.certificateKeyFile = certificateKeyFile;
5712  params.certificateKeyPassword = certificateKeyPassword;
5713  params.pkcs11 = pkcs11;
5714 
5715  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5716  }
5717 
5718 
5729  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5730  OrthancPluginContext* context)
5731  {
5732  char* result;
5733 
5734  _OrthancPluginRetrieveDynamicString params;
5735  params.result = &result;
5736  params.argument = NULL;
5737 
5738  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5739  {
5740  /* Error */
5741  return NULL;
5742  }
5743  else
5744  {
5745  return result;
5746  }
5747  }
5748 
5749 
5750 
5751 
5752  typedef struct
5753  {
5754  OrthancPluginFindCallback callback;
5755  } _OrthancPluginFindCallback;
5756 
5769  OrthancPluginContext* context,
5770  OrthancPluginFindCallback callback)
5771  {
5772  _OrthancPluginFindCallback params;
5773  params.callback = callback;
5774 
5775  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5776  }
5777 
5778 
5779  typedef struct
5780  {
5781  OrthancPluginFindAnswers *answers;
5782  const OrthancPluginFindQuery *query;
5783  const void *dicom;
5784  uint32_t size;
5785  uint32_t index;
5786  uint32_t *resultUint32;
5787  uint16_t *resultGroup;
5788  uint16_t *resultElement;
5789  char **resultString;
5790  } _OrthancPluginFindOperation;
5791 
5808  OrthancPluginContext* context,
5809  OrthancPluginFindAnswers* answers,
5810  const void* dicom,
5811  uint32_t size)
5812  {
5813  _OrthancPluginFindOperation params;
5814  memset(&params, 0, sizeof(params));
5815  params.answers = answers;
5816  params.dicom = dicom;
5817  params.size = size;
5818 
5819  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
5820  }
5821 
5822 
5837  OrthancPluginContext* context,
5838  OrthancPluginFindAnswers* answers)
5839  {
5840  _OrthancPluginFindOperation params;
5841  memset(&params, 0, sizeof(params));
5842  params.answers = answers;
5843 
5844  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
5845  }
5846 
5847 
5848 
5860  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
5861  OrthancPluginContext* context,
5862  const OrthancPluginFindQuery* query)
5863  {
5864  uint32_t count = 0;
5865 
5866  _OrthancPluginFindOperation params;
5867  memset(&params, 0, sizeof(params));
5868  params.query = query;
5869  params.resultUint32 = &count;
5870 
5871  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
5872  {
5873  /* Error */
5874  return 0;
5875  }
5876  else
5877  {
5878  return count;
5879  }
5880  }
5881 
5882 
5898  OrthancPluginContext* context,
5899  uint16_t* group,
5900  uint16_t* element,
5901  const OrthancPluginFindQuery* query,
5902  uint32_t index)
5903  {
5904  _OrthancPluginFindOperation params;
5905  memset(&params, 0, sizeof(params));
5906  params.query = query;
5907  params.index = index;
5908  params.resultGroup = group;
5909  params.resultElement = element;
5910 
5911  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
5912  }
5913 
5914 
5928  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
5929  OrthancPluginContext* context,
5930  const OrthancPluginFindQuery* query,
5931  uint32_t index)
5932  {
5933  char* result;
5934 
5935  _OrthancPluginFindOperation params;
5936  memset(&params, 0, sizeof(params));
5937  params.query = query;
5938  params.index = index;
5939  params.resultString = &result;
5940 
5941  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
5942  {
5943  /* Error */
5944  return NULL;
5945  }
5946  else
5947  {
5948  return result;
5949  }
5950  }
5951 
5952 
5966  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
5967  OrthancPluginContext* context,
5968  const OrthancPluginFindQuery* query,
5969  uint32_t index)
5970  {
5971  char* result;
5972 
5973  _OrthancPluginFindOperation params;
5974  memset(&params, 0, sizeof(params));
5975  params.query = query;
5976  params.index = index;
5977  params.resultString = &result;
5978 
5979  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
5980  {
5981  /* Error */
5982  return NULL;
5983  }
5984  else
5985  {
5986  return result;
5987  }
5988  }
5989 
5990 
5991 
5992 
5993  typedef struct
5994  {
5995  OrthancPluginMoveCallback callback;
5996  OrthancPluginGetMoveSize getMoveSize;
5997  OrthancPluginApplyMove applyMove;
5998  OrthancPluginFreeMove freeMove;
5999  } _OrthancPluginMoveCallback;
6000 
6015  OrthancPluginContext* context,
6016  OrthancPluginMoveCallback callback,
6017  OrthancPluginGetMoveSize getMoveSize,
6018  OrthancPluginApplyMove applyMove,
6019  OrthancPluginFreeMove freeMove)
6020  {
6021  _OrthancPluginMoveCallback params;
6022  params.callback = callback;
6023  params.getMoveSize = getMoveSize;
6024  params.applyMove = applyMove;
6025  params.freeMove = freeMove;
6026 
6027  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
6028  }
6029 
6030 
6031 
6032  typedef struct
6033  {
6034  OrthancPluginFindMatcher** target;
6035  const void* query;
6036  uint32_t size;
6037  } _OrthancPluginCreateFindMatcher;
6038 
6039 
6054  OrthancPluginContext* context,
6055  const void* query,
6056  uint32_t size)
6057  {
6058  OrthancPluginFindMatcher* target = NULL;
6059 
6060  _OrthancPluginCreateFindMatcher params;
6061  memset(&params, 0, sizeof(params));
6062  params.target = &target;
6063  params.query = query;
6064  params.size = size;
6065 
6066  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
6067  {
6068  return NULL;
6069  }
6070  else
6071  {
6072  return target;
6073  }
6074  }
6075 
6076 
6077  typedef struct
6078  {
6079  OrthancPluginFindMatcher* matcher;
6080  } _OrthancPluginFreeFindMatcher;
6081 
6091  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6092  OrthancPluginContext* context,
6093  OrthancPluginFindMatcher* matcher)
6094  {
6095  _OrthancPluginFreeFindMatcher params;
6096  params.matcher = matcher;
6097 
6098  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6099  }
6100 
6101 
6102  typedef struct
6103  {
6104  const OrthancPluginFindMatcher* matcher;
6105  const void* dicom;
6106  uint32_t size;
6107  int32_t* isMatch;
6108  } _OrthancPluginFindMatcherIsMatch;
6109 
6124  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6125  OrthancPluginContext* context,
6126  const OrthancPluginFindMatcher* matcher,
6127  const void* dicom,
6128  uint32_t size)
6129  {
6130  int32_t isMatch = 0;
6131 
6132  _OrthancPluginFindMatcherIsMatch params;
6133  params.matcher = matcher;
6134  params.dicom = dicom;
6135  params.size = size;
6136  params.isMatch = &isMatch;
6137 
6138  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6139  {
6140  return isMatch;
6141  }
6142  else
6143  {
6144  /* Error: Assume non-match */
6145  return 0;
6146  }
6147  }
6148 
6149 
6150  typedef struct
6151  {
6153  } _OrthancPluginIncomingHttpRequestFilter2;
6154 
6167  OrthancPluginContext* context,
6169  {
6170  _OrthancPluginIncomingHttpRequestFilter2 params;
6171  params.callback = callback;
6172 
6173  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6174  }
6175 
6176 
6177 
6178  typedef struct
6179  {
6180  OrthancPluginPeers** peers;
6181  } _OrthancPluginGetPeers;
6182 
6195  OrthancPluginContext* context)
6196  {
6197  OrthancPluginPeers* peers = NULL;
6198 
6199  _OrthancPluginGetPeers params;
6200  memset(&params, 0, sizeof(params));
6201  params.peers = &peers;
6202 
6203  if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6204  {
6205  return NULL;
6206  }
6207  else
6208  {
6209  return peers;
6210  }
6211  }
6212 
6213 
6214  typedef struct
6215  {
6216  OrthancPluginPeers* peers;
6217  } _OrthancPluginFreePeers;
6218 
6228  ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6229  OrthancPluginContext* context,
6230  OrthancPluginPeers* peers)
6231  {
6232  _OrthancPluginFreePeers params;
6233  params.peers = peers;
6234 
6235  context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6236  }
6237 
6238 
6239  typedef struct
6240  {
6241  uint32_t* target;
6242  const OrthancPluginPeers* peers;
6243  } _OrthancPluginGetPeersCount;
6244 
6258  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6259  OrthancPluginContext* context,
6260  const OrthancPluginPeers* peers)
6261  {
6262  uint32_t target = 0;
6263 
6264  _OrthancPluginGetPeersCount params;
6265  memset(&params, 0, sizeof(params));
6266  params.target = &target;
6267  params.peers = peers;
6268 
6269  if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6270  {
6271  /* Error */
6272  return 0;
6273  }
6274  else
6275  {
6276  return target;
6277  }
6278  }
6279 
6280 
6281  typedef struct
6282  {
6283  const char** target;
6284  const OrthancPluginPeers* peers;
6285  uint32_t peerIndex;
6286  const char* userProperty;
6287  } _OrthancPluginGetPeerProperty;
6288 
6306  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6307  OrthancPluginContext* context,
6308  const OrthancPluginPeers* peers,
6309  uint32_t peerIndex)
6310  {
6311  const char* target = NULL;
6312 
6313  _OrthancPluginGetPeerProperty params;
6314  memset(&params, 0, sizeof(params));
6315  params.target = &target;
6316  params.peers = peers;
6317  params.peerIndex = peerIndex;
6318  params.userProperty = NULL;
6319 
6320  if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6321  {
6322  /* Error */
6323  return NULL;
6324  }
6325  else
6326  {
6327  return target;
6328  }
6329  }
6330 
6331 
6347  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6348  OrthancPluginContext* context,
6349  const OrthancPluginPeers* peers,
6350  uint32_t peerIndex)
6351  {
6352  const char* target = NULL;
6353 
6354  _OrthancPluginGetPeerProperty params;
6355  memset(&params, 0, sizeof(params));
6356  params.target = &target;
6357  params.peers = peers;
6358  params.peerIndex = peerIndex;
6359  params.userProperty = NULL;
6360 
6361  if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6362  {
6363  /* Error */
6364  return NULL;
6365  }
6366  else
6367  {
6368  return target;
6369  }
6370  }
6371 
6372 
6373 
6393  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6394  OrthancPluginContext* context,
6395  const OrthancPluginPeers* peers,
6396  uint32_t peerIndex,
6397  const char* userProperty)
6398  {
6399  const char* target = NULL;
6400 
6401  _OrthancPluginGetPeerProperty params;
6402  memset(&params, 0, sizeof(params));
6403  params.target = &target;
6404  params.peers = peers;
6405  params.peerIndex = peerIndex;
6406  params.userProperty = userProperty;
6407 
6408  if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6409  {
6410  /* No such user property */
6411  return NULL;
6412  }
6413  else
6414  {
6415  return target;
6416  }
6417  }
6418 
6419 
6420 
6421  typedef struct
6422  {
6423  OrthancPluginMemoryBuffer* answerBody;
6424  OrthancPluginMemoryBuffer* answerHeaders;
6425  uint16_t* httpStatus;
6426  const OrthancPluginPeers* peers;
6427  uint32_t peerIndex;
6428  OrthancPluginHttpMethod method;
6429  const char* uri;
6430  uint32_t additionalHeadersCount;
6431  const char* const* additionalHeadersKeys;
6432  const char* const* additionalHeadersValues;
6433  const void* body;
6434  uint32_t bodySize;
6435  uint32_t timeout;
6436  } _OrthancPluginCallPeerApi;
6437 
6474  OrthancPluginContext* context,
6475  OrthancPluginMemoryBuffer* answerBody,
6476  OrthancPluginMemoryBuffer* answerHeaders,
6477  uint16_t* httpStatus,
6478  const OrthancPluginPeers* peers,
6479  uint32_t peerIndex,
6480  OrthancPluginHttpMethod method,
6481  const char* uri,
6482  uint32_t additionalHeadersCount,
6483  const char* const* additionalHeadersKeys,
6484  const char* const* additionalHeadersValues,
6485  const void* body,
6486  uint32_t bodySize,
6487  uint32_t timeout)
6488  {
6489  _OrthancPluginCallPeerApi params;
6490  memset(&params, 0, sizeof(params));
6491 
6492  params.answerBody = answerBody;
6493  params.answerHeaders = answerHeaders;
6494  params.httpStatus = httpStatus;
6495  params.peers = peers;
6496  params.peerIndex = peerIndex;
6497  params.method = method;
6498  params.uri = uri;
6499  params.additionalHeadersCount = additionalHeadersCount;
6500  params.additionalHeadersKeys = additionalHeadersKeys;
6501  params.additionalHeadersValues = additionalHeadersValues;
6502  params.body = body;
6503  params.bodySize = bodySize;
6504  params.timeout = timeout;
6505 
6506  return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6507  }
6508 
6509 
6510 
6511 
6512 
6513  typedef struct
6514  {
6515  OrthancPluginJob** target;
6516  void *job;
6517  OrthancPluginJobFinalize finalize;
6518  const char *type;
6519  OrthancPluginJobGetProgress getProgress;
6520  OrthancPluginJobGetContent getContent;
6521  OrthancPluginJobGetSerialized getSerialized;
6522  OrthancPluginJobStep step;
6523  OrthancPluginJobStop stop;
6524  OrthancPluginJobReset reset;
6525  } _OrthancPluginCreateJob;
6526 
6559  OrthancPluginContext *context,
6560  void *job,
6561  OrthancPluginJobFinalize finalize,
6562  const char *type,
6563  OrthancPluginJobGetProgress getProgress,
6564  OrthancPluginJobGetContent getContent,
6565  OrthancPluginJobGetSerialized getSerialized,
6566  OrthancPluginJobStep step,
6567  OrthancPluginJobStop stop,
6568  OrthancPluginJobReset reset)
6569  {
6570  OrthancPluginJob* target = NULL;
6571 
6572  _OrthancPluginCreateJob params;
6573  memset(&params, 0, sizeof(params));
6574 
6575  params.target = &target;
6576  params.job = job;
6577  params.finalize = finalize;
6578  params.type = type;
6579  params.getProgress = getProgress;
6580  params.getContent = getContent;
6581  params.getSerialized = getSerialized;
6582  params.step = step;
6583  params.stop = stop;
6584  params.reset = reset;
6585 
6586  if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6587  target == NULL)
6588  {
6589  /* Error */
6590  return NULL;
6591  }
6592  else
6593  {
6594  return target;
6595  }
6596  }
6597 
6598 
6599  typedef struct
6600  {
6601  OrthancPluginJob* job;
6602  } _OrthancPluginFreeJob;
6603 
6613  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6614  OrthancPluginContext* context,
6615  OrthancPluginJob* job)
6616  {
6617  _OrthancPluginFreeJob params;
6618  params.job = job;
6619 
6620  context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6621  }
6622 
6623 
6624 
6625  typedef struct
6626  {
6627  char** resultId;
6628  OrthancPluginJob *job;
6629  int priority;
6630  } _OrthancPluginSubmitJob;
6631 
6645  ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6646  OrthancPluginContext *context,
6647  OrthancPluginJob *job,
6648  int priority)
6649  {
6650  char* resultId = NULL;
6651 
6652  _OrthancPluginSubmitJob params;
6653  memset(&params, 0, sizeof(params));
6654 
6655  params.resultId = &resultId;
6656  params.job = job;
6657  params.priority = priority;
6658 
6659  if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6660  resultId == NULL)
6661  {
6662  /* Error */
6663  return NULL;
6664  }
6665  else
6666  {
6667  return resultId;
6668  }
6669  }
6670 
6671 
6672 
6673  typedef struct
6674  {
6675  OrthancPluginJobsUnserializer unserializer;
6676  } _OrthancPluginJobsUnserializer;
6677 
6690  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6691  OrthancPluginContext* context,
6692  OrthancPluginJobsUnserializer unserializer)
6693  {
6694  _OrthancPluginJobsUnserializer params;
6695  params.unserializer = unserializer;
6696 
6697  context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6698  }
6699 
6700 
6701 
6702  typedef struct
6703  {
6704  OrthancPluginRestOutput* output;
6705  const char* details;
6706  uint8_t log;
6707  } _OrthancPluginSetHttpErrorDetails;
6708 
6726  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
6727  OrthancPluginContext* context,
6728  OrthancPluginRestOutput* output,
6729  const char* details,
6730  uint8_t log)
6731  {
6732  _OrthancPluginSetHttpErrorDetails params;
6733  params.output = output;
6734  params.details = details;
6735  params.log = log;
6736  context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
6737  }
6738 
6739 
6740 
6741  typedef struct
6742  {
6743  const char** result;
6744  const char* argument;
6745  } _OrthancPluginRetrieveStaticString;
6746 
6758  ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
6759  OrthancPluginContext* context,
6760  const char* path)
6761  {
6762  const char* result = NULL;
6763 
6764  _OrthancPluginRetrieveStaticString params;
6765  params.result = &result;
6766  params.argument = path;
6767 
6768  if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
6769  {
6770  /* Error */
6771  return NULL;
6772  }
6773  else
6774  {
6775  return result;
6776  }
6777  }
6778 
6779 
6780 
6781  typedef struct
6782  {
6783  const char* name;
6784  float value;
6786  } _OrthancPluginSetMetricsValue;
6787 
6802  ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
6803  OrthancPluginContext* context,
6804  const char* name,
6805  float value,
6807  {
6808  _OrthancPluginSetMetricsValue params;
6809  params.name = name;
6810  params.value = value;
6811  params.type = type;
6812  context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
6813  }
6814 
6815 
6816 
6817  typedef struct
6818  {
6820  } _OrthancPluginRegisterRefreshMetricsCallback;
6821 
6833  OrthancPluginContext* context,
6835  {
6836  _OrthancPluginRegisterRefreshMetricsCallback params;
6837  params.callback = callback;
6838  context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
6839  }
6840 
6841 
6842 
6843 
6844  typedef struct
6845  {
6846  char** target;
6847  const void* dicom;
6848  uint32_t dicomSize;
6850  } _OrthancPluginEncodeDicomWeb;
6851 
6868  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
6869  OrthancPluginContext* context,
6870  const void* dicom,
6871  uint32_t dicomSize,
6873  {
6874  char* target = NULL;
6875 
6876  _OrthancPluginEncodeDicomWeb params;
6877  params.target = &target;
6878  params.dicom = dicom;
6879  params.dicomSize = dicomSize;
6880  params.callback = callback;
6881 
6882  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
6883  {
6884  /* Error */
6885  return NULL;
6886  }
6887  else
6888  {
6889  return target;
6890  }
6891  }
6892 
6893 
6910  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
6911  OrthancPluginContext* context,
6912  const void* dicom,
6913  uint32_t dicomSize,
6915  {
6916  char* target = NULL;
6917 
6918  _OrthancPluginEncodeDicomWeb params;
6919  params.target = &target;
6920  params.dicom = dicom;
6921  params.dicomSize = dicomSize;
6922  params.callback = callback;
6923 
6924  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
6925  {
6926  /* Error */
6927  return NULL;
6928  }
6929  else
6930  {
6931  return target;
6932  }
6933  }
6934 
6935 
6936 
6937  typedef struct
6938  {
6939  char** target;
6940  const void* dicom;
6941  uint32_t dicomSize;
6943  void* payload;
6944  } _OrthancPluginEncodeDicomWeb2;
6945 
6962  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson2(
6963  OrthancPluginContext* context,
6964  const void* dicom,
6965  uint32_t dicomSize,
6967  void* payload)
6968  {
6969  char* target = NULL;
6970 
6971  _OrthancPluginEncodeDicomWeb2 params;
6972  params.target = &target;
6973  params.dicom = dicom;
6974  params.dicomSize = dicomSize;
6975  params.callback = callback;
6976  params.payload = payload;
6977 
6978  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson2, &params) != OrthancPluginErrorCode_Success)
6979  {
6980  /* Error */
6981  return NULL;
6982  }
6983  else
6984  {
6985  return target;
6986  }
6987  }
6988 
6989 
7006  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml2(
7007  OrthancPluginContext* context,
7008  const void* dicom,
7009  uint32_t dicomSize,
7011  void* payload)
7012  {
7013  char* target = NULL;
7014 
7015  _OrthancPluginEncodeDicomWeb2 params;
7016  params.target = &target;
7017  params.dicom = dicom;
7018  params.dicomSize = dicomSize;
7019  params.callback = callback;
7020  params.payload = payload;
7021 
7022  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml2, &params) != OrthancPluginErrorCode_Success)
7023  {
7024  /* Error */
7025  return NULL;
7026  }
7027  else
7028  {
7029  return target;
7030  }
7031  }
7032 
7033 
7034 
7051  void* answer,
7052  const char* key,
7053  const char* value);
7054 
7055 
7072  void* answer,
7073  const void* data,
7074  uint32_t size);
7075 
7076 
7091  typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
7092 
7093 
7109 
7110 
7124  typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
7125 
7126 
7140  typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
7141 
7142 
7143  typedef struct
7144  {
7145  void* answer;
7148  uint16_t* httpStatus;
7149  OrthancPluginHttpMethod method;
7150  const char* url;
7151  uint32_t headersCount;
7152  const char* const* headersKeys;
7153  const char* const* headersValues;
7154  void* request;
7159  const char* username;
7160  const char* password;
7161  uint32_t timeout;
7162  const char* certificateFile;
7163  const char* certificateKeyFile;
7164  const char* certificateKeyPassword;
7165  uint8_t pkcs11;
7166  } _OrthancPluginChunkedHttpClient;
7167 
7168 
7220  OrthancPluginContext* context,
7221  void* answer,
7224  uint16_t* httpStatus,
7225  OrthancPluginHttpMethod method,
7226  const char* url,
7227  uint32_t headersCount,
7228  const char* const* headersKeys,
7229  const char* const* headersValues,
7230  void* request,
7235  const char* username,
7236  const char* password,
7237  uint32_t timeout,
7238  const char* certificateFile,
7239  const char* certificateKeyFile,
7240  const char* certificateKeyPassword,
7241  uint8_t pkcs11)
7242  {
7243  _OrthancPluginChunkedHttpClient params;
7244  memset(&params, 0, sizeof(params));
7245 
7246  /* In common with OrthancPluginHttpClient() */
7247  params.httpStatus = httpStatus;
7248  params.method = method;
7249  params.url = url;
7250  params.headersCount = headersCount;
7251  params.headersKeys = headersKeys;
7252  params.headersValues = headersValues;
7253  params.username = username;
7254  params.password = password;
7255  params.timeout = timeout;
7256  params.certificateFile = certificateFile;
7257  params.certificateKeyFile = certificateKeyFile;
7258  params.certificateKeyPassword = certificateKeyPassword;
7259  params.pkcs11 = pkcs11;
7260 
7261  /* For chunked body/answer */
7262  params.answer = answer;
7263  params.answerAddChunk = answerAddChunk;
7264  params.answerAddHeader = answerAddHeader;
7265  params.request = request;
7266  params.requestIsDone = requestIsDone;
7267  params.requestChunkData = requestChunkData;
7268  params.requestChunkSize = requestChunkSize;
7269  params.requestNext = requestNext;
7270 
7271  return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7272  }
7273 
7274 
7275 
7280  typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7281 
7282 
7283 
7301  const char* url,
7302  const OrthancPluginHttpRequest* request);
7303 
7304 
7320  const void* data,
7321  uint32_t size);
7322 
7323 
7340  OrthancPluginRestOutput* output);
7341 
7342 
7358 
7359  typedef struct
7360  {
7361  const char* pathRegularExpression;
7362  OrthancPluginRestCallback getHandler;
7364  OrthancPluginRestCallback deleteHandler;
7369  } _OrthancPluginChunkedRestCallback;
7370 
7371 
7401  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterChunkedRestCallback(
7402  OrthancPluginContext* context,
7403  const char* pathRegularExpression,
7404  OrthancPluginRestCallback getHandler,
7406  OrthancPluginRestCallback deleteHandler,
7411  {
7412  _OrthancPluginChunkedRestCallback params;
7413  params.pathRegularExpression = pathRegularExpression;
7414  params.getHandler = getHandler;
7415  params.postHandler = postHandler;
7416  params.deleteHandler = deleteHandler;
7417  params.putHandler = putHandler;
7418  params.addChunk = addChunk;
7419  params.execute = execute;
7420  params.finalize = finalize;
7421 
7422  context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
7423  }
7424 
7425 
7426 
7427 
7428 
7429  typedef struct
7430  {
7431  char** result;
7432  uint16_t group;
7433  uint16_t element;
7434  const char* privateCreator;
7435  } _OrthancPluginGetTagName;
7436 
7452  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
7453  OrthancPluginContext* context,
7454  uint16_t group,
7455  uint16_t element,
7456  const char* privateCreator)
7457  {
7458  char* result;
7459 
7460  _OrthancPluginGetTagName params;
7461  params.result = &result;
7462  params.group = group;
7463  params.element = element;
7464  params.privateCreator = privateCreator;
7465 
7466  if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
7467  {
7468  /* Error */
7469  return NULL;
7470  }
7471  else
7472  {
7473  return result;
7474  }
7475  }
7476 
7477 
7478 
7508  void** handler /* out */,
7509  const char* jobId,
7510  const char* transactionUid,
7511  const char* const* sopClassUids,
7512  const char* const* sopInstanceUids,
7513  uint32_t countInstances,
7514  const char* remoteAet,
7515  const char* calledAet);
7516 
7517 
7529  typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
7530 
7531 
7552  void* handler,
7553  const char* sopClassUid,
7554  const char* sopInstanceUid);
7555 
7556 
7557  typedef struct
7558  {
7562  } _OrthancPluginRegisterStorageCommitmentScpCallback;
7563 
7578  OrthancPluginContext* context,
7582  {
7583  _OrthancPluginRegisterStorageCommitmentScpCallback params;
7584  params.factory = factory;
7585  params.destructor = destructor;
7586  params.lookup = lookup;
7587  return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
7588  }
7589 
7590 
7591 
7608  const OrthancPluginDicomInstance* instance);
7609 
7610 
7611  typedef struct
7612  {
7614  } _OrthancPluginIncomingDicomInstanceFilter;
7615 
7639  OrthancPluginContext* context,
7641  {
7642  _OrthancPluginIncomingDicomInstanceFilter params;
7643  params.callback = callback;
7644 
7645  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, &params);
7646  }
7647 
7648 
7662  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceTransferSyntaxUid(
7663  OrthancPluginContext* context,
7664  const OrthancPluginDicomInstance* instance)
7665  {
7666  char* result;
7667 
7668  _OrthancPluginAccessDicomInstance params;
7669  memset(&params, 0, sizeof(params));
7670  params.resultStringToFree = &result;
7671  params.instance = instance;
7672 
7673  if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, &params) != OrthancPluginErrorCode_Success)
7674  {
7675  /* Error */
7676  return NULL;
7677  }
7678  else
7679  {
7680  return result;
7681  }
7682  }
7683 
7684 
7697  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData(
7698  OrthancPluginContext* context,
7699  const OrthancPluginDicomInstance* instance)
7700  {
7701  int64_t hasPixelData;
7702 
7703  _OrthancPluginAccessDicomInstance params;
7704  memset(&params, 0, sizeof(params));
7705  params.resultInt64 = &hasPixelData;
7706  params.instance = instance;
7707 
7708  if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, &params) != OrthancPluginErrorCode_Success ||
7709  hasPixelData < 0 ||
7710  hasPixelData > 1)
7711  {
7712  /* Error */
7713  return -1;
7714  }
7715  else
7716  {
7717  return (hasPixelData != 0);
7718  }
7719  }
7720 
7721 
7722 
7723 
7724 
7725 
7726  typedef struct
7727  {
7728  OrthancPluginDicomInstance** target;
7729  const void* buffer;
7730  uint32_t size;
7731  const char* transferSyntax;
7732  } _OrthancPluginCreateDicomInstance;
7733 
7748  OrthancPluginContext* context,
7749  const void* buffer,
7750  uint32_t size)
7751  {
7752  OrthancPluginDicomInstance* target = NULL;
7753 
7754  _OrthancPluginCreateDicomInstance params;
7755  params.target = &target;
7756  params.buffer = buffer;
7757  params.size = size;
7758 
7759  if (context->InvokeService(context, _OrthancPluginService_CreateDicomInstance, &params) != OrthancPluginErrorCode_Success)
7760  {
7761  /* Error */
7762  return NULL;
7763  }
7764  else
7765  {
7766  return target;
7767  }
7768  }
7769 
7770  typedef struct
7771  {
7773  } _OrthancPluginFreeDicomInstance;
7774 
7785  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeDicomInstance(
7786  OrthancPluginContext* context,
7788  {
7789  _OrthancPluginFreeDicomInstance params;
7790  params.dicom = dicom;
7791 
7792  context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, &params);
7793  }
7794 
7795 
7796  typedef struct
7797  {
7798  uint32_t* targetUint32;
7799  OrthancPluginMemoryBuffer* targetBuffer;
7800  OrthancPluginImage** targetImage;
7801  char** targetStringToFree;
7802  const OrthancPluginDicomInstance* instance;
7803  uint32_t frameIndex;
7806  uint32_t maxStringLength;
7807  OrthancPluginDicomWebBinaryCallback2 dicomWebCallback;
7808  void* dicomWebPayload;
7809  } _OrthancPluginAccessDicomInstance2;
7810 
7822  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetInstanceFramesCount(
7823  OrthancPluginContext* context,
7824  const OrthancPluginDicomInstance* instance)
7825  {
7826  uint32_t count;
7827 
7828  _OrthancPluginAccessDicomInstance2 params;
7829  memset(&params, 0, sizeof(params));
7830  params.targetUint32 = &count;
7831  params.instance = instance;
7832 
7833  if (context->InvokeService(context, _OrthancPluginService_GetInstanceFramesCount, &params) != OrthancPluginErrorCode_Success)
7834  {
7835  /* Error */
7836  return 0;
7837  }
7838  else
7839  {
7840  return count;
7841  }
7842  }
7843 
7844 
7863  OrthancPluginContext* context,
7864  OrthancPluginMemoryBuffer* target,
7865  const OrthancPluginDicomInstance* instance,
7866  uint32_t frameIndex)
7867  {
7868  _OrthancPluginAccessDicomInstance2 params;
7869  memset(&params, 0, sizeof(params));
7870  params.targetBuffer = target;
7871  params.instance = instance;
7872  params.frameIndex = frameIndex;
7873 
7874  return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, &params);
7875  }
7876 
7877 
7891  OrthancPluginContext* context,
7892  const OrthancPluginDicomInstance* instance,
7893  uint32_t frameIndex)
7894  {
7895  OrthancPluginImage* target = NULL;
7896 
7897  _OrthancPluginAccessDicomInstance2 params;
7898  memset(&params, 0, sizeof(params));
7899  params.targetImage = &target;
7900  params.instance = instance;
7901  params.frameIndex = frameIndex;
7902 
7903  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDecodedFrame, &params) != OrthancPluginErrorCode_Success)
7904  {
7905  return NULL;
7906  }
7907  else
7908  {
7909  return target;
7910  }
7911  }
7912 
7913 
7930  OrthancPluginContext* context,
7931  const void* buffer,
7932  uint32_t size,
7933  const char* transferSyntax)
7934  {
7935  OrthancPluginDicomInstance* target = NULL;
7936 
7937  _OrthancPluginCreateDicomInstance params;
7938  params.target = &target;
7939  params.buffer = buffer;
7940  params.size = size;
7941  params.transferSyntax = transferSyntax;
7942 
7943  if (context->InvokeService(context, _OrthancPluginService_TranscodeDicomInstance, &params) != OrthancPluginErrorCode_Success)
7944  {
7945  /* Error */
7946  return NULL;
7947  }
7948  else
7949  {
7950  return target;
7951  }
7952  }
7953 
7968  OrthancPluginContext* context,
7969  OrthancPluginMemoryBuffer* target,
7970  const OrthancPluginDicomInstance* instance)
7971  {
7972  _OrthancPluginAccessDicomInstance2 params;
7973  memset(&params, 0, sizeof(params));
7974  params.targetBuffer = target;
7975  params.instance = instance;
7976 
7977  return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, &params);
7978  }
7979 
7980 
7999  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceAdvancedJson(
8000  OrthancPluginContext* context,
8001  const OrthancPluginDicomInstance* instance,
8004  uint32_t maxStringLength)
8005  {
8006  char* result = NULL;
8007 
8008  _OrthancPluginAccessDicomInstance2 params;
8009  memset(&params, 0, sizeof(params));
8010  params.targetStringToFree = &result;
8011  params.instance = instance;
8012  params.format = format;
8013  params.flags = flags;
8014  params.maxStringLength = maxStringLength;
8015 
8016  if (context->InvokeService(context, _OrthancPluginService_GetInstanceAdvancedJson, &params) != OrthancPluginErrorCode_Success)
8017  {
8018  /* Error */
8019  return NULL;
8020  }
8021  else
8022  {
8023  return result;
8024  }
8025  }
8026 
8027 
8042  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebJson(
8043  OrthancPluginContext* context,
8044  const OrthancPluginDicomInstance* instance,
8046  void* payload)
8047  {
8048  char* target = NULL;
8049 
8050  _OrthancPluginAccessDicomInstance2 params;
8051  params.targetStringToFree = &target;
8052  params.instance = instance;
8053  params.dicomWebCallback = callback;
8054  params.dicomWebPayload = payload;
8055 
8056  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebJson, &params) != OrthancPluginErrorCode_Success)
8057  {
8058  /* Error */
8059  return NULL;
8060  }
8061  else
8062  {
8063  return target;
8064  }
8065  }
8066 
8067 
8082  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebXml(
8083  OrthancPluginContext* context,
8084  const OrthancPluginDicomInstance* instance,
8086  void* payload)
8087  {
8088  char* target = NULL;
8089 
8090  _OrthancPluginAccessDicomInstance2 params;
8091  params.targetStringToFree = &target;
8092  params.instance = instance;
8093  params.dicomWebCallback = callback;
8094  params.dicomWebPayload = payload;
8095 
8096  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebXml, &params) != OrthancPluginErrorCode_Success)
8097  {
8098  /* Error */
8099  return NULL;
8100  }
8101  else
8102  {
8103  return target;
8104  }
8105  }
8106 
8107 
8108 
8128  OrthancPluginMemoryBuffer* transcoded /* out */,
8129  const void* buffer,
8130  uint64_t size,
8131  const char* const* allowedSyntaxes,
8132  uint32_t countSyntaxes,
8133  uint8_t allowNewSopInstanceUid);
8134 
8135 
8136  typedef struct
8137  {
8139  } _OrthancPluginTranscoderCallback;
8140 
8155  OrthancPluginContext* context,
8157  {
8158  _OrthancPluginTranscoderCallback params;
8159  params.callback = callback;
8160 
8161  return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, &params);
8162  }
8163 
8164 
8165 
8166  typedef struct
8167  {
8168  OrthancPluginMemoryBuffer* target;
8169  uint32_t size;
8170  } _OrthancPluginCreateMemoryBuffer;
8171 
8190  OrthancPluginContext* context,
8191  OrthancPluginMemoryBuffer* target,
8192  uint32_t size)
8193  {
8194  _OrthancPluginCreateMemoryBuffer params;
8195  params.target = target;
8196  params.size = size;
8197 
8198  return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, &params);
8199  }
8200 
8201 
8228  OrthancPluginContext* context)
8229  {
8230  char* result;
8231 
8232  _OrthancPluginRetrieveDynamicString params;
8233  params.result = &result;
8234  params.argument = NULL;
8235 
8236  if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
8237  &params) != OrthancPluginErrorCode_Success)
8238  {
8239  /* Error */
8240  return NULL;
8241  }
8242  else
8243  {
8244  return result;
8245  }
8246  }
8247 #ifdef __cplusplus
8248 }
8249 #endif
8250 
8251 
OrthancPluginJobGetProgress
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1461
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:4338
OrthancPluginGetMoveSize
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1406
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:1836
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:3269
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:5674
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:2017
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:3736
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:5807
OrthancPluginGetOrthancDirectory
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:3113
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:2049
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:2311
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:7747
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:2395
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:7299
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:5473
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:1684
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:5302
OrthancPluginLookupSeries
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2566
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:7318
OrthancPluginIncomingDicomInstanceFilter
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition: OrthancCPlugin.h:7607
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:2783
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:4129
OrthancPluginGetPeerUrl
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6347
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:4592
OrthancPluginRegisterDecodeImageCallback
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5264
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:2282
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:3805
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:2962
OrthancPluginGetPeerName
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6306
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:1650
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:8227
OrthancPluginGetImagePitch
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3873
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:3003
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:7577
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:7822
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:4821
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:7452
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:5897
OrthancPluginLookupDictionary
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5519
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:4865
OrthancPluginGetConfigurationPath
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:3148
OrthancPluginHttpDelete
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4300
OrthancPluginCompressionType
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:743
OrthancPluginJobStep
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1509
OrthancPluginDictionaryEntry::minMultiplicity
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1687
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:5600
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:7006
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:4037
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:4498
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:6802
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:7662
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:5046
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:2646
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:2334
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:1584
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:6166
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:7890
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:4972
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:6053
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:1533
OrthancPluginValueRepresentation_AT
@ OrthancPluginValueRepresentation_AT
Definition: OrthancCPlugin.h:775
OrthancPluginReadFile
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3621
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:6473
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:7091
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:2531
OrthancPluginCompressionType_ZlibWithSize
@ OrthancPluginCompressionType_ZlibWithSize
Definition: OrthancCPlugin.h:745
OrthancPluginGetCommandLineArgumentsCount
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3373
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:7785
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:7697
OrthancPluginGetInstanceDicomWebXml
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:8082
OrthancPluginGetInstanceSize
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2816
OrthancPluginEncodeDicomWebXml
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:6910
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:8189
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:2180
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:7356
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:1871
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:2106
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:2923
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:1280
OrthancPluginChangeType_StableSeries
@ OrthancPluginChangeType_StableSeries
Definition: OrthancCPlugin.h:722
OrthancPluginGetOrthancPath
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:3083
OrthancPluginGetInstanceOrigin
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5179
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:5729
OrthancPluginValueRepresentation_LT
@ OrthancPluginValueRepresentation_LT
Definition: OrthancCPlugin.h:784
OrthancPluginFreeMemoryBuffer
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1855
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:7338
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:7967
OrthancPluginSetRootUri
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:3225
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:3513
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:3907
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:7124
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:2359
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:7929
OrthancPluginDicomWebBinaryMode_Ignore
@ OrthancPluginDicomWebBinaryMode_Ignore
Definition: OrthancCPlugin.h:950
OrthancPluginGetFontsCount
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4373
OrthancPluginRegisterIncomingDicomInstanceFilter
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition: OrthancCPlugin.h:7638
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:3542
OrthancPluginGetExpectedDatabaseVersion
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3439
OrthancPluginRegisterOnChangeCallback
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3194
OrthancPluginChangeType_OrthancStarted
@ OrthancPluginChangeType_OrthancStarted
Definition: OrthancCPlugin.h:724
OrthancPluginFreeJob
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6613
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:7071
OrthancPluginServerChunkedRequestReader
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition: OrthancCPlugin.h:7280
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:1688
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:5010
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:5228
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:4445
OrthancPluginGetErrorDescription
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3683
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:3342
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:1939
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:1381
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:3303
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:3838
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:1494
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:4668
OrthancPluginComputeMd5
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5437
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:6091
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:4082
OrthancPluginGetInstanceJson
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2885
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:4550
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:7550
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:7401
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:6014
OrthancPluginRegisterJobsUnserializer
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6690
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:4220
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:4262
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:4914
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:3247
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:1887
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:3772
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:2429
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:1550
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:5928
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:6558
OrthancPluginWorklistMarkIncomplete
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5076
OrthancPluginEncodeDicomWebJson
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:6868
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:1566
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:1476
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:6228
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:5768
OrthancPluginDictionaryEntry::vr
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1686
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:1311
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:1338
OrthancPluginFreeImage
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:3992
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:6758
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:1435
OrthancPluginGetFontName
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4413
OrthancPluginSetCookie
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2722
OrthancPluginJobFinalize
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1448
OrthancPluginApplyMove
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1421
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:7862
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:6194
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:6645
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:6832
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:7999
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:1683
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:5345
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:6393
OrthancPluginLookupPatient
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2461
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:1701
OrthancPluginWriteFile
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3652
OrthancPluginGetCommandLineArgument
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3407
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:2601
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:7219
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:3950
OrthancPluginRegisterRestCallbackNoLock
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:1979
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:1731
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:5114
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:5562
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:4777
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:6962
OrthancPluginStorageAreaRemove
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4629
OrthancPluginGetPeersCount
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6258
OrthancPluginGetFindQuerySize
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5860
OrthancPluginLogInfo
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:1903
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:5836
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:4182
OrthancPluginGetInstanceData
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2849
OrthancPluginGetInstanceDicomWebJson
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:8042
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:7140
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:1612
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:3584
OrthancPluginGetDicomForInstance
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2147
OrthancPluginWorklistGetDicomQuery
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5153
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:6726
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:7050
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:6124
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:7108
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:2247
OrthancPluginRegisterStorageArea
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:3051
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:8127
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:7507
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:2210
OrthancPluginRegisterTranscoderCallback
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition: OrthancCPlugin.h:8154
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:5966
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:2669
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:2692
OrthancPluginStorageCommitmentDestructor
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7529
OrthancPluginSetHttpHeader
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2747
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:4724
OrthancPluginErrorCode_NotLuaPredicate
@ OrthancPluginErrorCode_NotLuaPredicate
Definition: OrthancCPlugin.h:291
OrthancPluginLookupStudy
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2496
OrthancPluginDictionaryEntry::element
uint16_t element
Definition: OrthancCPlugin.h:1685
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:5391
OrthancPluginGetConfiguration
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3472