Orthanc Plugin SDK  1.12.1
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1 
107 #pragma once
108 
109 
110 #include <stdio.h>
111 #include <string.h>
112 
113 #ifdef WIN32
114 # define ORTHANC_PLUGINS_API __declspec(dllexport)
115 #elif __GNUC__ >= 4
116 # define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default")))
117 #else
118 # define ORTHANC_PLUGINS_API
119 #endif
120 
121 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
122 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 12
123 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 1
124 
125 
126 #if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
127 #define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
128  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
129  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
130  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
131  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
132  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
133 #endif
134 
135 
136 
137 /********************************************************************
138  ** Check that function inlining is properly supported. The use of
139  ** inlining is required, to avoid the duplication of object code
140  ** between two compilation modules that would use the Orthanc Plugin
141  ** API.
142  ********************************************************************/
143 
144 /* If the auto-detection of the "inline" keyword below does not work
145  automatically and that your compiler is known to properly support
146  inlining, uncomment the following #define and adapt the definition
147  of "static inline". */
148 
149 /* #define ORTHANC_PLUGIN_INLINE static inline */
150 
151 #ifndef ORTHANC_PLUGIN_INLINE
152 # if __STDC_VERSION__ >= 199901L
153 /* This is C99 or above: http://predef.sourceforge.net/prestd.html */
154 # define ORTHANC_PLUGIN_INLINE static inline
155 # elif defined(__cplusplus)
156 /* This is C++ */
157 # define ORTHANC_PLUGIN_INLINE static inline
158 # elif defined(__GNUC__)
159 /* This is GCC running in C89 mode */
160 # define ORTHANC_PLUGIN_INLINE static __inline
161 # elif defined(_MSC_VER)
162 /* This is Visual Studio running in C89 mode */
163 # define ORTHANC_PLUGIN_INLINE static __inline
164 # else
165 # error Your compiler is not known to support the "inline" keyword
166 # endif
167 #endif
168 
169 
170 
171 /********************************************************************
172  ** Inclusion of standard libraries.
173  ********************************************************************/
174 
180 #include <stdint.h>
181 
182 #include <stdlib.h>
183 
184 
185 
186 /********************************************************************
187  ** Definition of the Orthanc Plugin API.
188  ********************************************************************/
189 
192 #ifdef __cplusplus
193 extern "C"
194 {
195 #endif
196 
200  typedef enum
201  {
310 
311  _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
313 
314 
319  ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
320 
321 
325  typedef enum
326  {
332  _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
334 
335 
340  typedef struct
341  {
346 
350  uint32_t groupsCount;
351 
355  const char* const* groups;
356 
360  uint32_t getCount;
361 
365  const char* const* getKeys;
366 
370  const char* const* getValues;
371 
375  const void* body;
376 
380  uint32_t bodySize;
381 
382 
383  /* --------------------------------------------------
384  New in version 0.8.1
385  -------------------------------------------------- */
386 
390  uint32_t headersCount;
391 
395  const char* const* headersKeys;
396 
400  const char* const* headersValues;
401 
403 
404 
405  typedef enum
406  {
407  /* Generic services */
408  _OrthancPluginService_LogInfo = 1,
409  _OrthancPluginService_LogWarning = 2,
410  _OrthancPluginService_LogError = 3,
411  _OrthancPluginService_GetOrthancPath = 4,
412  _OrthancPluginService_GetOrthancDirectory = 5,
413  _OrthancPluginService_GetConfigurationPath = 6,
414  _OrthancPluginService_SetPluginProperty = 7,
415  _OrthancPluginService_GetGlobalProperty = 8,
416  _OrthancPluginService_SetGlobalProperty = 9,
417  _OrthancPluginService_GetCommandLineArgumentsCount = 10,
418  _OrthancPluginService_GetCommandLineArgument = 11,
419  _OrthancPluginService_GetExpectedDatabaseVersion = 12,
420  _OrthancPluginService_GetConfiguration = 13,
421  _OrthancPluginService_BufferCompression = 14,
422  _OrthancPluginService_ReadFile = 15,
423  _OrthancPluginService_WriteFile = 16,
424  _OrthancPluginService_GetErrorDescription = 17,
425  _OrthancPluginService_CallHttpClient = 18,
426  _OrthancPluginService_RegisterErrorCode = 19,
427  _OrthancPluginService_RegisterDictionaryTag = 20,
428  _OrthancPluginService_DicomBufferToJson = 21,
429  _OrthancPluginService_DicomInstanceToJson = 22,
430  _OrthancPluginService_CreateDicom = 23,
431  _OrthancPluginService_ComputeMd5 = 24,
432  _OrthancPluginService_ComputeSha1 = 25,
433  _OrthancPluginService_LookupDictionary = 26,
434  _OrthancPluginService_CallHttpClient2 = 27,
435  _OrthancPluginService_GenerateUuid = 28,
436  _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
437  _OrthancPluginService_AutodetectMimeType = 30,
438  _OrthancPluginService_SetMetricsValue = 31,
439  _OrthancPluginService_EncodeDicomWebJson = 32,
440  _OrthancPluginService_EncodeDicomWebXml = 33,
441  _OrthancPluginService_ChunkedHttpClient = 34, /* New in Orthanc 1.5.7 */
442  _OrthancPluginService_GetTagName = 35, /* New in Orthanc 1.5.7 */
443  _OrthancPluginService_EncodeDicomWebJson2 = 36, /* New in Orthanc 1.7.0 */
444  _OrthancPluginService_EncodeDicomWebXml2 = 37, /* New in Orthanc 1.7.0 */
445  _OrthancPluginService_CreateMemoryBuffer = 38, /* New in Orthanc 1.7.0 */
446  _OrthancPluginService_GenerateRestApiAuthorizationToken = 39, /* New in Orthanc 1.8.1 */
447  _OrthancPluginService_CreateMemoryBuffer64 = 40, /* New in Orthanc 1.9.0 */
448  _OrthancPluginService_CreateDicom2 = 41, /* New in Orthanc 1.9.0 */
449  _OrthancPluginService_GetDatabaseServerIdentifier = 42, /* New in Orthanc 1.11.1 */
450  _OrthancPluginService_SetMetricsIntegerValue = 43, /* New in Orthanc 1.12.1 */
451 
452  /* Registration of callbacks */
453  _OrthancPluginService_RegisterRestCallback = 1000,
454  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
455  _OrthancPluginService_RegisterStorageArea = 1002,
456  _OrthancPluginService_RegisterOnChangeCallback = 1003,
457  _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
458  _OrthancPluginService_RegisterWorklistCallback = 1005,
459  _OrthancPluginService_RegisterDecodeImageCallback = 1006,
460  _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
461  _OrthancPluginService_RegisterFindCallback = 1008,
462  _OrthancPluginService_RegisterMoveCallback = 1009,
463  _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
464  _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
465  _OrthancPluginService_RegisterChunkedRestCallback = 1012, /* New in Orthanc 1.5.7 */
466  _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
467  _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
468  _OrthancPluginService_RegisterTranscoderCallback = 1015, /* New in Orthanc 1.7.0 */
469  _OrthancPluginService_RegisterStorageArea2 = 1016, /* New in Orthanc 1.9.0 */
470  _OrthancPluginService_RegisterIncomingCStoreInstanceFilter = 1017, /* New in Orthanc 1.10.0 */
471  _OrthancPluginService_RegisterReceivedInstanceCallback = 1018, /* New in Orthanc 1.10.0 */
472  _OrthancPluginService_RegisterWebDavCollection = 1019, /* New in Orthanc 1.10.1 */
473 
474  /* Sending answers to REST calls */
475  _OrthancPluginService_AnswerBuffer = 2000,
476  _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
477  _OrthancPluginService_Redirect = 2002,
478  _OrthancPluginService_SendHttpStatusCode = 2003,
479  _OrthancPluginService_SendUnauthorized = 2004,
480  _OrthancPluginService_SendMethodNotAllowed = 2005,
481  _OrthancPluginService_SetCookie = 2006,
482  _OrthancPluginService_SetHttpHeader = 2007,
483  _OrthancPluginService_StartMultipartAnswer = 2008,
484  _OrthancPluginService_SendMultipartItem = 2009,
485  _OrthancPluginService_SendHttpStatus = 2010,
486  _OrthancPluginService_CompressAndAnswerImage = 2011,
487  _OrthancPluginService_SendMultipartItem2 = 2012,
488  _OrthancPluginService_SetHttpErrorDetails = 2013,
489 
490  /* Access to the Orthanc database and API */
491  _OrthancPluginService_GetDicomForInstance = 3000,
492  _OrthancPluginService_RestApiGet = 3001,
493  _OrthancPluginService_RestApiPost = 3002,
494  _OrthancPluginService_RestApiDelete = 3003,
495  _OrthancPluginService_RestApiPut = 3004,
496  _OrthancPluginService_LookupPatient = 3005,
497  _OrthancPluginService_LookupStudy = 3006,
498  _OrthancPluginService_LookupSeries = 3007,
499  _OrthancPluginService_LookupInstance = 3008,
500  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
501  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
502  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
503  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
504  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
505  _OrthancPluginService_ReconstructMainDicomTags = 3014,
506  _OrthancPluginService_RestApiGet2 = 3015,
507  _OrthancPluginService_CallRestApi = 3016, /* New in Orthanc 1.9.2 */
508 
509  /* Access to DICOM instances */
510  _OrthancPluginService_GetInstanceRemoteAet = 4000,
511  _OrthancPluginService_GetInstanceSize = 4001,
512  _OrthancPluginService_GetInstanceData = 4002,
513  _OrthancPluginService_GetInstanceJson = 4003,
514  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
515  _OrthancPluginService_HasInstanceMetadata = 4005,
516  _OrthancPluginService_GetInstanceMetadata = 4006,
517  _OrthancPluginService_GetInstanceOrigin = 4007,
518  _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
519  _OrthancPluginService_HasInstancePixelData = 4009,
520  _OrthancPluginService_CreateDicomInstance = 4010, /* New in Orthanc 1.7.0 */
521  _OrthancPluginService_FreeDicomInstance = 4011, /* New in Orthanc 1.7.0 */
522  _OrthancPluginService_GetInstanceFramesCount = 4012, /* New in Orthanc 1.7.0 */
523  _OrthancPluginService_GetInstanceRawFrame = 4013, /* New in Orthanc 1.7.0 */
524  _OrthancPluginService_GetInstanceDecodedFrame = 4014, /* New in Orthanc 1.7.0 */
525  _OrthancPluginService_TranscodeDicomInstance = 4015, /* New in Orthanc 1.7.0 */
526  _OrthancPluginService_SerializeDicomInstance = 4016, /* New in Orthanc 1.7.0 */
527  _OrthancPluginService_GetInstanceAdvancedJson = 4017, /* New in Orthanc 1.7.0 */
528  _OrthancPluginService_GetInstanceDicomWebJson = 4018, /* New in Orthanc 1.7.0 */
529  _OrthancPluginService_GetInstanceDicomWebXml = 4019, /* New in Orthanc 1.7.0 */
530  _OrthancPluginService_LoadDicomInstance = 4020, /* New in Orthanc 1.12.1 */
531 
532  /* Services for plugins implementing a database back-end */
533  _OrthancPluginService_RegisterDatabaseBackend = 5000, /* New in Orthanc 0.8.6 */
534  _OrthancPluginService_DatabaseAnswer = 5001,
535  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002, /* New in Orthanc 0.9.4 */
536  _OrthancPluginService_StorageAreaCreate = 5003,
537  _OrthancPluginService_StorageAreaRead = 5004,
538  _OrthancPluginService_StorageAreaRemove = 5005,
539  _OrthancPluginService_RegisterDatabaseBackendV3 = 5006, /* New in Orthanc 1.9.2 */
540  _OrthancPluginService_RegisterDatabaseBackendV4 = 5007, /* New in Orthanc 1.12.0 */
541 
542  /* Primitives for handling images */
543  _OrthancPluginService_GetImagePixelFormat = 6000,
544  _OrthancPluginService_GetImageWidth = 6001,
545  _OrthancPluginService_GetImageHeight = 6002,
546  _OrthancPluginService_GetImagePitch = 6003,
547  _OrthancPluginService_GetImageBuffer = 6004,
548  _OrthancPluginService_UncompressImage = 6005,
549  _OrthancPluginService_FreeImage = 6006,
550  _OrthancPluginService_CompressImage = 6007,
551  _OrthancPluginService_ConvertPixelFormat = 6008,
552  _OrthancPluginService_GetFontsCount = 6009,
553  _OrthancPluginService_GetFontInfo = 6010,
554  _OrthancPluginService_DrawText = 6011,
555  _OrthancPluginService_CreateImage = 6012,
556  _OrthancPluginService_CreateImageAccessor = 6013,
557  _OrthancPluginService_DecodeDicomImage = 6014,
558 
559  /* Primitives for handling C-Find, C-Move and worklists */
560  _OrthancPluginService_WorklistAddAnswer = 7000,
561  _OrthancPluginService_WorklistMarkIncomplete = 7001,
562  _OrthancPluginService_WorklistIsMatch = 7002,
563  _OrthancPluginService_WorklistGetDicomQuery = 7003,
564  _OrthancPluginService_FindAddAnswer = 7004,
565  _OrthancPluginService_FindMarkIncomplete = 7005,
566  _OrthancPluginService_GetFindQuerySize = 7006,
567  _OrthancPluginService_GetFindQueryTag = 7007,
568  _OrthancPluginService_GetFindQueryTagName = 7008,
569  _OrthancPluginService_GetFindQueryValue = 7009,
570  _OrthancPluginService_CreateFindMatcher = 7010,
571  _OrthancPluginService_FreeFindMatcher = 7011,
572  _OrthancPluginService_FindMatcherIsMatch = 7012,
573 
574  /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
575  _OrthancPluginService_GetPeers = 8000,
576  _OrthancPluginService_FreePeers = 8001,
577  _OrthancPluginService_GetPeersCount = 8003,
578  _OrthancPluginService_GetPeerName = 8004,
579  _OrthancPluginService_GetPeerUrl = 8005,
580  _OrthancPluginService_CallPeerApi = 8006,
581  _OrthancPluginService_GetPeerUserProperty = 8007,
582 
583  /* Primitives for handling jobs (new in 1.4.2) */
584  _OrthancPluginService_CreateJob = 9000, /* Deprecated since SDK 1.11.3 */
585  _OrthancPluginService_FreeJob = 9001,
586  _OrthancPluginService_SubmitJob = 9002,
587  _OrthancPluginService_RegisterJobsUnserializer = 9003,
588  _OrthancPluginService_CreateJob2 = 9004, /* New in SDK 1.11.3 */
589 
590  _OrthancPluginService_INTERNAL = 0x7fffffff
591  } _OrthancPluginService;
592 
593 
594  typedef enum
595  {
596  _OrthancPluginProperty_Description = 1,
597  _OrthancPluginProperty_RootUri = 2,
598  _OrthancPluginProperty_OrthancExplorer = 3,
599 
600  _OrthancPluginProperty_INTERNAL = 0x7fffffff
601  } _OrthancPluginProperty;
602 
603 
604 
609  typedef enum
610  {
618 
626 
634 
642 
650 
660 
668 
676 
684 
692 
693  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
695 
696 
697 
701  typedef enum
702  {
708  _OrthancPluginContentType_INTERNAL = 0x7fffffff
710 
711 
712 
716  typedef enum
717  {
724  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
726 
727 
728 
733  typedef enum
734  {
755  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
757 
758 
763  typedef enum
764  {
770  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
772 
773 
778  typedef enum
779  {
784  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
786 
787 
792  typedef enum
793  {
822  _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
824 
825 
831  typedef enum
832  {
837  _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
839 
840 
846  typedef enum
847  {
848  OrthancPluginDicomToJsonFlags_None = 0,
858  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
860 
861 
867  typedef enum
868  {
869  OrthancPluginCreateDicomFlags_None = 0,
873  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
875 
876 
882  typedef enum
883  {
889  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
891 
892 
897  typedef enum
898  {
905  _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
907 
908 
912  typedef enum
913  {
921  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
923 
924 
928  typedef enum
929  {
934 
935 
942  typedef enum
943  {
949 
950 
954  typedef enum
955  {
965 
966 
971  typedef enum
972  {
977 
978 
984  typedef enum
985  {
1013 
1014 
1018  typedef enum
1019  {
1024  _OrthancPluginReceivedInstanceAction_INTERNAL = 0x7fffffff
1026 
1027 
1032  typedef enum
1033  {
1046  _OrthancPluginLoadDicomInstanceMode_INTERNAL = 0x7fffffff
1048 
1049 
1057  typedef struct
1058  {
1062  void* data;
1063 
1067  uint32_t size;
1069 
1070 
1071 
1079  typedef struct
1080  {
1084  void* data;
1085 
1089  uint64_t size;
1091 
1092 
1093 
1094 
1099  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
1100 
1101 
1102 
1107  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
1108 
1109 
1110 
1115  typedef struct _OrthancPluginImage_t OrthancPluginImage;
1116 
1117 
1118 
1123  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
1124 
1125 
1126 
1131  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
1132 
1133 
1134 
1139  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
1140 
1141 
1142 
1147  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1148 
1149 
1150 
1155  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1156 
1157 
1158 
1163  typedef struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher;
1164 
1165 
1166 
1171  typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1172 
1173 
1174 
1179  typedef struct _OrthancPluginJob_t OrthancPluginJob;
1180 
1181 
1182 
1188  typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1189 
1190 
1191 
1197  OrthancPluginRestOutput* output,
1198  const char* url,
1199  const OrthancPluginHttpRequest* request);
1200 
1201 
1202 
1208  const OrthancPluginDicomInstance* instance,
1209  const char* instanceId);
1210 
1211 
1212 
1218  OrthancPluginChangeType changeType,
1219  OrthancPluginResourceType resourceType,
1220  const char* resourceId);
1221 
1222 
1223 
1229  OrthancPluginImage** target,
1230  const void* dicom,
1231  const uint32_t size,
1232  uint32_t frameIndex);
1233 
1234 
1235 
1240  typedef void (*OrthancPluginFree) (void* buffer);
1241 
1242 
1243 
1253  const char* bulkDataUri);
1254 
1255 
1256 
1270  const char* uuid,
1271  const void* content,
1272  int64_t size,
1274 
1275 
1276 
1297  void** content,
1298  int64_t* size,
1299  const char* uuid,
1301 
1302 
1303 
1318  const char* uuid,
1320 
1321 
1322 
1341  const char* uuid,
1343  uint64_t rangeStart);
1344 
1345 
1346 
1358  const char* uuid,
1360 
1361 
1362 
1378  const OrthancPluginWorklistQuery* query,
1379  const char* issuerAet,
1380  const char* calledAet);
1381 
1382 
1383 
1408  OrthancPluginHttpMethod method,
1409  const char* uri,
1410  const char* ip,
1411  uint32_t headersCount,
1412  const char* const* headersKeys,
1413  const char* const* headersValues);
1414 
1415 
1416 
1443  OrthancPluginHttpMethod method,
1444  const char* uri,
1445  const char* ip,
1446  uint32_t headersCount,
1447  const char* const* headersKeys,
1448  const char* const* headersValues,
1449  uint32_t getArgumentsCount,
1450  const char* const* getArgumentsKeys,
1451  const char* const* getArgumentsValues);
1452 
1453 
1454 
1470  OrthancPluginFindAnswers* answers,
1471  const OrthancPluginFindQuery* query,
1472  const char* issuerAet,
1473  const char* calledAet);
1474 
1475 
1476 
1512  typedef void* (*OrthancPluginMoveCallback) (
1513  OrthancPluginResourceType resourceType,
1514  const char* patientId,
1515  const char* accessionNumber,
1516  const char* studyInstanceUid,
1517  const char* seriesInstanceUid,
1518  const char* sopInstanceUid,
1519  const char* originatorAet,
1520  const char* sourceAet,
1521  const char* targetAet,
1522  uint16_t originatorId);
1523 
1524 
1537  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1538 
1539 
1552  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1553 
1554 
1566  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1567 
1568 
1579  typedef void (*OrthancPluginJobFinalize) (void* job);
1580 
1581 
1592  typedef float (*OrthancPluginJobGetProgress) (void* job);
1593 
1594 
1608  typedef const char* (*OrthancPluginJobGetContent) (void* job);
1609 
1610 
1627  void* job);
1628 
1629 
1646  typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1647 
1648 
1667  void* job);
1668 
1669 
1683 
1684 
1708 
1709 
1724 
1725 
1739  typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1740  const char* serialized);
1741 
1742 
1743 
1759 
1760 
1761 
1789  uint32_t levelDepth,
1790  const uint16_t* levelTagGroup,
1791  const uint16_t* levelTagElement,
1792  const uint32_t* levelIndex,
1793  uint16_t tagGroup,
1794  uint16_t tagElement,
1796 
1797 
1798 
1827  uint32_t levelDepth,
1828  const uint16_t* levelTagGroup,
1829  const uint16_t* levelTagElement,
1830  const uint32_t* levelIndex,
1831  uint16_t tagGroup,
1832  uint16_t tagElement,
1834  void* payload);
1835 
1836 
1837 
1841  typedef struct _OrthancPluginContext_t
1842  {
1843  void* pluginsManager;
1844  const char* orthancVersion;
1845  OrthancPluginFree Free;
1846  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1847  _OrthancPluginService service,
1848  const void* params);
1850 
1851 
1852 
1856  typedef struct
1857  {
1858  uint16_t group;
1859  uint16_t element;
1861  uint32_t minMultiplicity;
1862  uint32_t maxMultiplicity;
1864 
1865 
1866 
1875  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1876  OrthancPluginContext* context,
1877  char* str)
1878  {
1879  if (str != NULL)
1880  {
1881  context->Free(str);
1882  }
1883  }
1884 
1885 
1905  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1906  OrthancPluginContext* context,
1907  int expectedMajor,
1908  int expectedMinor,
1909  int expectedRevision)
1910  {
1911  int major, minor, revision;
1912 
1913  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1914  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1915  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1916  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1917  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1918  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1919  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1920  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1921  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1922  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1923  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1924  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1925  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1926  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1927  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1928  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1929  sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1930  sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
1931  sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
1932  sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
1933  sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason) ||
1934  sizeof(int32_t) != sizeof(OrthancPluginLoadDicomInstanceMode))
1935  {
1936  /* Mismatch in the size of the enumerations */
1937  return 0;
1938  }
1939 
1940  /* Assume compatibility with the mainline */
1941  if (!strcmp(context->orthancVersion, "mainline"))
1942  {
1943  return 1;
1944  }
1945 
1946  /* Parse the version of the Orthanc core */
1947  if (
1948 #ifdef _MSC_VER
1949  sscanf_s
1950 #else
1951  sscanf
1952 #endif
1953  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1954  {
1955  return 0;
1956  }
1957 
1958  /* Check the major number of the version */
1959 
1960  if (major > expectedMajor)
1961  {
1962  return 1;
1963  }
1964 
1965  if (major < expectedMajor)
1966  {
1967  return 0;
1968  }
1969 
1970  /* Check the minor number of the version */
1971 
1972  if (minor > expectedMinor)
1973  {
1974  return 1;
1975  }
1976 
1977  if (minor < expectedMinor)
1978  {
1979  return 0;
1980  }
1981 
1982  /* Check the revision number of the version */
1983 
1984  if (revision >= expectedRevision)
1985  {
1986  return 1;
1987  }
1988  else
1989  {
1990  return 0;
1991  }
1992  }
1993 
1994 
2011  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
2012  OrthancPluginContext* context)
2013  {
2015  context,
2016  ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
2017  ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
2018  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
2019  }
2020 
2021 
2030  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
2031  OrthancPluginContext* context,
2032  OrthancPluginMemoryBuffer* buffer)
2033  {
2034  context->Free(buffer->data);
2035  }
2036 
2037 
2046  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer64(
2047  OrthancPluginContext* context,
2049  {
2050  context->Free(buffer->data);
2051  }
2052 
2053 
2062  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
2063  OrthancPluginContext* context,
2064  const char* message)
2065  {
2066  context->InvokeService(context, _OrthancPluginService_LogError, message);
2067  }
2068 
2069 
2078  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
2079  OrthancPluginContext* context,
2080  const char* message)
2081  {
2082  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
2083  }
2084 
2085 
2094  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
2095  OrthancPluginContext* context,
2096  const char* message)
2097  {
2098  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
2099  }
2100 
2101 
2102 
2103  typedef struct
2104  {
2105  const char* pathRegularExpression;
2106  OrthancPluginRestCallback callback;
2107  } _OrthancPluginRestCallback;
2108 
2130  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
2131  OrthancPluginContext* context,
2132  const char* pathRegularExpression,
2133  OrthancPluginRestCallback callback)
2134  {
2135  _OrthancPluginRestCallback params;
2136  params.pathRegularExpression = pathRegularExpression;
2137  params.callback = callback;
2138  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
2139  }
2140 
2141 
2142 
2170  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
2171  OrthancPluginContext* context,
2172  const char* pathRegularExpression,
2173  OrthancPluginRestCallback callback)
2174  {
2175  _OrthancPluginRestCallback params;
2176  params.pathRegularExpression = pathRegularExpression;
2177  params.callback = callback;
2178  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
2179  }
2180 
2181 
2182 
2183  typedef struct
2184  {
2186  } _OrthancPluginOnStoredInstanceCallback;
2187 
2209  OrthancPluginContext* context,
2211  {
2212  _OrthancPluginOnStoredInstanceCallback params;
2213  params.callback = callback;
2214 
2215  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
2216  }
2217 
2218 
2219 
2220  typedef struct
2221  {
2222  OrthancPluginRestOutput* output;
2223  const void* answer;
2224  uint32_t answerSize;
2225  const char* mimeType;
2226  } _OrthancPluginAnswerBuffer;
2227 
2240  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
2241  OrthancPluginContext* context,
2242  OrthancPluginRestOutput* output,
2243  const void* answer,
2244  uint32_t answerSize,
2245  const char* mimeType)
2246  {
2247  _OrthancPluginAnswerBuffer params;
2248  params.output = output;
2249  params.answer = answer;
2250  params.answerSize = answerSize;
2251  params.mimeType = mimeType;
2252  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
2253  }
2254 
2255 
2256  typedef struct
2257  {
2258  OrthancPluginRestOutput* output;
2259  OrthancPluginPixelFormat format;
2260  uint32_t width;
2261  uint32_t height;
2262  uint32_t pitch;
2263  const void* buffer;
2264  } _OrthancPluginCompressAndAnswerPngImage;
2265 
2266  typedef struct
2267  {
2268  OrthancPluginRestOutput* output;
2269  OrthancPluginImageFormat imageFormat;
2270  OrthancPluginPixelFormat pixelFormat;
2271  uint32_t width;
2272  uint32_t height;
2273  uint32_t pitch;
2274  const void* buffer;
2275  uint8_t quality;
2276  } _OrthancPluginCompressAndAnswerImage;
2277 
2278 
2297  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2298  OrthancPluginContext* context,
2299  OrthancPluginRestOutput* output,
2300  OrthancPluginPixelFormat format,
2301  uint32_t width,
2302  uint32_t height,
2303  uint32_t pitch,
2304  const void* buffer)
2305  {
2306  _OrthancPluginCompressAndAnswerImage params;
2307  params.output = output;
2308  params.imageFormat = OrthancPluginImageFormat_Png;
2309  params.pixelFormat = format;
2310  params.width = width;
2311  params.height = height;
2312  params.pitch = pitch;
2313  params.buffer = buffer;
2314  params.quality = 0; /* No quality for PNG */
2315  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2316  }
2317 
2318 
2319 
2320  typedef struct
2321  {
2322  OrthancPluginMemoryBuffer* target;
2323  const char* instanceId;
2324  } _OrthancPluginGetDicomForInstance;
2325 
2339  OrthancPluginContext* context,
2340  OrthancPluginMemoryBuffer* target,
2341  const char* instanceId)
2342  {
2343  _OrthancPluginGetDicomForInstance params;
2344  params.target = target;
2345  params.instanceId = instanceId;
2346  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2347  }
2348 
2349 
2350 
2351  typedef struct
2352  {
2353  OrthancPluginMemoryBuffer* target;
2354  const char* uri;
2355  } _OrthancPluginRestApiGet;
2356 
2372  OrthancPluginContext* context,
2373  OrthancPluginMemoryBuffer* target,
2374  const char* uri)
2375  {
2376  _OrthancPluginRestApiGet params;
2377  params.target = target;
2378  params.uri = uri;
2379  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2380  }
2381 
2382 
2383 
2402  OrthancPluginContext* context,
2403  OrthancPluginMemoryBuffer* target,
2404  const char* uri)
2405  {
2406  _OrthancPluginRestApiGet params;
2407  params.target = target;
2408  params.uri = uri;
2409  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2410  }
2411 
2412 
2413 
2414  typedef struct
2415  {
2416  OrthancPluginMemoryBuffer* target;
2417  const char* uri;
2418  const void* body;
2419  uint32_t bodySize;
2420  } _OrthancPluginRestApiPostPut;
2421 
2439  OrthancPluginContext* context,
2440  OrthancPluginMemoryBuffer* target,
2441  const char* uri,
2442  const void* body,
2443  uint32_t bodySize)
2444  {
2445  _OrthancPluginRestApiPostPut params;
2446  params.target = target;
2447  params.uri = uri;
2448  params.body = body;
2449  params.bodySize = bodySize;
2450  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2451  }
2452 
2453 
2474  OrthancPluginContext* context,
2475  OrthancPluginMemoryBuffer* target,
2476  const char* uri,
2477  const void* body,
2478  uint32_t bodySize)
2479  {
2480  _OrthancPluginRestApiPostPut params;
2481  params.target = target;
2482  params.uri = uri;
2483  params.body = body;
2484  params.bodySize = bodySize;
2485  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2486  }
2487 
2488 
2489 
2503  OrthancPluginContext* context,
2504  const char* uri)
2505  {
2506  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2507  }
2508 
2509 
2526  OrthancPluginContext* context,
2527  const char* uri)
2528  {
2529  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2530  }
2531 
2532 
2533 
2551  OrthancPluginContext* context,
2552  OrthancPluginMemoryBuffer* target,
2553  const char* uri,
2554  const void* body,
2555  uint32_t bodySize)
2556  {
2557  _OrthancPluginRestApiPostPut params;
2558  params.target = target;
2559  params.uri = uri;
2560  params.body = body;
2561  params.bodySize = bodySize;
2562  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2563  }
2564 
2565 
2566 
2587  OrthancPluginContext* context,
2588  OrthancPluginMemoryBuffer* target,
2589  const char* uri,
2590  const void* body,
2591  uint32_t bodySize)
2592  {
2593  _OrthancPluginRestApiPostPut params;
2594  params.target = target;
2595  params.uri = uri;
2596  params.body = body;
2597  params.bodySize = bodySize;
2598  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2599  }
2600 
2601 
2602 
2603  typedef struct
2604  {
2605  OrthancPluginRestOutput* output;
2606  const char* argument;
2607  } _OrthancPluginOutputPlusArgument;
2608 
2620  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2621  OrthancPluginContext* context,
2622  OrthancPluginRestOutput* output,
2623  const char* redirection)
2624  {
2625  _OrthancPluginOutputPlusArgument params;
2626  params.output = output;
2627  params.argument = redirection;
2628  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2629  }
2630 
2631 
2632 
2633  typedef struct
2634  {
2635  char** result;
2636  const char* argument;
2637  } _OrthancPluginRetrieveDynamicString;
2638 
2652  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2653  OrthancPluginContext* context,
2654  const char* patientID)
2655  {
2656  char* result;
2657 
2658  _OrthancPluginRetrieveDynamicString params;
2659  params.result = &result;
2660  params.argument = patientID;
2661 
2662  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2663  {
2664  /* Error */
2665  return NULL;
2666  }
2667  else
2668  {
2669  return result;
2670  }
2671  }
2672 
2673 
2687  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2688  OrthancPluginContext* context,
2689  const char* studyUID)
2690  {
2691  char* result;
2692 
2693  _OrthancPluginRetrieveDynamicString params;
2694  params.result = &result;
2695  params.argument = studyUID;
2696 
2697  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2698  {
2699  /* Error */
2700  return NULL;
2701  }
2702  else
2703  {
2704  return result;
2705  }
2706  }
2707 
2708 
2722  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
2723  OrthancPluginContext* context,
2724  const char* accessionNumber)
2725  {
2726  char* result;
2727 
2728  _OrthancPluginRetrieveDynamicString params;
2729  params.result = &result;
2730  params.argument = accessionNumber;
2731 
2732  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2733  {
2734  /* Error */
2735  return NULL;
2736  }
2737  else
2738  {
2739  return result;
2740  }
2741  }
2742 
2743 
2757  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2758  OrthancPluginContext* context,
2759  const char* seriesUID)
2760  {
2761  char* result;
2762 
2763  _OrthancPluginRetrieveDynamicString params;
2764  params.result = &result;
2765  params.argument = seriesUID;
2766 
2767  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2768  {
2769  /* Error */
2770  return NULL;
2771  }
2772  else
2773  {
2774  return result;
2775  }
2776  }
2777 
2778 
2792  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2793  OrthancPluginContext* context,
2794  const char* sopInstanceUID)
2795  {
2796  char* result;
2797 
2798  _OrthancPluginRetrieveDynamicString params;
2799  params.result = &result;
2800  params.argument = sopInstanceUID;
2801 
2802  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2803  {
2804  /* Error */
2805  return NULL;
2806  }
2807  else
2808  {
2809  return result;
2810  }
2811  }
2812 
2813 
2814 
2815  typedef struct
2816  {
2817  OrthancPluginRestOutput* output;
2818  uint16_t status;
2819  } _OrthancPluginSendHttpStatusCode;
2820 
2837  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2838  OrthancPluginContext* context,
2839  OrthancPluginRestOutput* output,
2840  uint16_t status)
2841  {
2842  _OrthancPluginSendHttpStatusCode params;
2843  params.output = output;
2844  params.status = status;
2845  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2846  }
2847 
2848 
2860  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2861  OrthancPluginContext* context,
2862  OrthancPluginRestOutput* output,
2863  const char* realm)
2864  {
2865  _OrthancPluginOutputPlusArgument params;
2866  params.output = output;
2867  params.argument = realm;
2868  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2869  }
2870 
2871 
2883  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2884  OrthancPluginContext* context,
2885  OrthancPluginRestOutput* output,
2886  const char* allowedMethods)
2887  {
2888  _OrthancPluginOutputPlusArgument params;
2889  params.output = output;
2890  params.argument = allowedMethods;
2891  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2892  }
2893 
2894 
2895  typedef struct
2896  {
2897  OrthancPluginRestOutput* output;
2898  const char* key;
2899  const char* value;
2900  } _OrthancPluginSetHttpHeader;
2901 
2913  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2914  OrthancPluginContext* context,
2915  OrthancPluginRestOutput* output,
2916  const char* cookie,
2917  const char* value)
2918  {
2919  _OrthancPluginSetHttpHeader params;
2920  params.output = output;
2921  params.key = cookie;
2922  params.value = value;
2923  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2924  }
2925 
2926 
2938  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2939  OrthancPluginContext* context,
2940  OrthancPluginRestOutput* output,
2941  const char* key,
2942  const char* value)
2943  {
2944  _OrthancPluginSetHttpHeader params;
2945  params.output = output;
2946  params.key = key;
2947  params.value = value;
2948  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2949  }
2950 
2951 
2952  typedef struct
2953  {
2954  char** resultStringToFree;
2955  const char** resultString;
2956  int64_t* resultInt64;
2957  const char* key;
2958  const OrthancPluginDicomInstance* instance;
2959  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2960  } _OrthancPluginAccessDicomInstance;
2961 
2962 
2974  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2975  OrthancPluginContext* context,
2976  const OrthancPluginDicomInstance* instance)
2977  {
2978  const char* result;
2979 
2980  _OrthancPluginAccessDicomInstance params;
2981  memset(&params, 0, sizeof(params));
2982  params.resultString = &result;
2983  params.instance = instance;
2984 
2985  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2986  {
2987  /* Error */
2988  return NULL;
2989  }
2990  else
2991  {
2992  return result;
2993  }
2994  }
2995 
2996 
3007  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
3008  OrthancPluginContext* context,
3009  const OrthancPluginDicomInstance* instance)
3010  {
3011  int64_t size;
3012 
3013  _OrthancPluginAccessDicomInstance params;
3014  memset(&params, 0, sizeof(params));
3015  params.resultInt64 = &size;
3016  params.instance = instance;
3017 
3018  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
3019  {
3020  /* Error */
3021  return -1;
3022  }
3023  else
3024  {
3025  return size;
3026  }
3027  }
3028 
3029 
3040  ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData(
3041  OrthancPluginContext* context,
3042  const OrthancPluginDicomInstance* instance)
3043  {
3044  const char* result;
3045 
3046  _OrthancPluginAccessDicomInstance params;
3047  memset(&params, 0, sizeof(params));
3048  params.resultString = &result;
3049  params.instance = instance;
3050 
3051  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
3052  {
3053  /* Error */
3054  return NULL;
3055  }
3056  else
3057  {
3058  return result;
3059  }
3060  }
3061 
3062 
3076  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
3077  OrthancPluginContext* context,
3078  const OrthancPluginDicomInstance* instance)
3079  {
3080  char* result;
3081 
3082  _OrthancPluginAccessDicomInstance params;
3083  memset(&params, 0, sizeof(params));
3084  params.resultStringToFree = &result;
3085  params.instance = instance;
3086 
3087  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
3088  {
3089  /* Error */
3090  return NULL;
3091  }
3092  else
3093  {
3094  return result;
3095  }
3096  }
3097 
3098 
3114  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
3115  OrthancPluginContext* context,
3116  const OrthancPluginDicomInstance* instance)
3117  {
3118  char* result;
3119 
3120  _OrthancPluginAccessDicomInstance params;
3121  memset(&params, 0, sizeof(params));
3122  params.resultStringToFree = &result;
3123  params.instance = instance;
3124 
3125  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
3126  {
3127  /* Error */
3128  return NULL;
3129  }
3130  else
3131  {
3132  return result;
3133  }
3134  }
3135 
3136 
3153  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
3154  OrthancPluginContext* context,
3155  const OrthancPluginDicomInstance* instance,
3156  const char* metadata)
3157  {
3158  int64_t result;
3159 
3160  _OrthancPluginAccessDicomInstance params;
3161  memset(&params, 0, sizeof(params));
3162  params.resultInt64 = &result;
3163  params.instance = instance;
3164  params.key = metadata;
3165 
3166  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3167  {
3168  /* Error */
3169  return -1;
3170  }
3171  else
3172  {
3173  return (result != 0);
3174  }
3175  }
3176 
3177 
3194  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
3195  OrthancPluginContext* context,
3196  const OrthancPluginDicomInstance* instance,
3197  const char* metadata)
3198  {
3199  const char* result;
3200 
3201  _OrthancPluginAccessDicomInstance params;
3202  memset(&params, 0, sizeof(params));
3203  params.resultString = &result;
3204  params.instance = instance;
3205  params.key = metadata;
3206 
3207  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3208  {
3209  /* Error */
3210  return NULL;
3211  }
3212  else
3213  {
3214  return result;
3215  }
3216  }
3217 
3218 
3219 
3220  typedef struct
3221  {
3225  OrthancPluginFree free;
3226  } _OrthancPluginRegisterStorageArea;
3227 
3243  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
3244  OrthancPluginContext* context,
3248  {
3249  _OrthancPluginRegisterStorageArea params;
3250  params.create = create;
3251  params.read = read;
3252  params.remove = remove;
3253 
3254 #ifdef __cplusplus
3255  params.free = ::free;
3256 #else
3257  params.free = free;
3258 #endif
3259 
3260  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3261  }
3262 
3263 
3264 
3275  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3276  {
3277  char* result;
3278 
3279  _OrthancPluginRetrieveDynamicString params;
3280  params.result = &result;
3281  params.argument = NULL;
3282 
3283  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3284  {
3285  /* Error */
3286  return NULL;
3287  }
3288  else
3289  {
3290  return result;
3291  }
3292  }
3293 
3294 
3305  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3306  {
3307  char* result;
3308 
3309  _OrthancPluginRetrieveDynamicString params;
3310  params.result = &result;
3311  params.argument = NULL;
3312 
3313  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3314  {
3315  /* Error */
3316  return NULL;
3317  }
3318  else
3319  {
3320  return result;
3321  }
3322  }
3323 
3324 
3340  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3341  {
3342  char* result;
3343 
3344  _OrthancPluginRetrieveDynamicString params;
3345  params.result = &result;
3346  params.argument = NULL;
3347 
3348  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3349  {
3350  /* Error */
3351  return NULL;
3352  }
3353  else
3354  {
3355  return result;
3356  }
3357  }
3358 
3359 
3360 
3361  typedef struct
3362  {
3364  } _OrthancPluginOnChangeCallback;
3365 
3386  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3387  OrthancPluginContext* context,
3389  {
3390  _OrthancPluginOnChangeCallback params;
3391  params.callback = callback;
3392 
3393  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3394  }
3395 
3396 
3397 
3398  typedef struct
3399  {
3400  const char* plugin;
3401  _OrthancPluginProperty property;
3402  const char* value;
3403  } _OrthancPluginSetPluginProperty;
3404 
3405 
3417  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3418  OrthancPluginContext* context,
3419  const char* uri)
3420  {
3421  _OrthancPluginSetPluginProperty params;
3422  params.plugin = OrthancPluginGetName();
3423  params.property = _OrthancPluginProperty_RootUri;
3424  params.value = uri;
3425 
3426  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3427  }
3428 
3429 
3439  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3440  OrthancPluginContext* context,
3441  const char* description)
3442  {
3443  _OrthancPluginSetPluginProperty params;
3444  params.plugin = OrthancPluginGetName();
3445  params.property = _OrthancPluginProperty_Description;
3446  params.value = description;
3447 
3448  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3449  }
3450 
3451 
3461  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3462  OrthancPluginContext* context,
3463  const char* javascript)
3464  {
3465  _OrthancPluginSetPluginProperty params;
3466  params.plugin = OrthancPluginGetName();
3467  params.property = _OrthancPluginProperty_OrthancExplorer;
3468  params.value = javascript;
3469 
3470  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3471  }
3472 
3473 
3474  typedef struct
3475  {
3476  char** result;
3477  int32_t property;
3478  const char* value;
3479  } _OrthancPluginGlobalProperty;
3480 
3481 
3495  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3496  OrthancPluginContext* context,
3497  int32_t property,
3498  const char* defaultValue)
3499  {
3500  char* result;
3501 
3502  _OrthancPluginGlobalProperty params;
3503  params.result = &result;
3504  params.property = property;
3505  params.value = defaultValue;
3506 
3507  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3508  {
3509  /* Error */
3510  return NULL;
3511  }
3512  else
3513  {
3514  return result;
3515  }
3516  }
3517 
3518 
3535  OrthancPluginContext* context,
3536  int32_t property,
3537  const char* value)
3538  {
3539  _OrthancPluginGlobalProperty params;
3540  params.result = NULL;
3541  params.property = property;
3542  params.value = value;
3543 
3544  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3545  }
3546 
3547 
3548 
3549  typedef struct
3550  {
3551  int32_t *resultInt32;
3552  uint32_t *resultUint32;
3553  int64_t *resultInt64;
3554  uint64_t *resultUint64;
3555  } _OrthancPluginReturnSingleValue;
3556 
3565  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3566  OrthancPluginContext* context)
3567  {
3568  uint32_t count = 0;
3569 
3570  _OrthancPluginReturnSingleValue params;
3571  memset(&params, 0, sizeof(params));
3572  params.resultUint32 = &count;
3573 
3574  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3575  {
3576  /* Error */
3577  return 0;
3578  }
3579  else
3580  {
3581  return count;
3582  }
3583  }
3584 
3585 
3586 
3599  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3600  OrthancPluginContext* context,
3601  uint32_t argument)
3602  {
3603  char* result;
3604 
3605  _OrthancPluginGlobalProperty params;
3606  params.result = &result;
3607  params.property = (int32_t) argument;
3608  params.value = NULL;
3609 
3610  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3611  {
3612  /* Error */
3613  return NULL;
3614  }
3615  else
3616  {
3617  return result;
3618  }
3619  }
3620 
3621 
3631  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3632  OrthancPluginContext* context)
3633  {
3634  uint32_t count = 0;
3635 
3636  _OrthancPluginReturnSingleValue params;
3637  memset(&params, 0, sizeof(params));
3638  params.resultUint32 = &count;
3639 
3640  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3641  {
3642  /* Error */
3643  return 0;
3644  }
3645  else
3646  {
3647  return count;
3648  }
3649  }
3650 
3651 
3652 
3664  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3665  {
3666  char* result;
3667 
3668  _OrthancPluginRetrieveDynamicString params;
3669  params.result = &result;
3670  params.argument = NULL;
3671 
3672  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3673  {
3674  /* Error */
3675  return NULL;
3676  }
3677  else
3678  {
3679  return result;
3680  }
3681  }
3682 
3683 
3684 
3685  typedef struct
3686  {
3687  OrthancPluginRestOutput* output;
3688  const char* subType;
3689  const char* contentType;
3690  } _OrthancPluginStartMultipartAnswer;
3691 
3706  OrthancPluginContext* context,
3707  OrthancPluginRestOutput* output,
3708  const char* subType,
3709  const char* contentType)
3710  {
3711  _OrthancPluginStartMultipartAnswer params;
3712  params.output = output;
3713  params.subType = subType;
3714  params.contentType = contentType;
3715  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3716  }
3717 
3718 
3735  OrthancPluginContext* context,
3736  OrthancPluginRestOutput* output,
3737  const void* answer,
3738  uint32_t answerSize)
3739  {
3740  _OrthancPluginAnswerBuffer params;
3741  params.output = output;
3742  params.answer = answer;
3743  params.answerSize = answerSize;
3744  params.mimeType = NULL;
3745  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3746  }
3747 
3748 
3749 
3750  typedef struct
3751  {
3752  OrthancPluginMemoryBuffer* target;
3753  const void* source;
3754  uint32_t size;
3755  OrthancPluginCompressionType compression;
3756  uint8_t uncompress;
3757  } _OrthancPluginBufferCompression;
3758 
3759 
3777  OrthancPluginContext* context,
3778  OrthancPluginMemoryBuffer* target,
3779  const void* source,
3780  uint32_t size,
3781  OrthancPluginCompressionType compression,
3782  uint8_t uncompress)
3783  {
3784  _OrthancPluginBufferCompression params;
3785  params.target = target;
3786  params.source = source;
3787  params.size = size;
3788  params.compression = compression;
3789  params.uncompress = uncompress;
3790 
3791  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3792  }
3793 
3794 
3795 
3796  typedef struct
3797  {
3798  OrthancPluginMemoryBuffer* target;
3799  const char* path;
3800  } _OrthancPluginReadFile;
3801 
3814  OrthancPluginContext* context,
3815  OrthancPluginMemoryBuffer* target,
3816  const char* path)
3817  {
3818  _OrthancPluginReadFile params;
3819  params.target = target;
3820  params.path = path;
3821  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3822  }
3823 
3824 
3825 
3826  typedef struct
3827  {
3828  const char* path;
3829  const void* data;
3830  uint32_t size;
3831  } _OrthancPluginWriteFile;
3832 
3845  OrthancPluginContext* context,
3846  const char* path,
3847  const void* data,
3848  uint32_t size)
3849  {
3850  _OrthancPluginWriteFile params;
3851  params.path = path;
3852  params.data = data;
3853  params.size = size;
3854  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3855  }
3856 
3857 
3858 
3859  typedef struct
3860  {
3861  const char** target;
3862  OrthancPluginErrorCode error;
3863  } _OrthancPluginGetErrorDescription;
3864 
3875  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3876  OrthancPluginContext* context,
3877  OrthancPluginErrorCode error)
3878  {
3879  const char* result = NULL;
3880 
3881  _OrthancPluginGetErrorDescription params;
3882  params.target = &result;
3883  params.error = error;
3884 
3885  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3886  result == NULL)
3887  {
3888  return "Unknown error code";
3889  }
3890  else
3891  {
3892  return result;
3893  }
3894  }
3895 
3896 
3897 
3898  typedef struct
3899  {
3900  OrthancPluginRestOutput* output;
3901  uint16_t status;
3902  const void* body;
3903  uint32_t bodySize;
3904  } _OrthancPluginSendHttpStatus;
3905 
3928  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3929  OrthancPluginContext* context,
3930  OrthancPluginRestOutput* output,
3931  uint16_t status,
3932  const void* body,
3933  uint32_t bodySize)
3934  {
3935  _OrthancPluginSendHttpStatus params;
3936  params.output = output;
3937  params.status = status;
3938  params.body = body;
3939  params.bodySize = bodySize;
3940  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3941  }
3942 
3943 
3944 
3945  typedef struct
3946  {
3947  const OrthancPluginImage* image;
3948  uint32_t* resultUint32;
3949  OrthancPluginPixelFormat* resultPixelFormat;
3950  void** resultBuffer;
3951  } _OrthancPluginGetImageInfo;
3952 
3953 
3965  OrthancPluginContext* context,
3966  const OrthancPluginImage* image)
3967  {
3968  OrthancPluginPixelFormat target;
3969 
3970  _OrthancPluginGetImageInfo params;
3971  memset(&params, 0, sizeof(params));
3972  params.image = image;
3973  params.resultPixelFormat = &target;
3974 
3975  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3976  {
3978  }
3979  else
3980  {
3981  return (OrthancPluginPixelFormat) target;
3982  }
3983  }
3984 
3985 
3986 
3997  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3998  OrthancPluginContext* context,
3999  const OrthancPluginImage* image)
4000  {
4001  uint32_t width;
4002 
4003  _OrthancPluginGetImageInfo params;
4004  memset(&params, 0, sizeof(params));
4005  params.image = image;
4006  params.resultUint32 = &width;
4007 
4008  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
4009  {
4010  return 0;
4011  }
4012  else
4013  {
4014  return width;
4015  }
4016  }
4017 
4018 
4019 
4030  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
4031  OrthancPluginContext* context,
4032  const OrthancPluginImage* image)
4033  {
4034  uint32_t height;
4035 
4036  _OrthancPluginGetImageInfo params;
4037  memset(&params, 0, sizeof(params));
4038  params.image = image;
4039  params.resultUint32 = &height;
4040 
4041  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
4042  {
4043  return 0;
4044  }
4045  else
4046  {
4047  return height;
4048  }
4049  }
4050 
4051 
4052 
4065  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
4066  OrthancPluginContext* context,
4067  const OrthancPluginImage* image)
4068  {
4069  uint32_t pitch;
4070 
4071  _OrthancPluginGetImageInfo params;
4072  memset(&params, 0, sizeof(params));
4073  params.image = image;
4074  params.resultUint32 = &pitch;
4075 
4076  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
4077  {
4078  return 0;
4079  }
4080  else
4081  {
4082  return pitch;
4083  }
4084  }
4085 
4086 
4087 
4099  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
4100  OrthancPluginContext* context,
4101  const OrthancPluginImage* image)
4102  {
4103  void* target = NULL;
4104 
4105  _OrthancPluginGetImageInfo params;
4106  memset(&params, 0, sizeof(params));
4107  params.resultBuffer = &target;
4108  params.image = image;
4109 
4110  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
4111  {
4112  return NULL;
4113  }
4114  else
4115  {
4116  return target;
4117  }
4118  }
4119 
4120 
4121  typedef struct
4122  {
4123  OrthancPluginImage** target;
4124  const void* data;
4125  uint32_t size;
4126  OrthancPluginImageFormat format;
4127  } _OrthancPluginUncompressImage;
4128 
4129 
4143  OrthancPluginContext* context,
4144  const void* data,
4145  uint32_t size,
4146  OrthancPluginImageFormat format)
4147  {
4148  OrthancPluginImage* target = NULL;
4149 
4150  _OrthancPluginUncompressImage params;
4151  memset(&params, 0, sizeof(params));
4152  params.target = &target;
4153  params.data = data;
4154  params.size = size;
4155  params.format = format;
4156 
4157  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
4158  {
4159  return NULL;
4160  }
4161  else
4162  {
4163  return target;
4164  }
4165  }
4166 
4167 
4168 
4169 
4170  typedef struct
4171  {
4172  OrthancPluginImage* image;
4173  } _OrthancPluginFreeImage;
4174 
4184  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
4185  OrthancPluginContext* context,
4186  OrthancPluginImage* image)
4187  {
4188  _OrthancPluginFreeImage params;
4189  params.image = image;
4190 
4191  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
4192  }
4193 
4194 
4195 
4196 
4197  typedef struct
4198  {
4199  OrthancPluginMemoryBuffer* target;
4200  OrthancPluginImageFormat imageFormat;
4201  OrthancPluginPixelFormat pixelFormat;
4202  uint32_t width;
4203  uint32_t height;
4204  uint32_t pitch;
4205  const void* buffer;
4206  uint8_t quality;
4207  } _OrthancPluginCompressImage;
4208 
4209 
4230  OrthancPluginContext* context,
4231  OrthancPluginMemoryBuffer* target,
4232  OrthancPluginPixelFormat format,
4233  uint32_t width,
4234  uint32_t height,
4235  uint32_t pitch,
4236  const void* buffer)
4237  {
4238  _OrthancPluginCompressImage params;
4239  memset(&params, 0, sizeof(params));
4240  params.target = target;
4241  params.imageFormat = OrthancPluginImageFormat_Png;
4242  params.pixelFormat = format;
4243  params.width = width;
4244  params.height = height;
4245  params.pitch = pitch;
4246  params.buffer = buffer;
4247  params.quality = 0; /* Unused for PNG */
4248 
4249  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4250  }
4251 
4252 
4275  OrthancPluginContext* context,
4276  OrthancPluginMemoryBuffer* target,
4277  OrthancPluginPixelFormat format,
4278  uint32_t width,
4279  uint32_t height,
4280  uint32_t pitch,
4281  const void* buffer,
4282  uint8_t quality)
4283  {
4284  _OrthancPluginCompressImage params;
4285  memset(&params, 0, sizeof(params));
4286  params.target = target;
4287  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4288  params.pixelFormat = format;
4289  params.width = width;
4290  params.height = height;
4291  params.pitch = pitch;
4292  params.buffer = buffer;
4293  params.quality = quality;
4294 
4295  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4296  }
4297 
4298 
4299 
4321  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
4322  OrthancPluginContext* context,
4323  OrthancPluginRestOutput* output,
4324  OrthancPluginPixelFormat format,
4325  uint32_t width,
4326  uint32_t height,
4327  uint32_t pitch,
4328  const void* buffer,
4329  uint8_t quality)
4330  {
4331  _OrthancPluginCompressAndAnswerImage params;
4332  params.output = output;
4333  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4334  params.pixelFormat = format;
4335  params.width = width;
4336  params.height = height;
4337  params.pitch = pitch;
4338  params.buffer = buffer;
4339  params.quality = quality;
4340  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4341  }
4342 
4343 
4344 
4345 
4346  typedef struct
4347  {
4348  OrthancPluginMemoryBuffer* target;
4349  OrthancPluginHttpMethod method;
4350  const char* url;
4351  const char* username;
4352  const char* password;
4353  const void* body;
4354  uint32_t bodySize;
4355  } _OrthancPluginCallHttpClient;
4356 
4357 
4375  OrthancPluginContext* context,
4376  OrthancPluginMemoryBuffer* target,
4377  const char* url,
4378  const char* username,
4379  const char* password)
4380  {
4381  _OrthancPluginCallHttpClient params;
4382  memset(&params, 0, sizeof(params));
4383 
4384  params.target = target;
4385  params.method = OrthancPluginHttpMethod_Get;
4386  params.url = url;
4387  params.username = username;
4388  params.password = password;
4389 
4390  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4391  }
4392 
4393 
4413  OrthancPluginContext* context,
4414  OrthancPluginMemoryBuffer* target,
4415  const char* url,
4416  const void* body,
4417  uint32_t bodySize,
4418  const char* username,
4419  const char* password)
4420  {
4421  _OrthancPluginCallHttpClient params;
4422  memset(&params, 0, sizeof(params));
4423 
4424  params.target = target;
4425  params.method = OrthancPluginHttpMethod_Post;
4426  params.url = url;
4427  params.body = body;
4428  params.bodySize = bodySize;
4429  params.username = username;
4430  params.password = password;
4431 
4432  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4433  }
4434 
4435 
4455  OrthancPluginContext* context,
4456  OrthancPluginMemoryBuffer* target,
4457  const char* url,
4458  const void* body,
4459  uint32_t bodySize,
4460  const char* username,
4461  const char* password)
4462  {
4463  _OrthancPluginCallHttpClient params;
4464  memset(&params, 0, sizeof(params));
4465 
4466  params.target = target;
4467  params.method = OrthancPluginHttpMethod_Put;
4468  params.url = url;
4469  params.body = body;
4470  params.bodySize = bodySize;
4471  params.username = username;
4472  params.password = password;
4473 
4474  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4475  }
4476 
4477 
4493  OrthancPluginContext* context,
4494  const char* url,
4495  const char* username,
4496  const char* password)
4497  {
4498  _OrthancPluginCallHttpClient params;
4499  memset(&params, 0, sizeof(params));
4500 
4501  params.method = OrthancPluginHttpMethod_Delete;
4502  params.url = url;
4503  params.username = username;
4504  params.password = password;
4505 
4506  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4507  }
4508 
4509 
4510 
4511  typedef struct
4512  {
4513  OrthancPluginImage** target;
4514  const OrthancPluginImage* source;
4515  OrthancPluginPixelFormat targetFormat;
4516  } _OrthancPluginConvertPixelFormat;
4517 
4518 
4531  OrthancPluginContext* context,
4532  const OrthancPluginImage* source,
4533  OrthancPluginPixelFormat targetFormat)
4534  {
4535  OrthancPluginImage* target = NULL;
4536 
4537  _OrthancPluginConvertPixelFormat params;
4538  params.target = &target;
4539  params.source = source;
4540  params.targetFormat = targetFormat;
4541 
4542  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4543  {
4544  return NULL;
4545  }
4546  else
4547  {
4548  return target;
4549  }
4550  }
4551 
4552 
4553 
4565  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4566  OrthancPluginContext* context)
4567  {
4568  uint32_t count = 0;
4569 
4570  _OrthancPluginReturnSingleValue params;
4571  memset(&params, 0, sizeof(params));
4572  params.resultUint32 = &count;
4573 
4574  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4575  {
4576  /* Error */
4577  return 0;
4578  }
4579  else
4580  {
4581  return count;
4582  }
4583  }
4584 
4585 
4586 
4587 
4588  typedef struct
4589  {
4590  uint32_t fontIndex; /* in */
4591  const char** name; /* out */
4592  uint32_t* size; /* out */
4593  } _OrthancPluginGetFontInfo;
4594 
4605  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4606  OrthancPluginContext* context,
4607  uint32_t fontIndex)
4608  {
4609  const char* result = NULL;
4610 
4611  _OrthancPluginGetFontInfo params;
4612  memset(&params, 0, sizeof(params));
4613  params.name = &result;
4614  params.fontIndex = fontIndex;
4615 
4616  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4617  {
4618  return NULL;
4619  }
4620  else
4621  {
4622  return result;
4623  }
4624  }
4625 
4626 
4637  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4638  OrthancPluginContext* context,
4639  uint32_t fontIndex)
4640  {
4641  uint32_t result;
4642 
4643  _OrthancPluginGetFontInfo params;
4644  memset(&params, 0, sizeof(params));
4645  params.size = &result;
4646  params.fontIndex = fontIndex;
4647 
4648  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4649  {
4650  return 0;
4651  }
4652  else
4653  {
4654  return result;
4655  }
4656  }
4657 
4658 
4659 
4660  typedef struct
4661  {
4662  OrthancPluginImage* image;
4663  uint32_t fontIndex;
4664  const char* utf8Text;
4665  int32_t x;
4666  int32_t y;
4667  uint8_t r;
4668  uint8_t g;
4669  uint8_t b;
4670  } _OrthancPluginDrawText;
4671 
4672 
4691  OrthancPluginContext* context,
4692  OrthancPluginImage* image,
4693  uint32_t fontIndex,
4694  const char* utf8Text,
4695  int32_t x,
4696  int32_t y,
4697  uint8_t r,
4698  uint8_t g,
4699  uint8_t b)
4700  {
4701  _OrthancPluginDrawText params;
4702  memset(&params, 0, sizeof(params));
4703  params.image = image;
4704  params.fontIndex = fontIndex;
4705  params.utf8Text = utf8Text;
4706  params.x = x;
4707  params.y = y;
4708  params.r = r;
4709  params.g = g;
4710  params.b = b;
4711 
4712  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4713  }
4714 
4715 
4716 
4717  typedef struct
4718  {
4719  OrthancPluginStorageArea* storageArea;
4720  const char* uuid;
4721  const void* content;
4722  uint64_t size;
4724  } _OrthancPluginStorageAreaCreate;
4725 
4726 
4745  OrthancPluginContext* context,
4746  OrthancPluginStorageArea* storageArea,
4747  const char* uuid,
4748  const void* content,
4749  uint64_t size,
4751  {
4752  _OrthancPluginStorageAreaCreate params;
4753  params.storageArea = storageArea;
4754  params.uuid = uuid;
4755  params.content = content;
4756  params.size = size;
4757  params.type = type;
4758 
4759  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4760  }
4761 
4762 
4763  typedef struct
4764  {
4765  OrthancPluginMemoryBuffer* target;
4766  OrthancPluginStorageArea* storageArea;
4767  const char* uuid;
4769  } _OrthancPluginStorageAreaRead;
4770 
4771 
4789  OrthancPluginContext* context,
4790  OrthancPluginMemoryBuffer* target,
4791  OrthancPluginStorageArea* storageArea,
4792  const char* uuid,
4794  {
4795  _OrthancPluginStorageAreaRead params;
4796  params.target = target;
4797  params.storageArea = storageArea;
4798  params.uuid = uuid;
4799  params.type = type;
4800 
4801  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4802  }
4803 
4804 
4805  typedef struct
4806  {
4807  OrthancPluginStorageArea* storageArea;
4808  const char* uuid;
4810  } _OrthancPluginStorageAreaRemove;
4811 
4828  OrthancPluginContext* context,
4829  OrthancPluginStorageArea* storageArea,
4830  const char* uuid,
4832  {
4833  _OrthancPluginStorageAreaRemove params;
4834  params.storageArea = storageArea;
4835  params.uuid = uuid;
4836  params.type = type;
4837 
4838  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4839  }
4840 
4841 
4842 
4843  typedef struct
4844  {
4845  OrthancPluginErrorCode* target;
4846  int32_t code;
4847  uint16_t httpStatus;
4848  const char* message;
4849  } _OrthancPluginRegisterErrorCode;
4850 
4867  OrthancPluginContext* context,
4868  int32_t code,
4869  uint16_t httpStatus,
4870  const char* message)
4871  {
4872  OrthancPluginErrorCode target;
4873 
4874  _OrthancPluginRegisterErrorCode params;
4875  params.target = &target;
4876  params.code = code;
4877  params.httpStatus = httpStatus;
4878  params.message = message;
4879 
4880  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4881  {
4882  return target;
4883  }
4884  else
4885  {
4886  /* There was an error while assigned the error. Use a generic code. */
4888  }
4889  }
4890 
4891 
4892 
4893  typedef struct
4894  {
4895  uint16_t group;
4896  uint16_t element;
4898  const char* name;
4899  uint32_t minMultiplicity;
4900  uint32_t maxMultiplicity;
4901  } _OrthancPluginRegisterDictionaryTag;
4902 
4923  OrthancPluginContext* context,
4924  uint16_t group,
4925  uint16_t element,
4927  const char* name,
4928  uint32_t minMultiplicity,
4929  uint32_t maxMultiplicity)
4930  {
4931  _OrthancPluginRegisterDictionaryTag params;
4932  params.group = group;
4933  params.element = element;
4934  params.vr = vr;
4935  params.name = name;
4936  params.minMultiplicity = minMultiplicity;
4937  params.maxMultiplicity = maxMultiplicity;
4938 
4939  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4940  }
4941 
4942 
4943 
4944  typedef struct
4945  {
4946  uint16_t group;
4947  uint16_t element;
4949  const char* name;
4950  uint32_t minMultiplicity;
4951  uint32_t maxMultiplicity;
4952  const char* privateCreator;
4953  } _OrthancPluginRegisterPrivateDictionaryTag;
4954 
4976  OrthancPluginContext* context,
4977  uint16_t group,
4978  uint16_t element,
4980  const char* name,
4981  uint32_t minMultiplicity,
4982  uint32_t maxMultiplicity,
4983  const char* privateCreator)
4984  {
4985  _OrthancPluginRegisterPrivateDictionaryTag params;
4986  params.group = group;
4987  params.element = element;
4988  params.vr = vr;
4989  params.name = name;
4990  params.minMultiplicity = minMultiplicity;
4991  params.maxMultiplicity = maxMultiplicity;
4992  params.privateCreator = privateCreator;
4993 
4994  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4995  }
4996 
4997 
4998 
4999  typedef struct
5000  {
5001  OrthancPluginStorageArea* storageArea;
5003  } _OrthancPluginReconstructMainDicomTags;
5004 
5020  OrthancPluginContext* context,
5021  OrthancPluginStorageArea* storageArea,
5023  {
5024  _OrthancPluginReconstructMainDicomTags params;
5025  params.level = level;
5026  params.storageArea = storageArea;
5027 
5028  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
5029  }
5030 
5031 
5032  typedef struct
5033  {
5034  char** result;
5035  const char* instanceId;
5036  const void* buffer;
5037  uint32_t size;
5040  uint32_t maxStringLength;
5041  } _OrthancPluginDicomToJson;
5042 
5043 
5063  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
5064  OrthancPluginContext* context,
5065  const void* buffer,
5066  uint32_t size,
5069  uint32_t maxStringLength)
5070  {
5071  char* result;
5072 
5073  _OrthancPluginDicomToJson params;
5074  memset(&params, 0, sizeof(params));
5075  params.result = &result;
5076  params.buffer = buffer;
5077  params.size = size;
5078  params.format = format;
5079  params.flags = flags;
5080  params.maxStringLength = maxStringLength;
5081 
5082  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
5083  {
5084  /* Error */
5085  return NULL;
5086  }
5087  else
5088  {
5089  return result;
5090  }
5091  }
5092 
5093 
5112  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
5113  OrthancPluginContext* context,
5114  const char* instanceId,
5117  uint32_t maxStringLength)
5118  {
5119  char* result;
5120 
5121  _OrthancPluginDicomToJson params;
5122  memset(&params, 0, sizeof(params));
5123  params.result = &result;
5124  params.instanceId = instanceId;
5125  params.format = format;
5126  params.flags = flags;
5127  params.maxStringLength = maxStringLength;
5128 
5129  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
5130  {
5131  /* Error */
5132  return NULL;
5133  }
5134  else
5135  {
5136  return result;
5137  }
5138  }
5139 
5140 
5141  typedef struct
5142  {
5143  OrthancPluginMemoryBuffer* target;
5144  const char* uri;
5145  uint32_t headersCount;
5146  const char* const* headersKeys;
5147  const char* const* headersValues;
5148  int32_t afterPlugins;
5149  } _OrthancPluginRestApiGet2;
5150 
5171  OrthancPluginContext* context,
5172  OrthancPluginMemoryBuffer* target,
5173  const char* uri,
5174  uint32_t headersCount,
5175  const char* const* headersKeys,
5176  const char* const* headersValues,
5177  int32_t afterPlugins)
5178  {
5179  _OrthancPluginRestApiGet2 params;
5180  params.target = target;
5181  params.uri = uri;
5182  params.headersCount = headersCount;
5183  params.headersKeys = headersKeys;
5184  params.headersValues = headersValues;
5185  params.afterPlugins = afterPlugins;
5186 
5187  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
5188  }
5189 
5190 
5191 
5192  typedef struct
5193  {
5195  } _OrthancPluginWorklistCallback;
5196 
5209  OrthancPluginContext* context,
5211  {
5212  _OrthancPluginWorklistCallback params;
5213  params.callback = callback;
5214 
5215  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
5216  }
5217 
5218 
5219 
5220  typedef struct
5221  {
5223  const OrthancPluginWorklistQuery* query;
5224  const void* dicom;
5225  uint32_t size;
5226  } _OrthancPluginWorklistAnswersOperation;
5227 
5245  OrthancPluginContext* context,
5247  const OrthancPluginWorklistQuery* query,
5248  const void* dicom,
5249  uint32_t size)
5250  {
5251  _OrthancPluginWorklistAnswersOperation params;
5252  params.answers = answers;
5253  params.query = query;
5254  params.dicom = dicom;
5255  params.size = size;
5256 
5257  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
5258  }
5259 
5260 
5275  OrthancPluginContext* context,
5277  {
5278  _OrthancPluginWorklistAnswersOperation params;
5279  params.answers = answers;
5280  params.query = NULL;
5281  params.dicom = NULL;
5282  params.size = 0;
5283 
5284  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5285  }
5286 
5287 
5288  typedef struct
5289  {
5290  const OrthancPluginWorklistQuery* query;
5291  const void* dicom;
5292  uint32_t size;
5293  int32_t* isMatch;
5294  OrthancPluginMemoryBuffer* target;
5295  } _OrthancPluginWorklistQueryOperation;
5296 
5312  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5313  OrthancPluginContext* context,
5314  const OrthancPluginWorklistQuery* query,
5315  const void* dicom,
5316  uint32_t size)
5317  {
5318  int32_t isMatch = 0;
5319 
5320  _OrthancPluginWorklistQueryOperation params;
5321  params.query = query;
5322  params.dicom = dicom;
5323  params.size = size;
5324  params.isMatch = &isMatch;
5325  params.target = NULL;
5326 
5327  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5328  {
5329  return isMatch;
5330  }
5331  else
5332  {
5333  /* Error: Assume non-match */
5334  return 0;
5335  }
5336  }
5337 
5338 
5352  OrthancPluginContext* context,
5353  OrthancPluginMemoryBuffer* target,
5354  const OrthancPluginWorklistQuery* query)
5355  {
5356  _OrthancPluginWorklistQueryOperation params;
5357  params.query = query;
5358  params.dicom = NULL;
5359  params.size = 0;
5360  params.isMatch = NULL;
5361  params.target = target;
5362 
5363  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5364  }
5365 
5366 
5378  OrthancPluginContext* context,
5379  const OrthancPluginDicomInstance* instance)
5380  {
5382 
5383  _OrthancPluginAccessDicomInstance params;
5384  memset(&params, 0, sizeof(params));
5385  params.resultOrigin = &origin;
5386  params.instance = instance;
5387 
5388  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5389  {
5390  /* Error */
5392  }
5393  else
5394  {
5395  return origin;
5396  }
5397  }
5398 
5399 
5400  typedef struct
5401  {
5402  OrthancPluginMemoryBuffer* target;
5403  const char* json;
5404  const OrthancPluginImage* pixelData;
5406  } _OrthancPluginCreateDicom;
5407 
5434  OrthancPluginContext* context,
5435  OrthancPluginMemoryBuffer* target,
5436  const char* json,
5437  const OrthancPluginImage* pixelData,
5439  {
5440  _OrthancPluginCreateDicom params;
5441  params.target = target;
5442  params.json = json;
5443  params.pixelData = pixelData;
5444  params.flags = flags;
5445 
5446  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5447  }
5448 
5449 
5450  typedef struct
5451  {
5453  } _OrthancPluginDecodeImageCallback;
5454 
5470  OrthancPluginContext* context,
5472  {
5473  _OrthancPluginDecodeImageCallback params;
5474  params.callback = callback;
5475 
5476  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5477  }
5478 
5479 
5480 
5481  typedef struct
5482  {
5483  OrthancPluginImage** target;
5484  OrthancPluginPixelFormat format;
5485  uint32_t width;
5486  uint32_t height;
5487  uint32_t pitch;
5488  void* buffer;
5489  const void* constBuffer;
5490  uint32_t bufferSize;
5491  uint32_t frameIndex;
5492  } _OrthancPluginCreateImage;
5493 
5494 
5508  OrthancPluginContext* context,
5509  OrthancPluginPixelFormat format,
5510  uint32_t width,
5511  uint32_t height)
5512  {
5513  OrthancPluginImage* target = NULL;
5514 
5515  _OrthancPluginCreateImage params;
5516  memset(&params, 0, sizeof(params));
5517  params.target = &target;
5518  params.format = format;
5519  params.width = width;
5520  params.height = height;
5521 
5522  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5523  {
5524  return NULL;
5525  }
5526  else
5527  {
5528  return target;
5529  }
5530  }
5531 
5532 
5551  OrthancPluginContext* context,
5552  OrthancPluginPixelFormat format,
5553  uint32_t width,
5554  uint32_t height,
5555  uint32_t pitch,
5556  void* buffer)
5557  {
5558  OrthancPluginImage* target = NULL;
5559 
5560  _OrthancPluginCreateImage params;
5561  memset(&params, 0, sizeof(params));
5562  params.target = &target;
5563  params.format = format;
5564  params.width = width;
5565  params.height = height;
5566  params.pitch = pitch;
5567  params.buffer = buffer;
5568 
5569  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5570  {
5571  return NULL;
5572  }
5573  else
5574  {
5575  return target;
5576  }
5577  }
5578 
5579 
5580 
5597  OrthancPluginContext* context,
5598  const void* buffer,
5599  uint32_t bufferSize,
5600  uint32_t frameIndex)
5601  {
5602  OrthancPluginImage* target = NULL;
5603 
5604  _OrthancPluginCreateImage params;
5605  memset(&params, 0, sizeof(params));
5606  params.target = &target;
5607  params.constBuffer = buffer;
5608  params.bufferSize = bufferSize;
5609  params.frameIndex = frameIndex;
5610 
5611  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5612  {
5613  return NULL;
5614  }
5615  else
5616  {
5617  return target;
5618  }
5619  }
5620 
5621 
5622 
5623  typedef struct
5624  {
5625  char** result;
5626  const void* buffer;
5627  uint32_t size;
5628  } _OrthancPluginComputeHash;
5629 
5642  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5643  OrthancPluginContext* context,
5644  const void* buffer,
5645  uint32_t size)
5646  {
5647  char* result;
5648 
5649  _OrthancPluginComputeHash params;
5650  params.result = &result;
5651  params.buffer = buffer;
5652  params.size = size;
5653 
5654  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5655  {
5656  /* Error */
5657  return NULL;
5658  }
5659  else
5660  {
5661  return result;
5662  }
5663  }
5664 
5665 
5678  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5679  OrthancPluginContext* context,
5680  const void* buffer,
5681  uint32_t size)
5682  {
5683  char* result;
5684 
5685  _OrthancPluginComputeHash params;
5686  params.result = &result;
5687  params.buffer = buffer;
5688  params.size = size;
5689 
5690  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5691  {
5692  /* Error */
5693  return NULL;
5694  }
5695  else
5696  {
5697  return result;
5698  }
5699  }
5700 
5701 
5702 
5703  typedef struct
5704  {
5706  const char* name;
5707  } _OrthancPluginLookupDictionary;
5708 
5725  OrthancPluginContext* context,
5727  const char* name)
5728  {
5729  _OrthancPluginLookupDictionary params;
5730  params.target = target;
5731  params.name = name;
5732  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5733  }
5734 
5735 
5736 
5737  typedef struct
5738  {
5739  OrthancPluginRestOutput* output;
5740  const void* answer;
5741  uint32_t answerSize;
5742  uint32_t headersCount;
5743  const char* const* headersKeys;
5744  const char* const* headersValues;
5745  } _OrthancPluginSendMultipartItem2;
5746 
5768  OrthancPluginContext* context,
5769  OrthancPluginRestOutput* output,
5770  const void* answer,
5771  uint32_t answerSize,
5772  uint32_t headersCount,
5773  const char* const* headersKeys,
5774  const char* const* headersValues)
5775  {
5776  _OrthancPluginSendMultipartItem2 params;
5777  params.output = output;
5778  params.answer = answer;
5779  params.answerSize = answerSize;
5780  params.headersCount = headersCount;
5781  params.headersKeys = headersKeys;
5782  params.headersValues = headersValues;
5783 
5784  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5785  }
5786 
5787 
5788  typedef struct
5789  {
5791  } _OrthancPluginIncomingHttpRequestFilter;
5792 
5806  OrthancPluginContext* context,
5808  {
5809  _OrthancPluginIncomingHttpRequestFilter params;
5810  params.callback = callback;
5811 
5812  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5813  }
5814 
5815 
5816 
5817  typedef struct
5818  {
5819  OrthancPluginMemoryBuffer* answerBody;
5820  OrthancPluginMemoryBuffer* answerHeaders;
5821  uint16_t* httpStatus;
5822  OrthancPluginHttpMethod method;
5823  const char* url;
5824  uint32_t headersCount;
5825  const char* const* headersKeys;
5826  const char* const* headersValues;
5827  const void* body;
5828  uint32_t bodySize;
5829  const char* username;
5830  const char* password;
5831  uint32_t timeout;
5832  const char* certificateFile;
5833  const char* certificateKeyFile;
5834  const char* certificateKeyPassword;
5835  uint8_t pkcs11;
5836  } _OrthancPluginCallHttpClient2;
5837 
5838 
5839 
5881  OrthancPluginContext* context,
5882  OrthancPluginMemoryBuffer* answerBody,
5883  OrthancPluginMemoryBuffer* answerHeaders,
5884  uint16_t* httpStatus,
5885  OrthancPluginHttpMethod method,
5886  const char* url,
5887  uint32_t headersCount,
5888  const char* const* headersKeys,
5889  const char* const* headersValues,
5890  const void* body,
5891  uint32_t bodySize,
5892  const char* username,
5893  const char* password,
5894  uint32_t timeout,
5895  const char* certificateFile,
5896  const char* certificateKeyFile,
5897  const char* certificateKeyPassword,
5898  uint8_t pkcs11)
5899  {
5900  _OrthancPluginCallHttpClient2 params;
5901  memset(&params, 0, sizeof(params));
5902 
5903  params.answerBody = answerBody;
5904  params.answerHeaders = answerHeaders;
5905  params.httpStatus = httpStatus;
5906  params.method = method;
5907  params.url = url;
5908  params.headersCount = headersCount;
5909  params.headersKeys = headersKeys;
5910  params.headersValues = headersValues;
5911  params.body = body;
5912  params.bodySize = bodySize;
5913  params.username = username;
5914  params.password = password;
5915  params.timeout = timeout;
5916  params.certificateFile = certificateFile;
5917  params.certificateKeyFile = certificateKeyFile;
5918  params.certificateKeyPassword = certificateKeyPassword;
5919  params.pkcs11 = pkcs11;
5920 
5921  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5922  }
5923 
5924 
5935  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5936  OrthancPluginContext* context)
5937  {
5938  char* result;
5939 
5940  _OrthancPluginRetrieveDynamicString params;
5941  params.result = &result;
5942  params.argument = NULL;
5943 
5944  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5945  {
5946  /* Error */
5947  return NULL;
5948  }
5949  else
5950  {
5951  return result;
5952  }
5953  }
5954 
5955 
5956 
5957 
5958  typedef struct
5959  {
5960  OrthancPluginFindCallback callback;
5961  } _OrthancPluginFindCallback;
5962 
5975  OrthancPluginContext* context,
5976  OrthancPluginFindCallback callback)
5977  {
5978  _OrthancPluginFindCallback params;
5979  params.callback = callback;
5980 
5981  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5982  }
5983 
5984 
5985  typedef struct
5986  {
5987  OrthancPluginFindAnswers *answers;
5988  const OrthancPluginFindQuery *query;
5989  const void *dicom;
5990  uint32_t size;
5991  uint32_t index;
5992  uint32_t *resultUint32;
5993  uint16_t *resultGroup;
5994  uint16_t *resultElement;
5995  char **resultString;
5996  } _OrthancPluginFindOperation;
5997 
6014  OrthancPluginContext* context,
6015  OrthancPluginFindAnswers* answers,
6016  const void* dicom,
6017  uint32_t size)
6018  {
6019  _OrthancPluginFindOperation params;
6020  memset(&params, 0, sizeof(params));
6021  params.answers = answers;
6022  params.dicom = dicom;
6023  params.size = size;
6024 
6025  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
6026  }
6027 
6028 
6043  OrthancPluginContext* context,
6044  OrthancPluginFindAnswers* answers)
6045  {
6046  _OrthancPluginFindOperation params;
6047  memset(&params, 0, sizeof(params));
6048  params.answers = answers;
6049 
6050  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
6051  }
6052 
6053 
6054 
6066  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
6067  OrthancPluginContext* context,
6068  const OrthancPluginFindQuery* query)
6069  {
6070  uint32_t count = 0;
6071 
6072  _OrthancPluginFindOperation params;
6073  memset(&params, 0, sizeof(params));
6074  params.query = query;
6075  params.resultUint32 = &count;
6076 
6077  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
6078  {
6079  /* Error */
6080  return 0;
6081  }
6082  else
6083  {
6084  return count;
6085  }
6086  }
6087 
6088 
6104  OrthancPluginContext* context,
6105  uint16_t* group,
6106  uint16_t* element,
6107  const OrthancPluginFindQuery* query,
6108  uint32_t index)
6109  {
6110  _OrthancPluginFindOperation params;
6111  memset(&params, 0, sizeof(params));
6112  params.query = query;
6113  params.index = index;
6114  params.resultGroup = group;
6115  params.resultElement = element;
6116 
6117  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
6118  }
6119 
6120 
6134  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
6135  OrthancPluginContext* context,
6136  const OrthancPluginFindQuery* query,
6137  uint32_t index)
6138  {
6139  char* result;
6140 
6141  _OrthancPluginFindOperation params;
6142  memset(&params, 0, sizeof(params));
6143  params.query = query;
6144  params.index = index;
6145  params.resultString = &result;
6146 
6147  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
6148  {
6149  /* Error */
6150  return NULL;
6151  }
6152  else
6153  {
6154  return result;
6155  }
6156  }
6157 
6158 
6172  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
6173  OrthancPluginContext* context,
6174  const OrthancPluginFindQuery* query,
6175  uint32_t index)
6176  {
6177  char* result;
6178 
6179  _OrthancPluginFindOperation params;
6180  memset(&params, 0, sizeof(params));
6181  params.query = query;
6182  params.index = index;
6183  params.resultString = &result;
6184 
6185  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
6186  {
6187  /* Error */
6188  return NULL;
6189  }
6190  else
6191  {
6192  return result;
6193  }
6194  }
6195 
6196 
6197 
6198 
6199  typedef struct
6200  {
6201  OrthancPluginMoveCallback callback;
6202  OrthancPluginGetMoveSize getMoveSize;
6203  OrthancPluginApplyMove applyMove;
6204  OrthancPluginFreeMove freeMove;
6205  } _OrthancPluginMoveCallback;
6206 
6221  OrthancPluginContext* context,
6222  OrthancPluginMoveCallback callback,
6223  OrthancPluginGetMoveSize getMoveSize,
6224  OrthancPluginApplyMove applyMove,
6225  OrthancPluginFreeMove freeMove)
6226  {
6227  _OrthancPluginMoveCallback params;
6228  params.callback = callback;
6229  params.getMoveSize = getMoveSize;
6230  params.applyMove = applyMove;
6231  params.freeMove = freeMove;
6232 
6233  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
6234  }
6235 
6236 
6237 
6238  typedef struct
6239  {
6240  OrthancPluginFindMatcher** target;
6241  const void* query;
6242  uint32_t size;
6243  } _OrthancPluginCreateFindMatcher;
6244 
6245 
6260  OrthancPluginContext* context,
6261  const void* query,
6262  uint32_t size)
6263  {
6264  OrthancPluginFindMatcher* target = NULL;
6265 
6266  _OrthancPluginCreateFindMatcher params;
6267  memset(&params, 0, sizeof(params));
6268  params.target = &target;
6269  params.query = query;
6270  params.size = size;
6271 
6272  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
6273  {
6274  return NULL;
6275  }
6276  else
6277  {
6278  return target;
6279  }
6280  }
6281 
6282 
6283  typedef struct
6284  {
6285  OrthancPluginFindMatcher* matcher;
6286  } _OrthancPluginFreeFindMatcher;
6287 
6297  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6298  OrthancPluginContext* context,
6299  OrthancPluginFindMatcher* matcher)
6300  {
6301  _OrthancPluginFreeFindMatcher params;
6302  params.matcher = matcher;
6303 
6304  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6305  }
6306 
6307 
6308  typedef struct
6309  {
6310  const OrthancPluginFindMatcher* matcher;
6311  const void* dicom;
6312  uint32_t size;
6313  int32_t* isMatch;
6314  } _OrthancPluginFindMatcherIsMatch;
6315 
6330  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6331  OrthancPluginContext* context,
6332  const OrthancPluginFindMatcher* matcher,
6333  const void* dicom,
6334  uint32_t size)
6335  {
6336  int32_t isMatch = 0;
6337 
6338  _OrthancPluginFindMatcherIsMatch params;
6339  params.matcher = matcher;
6340  params.dicom = dicom;
6341  params.size = size;
6342  params.isMatch = &isMatch;
6343 
6344  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6345  {
6346  return isMatch;
6347  }
6348  else
6349  {
6350  /* Error: Assume non-match */
6351  return 0;
6352  }
6353  }
6354 
6355 
6356  typedef struct
6357  {
6359  } _OrthancPluginIncomingHttpRequestFilter2;
6360 
6373  OrthancPluginContext* context,
6375  {
6376  _OrthancPluginIncomingHttpRequestFilter2 params;
6377  params.callback = callback;
6378 
6379  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6380  }
6381 
6382 
6383 
6384  typedef struct
6385  {
6386  OrthancPluginPeers** peers;
6387  } _OrthancPluginGetPeers;
6388 
6401  OrthancPluginContext* context)
6402  {
6403  OrthancPluginPeers* peers = NULL;
6404 
6405  _OrthancPluginGetPeers params;
6406  memset(&params, 0, sizeof(params));
6407  params.peers = &peers;
6408 
6409  if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6410  {
6411  return NULL;
6412  }
6413  else
6414  {
6415  return peers;
6416  }
6417  }
6418 
6419 
6420  typedef struct
6421  {
6422  OrthancPluginPeers* peers;
6423  } _OrthancPluginFreePeers;
6424 
6434  ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6435  OrthancPluginContext* context,
6436  OrthancPluginPeers* peers)
6437  {
6438  _OrthancPluginFreePeers params;
6439  params.peers = peers;
6440 
6441  context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6442  }
6443 
6444 
6445  typedef struct
6446  {
6447  uint32_t* target;
6448  const OrthancPluginPeers* peers;
6449  } _OrthancPluginGetPeersCount;
6450 
6464  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6465  OrthancPluginContext* context,
6466  const OrthancPluginPeers* peers)
6467  {
6468  uint32_t target = 0;
6469 
6470  _OrthancPluginGetPeersCount params;
6471  memset(&params, 0, sizeof(params));
6472  params.target = &target;
6473  params.peers = peers;
6474 
6475  if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6476  {
6477  /* Error */
6478  return 0;
6479  }
6480  else
6481  {
6482  return target;
6483  }
6484  }
6485 
6486 
6487  typedef struct
6488  {
6489  const char** target;
6490  const OrthancPluginPeers* peers;
6491  uint32_t peerIndex;
6492  const char* userProperty;
6493  } _OrthancPluginGetPeerProperty;
6494 
6512  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6513  OrthancPluginContext* context,
6514  const OrthancPluginPeers* peers,
6515  uint32_t peerIndex)
6516  {
6517  const char* target = NULL;
6518 
6519  _OrthancPluginGetPeerProperty params;
6520  memset(&params, 0, sizeof(params));
6521  params.target = &target;
6522  params.peers = peers;
6523  params.peerIndex = peerIndex;
6524  params.userProperty = NULL;
6525 
6526  if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6527  {
6528  /* Error */
6529  return NULL;
6530  }
6531  else
6532  {
6533  return target;
6534  }
6535  }
6536 
6537 
6553  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6554  OrthancPluginContext* context,
6555  const OrthancPluginPeers* peers,
6556  uint32_t peerIndex)
6557  {
6558  const char* target = NULL;
6559 
6560  _OrthancPluginGetPeerProperty params;
6561  memset(&params, 0, sizeof(params));
6562  params.target = &target;
6563  params.peers = peers;
6564  params.peerIndex = peerIndex;
6565  params.userProperty = NULL;
6566 
6567  if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6568  {
6569  /* Error */
6570  return NULL;
6571  }
6572  else
6573  {
6574  return target;
6575  }
6576  }
6577 
6578 
6579 
6599  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6600  OrthancPluginContext* context,
6601  const OrthancPluginPeers* peers,
6602  uint32_t peerIndex,
6603  const char* userProperty)
6604  {
6605  const char* target = NULL;
6606 
6607  _OrthancPluginGetPeerProperty params;
6608  memset(&params, 0, sizeof(params));
6609  params.target = &target;
6610  params.peers = peers;
6611  params.peerIndex = peerIndex;
6612  params.userProperty = userProperty;
6613 
6614  if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6615  {
6616  /* No such user property */
6617  return NULL;
6618  }
6619  else
6620  {
6621  return target;
6622  }
6623  }
6624 
6625 
6626 
6627  typedef struct
6628  {
6629  OrthancPluginMemoryBuffer* answerBody;
6630  OrthancPluginMemoryBuffer* answerHeaders;
6631  uint16_t* httpStatus;
6632  const OrthancPluginPeers* peers;
6633  uint32_t peerIndex;
6634  OrthancPluginHttpMethod method;
6635  const char* uri;
6636  uint32_t additionalHeadersCount;
6637  const char* const* additionalHeadersKeys;
6638  const char* const* additionalHeadersValues;
6639  const void* body;
6640  uint32_t bodySize;
6641  uint32_t timeout;
6642  } _OrthancPluginCallPeerApi;
6643 
6681  OrthancPluginContext* context,
6682  OrthancPluginMemoryBuffer* answerBody,
6683  OrthancPluginMemoryBuffer* answerHeaders,
6684  uint16_t* httpStatus,
6685  const OrthancPluginPeers* peers,
6686  uint32_t peerIndex,
6687  OrthancPluginHttpMethod method,
6688  const char* uri,
6689  uint32_t additionalHeadersCount,
6690  const char* const* additionalHeadersKeys,
6691  const char* const* additionalHeadersValues,
6692  const void* body,
6693  uint32_t bodySize,
6694  uint32_t timeout)
6695  {
6696  _OrthancPluginCallPeerApi params;
6697  memset(&params, 0, sizeof(params));
6698 
6699  params.answerBody = answerBody;
6700  params.answerHeaders = answerHeaders;
6701  params.httpStatus = httpStatus;
6702  params.peers = peers;
6703  params.peerIndex = peerIndex;
6704  params.method = method;
6705  params.uri = uri;
6706  params.additionalHeadersCount = additionalHeadersCount;
6707  params.additionalHeadersKeys = additionalHeadersKeys;
6708  params.additionalHeadersValues = additionalHeadersValues;
6709  params.body = body;
6710  params.bodySize = bodySize;
6711  params.timeout = timeout;
6712 
6713  return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6714  }
6715 
6716 
6717 
6718 
6719 
6720  typedef struct
6721  {
6722  OrthancPluginJob** target;
6723  void *job;
6724  OrthancPluginJobFinalize finalize;
6725  const char *type;
6726  OrthancPluginJobGetProgress getProgress;
6727  OrthancPluginJobGetContent getContent;
6728  OrthancPluginJobGetSerialized getSerialized;
6729  OrthancPluginJobStep step;
6730  OrthancPluginJobStop stop;
6731  OrthancPluginJobReset reset;
6732  } _OrthancPluginCreateJob;
6733 
6767  OrthancPluginContext *context,
6768  void *job,
6769  OrthancPluginJobFinalize finalize,
6770  const char *type,
6771  OrthancPluginJobGetProgress getProgress,
6772  OrthancPluginJobGetContent getContent,
6773  OrthancPluginJobGetSerialized getSerialized,
6774  OrthancPluginJobStep step,
6775  OrthancPluginJobStop stop,
6776  OrthancPluginJobReset reset)
6777  {
6778  OrthancPluginJob* target = NULL;
6779 
6780  _OrthancPluginCreateJob params;
6781  memset(&params, 0, sizeof(params));
6782 
6783  params.target = &target;
6784  params.job = job;
6785  params.finalize = finalize;
6786  params.type = type;
6787  params.getProgress = getProgress;
6788  params.getContent = getContent;
6789  params.getSerialized = getSerialized;
6790  params.step = step;
6791  params.stop = stop;
6792  params.reset = reset;
6793 
6794  if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6795  target == NULL)
6796  {
6797  /* Error */
6798  return NULL;
6799  }
6800  else
6801  {
6802  return target;
6803  }
6804  }
6805 
6806 
6807  typedef struct
6808  {
6809  OrthancPluginJob** target;
6810  void *job;
6811  OrthancPluginJobFinalize finalize;
6812  const char *type;
6813  OrthancPluginJobGetProgress getProgress;
6814  OrthancPluginJobGetContent2 getContent;
6815  OrthancPluginJobGetSerialized2 getSerialized;
6816  OrthancPluginJobStep step;
6817  OrthancPluginJobStop stop;
6818  OrthancPluginJobReset reset;
6819  } _OrthancPluginCreateJob2;
6820 
6853  OrthancPluginContext *context,
6854  void *job,
6855  OrthancPluginJobFinalize finalize,
6856  const char *type,
6857  OrthancPluginJobGetProgress getProgress,
6858  OrthancPluginJobGetContent2 getContent,
6859  OrthancPluginJobGetSerialized2 getSerialized,
6860  OrthancPluginJobStep step,
6861  OrthancPluginJobStop stop,
6862  OrthancPluginJobReset reset)
6863  {
6864  OrthancPluginJob* target = NULL;
6865 
6866  _OrthancPluginCreateJob2 params;
6867  memset(&params, 0, sizeof(params));
6868 
6869  params.target = &target;
6870  params.job = job;
6871  params.finalize = finalize;
6872  params.type = type;
6873  params.getProgress = getProgress;
6874  params.getContent = getContent;
6875  params.getSerialized = getSerialized;
6876  params.step = step;
6877  params.stop = stop;
6878  params.reset = reset;
6879 
6880  if (context->InvokeService(context, _OrthancPluginService_CreateJob2, &params) != OrthancPluginErrorCode_Success ||
6881  target == NULL)
6882  {
6883  /* Error */
6884  return NULL;
6885  }
6886  else
6887  {
6888  return target;
6889  }
6890  }
6891 
6892 
6893  typedef struct
6894  {
6895  OrthancPluginJob* job;
6896  } _OrthancPluginFreeJob;
6897 
6907  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6908  OrthancPluginContext* context,
6909  OrthancPluginJob* job)
6910  {
6911  _OrthancPluginFreeJob params;
6912  params.job = job;
6913 
6914  context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6915  }
6916 
6917 
6918 
6919  typedef struct
6920  {
6921  char** resultId;
6922  OrthancPluginJob *job;
6923  int priority;
6924  } _OrthancPluginSubmitJob;
6925 
6939  ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6940  OrthancPluginContext *context,
6941  OrthancPluginJob *job,
6942  int priority)
6943  {
6944  char* resultId = NULL;
6945 
6946  _OrthancPluginSubmitJob params;
6947  memset(&params, 0, sizeof(params));
6948 
6949  params.resultId = &resultId;
6950  params.job = job;
6951  params.priority = priority;
6952 
6953  if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6954  resultId == NULL)
6955  {
6956  /* Error */
6957  return NULL;
6958  }
6959  else
6960  {
6961  return resultId;
6962  }
6963  }
6964 
6965 
6966 
6967  typedef struct
6968  {
6969  OrthancPluginJobsUnserializer unserializer;
6970  } _OrthancPluginJobsUnserializer;
6971 
6984  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6985  OrthancPluginContext* context,
6986  OrthancPluginJobsUnserializer unserializer)
6987  {
6988  _OrthancPluginJobsUnserializer params;
6989  params.unserializer = unserializer;
6990 
6991  context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6992  }
6993 
6994 
6995 
6996  typedef struct
6997  {
6998  OrthancPluginRestOutput* output;
6999  const char* details;
7000  uint8_t log;
7001  } _OrthancPluginSetHttpErrorDetails;
7002 
7020  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
7021  OrthancPluginContext* context,
7022  OrthancPluginRestOutput* output,
7023  const char* details,
7024  uint8_t log)
7025  {
7026  _OrthancPluginSetHttpErrorDetails params;
7027  params.output = output;
7028  params.details = details;
7029  params.log = log;
7030  context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
7031  }
7032 
7033 
7034 
7035  typedef struct
7036  {
7037  const char** result;
7038  const char* argument;
7039  } _OrthancPluginRetrieveStaticString;
7040 
7052  ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
7053  OrthancPluginContext* context,
7054  const char* path)
7055  {
7056  const char* result = NULL;
7057 
7058  _OrthancPluginRetrieveStaticString params;
7059  params.result = &result;
7060  params.argument = path;
7061 
7062  if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
7063  {
7064  /* Error */
7065  return NULL;
7066  }
7067  else
7068  {
7069  return result;
7070  }
7071  }
7072 
7073 
7074 
7075  typedef struct
7076  {
7077  const char* name;
7078  float value;
7080  } _OrthancPluginSetMetricsValue;
7081 
7098  ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
7099  OrthancPluginContext* context,
7100  const char* name,
7101  float value,
7103  {
7104  _OrthancPluginSetMetricsValue params;
7105  params.name = name;
7106  params.value = value;
7107  params.type = type;
7108  context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
7109  }
7110 
7111 
7112 
7113  typedef struct
7114  {
7116  } _OrthancPluginRegisterRefreshMetricsCallback;
7117 
7130  OrthancPluginContext* context,
7132  {
7133  _OrthancPluginRegisterRefreshMetricsCallback params;
7134  params.callback = callback;
7135  context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
7136  }
7137 
7138 
7139 
7140 
7141  typedef struct
7142  {
7143  char** target;
7144  const void* dicom;
7145  uint32_t dicomSize;
7147  } _OrthancPluginEncodeDicomWeb;
7148 
7165  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
7166  OrthancPluginContext* context,
7167  const void* dicom,
7168  uint32_t dicomSize,
7170  {
7171  char* target = NULL;
7172 
7173  _OrthancPluginEncodeDicomWeb params;
7174  params.target = &target;
7175  params.dicom = dicom;
7176  params.dicomSize = dicomSize;
7177  params.callback = callback;
7178 
7179  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
7180  {
7181  /* Error */
7182  return NULL;
7183  }
7184  else
7185  {
7186  return target;
7187  }
7188  }
7189 
7190 
7207  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
7208  OrthancPluginContext* context,
7209  const void* dicom,
7210  uint32_t dicomSize,
7212  {
7213  char* target = NULL;
7214 
7215  _OrthancPluginEncodeDicomWeb params;
7216  params.target = &target;
7217  params.dicom = dicom;
7218  params.dicomSize = dicomSize;
7219  params.callback = callback;
7220 
7221  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
7222  {
7223  /* Error */
7224  return NULL;
7225  }
7226  else
7227  {
7228  return target;
7229  }
7230  }
7231 
7232 
7233 
7234  typedef struct
7235  {
7236  char** target;
7237  const void* dicom;
7238  uint32_t dicomSize;
7240  void* payload;
7241  } _OrthancPluginEncodeDicomWeb2;
7242 
7259  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson2(
7260  OrthancPluginContext* context,
7261  const void* dicom,
7262  uint32_t dicomSize,
7264  void* payload)
7265  {
7266  char* target = NULL;
7267 
7268  _OrthancPluginEncodeDicomWeb2 params;
7269  params.target = &target;
7270  params.dicom = dicom;
7271  params.dicomSize = dicomSize;
7272  params.callback = callback;
7273  params.payload = payload;
7274 
7275  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson2, &params) != OrthancPluginErrorCode_Success)
7276  {
7277  /* Error */
7278  return NULL;
7279  }
7280  else
7281  {
7282  return target;
7283  }
7284  }
7285 
7286 
7303  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml2(
7304  OrthancPluginContext* context,
7305  const void* dicom,
7306  uint32_t dicomSize,
7308  void* payload)
7309  {
7310  char* target = NULL;
7311 
7312  _OrthancPluginEncodeDicomWeb2 params;
7313  params.target = &target;
7314  params.dicom = dicom;
7315  params.dicomSize = dicomSize;
7316  params.callback = callback;
7317  params.payload = payload;
7318 
7319  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml2, &params) != OrthancPluginErrorCode_Success)
7320  {
7321  /* Error */
7322  return NULL;
7323  }
7324  else
7325  {
7326  return target;
7327  }
7328  }
7329 
7330 
7331 
7348  void* answer,
7349  const char* key,
7350  const char* value);
7351 
7352 
7369  void* answer,
7370  const void* data,
7371  uint32_t size);
7372 
7373 
7388  typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
7389 
7390 
7406 
7407 
7421  typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
7422 
7423 
7437  typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
7438 
7439 
7440  typedef struct
7441  {
7442  void* answer;
7445  uint16_t* httpStatus;
7446  OrthancPluginHttpMethod method;
7447  const char* url;
7448  uint32_t headersCount;
7449  const char* const* headersKeys;
7450  const char* const* headersValues;
7451  void* request;
7456  const char* username;
7457  const char* password;
7458  uint32_t timeout;
7459  const char* certificateFile;
7460  const char* certificateKeyFile;
7461  const char* certificateKeyPassword;
7462  uint8_t pkcs11;
7463  } _OrthancPluginChunkedHttpClient;
7464 
7465 
7517  OrthancPluginContext* context,
7518  void* answer,
7521  uint16_t* httpStatus,
7522  OrthancPluginHttpMethod method,
7523  const char* url,
7524  uint32_t headersCount,
7525  const char* const* headersKeys,
7526  const char* const* headersValues,
7527  void* request,
7532  const char* username,
7533  const char* password,
7534  uint32_t timeout,
7535  const char* certificateFile,
7536  const char* certificateKeyFile,
7537  const char* certificateKeyPassword,
7538  uint8_t pkcs11)
7539  {
7540  _OrthancPluginChunkedHttpClient params;
7541  memset(&params, 0, sizeof(params));
7542 
7543  /* In common with OrthancPluginHttpClient() */
7544  params.httpStatus = httpStatus;
7545  params.method = method;
7546  params.url = url;
7547  params.headersCount = headersCount;
7548  params.headersKeys = headersKeys;
7549  params.headersValues = headersValues;
7550  params.username = username;
7551  params.password = password;
7552  params.timeout = timeout;
7553  params.certificateFile = certificateFile;
7554  params.certificateKeyFile = certificateKeyFile;
7555  params.certificateKeyPassword = certificateKeyPassword;
7556  params.pkcs11 = pkcs11;
7557 
7558  /* For chunked body/answer */
7559  params.answer = answer;
7560  params.answerAddChunk = answerAddChunk;
7561  params.answerAddHeader = answerAddHeader;
7562  params.request = request;
7563  params.requestIsDone = requestIsDone;
7564  params.requestChunkData = requestChunkData;
7565  params.requestChunkSize = requestChunkSize;
7566  params.requestNext = requestNext;
7567 
7568  return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7569  }
7570 
7571 
7572 
7577  typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7578 
7579 
7580 
7598  const char* url,
7599  const OrthancPluginHttpRequest* request);
7600 
7601 
7617  const void* data,
7618  uint32_t size);
7619 
7620 
7637  OrthancPluginRestOutput* output);
7638 
7639 
7655 
7656  typedef struct
7657  {
7658  const char* pathRegularExpression;
7659  OrthancPluginRestCallback getHandler;
7661  OrthancPluginRestCallback deleteHandler;
7666  } _OrthancPluginChunkedRestCallback;
7667 
7668 
7698  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterChunkedRestCallback(
7699  OrthancPluginContext* context,
7700  const char* pathRegularExpression,
7701  OrthancPluginRestCallback getHandler,
7703  OrthancPluginRestCallback deleteHandler,
7708  {
7709  _OrthancPluginChunkedRestCallback params;
7710  params.pathRegularExpression = pathRegularExpression;
7711  params.getHandler = getHandler;
7712  params.postHandler = postHandler;
7713  params.deleteHandler = deleteHandler;
7714  params.putHandler = putHandler;
7715  params.addChunk = addChunk;
7716  params.execute = execute;
7717  params.finalize = finalize;
7718 
7719  context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
7720  }
7721 
7722 
7723 
7724 
7725 
7726  typedef struct
7727  {
7728  char** result;
7729  uint16_t group;
7730  uint16_t element;
7731  const char* privateCreator;
7732  } _OrthancPluginGetTagName;
7733 
7749  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
7750  OrthancPluginContext* context,
7751  uint16_t group,
7752  uint16_t element,
7753  const char* privateCreator)
7754  {
7755  char* result;
7756 
7757  _OrthancPluginGetTagName params;
7758  params.result = &result;
7759  params.group = group;
7760  params.element = element;
7761  params.privateCreator = privateCreator;
7762 
7763  if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
7764  {
7765  /* Error */
7766  return NULL;
7767  }
7768  else
7769  {
7770  return result;
7771  }
7772  }
7773 
7774 
7775 
7805  void** handler /* out */,
7806  const char* jobId,
7807  const char* transactionUid,
7808  const char* const* sopClassUids,
7809  const char* const* sopInstanceUids,
7810  uint32_t countInstances,
7811  const char* remoteAet,
7812  const char* calledAet);
7813 
7814 
7826  typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
7827 
7828 
7849  void* handler,
7850  const char* sopClassUid,
7851  const char* sopInstanceUid);
7852 
7853 
7854  typedef struct
7855  {
7859  } _OrthancPluginRegisterStorageCommitmentScpCallback;
7860 
7875  OrthancPluginContext* context,
7879  {
7880  _OrthancPluginRegisterStorageCommitmentScpCallback params;
7881  params.factory = factory;
7882  params.destructor = destructor;
7883  params.lookup = lookup;
7884  return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
7885  }
7886 
7887 
7888 
7915  const OrthancPluginDicomInstance* instance);
7916 
7917 
7918  typedef struct
7919  {
7921  } _OrthancPluginIncomingDicomInstanceFilter;
7922 
7936  OrthancPluginContext* context,
7938  {
7939  _OrthancPluginIncomingDicomInstanceFilter params;
7940  params.callback = callback;
7941 
7942  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, &params);
7943  }
7944 
7945 
7977  uint16_t* dimseStatus /* out */,
7978  const OrthancPluginDicomInstance* instance);
7979 
7980 
7981  typedef struct
7982  {
7984  } _OrthancPluginIncomingCStoreInstanceFilter;
7985 
7999  OrthancPluginContext* context,
8001  {
8002  _OrthancPluginIncomingCStoreInstanceFilter params;
8003  params.callback = callback;
8004 
8005  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingCStoreInstanceFilter, &params);
8006  }
8007 
8044  OrthancPluginMemoryBuffer64* modifiedDicomBuffer,
8045  const void* receivedDicomBuffer,
8046  uint64_t receivedDicomBufferSize,
8048 
8049 
8050  typedef struct
8051  {
8053  } _OrthancPluginReceivedInstanceCallback;
8054 
8076  OrthancPluginContext* context,
8078  {
8079  _OrthancPluginReceivedInstanceCallback params;
8080  params.callback = callback;
8081 
8082  return context->InvokeService(context, _OrthancPluginService_RegisterReceivedInstanceCallback, &params);
8083  }
8084 
8098  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceTransferSyntaxUid(
8099  OrthancPluginContext* context,
8100  const OrthancPluginDicomInstance* instance)
8101  {
8102  char* result;
8103 
8104  _OrthancPluginAccessDicomInstance params;
8105  memset(&params, 0, sizeof(params));
8106  params.resultStringToFree = &result;
8107  params.instance = instance;
8108 
8109  if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, &params) != OrthancPluginErrorCode_Success)
8110  {
8111  /* Error */
8112  return NULL;
8113  }
8114  else
8115  {
8116  return result;
8117  }
8118  }
8119 
8120 
8133  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData(
8134  OrthancPluginContext* context,
8135  const OrthancPluginDicomInstance* instance)
8136  {
8137  int64_t hasPixelData;
8138 
8139  _OrthancPluginAccessDicomInstance params;
8140  memset(&params, 0, sizeof(params));
8141  params.resultInt64 = &hasPixelData;
8142  params.instance = instance;
8143 
8144  if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, &params) != OrthancPluginErrorCode_Success ||
8145  hasPixelData < 0 ||
8146  hasPixelData > 1)
8147  {
8148  /* Error */
8149  return -1;
8150  }
8151  else
8152  {
8153  return (hasPixelData != 0);
8154  }
8155  }
8156 
8157 
8158 
8159 
8160 
8161 
8162  typedef struct
8163  {
8164  OrthancPluginDicomInstance** target;
8165  const void* buffer;
8166  uint32_t size;
8167  const char* transferSyntax;
8168  } _OrthancPluginCreateDicomInstance;
8169 
8184  OrthancPluginContext* context,
8185  const void* buffer,
8186  uint32_t size)
8187  {
8188  OrthancPluginDicomInstance* target = NULL;
8189 
8190  _OrthancPluginCreateDicomInstance params;
8191  params.target = &target;
8192  params.buffer = buffer;
8193  params.size = size;
8194 
8195  if (context->InvokeService(context, _OrthancPluginService_CreateDicomInstance, &params) != OrthancPluginErrorCode_Success)
8196  {
8197  /* Error */
8198  return NULL;
8199  }
8200  else
8201  {
8202  return target;
8203  }
8204  }
8205 
8206  typedef struct
8207  {
8209  } _OrthancPluginFreeDicomInstance;
8210 
8221  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeDicomInstance(
8222  OrthancPluginContext* context,
8224  {
8225  _OrthancPluginFreeDicomInstance params;
8226  params.dicom = dicom;
8227 
8228  context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, &params);
8229  }
8230 
8231 
8232  typedef struct
8233  {
8234  uint32_t* targetUint32;
8235  OrthancPluginMemoryBuffer* targetBuffer;
8236  OrthancPluginImage** targetImage;
8237  char** targetStringToFree;
8238  const OrthancPluginDicomInstance* instance;
8239  uint32_t frameIndex;
8242  uint32_t maxStringLength;
8243  OrthancPluginDicomWebBinaryCallback2 dicomWebCallback;
8244  void* dicomWebPayload;
8245  } _OrthancPluginAccessDicomInstance2;
8246 
8258  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetInstanceFramesCount(
8259  OrthancPluginContext* context,
8260  const OrthancPluginDicomInstance* instance)
8261  {
8262  uint32_t count;
8263 
8264  _OrthancPluginAccessDicomInstance2 params;
8265  memset(&params, 0, sizeof(params));
8266  params.targetUint32 = &count;
8267  params.instance = instance;
8268 
8269  if (context->InvokeService(context, _OrthancPluginService_GetInstanceFramesCount, &params) != OrthancPluginErrorCode_Success)
8270  {
8271  /* Error */
8272  return 0;
8273  }
8274  else
8275  {
8276  return count;
8277  }
8278  }
8279 
8280 
8299  OrthancPluginContext* context,
8300  OrthancPluginMemoryBuffer* target,
8301  const OrthancPluginDicomInstance* instance,
8302  uint32_t frameIndex)
8303  {
8304  _OrthancPluginAccessDicomInstance2 params;
8305  memset(&params, 0, sizeof(params));
8306  params.targetBuffer = target;
8307  params.instance = instance;
8308  params.frameIndex = frameIndex;
8309 
8310  return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, &params);
8311  }
8312 
8313 
8327  OrthancPluginContext* context,
8328  const OrthancPluginDicomInstance* instance,
8329  uint32_t frameIndex)
8330  {
8331  OrthancPluginImage* target = NULL;
8332 
8333  _OrthancPluginAccessDicomInstance2 params;
8334  memset(&params, 0, sizeof(params));
8335  params.targetImage = &target;
8336  params.instance = instance;
8337  params.frameIndex = frameIndex;
8338 
8339  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDecodedFrame, &params) != OrthancPluginErrorCode_Success)
8340  {
8341  return NULL;
8342  }
8343  else
8344  {
8345  return target;
8346  }
8347  }
8348 
8349 
8366  OrthancPluginContext* context,
8367  const void* buffer,
8368  uint32_t size,
8369  const char* transferSyntax)
8370  {
8371  OrthancPluginDicomInstance* target = NULL;
8372 
8373  _OrthancPluginCreateDicomInstance params;
8374  params.target = &target;
8375  params.buffer = buffer;
8376  params.size = size;
8377  params.transferSyntax = transferSyntax;
8378 
8379  if (context->InvokeService(context, _OrthancPluginService_TranscodeDicomInstance, &params) != OrthancPluginErrorCode_Success)
8380  {
8381  /* Error */
8382  return NULL;
8383  }
8384  else
8385  {
8386  return target;
8387  }
8388  }
8389 
8404  OrthancPluginContext* context,
8405  OrthancPluginMemoryBuffer* target,
8406  const OrthancPluginDicomInstance* instance)
8407  {
8408  _OrthancPluginAccessDicomInstance2 params;
8409  memset(&params, 0, sizeof(params));
8410  params.targetBuffer = target;
8411  params.instance = instance;
8412 
8413  return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, &params);
8414  }
8415 
8416 
8435  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceAdvancedJson(
8436  OrthancPluginContext* context,
8437  const OrthancPluginDicomInstance* instance,
8440  uint32_t maxStringLength)
8441  {
8442  char* result = NULL;
8443 
8444  _OrthancPluginAccessDicomInstance2 params;
8445  memset(&params, 0, sizeof(params));
8446  params.targetStringToFree = &result;
8447  params.instance = instance;
8448  params.format = format;
8449  params.flags = flags;
8450  params.maxStringLength = maxStringLength;
8451 
8452  if (context->InvokeService(context, _OrthancPluginService_GetInstanceAdvancedJson, &params) != OrthancPluginErrorCode_Success)
8453  {
8454  /* Error */
8455  return NULL;
8456  }
8457  else
8458  {
8459  return result;
8460  }
8461  }
8462 
8463 
8478  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebJson(
8479  OrthancPluginContext* context,
8480  const OrthancPluginDicomInstance* instance,
8482  void* payload)
8483  {
8484  char* target = NULL;
8485 
8486  _OrthancPluginAccessDicomInstance2 params;
8487  params.targetStringToFree = &target;
8488  params.instance = instance;
8489  params.dicomWebCallback = callback;
8490  params.dicomWebPayload = payload;
8491 
8492  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebJson, &params) != OrthancPluginErrorCode_Success)
8493  {
8494  /* Error */
8495  return NULL;
8496  }
8497  else
8498  {
8499  return target;
8500  }
8501  }
8502 
8503 
8518  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebXml(
8519  OrthancPluginContext* context,
8520  const OrthancPluginDicomInstance* instance,
8522  void* payload)
8523  {
8524  char* target = NULL;
8525 
8526  _OrthancPluginAccessDicomInstance2 params;
8527  params.targetStringToFree = &target;
8528  params.instance = instance;
8529  params.dicomWebCallback = callback;
8530  params.dicomWebPayload = payload;
8531 
8532  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebXml, &params) != OrthancPluginErrorCode_Success)
8533  {
8534  /* Error */
8535  return NULL;
8536  }
8537  else
8538  {
8539  return target;
8540  }
8541  }
8542 
8543 
8544 
8564  OrthancPluginMemoryBuffer* transcoded /* out */,
8565  const void* buffer,
8566  uint64_t size,
8567  const char* const* allowedSyntaxes,
8568  uint32_t countSyntaxes,
8569  uint8_t allowNewSopInstanceUid);
8570 
8571 
8572  typedef struct
8573  {
8575  } _OrthancPluginTranscoderCallback;
8576 
8591  OrthancPluginContext* context,
8593  {
8594  _OrthancPluginTranscoderCallback params;
8595  params.callback = callback;
8596 
8597  return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, &params);
8598  }
8599 
8600 
8601 
8602  typedef struct
8603  {
8604  OrthancPluginMemoryBuffer* target;
8605  uint32_t size;
8606  } _OrthancPluginCreateMemoryBuffer;
8607 
8626  OrthancPluginContext* context,
8627  OrthancPluginMemoryBuffer* target,
8628  uint32_t size)
8629  {
8630  _OrthancPluginCreateMemoryBuffer params;
8631  params.target = target;
8632  params.size = size;
8633 
8634  return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, &params);
8635  }
8636 
8637 
8664  OrthancPluginContext* context)
8665  {
8666  char* result;
8667 
8668  _OrthancPluginRetrieveDynamicString params;
8669  params.result = &result;
8670  params.argument = NULL;
8671 
8672  if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
8673  &params) != OrthancPluginErrorCode_Success)
8674  {
8675  /* Error */
8676  return NULL;
8677  }
8678  else
8679  {
8680  return result;
8681  }
8682  }
8683 
8684 
8685 
8686  typedef struct
8687  {
8689  uint64_t size;
8690  } _OrthancPluginCreateMemoryBuffer64;
8691 
8710  OrthancPluginContext* context,
8712  uint64_t size)
8713  {
8714  _OrthancPluginCreateMemoryBuffer64 params;
8715  params.target = target;
8716  params.size = size;
8717 
8718  return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer64, &params);
8719  }
8720 
8721 
8722  typedef struct
8723  {
8728  } _OrthancPluginRegisterStorageArea2;
8729 
8746  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea2(
8747  OrthancPluginContext* context,
8752  {
8753  _OrthancPluginRegisterStorageArea2 params;
8754  params.create = create;
8755  params.readWhole = readWhole;
8756  params.readRange = readRange;
8757  params.remove = remove;
8758  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea2, &params);
8759  }
8760 
8761 
8762 
8763  typedef struct
8764  {
8765  _OrthancPluginCreateDicom createDicom;
8766  const char* privateCreator;
8767  } _OrthancPluginCreateDicom2;
8768 
8794  OrthancPluginContext* context,
8795  OrthancPluginMemoryBuffer* target,
8796  const char* json,
8797  const OrthancPluginImage* pixelData,
8799  const char* privateCreator)
8800  {
8801  _OrthancPluginCreateDicom2 params;
8802  params.createDicom.target = target;
8803  params.createDicom.json = json;
8804  params.createDicom.pixelData = pixelData;
8805  params.createDicom.flags = flags;
8806  params.privateCreator = privateCreator;
8807 
8808  return context->InvokeService(context, _OrthancPluginService_CreateDicom2, &params);
8809  }
8810 
8811 
8812 
8813 
8814 
8815 
8816  typedef struct
8817  {
8818  OrthancPluginMemoryBuffer* answerBody;
8819  OrthancPluginMemoryBuffer* answerHeaders;
8820  uint16_t* httpStatus;
8821  OrthancPluginHttpMethod method;
8822  const char* uri;
8823  uint32_t headersCount;
8824  const char* const* headersKeys;
8825  const char* const* headersValues;
8826  const void* body;
8827  uint32_t bodySize;
8828  uint8_t afterPlugins;
8829  } _OrthancPluginCallRestApi;
8830 
8862  OrthancPluginContext* context,
8863  OrthancPluginMemoryBuffer* answerBody,
8864  OrthancPluginMemoryBuffer* answerHeaders,
8865  uint16_t* httpStatus,
8866  OrthancPluginHttpMethod method,
8867  const char* uri,
8868  uint32_t headersCount,
8869  const char* const* headersKeys,
8870  const char* const* headersValues,
8871  const void* body,
8872  uint32_t bodySize,
8873  uint8_t afterPlugins)
8874  {
8875  _OrthancPluginCallRestApi params;
8876  memset(&params, 0, sizeof(params));
8877 
8878  params.answerBody = answerBody;
8879  params.answerHeaders = answerHeaders;
8880  params.httpStatus = httpStatus;
8881  params.method = method;
8882  params.uri = uri;
8883  params.headersCount = headersCount;
8884  params.headersKeys = headersKeys;
8885  params.headersValues = headersValues;
8886  params.body = body;
8887  params.bodySize = bodySize;
8888  params.afterPlugins = afterPlugins;
8889 
8890  return context->InvokeService(context, _OrthancPluginService_CallRestApi, &params);
8891  }
8892 
8893 
8894 
8899  typedef struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection;
8900 
8901 
8919  OrthancPluginWebDavCollection* collection,
8920  const char* name,
8921  uint64_t size,
8922  const char* mimeType,
8923  const char* dateTime);
8924 
8925 
8940  OrthancPluginWebDavCollection* collection,
8941  const char* name,
8942  const char* dateTime);
8943 
8944 
8967  OrthancPluginWebDavCollection* collection,
8968  const void* data,
8969  uint64_t size,
8970  const char* mimeType,
8971  const char* dateTime);
8972 
8973 
8988  uint8_t* isExisting, /* out */
8989  uint32_t pathSize,
8990  const char* const* pathItems,
8991  void* payload);
8992 
8993 
9013  uint8_t* isExisting, /* out */
9014  OrthancPluginWebDavCollection* collection,
9016  OrthancPluginWebDavAddFolder addFolder,
9017  uint32_t pathSize,
9018  const char* const* pathItems,
9019  void* payload);
9020 
9021 
9039  OrthancPluginWebDavCollection* collection,
9040  OrthancPluginWebDavRetrieveFile retrieveFile,
9041  uint32_t pathSize,
9042  const char* const* pathItems,
9043  void* payload);
9044 
9045 
9062  uint8_t* isReadOnly, /* out */
9063  uint32_t pathSize,
9064  const char* const* pathItems,
9065  const void* data,
9066  uint64_t size,
9067  void* payload);
9068 
9069 
9084  uint8_t* isReadOnly, /* out */
9085  uint32_t pathSize,
9086  const char* const* pathItems,
9087  void* payload);
9088 
9089 
9104  uint8_t* isReadOnly, /* out */
9105  uint32_t pathSize,
9106  const char* const* pathItems,
9107  void* payload);
9108 
9109 
9110  typedef struct
9111  {
9112  const char* uri;
9119  void* payload;
9120  } _OrthancPluginRegisterWebDavCollection;
9121 
9143  OrthancPluginContext* context,
9144  const char* uri,
9151  void* payload)
9152  {
9153  _OrthancPluginRegisterWebDavCollection params;
9154  params.uri = uri;
9155  params.isExistingFolder = isExistingFolder;
9156  params.listFolder = listFolder;
9157  params.retrieveFile = retrieveFile;
9158  params.storeFile = storeFile;
9159  params.createFolder = createFolder;
9160  params.deleteItem = deleteItem;
9161  params.payload = payload;
9162 
9163  return context->InvokeService(context, _OrthancPluginService_RegisterWebDavCollection, &params);
9164  }
9165 
9166 
9175  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetDatabaseServerIdentifier(
9176  OrthancPluginContext* context)
9177  {
9178  const char* result;
9179 
9180  _OrthancPluginRetrieveStaticString params;
9181  params.result = &result;
9182  params.argument = NULL;
9183 
9184  if (context->InvokeService(context, _OrthancPluginService_GetDatabaseServerIdentifier, &params) != OrthancPluginErrorCode_Success)
9185  {
9186  /* Error */
9187  return NULL;
9188  }
9189  else
9190  {
9191  return result;
9192  }
9193  }
9194 
9195 
9203  OrthancPluginMemoryBuffer64* response,
9204  void* backend,
9205  const void* request,
9206  uint64_t requestSize);
9207 
9213  typedef void (*OrthancPluginFinalizeDatabaseBackendV4) (void* backend);
9214 
9215  typedef struct
9216  {
9217  void* backend;
9218  uint32_t maxDatabaseRetries;
9221  } _OrthancPluginRegisterDatabaseBackendV4;
9222 
9241  OrthancPluginContext* context,
9242  void* backend,
9243  uint32_t maxDatabaseRetries,
9246  {
9247  _OrthancPluginRegisterDatabaseBackendV4 params;
9248  params.backend = backend;
9249  params.maxDatabaseRetries = maxDatabaseRetries;
9250  params.operations = operations;
9251  params.finalize = finalize;
9252 
9253  return context->InvokeService(context, _OrthancPluginService_RegisterDatabaseBackendV4, &params);
9254  }
9255 
9256 
9257  typedef struct
9258  {
9259  OrthancPluginDicomInstance** target;
9260  const char* instanceId;
9262  } _OrthancPluginLoadDicomInstance;
9263 
9278  OrthancPluginContext* context,
9279  const char* instanceId,
9281  {
9282  OrthancPluginDicomInstance* target = NULL;
9283 
9284  _OrthancPluginLoadDicomInstance params;
9285  params.target = &target;
9286  params.instanceId = instanceId;
9287  params.mode = mode;
9288 
9289  if (context->InvokeService(context, _OrthancPluginService_LoadDicomInstance, &params) != OrthancPluginErrorCode_Success)
9290  {
9291  /* Error */
9292  return NULL;
9293  }
9294  else
9295  {
9296  return target;
9297  }
9298  }
9299 
9300 
9301  typedef struct
9302  {
9303  const char* name;
9304  int64_t value;
9306  } _OrthancPluginSetMetricsIntegerValue;
9307 
9323  ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsIntegerValue(
9324  OrthancPluginContext* context,
9325  const char* name,
9326  int64_t value,
9328  {
9329  _OrthancPluginSetMetricsIntegerValue params;
9330  params.name = name;
9331  params.value = value;
9332  params.type = type;
9333  context->InvokeService(context, _OrthancPluginService_SetMetricsIntegerValue, &params);
9334  }
9335 
9336 
9337 #ifdef __cplusplus
9338 }
9339 #endif
9340 
9341 
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition: OrthancCPlugin.h:8098
Definition: OrthancCPlugin.h:781
Definition: OrthancCPlugin.h:885
OrthancPluginChangeType
Definition: OrthancCPlugin.h:733
Definition: OrthancCPlugin.h:236
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2837
OrthancPluginErrorCode(* OrthancPluginWebDavCreateFolderCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback to create a folder.
Definition: OrthancCPlugin.h:9083
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6434
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:6013
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2938
Definition: OrthancCPlugin.h:804
OrthancPluginErrorCode(* OrthancPluginWebDavListFolderCallback)(uint8_t *isExisting, OrthancPluginWebDavCollection *collection, OrthancPluginWebDavAddFile addFile, OrthancPluginWebDavAddFolder addFolder, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback for listing the content of a folder.
Definition: OrthancCPlugin.h:9012
Definition: OrthancCPlugin.h:975
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:8326
Definition: OrthancCPlugin.h:278
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:2094
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5469
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:5880
Definition: OrthancCPlugin.h:886
The parameters of a REST request.
Definition: OrthancCPlugin.h:340
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2620
OrthancPluginContentType
Definition: OrthancCPlugin.h:701
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2525
Definition: OrthancCPlugin.h:719
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:8518
A 64-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1079
OrthancPluginErrorCode(* OrthancPluginChunkedClientRequestNext)(void *request)
Callback to advance in the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7405
Definition: OrthancCPlugin.h:803
struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode
Opaque structure that represents a node in a JSON or XML document used in DICOMweb.
Definition: OrthancCPlugin.h:1188
Definition: OrthancCPlugin.h:917
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:4229
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:4321
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:928
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:2011
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:7020
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition: OrthancCPlugin.h:8403
Definition: OrthancCPlugin.h:270
Definition: OrthancCPlugin.h:206
Definition: OrthancCPlugin.h:268
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:912
struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection
Opaque structure that represents a WebDAV collection.
Definition: OrthancCPlugin.h:8899
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1608
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition: OrthancCPlugin.h:8365
Definition: OrthancCPlugin.h:801
Definition: OrthancCPlugin.h:946
Definition: OrthancCPlugin.h:244
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:8435
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:4975
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:3114
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:2473
Definition: OrthancCPlugin.h:293
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:625
Definition: OrthancCPlugin.h:748
Definition: OrthancCPlugin.h:228
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:400
Definition: OrthancCPlugin.h:280
Definition: OrthancCPlugin.h:282
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:395
Definition: OrthancCPlugin.h:266
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:867
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5678
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:6766
Definition: OrthancCPlugin.h:284
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:609
Definition: OrthancCPlugin.h:918
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:360
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int priority)
Submit a new job to the jobs engine of Orthanc.
Definition: OrthancCPlugin.h:6939
Definition: OrthancCPlugin.h:651
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:3243
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:7052
Definition: OrthancCPlugin.h:901
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2338
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:778
Definition: OrthancCPlugin.h:214
Definition: OrthancCPlugin.h:306
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1875
Definition: OrthancCPlugin.h:290
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:7874
OrthancPluginErrorCode(* OrthancPluginWebDavAddFolder)(OrthancPluginWebDavCollection *collection, const char *name, const char *dateTime)
Declare a subfolder while returning the content of a folder.
Definition: OrthancCPlugin.h:8939
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4605
Definition: OrthancCPlugin.h:234
Definition: OrthancCPlugin.h:296
OrthancPluginErrorCode OrthancPluginRegisterIncomingCStoreInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingCStoreInstanceFilter callback)
Register a callback to filter incoming DICOM instances received by Orthanc through C-STORE...
Definition: OrthancCPlugin.h:7998
Definition: OrthancCPlugin.h:288
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:5767
Definition: OrthancCPlugin.h:328
Definition: OrthancCPlugin.h:225
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5642
Definition: OrthancCPlugin.h:930
Definition: OrthancCPlugin.h:227
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:200
struct _OrthancPluginJob_t OrthancPluginJob
Opaque structure to a job to be executed by Orthanc.
Definition: OrthancCPlugin.h:1179
void OrthancPluginFreeMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:2046
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4530
Definition: OrthancCPlugin.h:291
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:1376
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, uint32_t size)
Create a 32-bit memory buffer.
Definition: OrthancCPlugin.h:8625
Definition: OrthancCPlugin.h:742
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4788
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition: OrthancCPlugin.h:7935
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4565
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:3340
Definition: OrthancCPlugin.h:223
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:6103
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3386
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:649
Definition: OrthancCPlugin.h:849
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:846
Definition: OrthancCPlugin.h:947
Definition: OrthancCPlugin.h:216
OrthancPluginReceivedInstanceAction
Definition: OrthancCPlugin.h:1018
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2883
Definition: OrthancCPlugin.h:765
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:2550
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5935
OrthancPluginLoadDicomInstanceMode
Definition: OrthancCPlugin.h:1032
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:1824
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1592
Definition: OrthancCPlugin.h:750
uint8_t(* OrthancPluginChunkedClientRequestIsDone)(void *request)
Callback to know whether the request body is entirely read during a chunked transfer.
Definition: OrthancCPlugin.h:7388
Definition: OrthancCPlugin.h:945
Definition: OrthancCPlugin.h:736
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5596
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:1407
Definition: OrthancCPlugin.h:267
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:831
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5724
Definition: OrthancCPlugin.h:1020
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1706
Definition: OrthancCPlugin.h:833
const void *(* OrthancPluginChunkedClientRequestGetChunkData)(void *request)
Callback to read the current chunk of the request body during a chunked transfer. ...
Definition: OrthancCPlugin.h:7421
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4866
Definition: OrthancCPlugin.h:248
uint16_t group
Definition: OrthancCPlugin.h:1858
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:4099
Definition: OrthancCPlugin.h:1041
int32_t(* OrthancPluginJobGetSerialized2)(OrthancPluginMemoryBuffer *target, void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1666
Definition: OrthancCPlugin.h:794
OrthancPluginErrorCode OrthancPluginRegisterWebDavCollection(OrthancPluginContext *context, const char *uri, OrthancPluginWebDavIsExistingFolderCallback isExistingFolder, OrthancPluginWebDavListFolderCallback listFolder, OrthancPluginWebDavRetrieveFileCallback retrieveFile, OrthancPluginWebDavStoreFileCallback storeFile, OrthancPluginWebDavCreateFolderCallback createFolder, OrthancPluginWebDavDeleteItemCallback deleteItem, void *payload)
Register a WebDAV virtual filesystem.
Definition: OrthancCPlugin.h:9142
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1861
Definition: OrthancCPlugin.h:835
Definition: OrthancCPlugin.h:806
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:5244
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:4454
Definition: OrthancCPlugin.h:944
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:942
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1131
Definition: OrthancCPlugin.h:780
Definition: OrthancCPlugin.h:260
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:1123
Definition: OrthancCPlugin.h:252
Definition: OrthancCPlugin.h:703
OrthancPluginErrorCode(* OrthancPluginWebDavIsExistingFolderCallback)(uint8_t *isExisting, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback for testing the existence of a folder.
Definition: OrthancCPlugin.h:8987
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:3076
Definition: OrthancCPlugin.h:740
Color image in RGB48 format.
Definition: OrthancCPlugin.h:659
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3631
Definition: OrthancCPlugin.h:283
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:617
Definition: OrthancCPlugin.h:281
Definition: OrthancCPlugin.h:217
OrthancPluginConstraintType
Definition: OrthancCPlugin.h:897
Definition: OrthancCPlugin.h:752
OrthancPluginResourceType
Definition: OrthancCPlugin.h:716
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:325
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:1250
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition: OrthancCPlugin.h:8183
Definition: OrthancCPlugin.h:233
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:4030
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:792
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3664
Definition: OrthancCPlugin.h:204
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:4142
Definition: OrthancCPlugin.h:286
Definition: OrthancCPlugin.h:796
void OrthancPluginRegisterStorageArea2(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageReadWhole readWhole, OrthancPluginStorageReadRange readRange, OrthancPluginStorageRemove remove)
Register a custom storage area, with support for range request.
Definition: OrthancCPlugin.h:8746
Definition: OrthancCPlugin.h:220
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7207
Definition: OrthancCPlugin.h:721
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1196
Definition: OrthancCPlugin.h:277
Definition: OrthancCPlugin.h:766
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:8298
Definition: OrthancCPlugin.h:799
Definition: OrthancCPlugin.h:294
Definition: OrthancCPlugin.h:932
void OrthancPluginSetMetricsValue(OrthancPluginContext *context, const char *name, float value, OrthancPluginMetricsType type)
Set the value of a floating-point metrics.
Definition: OrthancCPlugin.h:7098
int32_t(* OrthancPluginIncomingCStoreInstanceFilter)(uint16_t *dimseStatus, const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition: OrthancCPlugin.h:7976
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:3305
Definition: OrthancCPlugin.h:238
OrthancPluginReceivedInstanceAction(* OrthancPluginReceivedInstanceCallback)(OrthancPluginMemoryBuffer64 *modifiedDicomBuffer, const void *receivedDicomBuffer, uint64_t receivedDicomBufferSize, OrthancPluginInstanceOrigin origin)
Callback to keep/discard/modify a DICOM instance received by Orthanc from any source (C-STORE or REST...
Definition: OrthancCPlugin.h:8043
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:2438
Definition: OrthancCPlugin.h:768
Definition: OrthancCPlugin.h:818
Definition: OrthancCPlugin.h:269
Color image in RGB24 format.
Definition: OrthancCPlugin.h:641
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6372
char * OrthancPluginGenerateRestApiAuthorizationToken(OrthancPluginContext *context)
Generate a token to grant full access to the REST API of Orthanc.
Definition: OrthancCPlugin.h:8663
OrthancPluginErrorCode(* OrthancPluginWebDavRetrieveFileCallback)(OrthancPluginWebDavCollection *collection, OrthancPluginWebDavRetrieveFile retrieveFile, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback for retrieving the content of a file.
Definition: OrthancCPlugin.h:9038
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:633
Definition: OrthancCPlugin.h:956
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1856
Definition: OrthancCPlugin.h:279
Definition: OrthancCPlugin.h:210
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:1163
Definition: OrthancCPlugin.h:735
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:763
void OrthancPluginSendHttpStatus(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status, const void *body, uint32_t bodySize)
Send a HTTP status, with a custom body.
Definition: OrthancCPlugin.h:3928
Definition: OrthancCPlugin.h:202
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:5170
Definition: OrthancCPlugin.h:852
OrthancPluginErrorCode(* OrthancPluginWebDavAddFile)(OrthancPluginWebDavCollection *collection, const char *name, uint64_t size, const char *mimeType, const char *dateTime)
Declare a file while returning the content of a folder.
Definition: OrthancCPlugin.h:8918
struct _OrthancPluginPeers_t OrthancPluginPeers
Opaque structure to the set of remote Orthanc Peers that are known to the local Orthanc server...
Definition: OrthancCPlugin.h:1171
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3964
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:4690
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *target, uint64_t size)
Create a 64-bit memory buffer.
Definition: OrthancCPlugin.h:8709
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:4065
Definition: OrthancCPlugin.h:704
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:2297
Definition: OrthancCPlugin.h:299
Definition: OrthancCPlugin.h:305
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1682
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1084
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1862
Definition: OrthancCPlugin.h:974
OrthancPluginErrorCode OrthancPluginCallRestApi(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, OrthancPluginHttpMethod method, const char *uri, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, const void *body, uint32_t bodySize, uint8_t afterPlugins)
Call the REST API of Orthanc with full flexibility.
Definition: OrthancCPlugin.h:8861
Definition: OrthancCPlugin.h:298
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:1228
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:5063
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1240
Definition: OrthancCPlugin.h:902
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3565
Definition: OrthancCPlugin.h:250
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2860
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:6680
Definition: OrthancCPlugin.h:212
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:691
Definition: OrthancCPlugin.h:275
Definition: OrthancCPlugin.h:263
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:6297
OrthancPluginErrorCode OrthancPluginCreateDicom2(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *json, const OrthancPluginImage *pixelData, OrthancPluginCreateDicomFlags flags, const char *privateCreator)
Create a DICOM instance from a JSON string and an image, with a private creator.
Definition: OrthancCPlugin.h:8793
Definition: OrthancCPlugin.h:295
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:2062
Definition: OrthancCPlugin.h:231
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:6259
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1062
OrthancPluginErrorCode OrthancPluginRegisterReceivedInstanceCallback(OrthancPluginContext *context, OrthancPluginReceivedInstanceCallback callback)
Register a callback to keep/discard/modify a DICOM instance received by Orthanc from any source (C-ST...
Definition: OrthancCPlugin.h:8075
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4637
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:3461
Definition: OrthancCPlugin.h:916
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1758
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2371
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3875
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:390
Definition: OrthancCPlugin.h:751
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:3040
OrthancPluginJob * OrthancPluginCreateJob2(OrthancPluginContext *context, void *job, OrthancPluginJobFinalize finalize, const char *type, OrthancPluginJobGetProgress getProgress, OrthancPluginJobGetContent2 getContent, OrthancPluginJobGetSerialized2 getSerialized, OrthancPluginJobStep step, OrthancPluginJobStop stop, OrthancPluginJobReset reset)
Create a custom job.
Definition: OrthancCPlugin.h:6852
Definition: OrthancCPlugin.h:741
Definition: OrthancCPlugin.h:851
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:2030
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:5208
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1269
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:3153
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:1512
Definition: OrthancCPlugin.h:812
Definition: OrthancCPlugin.h:243
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2502
Definition: OrthancCPlugin.h:816
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:7847
Definition: OrthancCPlugin.h:720
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3813
Definition: OrthancCPlugin.h:805
Definition: OrthancCPlugin.h:887
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1155
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:6220
Definition: OrthancCPlugin.h:329
Definition: OrthancCPlugin.h:749
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5507
Definition: OrthancCPlugin.h:807
Definition: OrthancCPlugin.h:255
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:3275
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3495
Definition: OrthancCPlugin.h:903
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1357
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:3194
Definition: OrthancCPlugin.h:834
Definition: OrthancCPlugin.h:264
Definition: OrthancCPlugin.h:856
Definition: OrthancCPlugin.h:302
Definition: OrthancCPlugin.h:327
OrthancPluginErrorCode(* OrthancPluginWebDavDeleteItemCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback to remove a file or a folder.
Definition: OrthancCPlugin.h:9103
Definition: OrthancCPlugin.h:963
Definition: OrthancCPlugin.h:743
Definition: OrthancCPlugin.h:309
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer...
Definition: OrthancCPlugin.h:7577
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:5019
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:6134
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6984
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition: OrthancCPlugin.h:8221
OrthancPluginErrorCode OrthancPluginRegisterDatabaseBackendV4(OrthancPluginContext *context, void *backend, uint32_t maxDatabaseRetries, OrthancPluginCallDatabaseBackendV4 operations, OrthancPluginFinalizeDatabaseBackendV4 finalize)
Definition: OrthancCPlugin.h:9240
char * OrthancPluginEncodeDicomWebJson2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7259
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3599
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:4374
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:3007
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:5550
Definition: OrthancCPlugin.h:272
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:8478
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5805
Definition: OrthancCPlugin.h:919
Definition: OrthancCPlugin.h:224
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:5112
OrthancPluginErrorCode(* OrthancPluginCallDatabaseBackendV4)(OrthancPluginMemoryBuffer64 *response, void *backend, const void *request, uint64_t requestSize)
Signature of a callback function that is triggered when the Orthanc core requests an operation from t...
Definition: OrthancCPlugin.h:9202
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition: OrthancCPlugin.h:7914
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:370
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:6599
Definition: OrthancCPlugin.h:819
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:1217
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6400
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:3776
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:8563
Definition: OrthancCPlugin.h:265
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:7368
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5274
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:5433
Definition: OrthancCPlugin.h:258
Definition: OrthancCPlugin.h:782
Definition: OrthancCPlugin.h:211
Definition: OrthancCPlugin.h:271
Definition: OrthancCPlugin.h:218
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:2170
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:4412
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1469
Definition: OrthancCPlugin.h:746
void(* OrthancPluginFinalizeDatabaseBackendV4)(void *backend)
Signature of a callback function that is triggered when the database plugin must be finalized...
Definition: OrthancCPlugin.h:9213
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5974
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1115
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3705
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1139
Definition: OrthancCPlugin.h:203
Definition: OrthancCPlugin.h:246
Definition: OrthancCPlugin.h:229
Definition: OrthancCPlugin.h:222
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5377
Definition: OrthancCPlugin.h:753
Definition: OrthancCPlugin.h:884
Definition: OrthancCPlugin.h:303
Definition: OrthancCPlugin.h:274
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1566
char * OrthancPluginEncodeDicomWebXml2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7303
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:3417
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:8133
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1646
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4827
Definition: OrthancCPlugin.h:931
Definition: OrthancCPlugin.h:706
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:1207
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6907
Definition: OrthancCPlugin.h:811
Definition: OrthancCPlugin.h:747
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:365
void OrthancPluginSetMetricsIntegerValue(OrthancPluginContext *context, const char *name, int64_t value, OrthancPluginMetricsType type)
Set the value of an integer metrics.
Definition: OrthancCPlugin.h:9323
Definition: OrthancCPlugin.h:814
Definition: OrthancCPlugin.h:738
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2652
OrthancPluginErrorCode(* OrthancPluginWebDavRetrieveFile)(OrthancPluginWebDavCollection *collection, const void *data, uint64_t size, const char *mimeType, const char *dateTime)
Retrieve the content of a file.
Definition: OrthancCPlugin.h:8966
OrthancPluginErrorCode(* OrthancPluginStorageReadRange)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type, uint64_t rangeStart)
Callback for reading a range of a file from the storage area.
Definition: OrthancCPlugin.h:1339
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition: OrthancCPlugin.h:1107
Definition: OrthancCPlugin.h:245
Definition: OrthancCPlugin.h:900
Definition: OrthancCPlugin.h:815
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:4184
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1860
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:7516
uint16_t element
Definition: OrthancCPlugin.h:1859
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2792
Definition: OrthancCPlugin.h:745
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3534
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1552
Definition: OrthancCPlugin.h:235
Definition: OrthancCPlugin.h:705
Definition: OrthancCPlugin.h:242
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:355
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3844
Definition: OrthancCPlugin.h:273
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1296
Definition: OrthancCPlugin.h:276
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2687
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1067
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:675
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2974
Definition: OrthancCPlugin.h:914
Definition: OrthancCPlugin.h:256
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1723
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7165
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:350
Definition: OrthancCPlugin.h:257
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderFactory)(OrthancPluginServerChunkedRequestReader **reader, const char *url, const OrthancPluginHttpRequest *request)
Callback to create a reader to handle incoming chunked HTTP transfers.
Definition: OrthancCPlugin.h:7596
Definition: OrthancCPlugin.h:722
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:2078
Definition: OrthancCPlugin.h:973
Definition: OrthancCPlugin.h:800
Definition: OrthancCPlugin.h:262
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:5312
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:1905
Definition: OrthancCPlugin.h:820
const void * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:375
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderExecute)(OrthancPluginServerChunkedRequestReader *reader, OrthancPluginRestOutput *output)
Callback invoked whenever the request body is entirely received.
Definition: OrthancCPlugin.h:7635
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:882
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:380
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:6042
Definition: OrthancCPlugin.h:330
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1739
OrthancPluginMetricsType
Definition: OrthancCPlugin.h:954
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:2586
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:3734
OrthancPluginDicomWebBinaryMode
Definition: OrthancCPlugin.h:971
Definition: OrthancCPlugin.h:240
Definition: OrthancCPlugin.h:308
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2913
Definition: OrthancCPlugin.h:737
char * OrthancPluginGetTagName(OrthancPluginContext *context, uint16_t group, uint16_t element, const char *privateCreator)
Returns the symbolic name of a DICOM tag.
Definition: OrthancCPlugin.h:7749
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6464
Definition: OrthancCPlugin.h:810
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6553
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:6066
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:1099
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:3439
Definition: OrthancCPlugin.h:304
Definition: OrthancCPlugin.h:237
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:2208
Definition: OrthancCPlugin.h:739
Definition: OrthancCPlugin.h:813
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:4922
Definition: OrthancCPlugin.h:259
Definition: OrthancCPlugin.h:1021
Definition: OrthancCPlugin.h:215
Definition: OrthancCPlugin.h:817
Definition: OrthancCPlugin.h:797
Definition: OrthancCPlugin.h:1022
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:667
Definition: OrthancCPlugin.h:899
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:2130
uint32_t(* OrthancPluginChunkedClientRequestGetChunkSize)(void *request)
Callback to read the size of the current request chunk during a chunked transfer. ...
Definition: OrthancCPlugin.h:7437
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2722
Definition: OrthancCPlugin.h:1037
Definition: OrthancCPlugin.h:809
Definition: OrthancCPlugin.h:795
Definition: OrthancCPlugin.h:207
Definition: OrthancCPlugin.h:718
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:7698
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5351
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:2401
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:7347
Definition: OrthancCPlugin.h:915
Definition: OrthancCPlugin.h:226
Definition: OrthancCPlugin.h:297
Definition: OrthancCPlugin.h:208
Definition: OrthancCPlugin.h:213
Definition: OrthancCPlugin.h:1034
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1147
Definition: OrthancCPlugin.h:205
Definition: OrthancCPlugin.h:230
OrthancPluginErrorCode(* OrthancPluginWebDavStoreFileCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, const void *data, uint64_t size, void *payload)
Callback to store a file.
Definition: OrthancCPlugin.h:9061
Definition: OrthancCPlugin.h:744
Definition: OrthancCPlugin.h:767
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:7129
Definition: OrthancCPlugin.h:249
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:1442
Definition: OrthancCPlugin.h:241
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:345
Definition: OrthancCPlugin.h:292
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:4744
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:2240
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4492
A 32-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1057
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:7804
uint64_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1089
void(* OrthancPluginServerChunkedRequestReaderFinalize)(OrthancPluginServerChunkedRequestReader *reader)
Callback invoked to release the resources associated with an incoming HTTP chunked transfer...
Definition: OrthancCPlugin.h:7653
const char * OrthancPluginGetDatabaseServerIdentifier(OrthancPluginContext *context)
Gets the DatabaseServerIdentifier.
Definition: OrthancCPlugin.h:9175
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6512
OrthancPluginErrorCode(* OrthancPluginStorageReadWhole)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type)
Callback for reading a whole file from the storage area.
Definition: OrthancCPlugin.h:1316
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:683
OrthancPluginStorageCommitmentFailureReason
Definition: OrthancCPlugin.h:984
Definition: OrthancCPlugin.h:802
Definition: OrthancCPlugin.h:850
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition: OrthancCPlugin.h:8258
OrthancPluginDicomInstance * OrthancPluginLoadDicomInstance(OrthancPluginContext *context, const char *instanceId, OrthancPluginLoadDicomInstanceMode mode)
Load a DICOM instance from the Orthanc server.
Definition: OrthancCPlugin.h:9277
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition: OrthancCPlugin.h:8590
Definition: OrthancCPlugin.h:219
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7826
Definition: OrthancCPlugin.h:855
OrthancPluginErrorCode(* OrthancPluginJobGetContent2)(OrthancPluginMemoryBuffer *target, void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1626
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:6330
Definition: OrthancCPlugin.h:808
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1579
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2757
Definition: OrthancCPlugin.h:209
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1537
Definition: OrthancCPlugin.h:798
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:1786
Definition: OrthancCPlugin.h:285
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3997
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:7615
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:4274
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:6172
Definition: OrthancCPlugin.h:239
Definition: OrthancCPlugin.h:232