Orthanc Plugin SDK  1.12.0
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 0
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 
451  /* Registration of callbacks */
452  _OrthancPluginService_RegisterRestCallback = 1000,
453  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
454  _OrthancPluginService_RegisterStorageArea = 1002,
455  _OrthancPluginService_RegisterOnChangeCallback = 1003,
456  _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
457  _OrthancPluginService_RegisterWorklistCallback = 1005,
458  _OrthancPluginService_RegisterDecodeImageCallback = 1006,
459  _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
460  _OrthancPluginService_RegisterFindCallback = 1008,
461  _OrthancPluginService_RegisterMoveCallback = 1009,
462  _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
463  _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
464  _OrthancPluginService_RegisterChunkedRestCallback = 1012, /* New in Orthanc 1.5.7 */
465  _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
466  _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
467  _OrthancPluginService_RegisterTranscoderCallback = 1015, /* New in Orthanc 1.7.0 */
468  _OrthancPluginService_RegisterStorageArea2 = 1016, /* New in Orthanc 1.9.0 */
469  _OrthancPluginService_RegisterIncomingCStoreInstanceFilter = 1017, /* New in Orthanc 1.10.0 */
470  _OrthancPluginService_RegisterReceivedInstanceCallback = 1018, /* New in Orthanc 1.10.0 */
471  _OrthancPluginService_RegisterWebDavCollection = 1019, /* New in Orthanc 1.10.1 */
472 
473  /* Sending answers to REST calls */
474  _OrthancPluginService_AnswerBuffer = 2000,
475  _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
476  _OrthancPluginService_Redirect = 2002,
477  _OrthancPluginService_SendHttpStatusCode = 2003,
478  _OrthancPluginService_SendUnauthorized = 2004,
479  _OrthancPluginService_SendMethodNotAllowed = 2005,
480  _OrthancPluginService_SetCookie = 2006,
481  _OrthancPluginService_SetHttpHeader = 2007,
482  _OrthancPluginService_StartMultipartAnswer = 2008,
483  _OrthancPluginService_SendMultipartItem = 2009,
484  _OrthancPluginService_SendHttpStatus = 2010,
485  _OrthancPluginService_CompressAndAnswerImage = 2011,
486  _OrthancPluginService_SendMultipartItem2 = 2012,
487  _OrthancPluginService_SetHttpErrorDetails = 2013,
488 
489  /* Access to the Orthanc database and API */
490  _OrthancPluginService_GetDicomForInstance = 3000,
491  _OrthancPluginService_RestApiGet = 3001,
492  _OrthancPluginService_RestApiPost = 3002,
493  _OrthancPluginService_RestApiDelete = 3003,
494  _OrthancPluginService_RestApiPut = 3004,
495  _OrthancPluginService_LookupPatient = 3005,
496  _OrthancPluginService_LookupStudy = 3006,
497  _OrthancPluginService_LookupSeries = 3007,
498  _OrthancPluginService_LookupInstance = 3008,
499  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
500  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
501  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
502  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
503  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
504  _OrthancPluginService_ReconstructMainDicomTags = 3014,
505  _OrthancPluginService_RestApiGet2 = 3015,
506  _OrthancPluginService_CallRestApi = 3016, /* New in Orthanc 1.9.2 */
507 
508  /* Access to DICOM instances */
509  _OrthancPluginService_GetInstanceRemoteAet = 4000,
510  _OrthancPluginService_GetInstanceSize = 4001,
511  _OrthancPluginService_GetInstanceData = 4002,
512  _OrthancPluginService_GetInstanceJson = 4003,
513  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
514  _OrthancPluginService_HasInstanceMetadata = 4005,
515  _OrthancPluginService_GetInstanceMetadata = 4006,
516  _OrthancPluginService_GetInstanceOrigin = 4007,
517  _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
518  _OrthancPluginService_HasInstancePixelData = 4009,
519  _OrthancPluginService_CreateDicomInstance = 4010, /* New in Orthanc 1.7.0 */
520  _OrthancPluginService_FreeDicomInstance = 4011, /* New in Orthanc 1.7.0 */
521  _OrthancPluginService_GetInstanceFramesCount = 4012, /* New in Orthanc 1.7.0 */
522  _OrthancPluginService_GetInstanceRawFrame = 4013, /* New in Orthanc 1.7.0 */
523  _OrthancPluginService_GetInstanceDecodedFrame = 4014, /* New in Orthanc 1.7.0 */
524  _OrthancPluginService_TranscodeDicomInstance = 4015, /* New in Orthanc 1.7.0 */
525  _OrthancPluginService_SerializeDicomInstance = 4016, /* New in Orthanc 1.7.0 */
526  _OrthancPluginService_GetInstanceAdvancedJson = 4017, /* New in Orthanc 1.7.0 */
527  _OrthancPluginService_GetInstanceDicomWebJson = 4018, /* New in Orthanc 1.7.0 */
528  _OrthancPluginService_GetInstanceDicomWebXml = 4019, /* New in Orthanc 1.7.0 */
529 
530  /* Services for plugins implementing a database back-end */
531  _OrthancPluginService_RegisterDatabaseBackend = 5000, /* New in Orthanc 0.8.6 */
532  _OrthancPluginService_DatabaseAnswer = 5001,
533  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002, /* New in Orthanc 0.9.4 */
534  _OrthancPluginService_StorageAreaCreate = 5003,
535  _OrthancPluginService_StorageAreaRead = 5004,
536  _OrthancPluginService_StorageAreaRemove = 5005,
537  _OrthancPluginService_RegisterDatabaseBackendV3 = 5006, /* New in Orthanc 1.9.2 */
538  _OrthancPluginService_RegisterDatabaseBackendV4 = 5007, /* New in Orthanc 1.12.0 */
539 
540  /* Primitives for handling images */
541  _OrthancPluginService_GetImagePixelFormat = 6000,
542  _OrthancPluginService_GetImageWidth = 6001,
543  _OrthancPluginService_GetImageHeight = 6002,
544  _OrthancPluginService_GetImagePitch = 6003,
545  _OrthancPluginService_GetImageBuffer = 6004,
546  _OrthancPluginService_UncompressImage = 6005,
547  _OrthancPluginService_FreeImage = 6006,
548  _OrthancPluginService_CompressImage = 6007,
549  _OrthancPluginService_ConvertPixelFormat = 6008,
550  _OrthancPluginService_GetFontsCount = 6009,
551  _OrthancPluginService_GetFontInfo = 6010,
552  _OrthancPluginService_DrawText = 6011,
553  _OrthancPluginService_CreateImage = 6012,
554  _OrthancPluginService_CreateImageAccessor = 6013,
555  _OrthancPluginService_DecodeDicomImage = 6014,
556 
557  /* Primitives for handling C-Find, C-Move and worklists */
558  _OrthancPluginService_WorklistAddAnswer = 7000,
559  _OrthancPluginService_WorklistMarkIncomplete = 7001,
560  _OrthancPluginService_WorklistIsMatch = 7002,
561  _OrthancPluginService_WorklistGetDicomQuery = 7003,
562  _OrthancPluginService_FindAddAnswer = 7004,
563  _OrthancPluginService_FindMarkIncomplete = 7005,
564  _OrthancPluginService_GetFindQuerySize = 7006,
565  _OrthancPluginService_GetFindQueryTag = 7007,
566  _OrthancPluginService_GetFindQueryTagName = 7008,
567  _OrthancPluginService_GetFindQueryValue = 7009,
568  _OrthancPluginService_CreateFindMatcher = 7010,
569  _OrthancPluginService_FreeFindMatcher = 7011,
570  _OrthancPluginService_FindMatcherIsMatch = 7012,
571 
572  /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
573  _OrthancPluginService_GetPeers = 8000,
574  _OrthancPluginService_FreePeers = 8001,
575  _OrthancPluginService_GetPeersCount = 8003,
576  _OrthancPluginService_GetPeerName = 8004,
577  _OrthancPluginService_GetPeerUrl = 8005,
578  _OrthancPluginService_CallPeerApi = 8006,
579  _OrthancPluginService_GetPeerUserProperty = 8007,
580 
581  /* Primitives for handling jobs (new in 1.4.2) */
582  _OrthancPluginService_CreateJob = 9000, /* Deprecated since SDK 1.11.3 */
583  _OrthancPluginService_FreeJob = 9001,
584  _OrthancPluginService_SubmitJob = 9002,
585  _OrthancPluginService_RegisterJobsUnserializer = 9003,
586  _OrthancPluginService_CreateJob2 = 9004, /* New in SDK 1.11.3 */
587 
588  _OrthancPluginService_INTERNAL = 0x7fffffff
589  } _OrthancPluginService;
590 
591 
592  typedef enum
593  {
594  _OrthancPluginProperty_Description = 1,
595  _OrthancPluginProperty_RootUri = 2,
596  _OrthancPluginProperty_OrthancExplorer = 3,
597 
598  _OrthancPluginProperty_INTERNAL = 0x7fffffff
599  } _OrthancPluginProperty;
600 
601 
602 
607  typedef enum
608  {
616 
624 
632 
640 
648 
658 
666 
674 
682 
690 
691  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
693 
694 
695 
699  typedef enum
700  {
706  _OrthancPluginContentType_INTERNAL = 0x7fffffff
708 
709 
710 
714  typedef enum
715  {
722  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
724 
725 
726 
731  typedef enum
732  {
753  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
755 
756 
761  typedef enum
762  {
768  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
770 
771 
776  typedef enum
777  {
782  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
784 
785 
790  typedef enum
791  {
820  _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
822 
823 
829  typedef enum
830  {
835  _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
837 
838 
844  typedef enum
845  {
846  OrthancPluginDicomToJsonFlags_None = 0,
856  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
858 
859 
865  typedef enum
866  {
867  OrthancPluginCreateDicomFlags_None = 0,
871  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
873 
874 
880  typedef enum
881  {
887  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
889 
890 
895  typedef enum
896  {
903  _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
905 
906 
910  typedef enum
911  {
919  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
921 
922 
926  typedef enum
927  {
932 
933 
940  typedef enum
941  {
947 
948 
952  typedef enum
953  {
963 
964 
969  typedef enum
970  {
975 
976 
982  typedef enum
983  {
1011 
1012 
1016  typedef enum
1017  {
1022  _OrthancPluginReceivedInstanceAction_INTERNAL = 0x7fffffff
1024 
1025 
1033  typedef struct
1034  {
1038  void* data;
1039 
1043  uint32_t size;
1045 
1046 
1047 
1055  typedef struct
1056  {
1060  void* data;
1061 
1065  uint64_t size;
1067 
1068 
1069 
1070 
1075  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
1076 
1077 
1078 
1083  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
1084 
1085 
1086 
1091  typedef struct _OrthancPluginImage_t OrthancPluginImage;
1092 
1093 
1094 
1099  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
1100 
1101 
1102 
1107  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
1108 
1109 
1110 
1115  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
1116 
1117 
1118 
1123  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1124 
1125 
1126 
1131  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1132 
1133 
1134 
1139  typedef struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher;
1140 
1141 
1142 
1147  typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1148 
1149 
1150 
1155  typedef struct _OrthancPluginJob_t OrthancPluginJob;
1156 
1157 
1158 
1164  typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1165 
1166 
1167 
1173  OrthancPluginRestOutput* output,
1174  const char* url,
1175  const OrthancPluginHttpRequest* request);
1176 
1177 
1178 
1184  const OrthancPluginDicomInstance* instance,
1185  const char* instanceId);
1186 
1187 
1188 
1194  OrthancPluginChangeType changeType,
1195  OrthancPluginResourceType resourceType,
1196  const char* resourceId);
1197 
1198 
1199 
1205  OrthancPluginImage** target,
1206  const void* dicom,
1207  const uint32_t size,
1208  uint32_t frameIndex);
1209 
1210 
1211 
1216  typedef void (*OrthancPluginFree) (void* buffer);
1217 
1218 
1219 
1229  const char* bulkDataUri);
1230 
1231 
1232 
1246  const char* uuid,
1247  const void* content,
1248  int64_t size,
1250 
1251 
1252 
1273  void** content,
1274  int64_t* size,
1275  const char* uuid,
1277 
1278 
1279 
1294  const char* uuid,
1296 
1297 
1298 
1317  const char* uuid,
1319  uint64_t rangeStart);
1320 
1321 
1322 
1334  const char* uuid,
1336 
1337 
1338 
1354  const OrthancPluginWorklistQuery* query,
1355  const char* issuerAet,
1356  const char* calledAet);
1357 
1358 
1359 
1384  OrthancPluginHttpMethod method,
1385  const char* uri,
1386  const char* ip,
1387  uint32_t headersCount,
1388  const char* const* headersKeys,
1389  const char* const* headersValues);
1390 
1391 
1392 
1419  OrthancPluginHttpMethod method,
1420  const char* uri,
1421  const char* ip,
1422  uint32_t headersCount,
1423  const char* const* headersKeys,
1424  const char* const* headersValues,
1425  uint32_t getArgumentsCount,
1426  const char* const* getArgumentsKeys,
1427  const char* const* getArgumentsValues);
1428 
1429 
1430 
1446  OrthancPluginFindAnswers* answers,
1447  const OrthancPluginFindQuery* query,
1448  const char* issuerAet,
1449  const char* calledAet);
1450 
1451 
1452 
1488  typedef void* (*OrthancPluginMoveCallback) (
1489  OrthancPluginResourceType resourceType,
1490  const char* patientId,
1491  const char* accessionNumber,
1492  const char* studyInstanceUid,
1493  const char* seriesInstanceUid,
1494  const char* sopInstanceUid,
1495  const char* originatorAet,
1496  const char* sourceAet,
1497  const char* targetAet,
1498  uint16_t originatorId);
1499 
1500 
1513  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1514 
1515 
1528  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1529 
1530 
1542  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1543 
1544 
1555  typedef void (*OrthancPluginJobFinalize) (void* job);
1556 
1557 
1568  typedef float (*OrthancPluginJobGetProgress) (void* job);
1569 
1570 
1584  typedef const char* (*OrthancPluginJobGetContent) (void* job);
1585 
1586 
1603  void* job);
1604 
1605 
1622  typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1623 
1624 
1643  void* job);
1644 
1645 
1659 
1660 
1684 
1685 
1700 
1701 
1715  typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1716  const char* serialized);
1717 
1718 
1719 
1734 
1735 
1736 
1764  uint32_t levelDepth,
1765  const uint16_t* levelTagGroup,
1766  const uint16_t* levelTagElement,
1767  const uint32_t* levelIndex,
1768  uint16_t tagGroup,
1769  uint16_t tagElement,
1771 
1772 
1773 
1802  uint32_t levelDepth,
1803  const uint16_t* levelTagGroup,
1804  const uint16_t* levelTagElement,
1805  const uint32_t* levelIndex,
1806  uint16_t tagGroup,
1807  uint16_t tagElement,
1809  void* payload);
1810 
1811 
1812 
1816  typedef struct _OrthancPluginContext_t
1817  {
1818  void* pluginsManager;
1819  const char* orthancVersion;
1820  OrthancPluginFree Free;
1821  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1822  _OrthancPluginService service,
1823  const void* params);
1825 
1826 
1827 
1831  typedef struct
1832  {
1833  uint16_t group;
1834  uint16_t element;
1836  uint32_t minMultiplicity;
1837  uint32_t maxMultiplicity;
1839 
1840 
1841 
1850  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1851  OrthancPluginContext* context,
1852  char* str)
1853  {
1854  if (str != NULL)
1855  {
1856  context->Free(str);
1857  }
1858  }
1859 
1860 
1880  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1881  OrthancPluginContext* context,
1882  int expectedMajor,
1883  int expectedMinor,
1884  int expectedRevision)
1885  {
1886  int major, minor, revision;
1887 
1888  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1889  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1890  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1891  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1892  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1893  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1894  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1895  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1896  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1897  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1898  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1899  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1900  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1901  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1902  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1903  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1904  sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1905  sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
1906  sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
1907  sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
1908  sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason) ||
1909  sizeof(int32_t) != sizeof(OrthancPluginReceivedInstanceAction))
1910  {
1911  /* Mismatch in the size of the enumerations */
1912  return 0;
1913  }
1914 
1915  /* Assume compatibility with the mainline */
1916  if (!strcmp(context->orthancVersion, "mainline"))
1917  {
1918  return 1;
1919  }
1920 
1921  /* Parse the version of the Orthanc core */
1922  if (
1923 #ifdef _MSC_VER
1924  sscanf_s
1925 #else
1926  sscanf
1927 #endif
1928  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1929  {
1930  return 0;
1931  }
1932 
1933  /* Check the major number of the version */
1934 
1935  if (major > expectedMajor)
1936  {
1937  return 1;
1938  }
1939 
1940  if (major < expectedMajor)
1941  {
1942  return 0;
1943  }
1944 
1945  /* Check the minor number of the version */
1946 
1947  if (minor > expectedMinor)
1948  {
1949  return 1;
1950  }
1951 
1952  if (minor < expectedMinor)
1953  {
1954  return 0;
1955  }
1956 
1957  /* Check the revision number of the version */
1958 
1959  if (revision >= expectedRevision)
1960  {
1961  return 1;
1962  }
1963  else
1964  {
1965  return 0;
1966  }
1967  }
1968 
1969 
1986  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1987  OrthancPluginContext* context)
1988  {
1990  context,
1991  ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1992  ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1993  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1994  }
1995 
1996 
2005  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
2006  OrthancPluginContext* context,
2007  OrthancPluginMemoryBuffer* buffer)
2008  {
2009  context->Free(buffer->data);
2010  }
2011 
2012 
2021  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer64(
2022  OrthancPluginContext* context,
2024  {
2025  context->Free(buffer->data);
2026  }
2027 
2028 
2037  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
2038  OrthancPluginContext* context,
2039  const char* message)
2040  {
2041  context->InvokeService(context, _OrthancPluginService_LogError, message);
2042  }
2043 
2044 
2053  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
2054  OrthancPluginContext* context,
2055  const char* message)
2056  {
2057  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
2058  }
2059 
2060 
2069  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
2070  OrthancPluginContext* context,
2071  const char* message)
2072  {
2073  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
2074  }
2075 
2076 
2077 
2078  typedef struct
2079  {
2080  const char* pathRegularExpression;
2081  OrthancPluginRestCallback callback;
2082  } _OrthancPluginRestCallback;
2083 
2105  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
2106  OrthancPluginContext* context,
2107  const char* pathRegularExpression,
2108  OrthancPluginRestCallback callback)
2109  {
2110  _OrthancPluginRestCallback params;
2111  params.pathRegularExpression = pathRegularExpression;
2112  params.callback = callback;
2113  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
2114  }
2115 
2116 
2117 
2145  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
2146  OrthancPluginContext* context,
2147  const char* pathRegularExpression,
2148  OrthancPluginRestCallback callback)
2149  {
2150  _OrthancPluginRestCallback params;
2151  params.pathRegularExpression = pathRegularExpression;
2152  params.callback = callback;
2153  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
2154  }
2155 
2156 
2157 
2158  typedef struct
2159  {
2161  } _OrthancPluginOnStoredInstanceCallback;
2162 
2184  OrthancPluginContext* context,
2186  {
2187  _OrthancPluginOnStoredInstanceCallback params;
2188  params.callback = callback;
2189 
2190  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
2191  }
2192 
2193 
2194 
2195  typedef struct
2196  {
2197  OrthancPluginRestOutput* output;
2198  const void* answer;
2199  uint32_t answerSize;
2200  const char* mimeType;
2201  } _OrthancPluginAnswerBuffer;
2202 
2215  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
2216  OrthancPluginContext* context,
2217  OrthancPluginRestOutput* output,
2218  const void* answer,
2219  uint32_t answerSize,
2220  const char* mimeType)
2221  {
2222  _OrthancPluginAnswerBuffer params;
2223  params.output = output;
2224  params.answer = answer;
2225  params.answerSize = answerSize;
2226  params.mimeType = mimeType;
2227  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
2228  }
2229 
2230 
2231  typedef struct
2232  {
2233  OrthancPluginRestOutput* output;
2234  OrthancPluginPixelFormat format;
2235  uint32_t width;
2236  uint32_t height;
2237  uint32_t pitch;
2238  const void* buffer;
2239  } _OrthancPluginCompressAndAnswerPngImage;
2240 
2241  typedef struct
2242  {
2243  OrthancPluginRestOutput* output;
2244  OrthancPluginImageFormat imageFormat;
2245  OrthancPluginPixelFormat pixelFormat;
2246  uint32_t width;
2247  uint32_t height;
2248  uint32_t pitch;
2249  const void* buffer;
2250  uint8_t quality;
2251  } _OrthancPluginCompressAndAnswerImage;
2252 
2253 
2272  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2273  OrthancPluginContext* context,
2274  OrthancPluginRestOutput* output,
2275  OrthancPluginPixelFormat format,
2276  uint32_t width,
2277  uint32_t height,
2278  uint32_t pitch,
2279  const void* buffer)
2280  {
2281  _OrthancPluginCompressAndAnswerImage params;
2282  params.output = output;
2283  params.imageFormat = OrthancPluginImageFormat_Png;
2284  params.pixelFormat = format;
2285  params.width = width;
2286  params.height = height;
2287  params.pitch = pitch;
2288  params.buffer = buffer;
2289  params.quality = 0; /* No quality for PNG */
2290  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2291  }
2292 
2293 
2294 
2295  typedef struct
2296  {
2297  OrthancPluginMemoryBuffer* target;
2298  const char* instanceId;
2299  } _OrthancPluginGetDicomForInstance;
2300 
2314  OrthancPluginContext* context,
2315  OrthancPluginMemoryBuffer* target,
2316  const char* instanceId)
2317  {
2318  _OrthancPluginGetDicomForInstance params;
2319  params.target = target;
2320  params.instanceId = instanceId;
2321  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2322  }
2323 
2324 
2325 
2326  typedef struct
2327  {
2328  OrthancPluginMemoryBuffer* target;
2329  const char* uri;
2330  } _OrthancPluginRestApiGet;
2331 
2347  OrthancPluginContext* context,
2348  OrthancPluginMemoryBuffer* target,
2349  const char* uri)
2350  {
2351  _OrthancPluginRestApiGet params;
2352  params.target = target;
2353  params.uri = uri;
2354  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2355  }
2356 
2357 
2358 
2377  OrthancPluginContext* context,
2378  OrthancPluginMemoryBuffer* target,
2379  const char* uri)
2380  {
2381  _OrthancPluginRestApiGet params;
2382  params.target = target;
2383  params.uri = uri;
2384  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2385  }
2386 
2387 
2388 
2389  typedef struct
2390  {
2391  OrthancPluginMemoryBuffer* target;
2392  const char* uri;
2393  const void* body;
2394  uint32_t bodySize;
2395  } _OrthancPluginRestApiPostPut;
2396 
2414  OrthancPluginContext* context,
2415  OrthancPluginMemoryBuffer* target,
2416  const char* uri,
2417  const void* body,
2418  uint32_t bodySize)
2419  {
2420  _OrthancPluginRestApiPostPut params;
2421  params.target = target;
2422  params.uri = uri;
2423  params.body = body;
2424  params.bodySize = bodySize;
2425  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2426  }
2427 
2428 
2449  OrthancPluginContext* context,
2450  OrthancPluginMemoryBuffer* target,
2451  const char* uri,
2452  const void* body,
2453  uint32_t bodySize)
2454  {
2455  _OrthancPluginRestApiPostPut params;
2456  params.target = target;
2457  params.uri = uri;
2458  params.body = body;
2459  params.bodySize = bodySize;
2460  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2461  }
2462 
2463 
2464 
2478  OrthancPluginContext* context,
2479  const char* uri)
2480  {
2481  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2482  }
2483 
2484 
2501  OrthancPluginContext* context,
2502  const char* uri)
2503  {
2504  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2505  }
2506 
2507 
2508 
2526  OrthancPluginContext* context,
2527  OrthancPluginMemoryBuffer* target,
2528  const char* uri,
2529  const void* body,
2530  uint32_t bodySize)
2531  {
2532  _OrthancPluginRestApiPostPut params;
2533  params.target = target;
2534  params.uri = uri;
2535  params.body = body;
2536  params.bodySize = bodySize;
2537  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2538  }
2539 
2540 
2541 
2562  OrthancPluginContext* context,
2563  OrthancPluginMemoryBuffer* target,
2564  const char* uri,
2565  const void* body,
2566  uint32_t bodySize)
2567  {
2568  _OrthancPluginRestApiPostPut params;
2569  params.target = target;
2570  params.uri = uri;
2571  params.body = body;
2572  params.bodySize = bodySize;
2573  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2574  }
2575 
2576 
2577 
2578  typedef struct
2579  {
2580  OrthancPluginRestOutput* output;
2581  const char* argument;
2582  } _OrthancPluginOutputPlusArgument;
2583 
2595  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2596  OrthancPluginContext* context,
2597  OrthancPluginRestOutput* output,
2598  const char* redirection)
2599  {
2600  _OrthancPluginOutputPlusArgument params;
2601  params.output = output;
2602  params.argument = redirection;
2603  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2604  }
2605 
2606 
2607 
2608  typedef struct
2609  {
2610  char** result;
2611  const char* argument;
2612  } _OrthancPluginRetrieveDynamicString;
2613 
2627  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2628  OrthancPluginContext* context,
2629  const char* patientID)
2630  {
2631  char* result;
2632 
2633  _OrthancPluginRetrieveDynamicString params;
2634  params.result = &result;
2635  params.argument = patientID;
2636 
2637  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2638  {
2639  /* Error */
2640  return NULL;
2641  }
2642  else
2643  {
2644  return result;
2645  }
2646  }
2647 
2648 
2662  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2663  OrthancPluginContext* context,
2664  const char* studyUID)
2665  {
2666  char* result;
2667 
2668  _OrthancPluginRetrieveDynamicString params;
2669  params.result = &result;
2670  params.argument = studyUID;
2671 
2672  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2673  {
2674  /* Error */
2675  return NULL;
2676  }
2677  else
2678  {
2679  return result;
2680  }
2681  }
2682 
2683 
2697  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
2698  OrthancPluginContext* context,
2699  const char* accessionNumber)
2700  {
2701  char* result;
2702 
2703  _OrthancPluginRetrieveDynamicString params;
2704  params.result = &result;
2705  params.argument = accessionNumber;
2706 
2707  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2708  {
2709  /* Error */
2710  return NULL;
2711  }
2712  else
2713  {
2714  return result;
2715  }
2716  }
2717 
2718 
2732  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2733  OrthancPluginContext* context,
2734  const char* seriesUID)
2735  {
2736  char* result;
2737 
2738  _OrthancPluginRetrieveDynamicString params;
2739  params.result = &result;
2740  params.argument = seriesUID;
2741 
2742  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2743  {
2744  /* Error */
2745  return NULL;
2746  }
2747  else
2748  {
2749  return result;
2750  }
2751  }
2752 
2753 
2767  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2768  OrthancPluginContext* context,
2769  const char* sopInstanceUID)
2770  {
2771  char* result;
2772 
2773  _OrthancPluginRetrieveDynamicString params;
2774  params.result = &result;
2775  params.argument = sopInstanceUID;
2776 
2777  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2778  {
2779  /* Error */
2780  return NULL;
2781  }
2782  else
2783  {
2784  return result;
2785  }
2786  }
2787 
2788 
2789 
2790  typedef struct
2791  {
2792  OrthancPluginRestOutput* output;
2793  uint16_t status;
2794  } _OrthancPluginSendHttpStatusCode;
2795 
2812  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2813  OrthancPluginContext* context,
2814  OrthancPluginRestOutput* output,
2815  uint16_t status)
2816  {
2817  _OrthancPluginSendHttpStatusCode params;
2818  params.output = output;
2819  params.status = status;
2820  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2821  }
2822 
2823 
2835  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2836  OrthancPluginContext* context,
2837  OrthancPluginRestOutput* output,
2838  const char* realm)
2839  {
2840  _OrthancPluginOutputPlusArgument params;
2841  params.output = output;
2842  params.argument = realm;
2843  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2844  }
2845 
2846 
2858  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2859  OrthancPluginContext* context,
2860  OrthancPluginRestOutput* output,
2861  const char* allowedMethods)
2862  {
2863  _OrthancPluginOutputPlusArgument params;
2864  params.output = output;
2865  params.argument = allowedMethods;
2866  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2867  }
2868 
2869 
2870  typedef struct
2871  {
2872  OrthancPluginRestOutput* output;
2873  const char* key;
2874  const char* value;
2875  } _OrthancPluginSetHttpHeader;
2876 
2888  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2889  OrthancPluginContext* context,
2890  OrthancPluginRestOutput* output,
2891  const char* cookie,
2892  const char* value)
2893  {
2894  _OrthancPluginSetHttpHeader params;
2895  params.output = output;
2896  params.key = cookie;
2897  params.value = value;
2898  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2899  }
2900 
2901 
2913  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2914  OrthancPluginContext* context,
2915  OrthancPluginRestOutput* output,
2916  const char* key,
2917  const char* value)
2918  {
2919  _OrthancPluginSetHttpHeader params;
2920  params.output = output;
2921  params.key = key;
2922  params.value = value;
2923  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2924  }
2925 
2926 
2927  typedef struct
2928  {
2929  char** resultStringToFree;
2930  const char** resultString;
2931  int64_t* resultInt64;
2932  const char* key;
2933  const OrthancPluginDicomInstance* instance;
2934  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2935  } _OrthancPluginAccessDicomInstance;
2936 
2937 
2949  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2950  OrthancPluginContext* context,
2951  const OrthancPluginDicomInstance* instance)
2952  {
2953  const char* result;
2954 
2955  _OrthancPluginAccessDicomInstance params;
2956  memset(&params, 0, sizeof(params));
2957  params.resultString = &result;
2958  params.instance = instance;
2959 
2960  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2961  {
2962  /* Error */
2963  return NULL;
2964  }
2965  else
2966  {
2967  return result;
2968  }
2969  }
2970 
2971 
2982  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2983  OrthancPluginContext* context,
2984  const OrthancPluginDicomInstance* instance)
2985  {
2986  int64_t size;
2987 
2988  _OrthancPluginAccessDicomInstance params;
2989  memset(&params, 0, sizeof(params));
2990  params.resultInt64 = &size;
2991  params.instance = instance;
2992 
2993  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2994  {
2995  /* Error */
2996  return -1;
2997  }
2998  else
2999  {
3000  return size;
3001  }
3002  }
3003 
3004 
3015  ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData(
3016  OrthancPluginContext* context,
3017  const OrthancPluginDicomInstance* instance)
3018  {
3019  const char* result;
3020 
3021  _OrthancPluginAccessDicomInstance params;
3022  memset(&params, 0, sizeof(params));
3023  params.resultString = &result;
3024  params.instance = instance;
3025 
3026  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
3027  {
3028  /* Error */
3029  return NULL;
3030  }
3031  else
3032  {
3033  return result;
3034  }
3035  }
3036 
3037 
3051  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
3052  OrthancPluginContext* context,
3053  const OrthancPluginDicomInstance* instance)
3054  {
3055  char* result;
3056 
3057  _OrthancPluginAccessDicomInstance params;
3058  memset(&params, 0, sizeof(params));
3059  params.resultStringToFree = &result;
3060  params.instance = instance;
3061 
3062  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
3063  {
3064  /* Error */
3065  return NULL;
3066  }
3067  else
3068  {
3069  return result;
3070  }
3071  }
3072 
3073 
3089  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
3090  OrthancPluginContext* context,
3091  const OrthancPluginDicomInstance* instance)
3092  {
3093  char* result;
3094 
3095  _OrthancPluginAccessDicomInstance params;
3096  memset(&params, 0, sizeof(params));
3097  params.resultStringToFree = &result;
3098  params.instance = instance;
3099 
3100  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
3101  {
3102  /* Error */
3103  return NULL;
3104  }
3105  else
3106  {
3107  return result;
3108  }
3109  }
3110 
3111 
3128  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
3129  OrthancPluginContext* context,
3130  const OrthancPluginDicomInstance* instance,
3131  const char* metadata)
3132  {
3133  int64_t result;
3134 
3135  _OrthancPluginAccessDicomInstance params;
3136  memset(&params, 0, sizeof(params));
3137  params.resultInt64 = &result;
3138  params.instance = instance;
3139  params.key = metadata;
3140 
3141  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3142  {
3143  /* Error */
3144  return -1;
3145  }
3146  else
3147  {
3148  return (result != 0);
3149  }
3150  }
3151 
3152 
3169  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
3170  OrthancPluginContext* context,
3171  const OrthancPluginDicomInstance* instance,
3172  const char* metadata)
3173  {
3174  const char* result;
3175 
3176  _OrthancPluginAccessDicomInstance params;
3177  memset(&params, 0, sizeof(params));
3178  params.resultString = &result;
3179  params.instance = instance;
3180  params.key = metadata;
3181 
3182  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3183  {
3184  /* Error */
3185  return NULL;
3186  }
3187  else
3188  {
3189  return result;
3190  }
3191  }
3192 
3193 
3194 
3195  typedef struct
3196  {
3200  OrthancPluginFree free;
3201  } _OrthancPluginRegisterStorageArea;
3202 
3218  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
3219  OrthancPluginContext* context,
3223  {
3224  _OrthancPluginRegisterStorageArea params;
3225  params.create = create;
3226  params.read = read;
3227  params.remove = remove;
3228 
3229 #ifdef __cplusplus
3230  params.free = ::free;
3231 #else
3232  params.free = free;
3233 #endif
3234 
3235  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3236  }
3237 
3238 
3239 
3250  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3251  {
3252  char* result;
3253 
3254  _OrthancPluginRetrieveDynamicString params;
3255  params.result = &result;
3256  params.argument = NULL;
3257 
3258  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3259  {
3260  /* Error */
3261  return NULL;
3262  }
3263  else
3264  {
3265  return result;
3266  }
3267  }
3268 
3269 
3280  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3281  {
3282  char* result;
3283 
3284  _OrthancPluginRetrieveDynamicString params;
3285  params.result = &result;
3286  params.argument = NULL;
3287 
3288  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3289  {
3290  /* Error */
3291  return NULL;
3292  }
3293  else
3294  {
3295  return result;
3296  }
3297  }
3298 
3299 
3315  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3316  {
3317  char* result;
3318 
3319  _OrthancPluginRetrieveDynamicString params;
3320  params.result = &result;
3321  params.argument = NULL;
3322 
3323  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3324  {
3325  /* Error */
3326  return NULL;
3327  }
3328  else
3329  {
3330  return result;
3331  }
3332  }
3333 
3334 
3335 
3336  typedef struct
3337  {
3339  } _OrthancPluginOnChangeCallback;
3340 
3361  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3362  OrthancPluginContext* context,
3364  {
3365  _OrthancPluginOnChangeCallback params;
3366  params.callback = callback;
3367 
3368  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3369  }
3370 
3371 
3372 
3373  typedef struct
3374  {
3375  const char* plugin;
3376  _OrthancPluginProperty property;
3377  const char* value;
3378  } _OrthancPluginSetPluginProperty;
3379 
3380 
3392  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3393  OrthancPluginContext* context,
3394  const char* uri)
3395  {
3396  _OrthancPluginSetPluginProperty params;
3397  params.plugin = OrthancPluginGetName();
3398  params.property = _OrthancPluginProperty_RootUri;
3399  params.value = uri;
3400 
3401  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3402  }
3403 
3404 
3414  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3415  OrthancPluginContext* context,
3416  const char* description)
3417  {
3418  _OrthancPluginSetPluginProperty params;
3419  params.plugin = OrthancPluginGetName();
3420  params.property = _OrthancPluginProperty_Description;
3421  params.value = description;
3422 
3423  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3424  }
3425 
3426 
3436  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3437  OrthancPluginContext* context,
3438  const char* javascript)
3439  {
3440  _OrthancPluginSetPluginProperty params;
3441  params.plugin = OrthancPluginGetName();
3442  params.property = _OrthancPluginProperty_OrthancExplorer;
3443  params.value = javascript;
3444 
3445  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3446  }
3447 
3448 
3449  typedef struct
3450  {
3451  char** result;
3452  int32_t property;
3453  const char* value;
3454  } _OrthancPluginGlobalProperty;
3455 
3456 
3470  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3471  OrthancPluginContext* context,
3472  int32_t property,
3473  const char* defaultValue)
3474  {
3475  char* result;
3476 
3477  _OrthancPluginGlobalProperty params;
3478  params.result = &result;
3479  params.property = property;
3480  params.value = defaultValue;
3481 
3482  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3483  {
3484  /* Error */
3485  return NULL;
3486  }
3487  else
3488  {
3489  return result;
3490  }
3491  }
3492 
3493 
3510  OrthancPluginContext* context,
3511  int32_t property,
3512  const char* value)
3513  {
3514  _OrthancPluginGlobalProperty params;
3515  params.result = NULL;
3516  params.property = property;
3517  params.value = value;
3518 
3519  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3520  }
3521 
3522 
3523 
3524  typedef struct
3525  {
3526  int32_t *resultInt32;
3527  uint32_t *resultUint32;
3528  int64_t *resultInt64;
3529  uint64_t *resultUint64;
3530  } _OrthancPluginReturnSingleValue;
3531 
3540  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3541  OrthancPluginContext* context)
3542  {
3543  uint32_t count = 0;
3544 
3545  _OrthancPluginReturnSingleValue params;
3546  memset(&params, 0, sizeof(params));
3547  params.resultUint32 = &count;
3548 
3549  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3550  {
3551  /* Error */
3552  return 0;
3553  }
3554  else
3555  {
3556  return count;
3557  }
3558  }
3559 
3560 
3561 
3574  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3575  OrthancPluginContext* context,
3576  uint32_t argument)
3577  {
3578  char* result;
3579 
3580  _OrthancPluginGlobalProperty params;
3581  params.result = &result;
3582  params.property = (int32_t) argument;
3583  params.value = NULL;
3584 
3585  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3586  {
3587  /* Error */
3588  return NULL;
3589  }
3590  else
3591  {
3592  return result;
3593  }
3594  }
3595 
3596 
3606  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3607  OrthancPluginContext* context)
3608  {
3609  uint32_t count = 0;
3610 
3611  _OrthancPluginReturnSingleValue params;
3612  memset(&params, 0, sizeof(params));
3613  params.resultUint32 = &count;
3614 
3615  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3616  {
3617  /* Error */
3618  return 0;
3619  }
3620  else
3621  {
3622  return count;
3623  }
3624  }
3625 
3626 
3627 
3639  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3640  {
3641  char* result;
3642 
3643  _OrthancPluginRetrieveDynamicString params;
3644  params.result = &result;
3645  params.argument = NULL;
3646 
3647  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3648  {
3649  /* Error */
3650  return NULL;
3651  }
3652  else
3653  {
3654  return result;
3655  }
3656  }
3657 
3658 
3659 
3660  typedef struct
3661  {
3662  OrthancPluginRestOutput* output;
3663  const char* subType;
3664  const char* contentType;
3665  } _OrthancPluginStartMultipartAnswer;
3666 
3681  OrthancPluginContext* context,
3682  OrthancPluginRestOutput* output,
3683  const char* subType,
3684  const char* contentType)
3685  {
3686  _OrthancPluginStartMultipartAnswer params;
3687  params.output = output;
3688  params.subType = subType;
3689  params.contentType = contentType;
3690  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3691  }
3692 
3693 
3710  OrthancPluginContext* context,
3711  OrthancPluginRestOutput* output,
3712  const void* answer,
3713  uint32_t answerSize)
3714  {
3715  _OrthancPluginAnswerBuffer params;
3716  params.output = output;
3717  params.answer = answer;
3718  params.answerSize = answerSize;
3719  params.mimeType = NULL;
3720  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3721  }
3722 
3723 
3724 
3725  typedef struct
3726  {
3727  OrthancPluginMemoryBuffer* target;
3728  const void* source;
3729  uint32_t size;
3730  OrthancPluginCompressionType compression;
3731  uint8_t uncompress;
3732  } _OrthancPluginBufferCompression;
3733 
3734 
3752  OrthancPluginContext* context,
3753  OrthancPluginMemoryBuffer* target,
3754  const void* source,
3755  uint32_t size,
3756  OrthancPluginCompressionType compression,
3757  uint8_t uncompress)
3758  {
3759  _OrthancPluginBufferCompression params;
3760  params.target = target;
3761  params.source = source;
3762  params.size = size;
3763  params.compression = compression;
3764  params.uncompress = uncompress;
3765 
3766  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3767  }
3768 
3769 
3770 
3771  typedef struct
3772  {
3773  OrthancPluginMemoryBuffer* target;
3774  const char* path;
3775  } _OrthancPluginReadFile;
3776 
3789  OrthancPluginContext* context,
3790  OrthancPluginMemoryBuffer* target,
3791  const char* path)
3792  {
3793  _OrthancPluginReadFile params;
3794  params.target = target;
3795  params.path = path;
3796  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3797  }
3798 
3799 
3800 
3801  typedef struct
3802  {
3803  const char* path;
3804  const void* data;
3805  uint32_t size;
3806  } _OrthancPluginWriteFile;
3807 
3820  OrthancPluginContext* context,
3821  const char* path,
3822  const void* data,
3823  uint32_t size)
3824  {
3825  _OrthancPluginWriteFile params;
3826  params.path = path;
3827  params.data = data;
3828  params.size = size;
3829  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3830  }
3831 
3832 
3833 
3834  typedef struct
3835  {
3836  const char** target;
3837  OrthancPluginErrorCode error;
3838  } _OrthancPluginGetErrorDescription;
3839 
3850  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3851  OrthancPluginContext* context,
3852  OrthancPluginErrorCode error)
3853  {
3854  const char* result = NULL;
3855 
3856  _OrthancPluginGetErrorDescription params;
3857  params.target = &result;
3858  params.error = error;
3859 
3860  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3861  result == NULL)
3862  {
3863  return "Unknown error code";
3864  }
3865  else
3866  {
3867  return result;
3868  }
3869  }
3870 
3871 
3872 
3873  typedef struct
3874  {
3875  OrthancPluginRestOutput* output;
3876  uint16_t status;
3877  const void* body;
3878  uint32_t bodySize;
3879  } _OrthancPluginSendHttpStatus;
3880 
3903  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3904  OrthancPluginContext* context,
3905  OrthancPluginRestOutput* output,
3906  uint16_t status,
3907  const void* body,
3908  uint32_t bodySize)
3909  {
3910  _OrthancPluginSendHttpStatus params;
3911  params.output = output;
3912  params.status = status;
3913  params.body = body;
3914  params.bodySize = bodySize;
3915  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3916  }
3917 
3918 
3919 
3920  typedef struct
3921  {
3922  const OrthancPluginImage* image;
3923  uint32_t* resultUint32;
3924  OrthancPluginPixelFormat* resultPixelFormat;
3925  void** resultBuffer;
3926  } _OrthancPluginGetImageInfo;
3927 
3928 
3940  OrthancPluginContext* context,
3941  const OrthancPluginImage* image)
3942  {
3943  OrthancPluginPixelFormat target;
3944 
3945  _OrthancPluginGetImageInfo params;
3946  memset(&params, 0, sizeof(params));
3947  params.image = image;
3948  params.resultPixelFormat = &target;
3949 
3950  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3951  {
3953  }
3954  else
3955  {
3956  return (OrthancPluginPixelFormat) target;
3957  }
3958  }
3959 
3960 
3961 
3972  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3973  OrthancPluginContext* context,
3974  const OrthancPluginImage* image)
3975  {
3976  uint32_t width;
3977 
3978  _OrthancPluginGetImageInfo params;
3979  memset(&params, 0, sizeof(params));
3980  params.image = image;
3981  params.resultUint32 = &width;
3982 
3983  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3984  {
3985  return 0;
3986  }
3987  else
3988  {
3989  return width;
3990  }
3991  }
3992 
3993 
3994 
4005  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
4006  OrthancPluginContext* context,
4007  const OrthancPluginImage* image)
4008  {
4009  uint32_t height;
4010 
4011  _OrthancPluginGetImageInfo params;
4012  memset(&params, 0, sizeof(params));
4013  params.image = image;
4014  params.resultUint32 = &height;
4015 
4016  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
4017  {
4018  return 0;
4019  }
4020  else
4021  {
4022  return height;
4023  }
4024  }
4025 
4026 
4027 
4040  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
4041  OrthancPluginContext* context,
4042  const OrthancPluginImage* image)
4043  {
4044  uint32_t pitch;
4045 
4046  _OrthancPluginGetImageInfo params;
4047  memset(&params, 0, sizeof(params));
4048  params.image = image;
4049  params.resultUint32 = &pitch;
4050 
4051  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
4052  {
4053  return 0;
4054  }
4055  else
4056  {
4057  return pitch;
4058  }
4059  }
4060 
4061 
4062 
4074  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
4075  OrthancPluginContext* context,
4076  const OrthancPluginImage* image)
4077  {
4078  void* target = NULL;
4079 
4080  _OrthancPluginGetImageInfo params;
4081  memset(&params, 0, sizeof(params));
4082  params.resultBuffer = &target;
4083  params.image = image;
4084 
4085  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
4086  {
4087  return NULL;
4088  }
4089  else
4090  {
4091  return target;
4092  }
4093  }
4094 
4095 
4096  typedef struct
4097  {
4098  OrthancPluginImage** target;
4099  const void* data;
4100  uint32_t size;
4101  OrthancPluginImageFormat format;
4102  } _OrthancPluginUncompressImage;
4103 
4104 
4118  OrthancPluginContext* context,
4119  const void* data,
4120  uint32_t size,
4121  OrthancPluginImageFormat format)
4122  {
4123  OrthancPluginImage* target = NULL;
4124 
4125  _OrthancPluginUncompressImage params;
4126  memset(&params, 0, sizeof(params));
4127  params.target = &target;
4128  params.data = data;
4129  params.size = size;
4130  params.format = format;
4131 
4132  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
4133  {
4134  return NULL;
4135  }
4136  else
4137  {
4138  return target;
4139  }
4140  }
4141 
4142 
4143 
4144 
4145  typedef struct
4146  {
4147  OrthancPluginImage* image;
4148  } _OrthancPluginFreeImage;
4149 
4159  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
4160  OrthancPluginContext* context,
4161  OrthancPluginImage* image)
4162  {
4163  _OrthancPluginFreeImage params;
4164  params.image = image;
4165 
4166  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
4167  }
4168 
4169 
4170 
4171 
4172  typedef struct
4173  {
4174  OrthancPluginMemoryBuffer* target;
4175  OrthancPluginImageFormat imageFormat;
4176  OrthancPluginPixelFormat pixelFormat;
4177  uint32_t width;
4178  uint32_t height;
4179  uint32_t pitch;
4180  const void* buffer;
4181  uint8_t quality;
4182  } _OrthancPluginCompressImage;
4183 
4184 
4205  OrthancPluginContext* context,
4206  OrthancPluginMemoryBuffer* target,
4207  OrthancPluginPixelFormat format,
4208  uint32_t width,
4209  uint32_t height,
4210  uint32_t pitch,
4211  const void* buffer)
4212  {
4213  _OrthancPluginCompressImage params;
4214  memset(&params, 0, sizeof(params));
4215  params.target = target;
4216  params.imageFormat = OrthancPluginImageFormat_Png;
4217  params.pixelFormat = format;
4218  params.width = width;
4219  params.height = height;
4220  params.pitch = pitch;
4221  params.buffer = buffer;
4222  params.quality = 0; /* Unused for PNG */
4223 
4224  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4225  }
4226 
4227 
4250  OrthancPluginContext* context,
4251  OrthancPluginMemoryBuffer* target,
4252  OrthancPluginPixelFormat format,
4253  uint32_t width,
4254  uint32_t height,
4255  uint32_t pitch,
4256  const void* buffer,
4257  uint8_t quality)
4258  {
4259  _OrthancPluginCompressImage params;
4260  memset(&params, 0, sizeof(params));
4261  params.target = target;
4262  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4263  params.pixelFormat = format;
4264  params.width = width;
4265  params.height = height;
4266  params.pitch = pitch;
4267  params.buffer = buffer;
4268  params.quality = quality;
4269 
4270  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4271  }
4272 
4273 
4274 
4296  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
4297  OrthancPluginContext* context,
4298  OrthancPluginRestOutput* output,
4299  OrthancPluginPixelFormat format,
4300  uint32_t width,
4301  uint32_t height,
4302  uint32_t pitch,
4303  const void* buffer,
4304  uint8_t quality)
4305  {
4306  _OrthancPluginCompressAndAnswerImage params;
4307  params.output = output;
4308  params.imageFormat = OrthancPluginImageFormat_Jpeg;
4309  params.pixelFormat = format;
4310  params.width = width;
4311  params.height = height;
4312  params.pitch = pitch;
4313  params.buffer = buffer;
4314  params.quality = quality;
4315  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4316  }
4317 
4318 
4319 
4320 
4321  typedef struct
4322  {
4323  OrthancPluginMemoryBuffer* target;
4324  OrthancPluginHttpMethod method;
4325  const char* url;
4326  const char* username;
4327  const char* password;
4328  const void* body;
4329  uint32_t bodySize;
4330  } _OrthancPluginCallHttpClient;
4331 
4332 
4350  OrthancPluginContext* context,
4351  OrthancPluginMemoryBuffer* target,
4352  const char* url,
4353  const char* username,
4354  const char* password)
4355  {
4356  _OrthancPluginCallHttpClient params;
4357  memset(&params, 0, sizeof(params));
4358 
4359  params.target = target;
4360  params.method = OrthancPluginHttpMethod_Get;
4361  params.url = url;
4362  params.username = username;
4363  params.password = password;
4364 
4365  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4366  }
4367 
4368 
4388  OrthancPluginContext* context,
4389  OrthancPluginMemoryBuffer* target,
4390  const char* url,
4391  const void* body,
4392  uint32_t bodySize,
4393  const char* username,
4394  const char* password)
4395  {
4396  _OrthancPluginCallHttpClient params;
4397  memset(&params, 0, sizeof(params));
4398 
4399  params.target = target;
4400  params.method = OrthancPluginHttpMethod_Post;
4401  params.url = url;
4402  params.body = body;
4403  params.bodySize = bodySize;
4404  params.username = username;
4405  params.password = password;
4406 
4407  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4408  }
4409 
4410 
4430  OrthancPluginContext* context,
4431  OrthancPluginMemoryBuffer* target,
4432  const char* url,
4433  const void* body,
4434  uint32_t bodySize,
4435  const char* username,
4436  const char* password)
4437  {
4438  _OrthancPluginCallHttpClient params;
4439  memset(&params, 0, sizeof(params));
4440 
4441  params.target = target;
4442  params.method = OrthancPluginHttpMethod_Put;
4443  params.url = url;
4444  params.body = body;
4445  params.bodySize = bodySize;
4446  params.username = username;
4447  params.password = password;
4448 
4449  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4450  }
4451 
4452 
4468  OrthancPluginContext* context,
4469  const char* url,
4470  const char* username,
4471  const char* password)
4472  {
4473  _OrthancPluginCallHttpClient params;
4474  memset(&params, 0, sizeof(params));
4475 
4476  params.method = OrthancPluginHttpMethod_Delete;
4477  params.url = url;
4478  params.username = username;
4479  params.password = password;
4480 
4481  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4482  }
4483 
4484 
4485 
4486  typedef struct
4487  {
4488  OrthancPluginImage** target;
4489  const OrthancPluginImage* source;
4490  OrthancPluginPixelFormat targetFormat;
4491  } _OrthancPluginConvertPixelFormat;
4492 
4493 
4506  OrthancPluginContext* context,
4507  const OrthancPluginImage* source,
4508  OrthancPluginPixelFormat targetFormat)
4509  {
4510  OrthancPluginImage* target = NULL;
4511 
4512  _OrthancPluginConvertPixelFormat params;
4513  params.target = &target;
4514  params.source = source;
4515  params.targetFormat = targetFormat;
4516 
4517  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4518  {
4519  return NULL;
4520  }
4521  else
4522  {
4523  return target;
4524  }
4525  }
4526 
4527 
4528 
4540  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4541  OrthancPluginContext* context)
4542  {
4543  uint32_t count = 0;
4544 
4545  _OrthancPluginReturnSingleValue params;
4546  memset(&params, 0, sizeof(params));
4547  params.resultUint32 = &count;
4548 
4549  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4550  {
4551  /* Error */
4552  return 0;
4553  }
4554  else
4555  {
4556  return count;
4557  }
4558  }
4559 
4560 
4561 
4562 
4563  typedef struct
4564  {
4565  uint32_t fontIndex; /* in */
4566  const char** name; /* out */
4567  uint32_t* size; /* out */
4568  } _OrthancPluginGetFontInfo;
4569 
4580  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4581  OrthancPluginContext* context,
4582  uint32_t fontIndex)
4583  {
4584  const char* result = NULL;
4585 
4586  _OrthancPluginGetFontInfo params;
4587  memset(&params, 0, sizeof(params));
4588  params.name = &result;
4589  params.fontIndex = fontIndex;
4590 
4591  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4592  {
4593  return NULL;
4594  }
4595  else
4596  {
4597  return result;
4598  }
4599  }
4600 
4601 
4612  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4613  OrthancPluginContext* context,
4614  uint32_t fontIndex)
4615  {
4616  uint32_t result;
4617 
4618  _OrthancPluginGetFontInfo params;
4619  memset(&params, 0, sizeof(params));
4620  params.size = &result;
4621  params.fontIndex = fontIndex;
4622 
4623  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4624  {
4625  return 0;
4626  }
4627  else
4628  {
4629  return result;
4630  }
4631  }
4632 
4633 
4634 
4635  typedef struct
4636  {
4637  OrthancPluginImage* image;
4638  uint32_t fontIndex;
4639  const char* utf8Text;
4640  int32_t x;
4641  int32_t y;
4642  uint8_t r;
4643  uint8_t g;
4644  uint8_t b;
4645  } _OrthancPluginDrawText;
4646 
4647 
4666  OrthancPluginContext* context,
4667  OrthancPluginImage* image,
4668  uint32_t fontIndex,
4669  const char* utf8Text,
4670  int32_t x,
4671  int32_t y,
4672  uint8_t r,
4673  uint8_t g,
4674  uint8_t b)
4675  {
4676  _OrthancPluginDrawText params;
4677  memset(&params, 0, sizeof(params));
4678  params.image = image;
4679  params.fontIndex = fontIndex;
4680  params.utf8Text = utf8Text;
4681  params.x = x;
4682  params.y = y;
4683  params.r = r;
4684  params.g = g;
4685  params.b = b;
4686 
4687  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4688  }
4689 
4690 
4691 
4692  typedef struct
4693  {
4694  OrthancPluginStorageArea* storageArea;
4695  const char* uuid;
4696  const void* content;
4697  uint64_t size;
4699  } _OrthancPluginStorageAreaCreate;
4700 
4701 
4720  OrthancPluginContext* context,
4721  OrthancPluginStorageArea* storageArea,
4722  const char* uuid,
4723  const void* content,
4724  uint64_t size,
4726  {
4727  _OrthancPluginStorageAreaCreate params;
4728  params.storageArea = storageArea;
4729  params.uuid = uuid;
4730  params.content = content;
4731  params.size = size;
4732  params.type = type;
4733 
4734  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4735  }
4736 
4737 
4738  typedef struct
4739  {
4740  OrthancPluginMemoryBuffer* target;
4741  OrthancPluginStorageArea* storageArea;
4742  const char* uuid;
4744  } _OrthancPluginStorageAreaRead;
4745 
4746 
4764  OrthancPluginContext* context,
4765  OrthancPluginMemoryBuffer* target,
4766  OrthancPluginStorageArea* storageArea,
4767  const char* uuid,
4769  {
4770  _OrthancPluginStorageAreaRead params;
4771  params.target = target;
4772  params.storageArea = storageArea;
4773  params.uuid = uuid;
4774  params.type = type;
4775 
4776  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4777  }
4778 
4779 
4780  typedef struct
4781  {
4782  OrthancPluginStorageArea* storageArea;
4783  const char* uuid;
4785  } _OrthancPluginStorageAreaRemove;
4786 
4803  OrthancPluginContext* context,
4804  OrthancPluginStorageArea* storageArea,
4805  const char* uuid,
4807  {
4808  _OrthancPluginStorageAreaRemove params;
4809  params.storageArea = storageArea;
4810  params.uuid = uuid;
4811  params.type = type;
4812 
4813  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4814  }
4815 
4816 
4817 
4818  typedef struct
4819  {
4820  OrthancPluginErrorCode* target;
4821  int32_t code;
4822  uint16_t httpStatus;
4823  const char* message;
4824  } _OrthancPluginRegisterErrorCode;
4825 
4842  OrthancPluginContext* context,
4843  int32_t code,
4844  uint16_t httpStatus,
4845  const char* message)
4846  {
4847  OrthancPluginErrorCode target;
4848 
4849  _OrthancPluginRegisterErrorCode params;
4850  params.target = &target;
4851  params.code = code;
4852  params.httpStatus = httpStatus;
4853  params.message = message;
4854 
4855  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4856  {
4857  return target;
4858  }
4859  else
4860  {
4861  /* There was an error while assigned the error. Use a generic code. */
4863  }
4864  }
4865 
4866 
4867 
4868  typedef struct
4869  {
4870  uint16_t group;
4871  uint16_t element;
4873  const char* name;
4874  uint32_t minMultiplicity;
4875  uint32_t maxMultiplicity;
4876  } _OrthancPluginRegisterDictionaryTag;
4877 
4898  OrthancPluginContext* context,
4899  uint16_t group,
4900  uint16_t element,
4902  const char* name,
4903  uint32_t minMultiplicity,
4904  uint32_t maxMultiplicity)
4905  {
4906  _OrthancPluginRegisterDictionaryTag params;
4907  params.group = group;
4908  params.element = element;
4909  params.vr = vr;
4910  params.name = name;
4911  params.minMultiplicity = minMultiplicity;
4912  params.maxMultiplicity = maxMultiplicity;
4913 
4914  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4915  }
4916 
4917 
4918 
4919  typedef struct
4920  {
4921  uint16_t group;
4922  uint16_t element;
4924  const char* name;
4925  uint32_t minMultiplicity;
4926  uint32_t maxMultiplicity;
4927  const char* privateCreator;
4928  } _OrthancPluginRegisterPrivateDictionaryTag;
4929 
4951  OrthancPluginContext* context,
4952  uint16_t group,
4953  uint16_t element,
4955  const char* name,
4956  uint32_t minMultiplicity,
4957  uint32_t maxMultiplicity,
4958  const char* privateCreator)
4959  {
4960  _OrthancPluginRegisterPrivateDictionaryTag params;
4961  params.group = group;
4962  params.element = element;
4963  params.vr = vr;
4964  params.name = name;
4965  params.minMultiplicity = minMultiplicity;
4966  params.maxMultiplicity = maxMultiplicity;
4967  params.privateCreator = privateCreator;
4968 
4969  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4970  }
4971 
4972 
4973 
4974  typedef struct
4975  {
4976  OrthancPluginStorageArea* storageArea;
4978  } _OrthancPluginReconstructMainDicomTags;
4979 
4995  OrthancPluginContext* context,
4996  OrthancPluginStorageArea* storageArea,
4998  {
4999  _OrthancPluginReconstructMainDicomTags params;
5000  params.level = level;
5001  params.storageArea = storageArea;
5002 
5003  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
5004  }
5005 
5006 
5007  typedef struct
5008  {
5009  char** result;
5010  const char* instanceId;
5011  const void* buffer;
5012  uint32_t size;
5015  uint32_t maxStringLength;
5016  } _OrthancPluginDicomToJson;
5017 
5018 
5038  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
5039  OrthancPluginContext* context,
5040  const void* buffer,
5041  uint32_t size,
5044  uint32_t maxStringLength)
5045  {
5046  char* result;
5047 
5048  _OrthancPluginDicomToJson params;
5049  memset(&params, 0, sizeof(params));
5050  params.result = &result;
5051  params.buffer = buffer;
5052  params.size = size;
5053  params.format = format;
5054  params.flags = flags;
5055  params.maxStringLength = maxStringLength;
5056 
5057  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
5058  {
5059  /* Error */
5060  return NULL;
5061  }
5062  else
5063  {
5064  return result;
5065  }
5066  }
5067 
5068 
5087  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
5088  OrthancPluginContext* context,
5089  const char* instanceId,
5092  uint32_t maxStringLength)
5093  {
5094  char* result;
5095 
5096  _OrthancPluginDicomToJson params;
5097  memset(&params, 0, sizeof(params));
5098  params.result = &result;
5099  params.instanceId = instanceId;
5100  params.format = format;
5101  params.flags = flags;
5102  params.maxStringLength = maxStringLength;
5103 
5104  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
5105  {
5106  /* Error */
5107  return NULL;
5108  }
5109  else
5110  {
5111  return result;
5112  }
5113  }
5114 
5115 
5116  typedef struct
5117  {
5118  OrthancPluginMemoryBuffer* target;
5119  const char* uri;
5120  uint32_t headersCount;
5121  const char* const* headersKeys;
5122  const char* const* headersValues;
5123  int32_t afterPlugins;
5124  } _OrthancPluginRestApiGet2;
5125 
5146  OrthancPluginContext* context,
5147  OrthancPluginMemoryBuffer* target,
5148  const char* uri,
5149  uint32_t headersCount,
5150  const char* const* headersKeys,
5151  const char* const* headersValues,
5152  int32_t afterPlugins)
5153  {
5154  _OrthancPluginRestApiGet2 params;
5155  params.target = target;
5156  params.uri = uri;
5157  params.headersCount = headersCount;
5158  params.headersKeys = headersKeys;
5159  params.headersValues = headersValues;
5160  params.afterPlugins = afterPlugins;
5161 
5162  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
5163  }
5164 
5165 
5166 
5167  typedef struct
5168  {
5170  } _OrthancPluginWorklistCallback;
5171 
5184  OrthancPluginContext* context,
5186  {
5187  _OrthancPluginWorklistCallback params;
5188  params.callback = callback;
5189 
5190  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
5191  }
5192 
5193 
5194 
5195  typedef struct
5196  {
5198  const OrthancPluginWorklistQuery* query;
5199  const void* dicom;
5200  uint32_t size;
5201  } _OrthancPluginWorklistAnswersOperation;
5202 
5220  OrthancPluginContext* context,
5222  const OrthancPluginWorklistQuery* query,
5223  const void* dicom,
5224  uint32_t size)
5225  {
5226  _OrthancPluginWorklistAnswersOperation params;
5227  params.answers = answers;
5228  params.query = query;
5229  params.dicom = dicom;
5230  params.size = size;
5231 
5232  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
5233  }
5234 
5235 
5250  OrthancPluginContext* context,
5252  {
5253  _OrthancPluginWorklistAnswersOperation params;
5254  params.answers = answers;
5255  params.query = NULL;
5256  params.dicom = NULL;
5257  params.size = 0;
5258 
5259  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5260  }
5261 
5262 
5263  typedef struct
5264  {
5265  const OrthancPluginWorklistQuery* query;
5266  const void* dicom;
5267  uint32_t size;
5268  int32_t* isMatch;
5269  OrthancPluginMemoryBuffer* target;
5270  } _OrthancPluginWorklistQueryOperation;
5271 
5287  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5288  OrthancPluginContext* context,
5289  const OrthancPluginWorklistQuery* query,
5290  const void* dicom,
5291  uint32_t size)
5292  {
5293  int32_t isMatch = 0;
5294 
5295  _OrthancPluginWorklistQueryOperation params;
5296  params.query = query;
5297  params.dicom = dicom;
5298  params.size = size;
5299  params.isMatch = &isMatch;
5300  params.target = NULL;
5301 
5302  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5303  {
5304  return isMatch;
5305  }
5306  else
5307  {
5308  /* Error: Assume non-match */
5309  return 0;
5310  }
5311  }
5312 
5313 
5327  OrthancPluginContext* context,
5328  OrthancPluginMemoryBuffer* target,
5329  const OrthancPluginWorklistQuery* query)
5330  {
5331  _OrthancPluginWorklistQueryOperation params;
5332  params.query = query;
5333  params.dicom = NULL;
5334  params.size = 0;
5335  params.isMatch = NULL;
5336  params.target = target;
5337 
5338  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5339  }
5340 
5341 
5353  OrthancPluginContext* context,
5354  const OrthancPluginDicomInstance* instance)
5355  {
5357 
5358  _OrthancPluginAccessDicomInstance params;
5359  memset(&params, 0, sizeof(params));
5360  params.resultOrigin = &origin;
5361  params.instance = instance;
5362 
5363  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5364  {
5365  /* Error */
5367  }
5368  else
5369  {
5370  return origin;
5371  }
5372  }
5373 
5374 
5375  typedef struct
5376  {
5377  OrthancPluginMemoryBuffer* target;
5378  const char* json;
5379  const OrthancPluginImage* pixelData;
5381  } _OrthancPluginCreateDicom;
5382 
5409  OrthancPluginContext* context,
5410  OrthancPluginMemoryBuffer* target,
5411  const char* json,
5412  const OrthancPluginImage* pixelData,
5414  {
5415  _OrthancPluginCreateDicom params;
5416  params.target = target;
5417  params.json = json;
5418  params.pixelData = pixelData;
5419  params.flags = flags;
5420 
5421  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5422  }
5423 
5424 
5425  typedef struct
5426  {
5428  } _OrthancPluginDecodeImageCallback;
5429 
5445  OrthancPluginContext* context,
5447  {
5448  _OrthancPluginDecodeImageCallback params;
5449  params.callback = callback;
5450 
5451  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5452  }
5453 
5454 
5455 
5456  typedef struct
5457  {
5458  OrthancPluginImage** target;
5459  OrthancPluginPixelFormat format;
5460  uint32_t width;
5461  uint32_t height;
5462  uint32_t pitch;
5463  void* buffer;
5464  const void* constBuffer;
5465  uint32_t bufferSize;
5466  uint32_t frameIndex;
5467  } _OrthancPluginCreateImage;
5468 
5469 
5483  OrthancPluginContext* context,
5484  OrthancPluginPixelFormat format,
5485  uint32_t width,
5486  uint32_t height)
5487  {
5488  OrthancPluginImage* target = NULL;
5489 
5490  _OrthancPluginCreateImage params;
5491  memset(&params, 0, sizeof(params));
5492  params.target = &target;
5493  params.format = format;
5494  params.width = width;
5495  params.height = height;
5496 
5497  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5498  {
5499  return NULL;
5500  }
5501  else
5502  {
5503  return target;
5504  }
5505  }
5506 
5507 
5526  OrthancPluginContext* context,
5527  OrthancPluginPixelFormat format,
5528  uint32_t width,
5529  uint32_t height,
5530  uint32_t pitch,
5531  void* buffer)
5532  {
5533  OrthancPluginImage* target = NULL;
5534 
5535  _OrthancPluginCreateImage params;
5536  memset(&params, 0, sizeof(params));
5537  params.target = &target;
5538  params.format = format;
5539  params.width = width;
5540  params.height = height;
5541  params.pitch = pitch;
5542  params.buffer = buffer;
5543 
5544  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5545  {
5546  return NULL;
5547  }
5548  else
5549  {
5550  return target;
5551  }
5552  }
5553 
5554 
5555 
5572  OrthancPluginContext* context,
5573  const void* buffer,
5574  uint32_t bufferSize,
5575  uint32_t frameIndex)
5576  {
5577  OrthancPluginImage* target = NULL;
5578 
5579  _OrthancPluginCreateImage params;
5580  memset(&params, 0, sizeof(params));
5581  params.target = &target;
5582  params.constBuffer = buffer;
5583  params.bufferSize = bufferSize;
5584  params.frameIndex = frameIndex;
5585 
5586  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5587  {
5588  return NULL;
5589  }
5590  else
5591  {
5592  return target;
5593  }
5594  }
5595 
5596 
5597 
5598  typedef struct
5599  {
5600  char** result;
5601  const void* buffer;
5602  uint32_t size;
5603  } _OrthancPluginComputeHash;
5604 
5617  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5618  OrthancPluginContext* context,
5619  const void* buffer,
5620  uint32_t size)
5621  {
5622  char* result;
5623 
5624  _OrthancPluginComputeHash params;
5625  params.result = &result;
5626  params.buffer = buffer;
5627  params.size = size;
5628 
5629  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5630  {
5631  /* Error */
5632  return NULL;
5633  }
5634  else
5635  {
5636  return result;
5637  }
5638  }
5639 
5640 
5653  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5654  OrthancPluginContext* context,
5655  const void* buffer,
5656  uint32_t size)
5657  {
5658  char* result;
5659 
5660  _OrthancPluginComputeHash params;
5661  params.result = &result;
5662  params.buffer = buffer;
5663  params.size = size;
5664 
5665  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5666  {
5667  /* Error */
5668  return NULL;
5669  }
5670  else
5671  {
5672  return result;
5673  }
5674  }
5675 
5676 
5677 
5678  typedef struct
5679  {
5681  const char* name;
5682  } _OrthancPluginLookupDictionary;
5683 
5700  OrthancPluginContext* context,
5702  const char* name)
5703  {
5704  _OrthancPluginLookupDictionary params;
5705  params.target = target;
5706  params.name = name;
5707  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5708  }
5709 
5710 
5711 
5712  typedef struct
5713  {
5714  OrthancPluginRestOutput* output;
5715  const void* answer;
5716  uint32_t answerSize;
5717  uint32_t headersCount;
5718  const char* const* headersKeys;
5719  const char* const* headersValues;
5720  } _OrthancPluginSendMultipartItem2;
5721 
5743  OrthancPluginContext* context,
5744  OrthancPluginRestOutput* output,
5745  const void* answer,
5746  uint32_t answerSize,
5747  uint32_t headersCount,
5748  const char* const* headersKeys,
5749  const char* const* headersValues)
5750  {
5751  _OrthancPluginSendMultipartItem2 params;
5752  params.output = output;
5753  params.answer = answer;
5754  params.answerSize = answerSize;
5755  params.headersCount = headersCount;
5756  params.headersKeys = headersKeys;
5757  params.headersValues = headersValues;
5758 
5759  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5760  }
5761 
5762 
5763  typedef struct
5764  {
5766  } _OrthancPluginIncomingHttpRequestFilter;
5767 
5781  OrthancPluginContext* context,
5783  {
5784  _OrthancPluginIncomingHttpRequestFilter params;
5785  params.callback = callback;
5786 
5787  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5788  }
5789 
5790 
5791 
5792  typedef struct
5793  {
5794  OrthancPluginMemoryBuffer* answerBody;
5795  OrthancPluginMemoryBuffer* answerHeaders;
5796  uint16_t* httpStatus;
5797  OrthancPluginHttpMethod method;
5798  const char* url;
5799  uint32_t headersCount;
5800  const char* const* headersKeys;
5801  const char* const* headersValues;
5802  const void* body;
5803  uint32_t bodySize;
5804  const char* username;
5805  const char* password;
5806  uint32_t timeout;
5807  const char* certificateFile;
5808  const char* certificateKeyFile;
5809  const char* certificateKeyPassword;
5810  uint8_t pkcs11;
5811  } _OrthancPluginCallHttpClient2;
5812 
5813 
5814 
5856  OrthancPluginContext* context,
5857  OrthancPluginMemoryBuffer* answerBody,
5858  OrthancPluginMemoryBuffer* answerHeaders,
5859  uint16_t* httpStatus,
5860  OrthancPluginHttpMethod method,
5861  const char* url,
5862  uint32_t headersCount,
5863  const char* const* headersKeys,
5864  const char* const* headersValues,
5865  const void* body,
5866  uint32_t bodySize,
5867  const char* username,
5868  const char* password,
5869  uint32_t timeout,
5870  const char* certificateFile,
5871  const char* certificateKeyFile,
5872  const char* certificateKeyPassword,
5873  uint8_t pkcs11)
5874  {
5875  _OrthancPluginCallHttpClient2 params;
5876  memset(&params, 0, sizeof(params));
5877 
5878  params.answerBody = answerBody;
5879  params.answerHeaders = answerHeaders;
5880  params.httpStatus = httpStatus;
5881  params.method = method;
5882  params.url = url;
5883  params.headersCount = headersCount;
5884  params.headersKeys = headersKeys;
5885  params.headersValues = headersValues;
5886  params.body = body;
5887  params.bodySize = bodySize;
5888  params.username = username;
5889  params.password = password;
5890  params.timeout = timeout;
5891  params.certificateFile = certificateFile;
5892  params.certificateKeyFile = certificateKeyFile;
5893  params.certificateKeyPassword = certificateKeyPassword;
5894  params.pkcs11 = pkcs11;
5895 
5896  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5897  }
5898 
5899 
5910  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5911  OrthancPluginContext* context)
5912  {
5913  char* result;
5914 
5915  _OrthancPluginRetrieveDynamicString params;
5916  params.result = &result;
5917  params.argument = NULL;
5918 
5919  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5920  {
5921  /* Error */
5922  return NULL;
5923  }
5924  else
5925  {
5926  return result;
5927  }
5928  }
5929 
5930 
5931 
5932 
5933  typedef struct
5934  {
5935  OrthancPluginFindCallback callback;
5936  } _OrthancPluginFindCallback;
5937 
5950  OrthancPluginContext* context,
5951  OrthancPluginFindCallback callback)
5952  {
5953  _OrthancPluginFindCallback params;
5954  params.callback = callback;
5955 
5956  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5957  }
5958 
5959 
5960  typedef struct
5961  {
5962  OrthancPluginFindAnswers *answers;
5963  const OrthancPluginFindQuery *query;
5964  const void *dicom;
5965  uint32_t size;
5966  uint32_t index;
5967  uint32_t *resultUint32;
5968  uint16_t *resultGroup;
5969  uint16_t *resultElement;
5970  char **resultString;
5971  } _OrthancPluginFindOperation;
5972 
5989  OrthancPluginContext* context,
5990  OrthancPluginFindAnswers* answers,
5991  const void* dicom,
5992  uint32_t size)
5993  {
5994  _OrthancPluginFindOperation params;
5995  memset(&params, 0, sizeof(params));
5996  params.answers = answers;
5997  params.dicom = dicom;
5998  params.size = size;
5999 
6000  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
6001  }
6002 
6003 
6018  OrthancPluginContext* context,
6019  OrthancPluginFindAnswers* answers)
6020  {
6021  _OrthancPluginFindOperation params;
6022  memset(&params, 0, sizeof(params));
6023  params.answers = answers;
6024 
6025  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
6026  }
6027 
6028 
6029 
6041  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
6042  OrthancPluginContext* context,
6043  const OrthancPluginFindQuery* query)
6044  {
6045  uint32_t count = 0;
6046 
6047  _OrthancPluginFindOperation params;
6048  memset(&params, 0, sizeof(params));
6049  params.query = query;
6050  params.resultUint32 = &count;
6051 
6052  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
6053  {
6054  /* Error */
6055  return 0;
6056  }
6057  else
6058  {
6059  return count;
6060  }
6061  }
6062 
6063 
6079  OrthancPluginContext* context,
6080  uint16_t* group,
6081  uint16_t* element,
6082  const OrthancPluginFindQuery* query,
6083  uint32_t index)
6084  {
6085  _OrthancPluginFindOperation params;
6086  memset(&params, 0, sizeof(params));
6087  params.query = query;
6088  params.index = index;
6089  params.resultGroup = group;
6090  params.resultElement = element;
6091 
6092  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
6093  }
6094 
6095 
6109  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
6110  OrthancPluginContext* context,
6111  const OrthancPluginFindQuery* query,
6112  uint32_t index)
6113  {
6114  char* result;
6115 
6116  _OrthancPluginFindOperation params;
6117  memset(&params, 0, sizeof(params));
6118  params.query = query;
6119  params.index = index;
6120  params.resultString = &result;
6121 
6122  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
6123  {
6124  /* Error */
6125  return NULL;
6126  }
6127  else
6128  {
6129  return result;
6130  }
6131  }
6132 
6133 
6147  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
6148  OrthancPluginContext* context,
6149  const OrthancPluginFindQuery* query,
6150  uint32_t index)
6151  {
6152  char* result;
6153 
6154  _OrthancPluginFindOperation params;
6155  memset(&params, 0, sizeof(params));
6156  params.query = query;
6157  params.index = index;
6158  params.resultString = &result;
6159 
6160  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
6161  {
6162  /* Error */
6163  return NULL;
6164  }
6165  else
6166  {
6167  return result;
6168  }
6169  }
6170 
6171 
6172 
6173 
6174  typedef struct
6175  {
6176  OrthancPluginMoveCallback callback;
6177  OrthancPluginGetMoveSize getMoveSize;
6178  OrthancPluginApplyMove applyMove;
6179  OrthancPluginFreeMove freeMove;
6180  } _OrthancPluginMoveCallback;
6181 
6196  OrthancPluginContext* context,
6197  OrthancPluginMoveCallback callback,
6198  OrthancPluginGetMoveSize getMoveSize,
6199  OrthancPluginApplyMove applyMove,
6200  OrthancPluginFreeMove freeMove)
6201  {
6202  _OrthancPluginMoveCallback params;
6203  params.callback = callback;
6204  params.getMoveSize = getMoveSize;
6205  params.applyMove = applyMove;
6206  params.freeMove = freeMove;
6207 
6208  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
6209  }
6210 
6211 
6212 
6213  typedef struct
6214  {
6215  OrthancPluginFindMatcher** target;
6216  const void* query;
6217  uint32_t size;
6218  } _OrthancPluginCreateFindMatcher;
6219 
6220 
6235  OrthancPluginContext* context,
6236  const void* query,
6237  uint32_t size)
6238  {
6239  OrthancPluginFindMatcher* target = NULL;
6240 
6241  _OrthancPluginCreateFindMatcher params;
6242  memset(&params, 0, sizeof(params));
6243  params.target = &target;
6244  params.query = query;
6245  params.size = size;
6246 
6247  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
6248  {
6249  return NULL;
6250  }
6251  else
6252  {
6253  return target;
6254  }
6255  }
6256 
6257 
6258  typedef struct
6259  {
6260  OrthancPluginFindMatcher* matcher;
6261  } _OrthancPluginFreeFindMatcher;
6262 
6272  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6273  OrthancPluginContext* context,
6274  OrthancPluginFindMatcher* matcher)
6275  {
6276  _OrthancPluginFreeFindMatcher params;
6277  params.matcher = matcher;
6278 
6279  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6280  }
6281 
6282 
6283  typedef struct
6284  {
6285  const OrthancPluginFindMatcher* matcher;
6286  const void* dicom;
6287  uint32_t size;
6288  int32_t* isMatch;
6289  } _OrthancPluginFindMatcherIsMatch;
6290 
6305  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6306  OrthancPluginContext* context,
6307  const OrthancPluginFindMatcher* matcher,
6308  const void* dicom,
6309  uint32_t size)
6310  {
6311  int32_t isMatch = 0;
6312 
6313  _OrthancPluginFindMatcherIsMatch params;
6314  params.matcher = matcher;
6315  params.dicom = dicom;
6316  params.size = size;
6317  params.isMatch = &isMatch;
6318 
6319  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6320  {
6321  return isMatch;
6322  }
6323  else
6324  {
6325  /* Error: Assume non-match */
6326  return 0;
6327  }
6328  }
6329 
6330 
6331  typedef struct
6332  {
6334  } _OrthancPluginIncomingHttpRequestFilter2;
6335 
6348  OrthancPluginContext* context,
6350  {
6351  _OrthancPluginIncomingHttpRequestFilter2 params;
6352  params.callback = callback;
6353 
6354  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6355  }
6356 
6357 
6358 
6359  typedef struct
6360  {
6361  OrthancPluginPeers** peers;
6362  } _OrthancPluginGetPeers;
6363 
6376  OrthancPluginContext* context)
6377  {
6378  OrthancPluginPeers* peers = NULL;
6379 
6380  _OrthancPluginGetPeers params;
6381  memset(&params, 0, sizeof(params));
6382  params.peers = &peers;
6383 
6384  if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6385  {
6386  return NULL;
6387  }
6388  else
6389  {
6390  return peers;
6391  }
6392  }
6393 
6394 
6395  typedef struct
6396  {
6397  OrthancPluginPeers* peers;
6398  } _OrthancPluginFreePeers;
6399 
6409  ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6410  OrthancPluginContext* context,
6411  OrthancPluginPeers* peers)
6412  {
6413  _OrthancPluginFreePeers params;
6414  params.peers = peers;
6415 
6416  context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6417  }
6418 
6419 
6420  typedef struct
6421  {
6422  uint32_t* target;
6423  const OrthancPluginPeers* peers;
6424  } _OrthancPluginGetPeersCount;
6425 
6439  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6440  OrthancPluginContext* context,
6441  const OrthancPluginPeers* peers)
6442  {
6443  uint32_t target = 0;
6444 
6445  _OrthancPluginGetPeersCount params;
6446  memset(&params, 0, sizeof(params));
6447  params.target = &target;
6448  params.peers = peers;
6449 
6450  if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6451  {
6452  /* Error */
6453  return 0;
6454  }
6455  else
6456  {
6457  return target;
6458  }
6459  }
6460 
6461 
6462  typedef struct
6463  {
6464  const char** target;
6465  const OrthancPluginPeers* peers;
6466  uint32_t peerIndex;
6467  const char* userProperty;
6468  } _OrthancPluginGetPeerProperty;
6469 
6487  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6488  OrthancPluginContext* context,
6489  const OrthancPluginPeers* peers,
6490  uint32_t peerIndex)
6491  {
6492  const char* target = NULL;
6493 
6494  _OrthancPluginGetPeerProperty params;
6495  memset(&params, 0, sizeof(params));
6496  params.target = &target;
6497  params.peers = peers;
6498  params.peerIndex = peerIndex;
6499  params.userProperty = NULL;
6500 
6501  if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6502  {
6503  /* Error */
6504  return NULL;
6505  }
6506  else
6507  {
6508  return target;
6509  }
6510  }
6511 
6512 
6528  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6529  OrthancPluginContext* context,
6530  const OrthancPluginPeers* peers,
6531  uint32_t peerIndex)
6532  {
6533  const char* target = NULL;
6534 
6535  _OrthancPluginGetPeerProperty params;
6536  memset(&params, 0, sizeof(params));
6537  params.target = &target;
6538  params.peers = peers;
6539  params.peerIndex = peerIndex;
6540  params.userProperty = NULL;
6541 
6542  if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6543  {
6544  /* Error */
6545  return NULL;
6546  }
6547  else
6548  {
6549  return target;
6550  }
6551  }
6552 
6553 
6554 
6574  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6575  OrthancPluginContext* context,
6576  const OrthancPluginPeers* peers,
6577  uint32_t peerIndex,
6578  const char* userProperty)
6579  {
6580  const char* target = NULL;
6581 
6582  _OrthancPluginGetPeerProperty params;
6583  memset(&params, 0, sizeof(params));
6584  params.target = &target;
6585  params.peers = peers;
6586  params.peerIndex = peerIndex;
6587  params.userProperty = userProperty;
6588 
6589  if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6590  {
6591  /* No such user property */
6592  return NULL;
6593  }
6594  else
6595  {
6596  return target;
6597  }
6598  }
6599 
6600 
6601 
6602  typedef struct
6603  {
6604  OrthancPluginMemoryBuffer* answerBody;
6605  OrthancPluginMemoryBuffer* answerHeaders;
6606  uint16_t* httpStatus;
6607  const OrthancPluginPeers* peers;
6608  uint32_t peerIndex;
6609  OrthancPluginHttpMethod method;
6610  const char* uri;
6611  uint32_t additionalHeadersCount;
6612  const char* const* additionalHeadersKeys;
6613  const char* const* additionalHeadersValues;
6614  const void* body;
6615  uint32_t bodySize;
6616  uint32_t timeout;
6617  } _OrthancPluginCallPeerApi;
6618 
6656  OrthancPluginContext* context,
6657  OrthancPluginMemoryBuffer* answerBody,
6658  OrthancPluginMemoryBuffer* answerHeaders,
6659  uint16_t* httpStatus,
6660  const OrthancPluginPeers* peers,
6661  uint32_t peerIndex,
6662  OrthancPluginHttpMethod method,
6663  const char* uri,
6664  uint32_t additionalHeadersCount,
6665  const char* const* additionalHeadersKeys,
6666  const char* const* additionalHeadersValues,
6667  const void* body,
6668  uint32_t bodySize,
6669  uint32_t timeout)
6670  {
6671  _OrthancPluginCallPeerApi params;
6672  memset(&params, 0, sizeof(params));
6673 
6674  params.answerBody = answerBody;
6675  params.answerHeaders = answerHeaders;
6676  params.httpStatus = httpStatus;
6677  params.peers = peers;
6678  params.peerIndex = peerIndex;
6679  params.method = method;
6680  params.uri = uri;
6681  params.additionalHeadersCount = additionalHeadersCount;
6682  params.additionalHeadersKeys = additionalHeadersKeys;
6683  params.additionalHeadersValues = additionalHeadersValues;
6684  params.body = body;
6685  params.bodySize = bodySize;
6686  params.timeout = timeout;
6687 
6688  return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6689  }
6690 
6691 
6692 
6693 
6694 
6695  typedef struct
6696  {
6697  OrthancPluginJob** target;
6698  void *job;
6699  OrthancPluginJobFinalize finalize;
6700  const char *type;
6701  OrthancPluginJobGetProgress getProgress;
6702  OrthancPluginJobGetContent getContent;
6703  OrthancPluginJobGetSerialized getSerialized;
6704  OrthancPluginJobStep step;
6705  OrthancPluginJobStop stop;
6706  OrthancPluginJobReset reset;
6707  } _OrthancPluginCreateJob;
6708 
6742  OrthancPluginContext *context,
6743  void *job,
6744  OrthancPluginJobFinalize finalize,
6745  const char *type,
6746  OrthancPluginJobGetProgress getProgress,
6747  OrthancPluginJobGetContent getContent,
6748  OrthancPluginJobGetSerialized getSerialized,
6749  OrthancPluginJobStep step,
6750  OrthancPluginJobStop stop,
6751  OrthancPluginJobReset reset)
6752  {
6753  OrthancPluginJob* target = NULL;
6754 
6755  _OrthancPluginCreateJob params;
6756  memset(&params, 0, sizeof(params));
6757 
6758  params.target = &target;
6759  params.job = job;
6760  params.finalize = finalize;
6761  params.type = type;
6762  params.getProgress = getProgress;
6763  params.getContent = getContent;
6764  params.getSerialized = getSerialized;
6765  params.step = step;
6766  params.stop = stop;
6767  params.reset = reset;
6768 
6769  if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6770  target == NULL)
6771  {
6772  /* Error */
6773  return NULL;
6774  }
6775  else
6776  {
6777  return target;
6778  }
6779  }
6780 
6781 
6782  typedef struct
6783  {
6784  OrthancPluginJob** target;
6785  void *job;
6786  OrthancPluginJobFinalize finalize;
6787  const char *type;
6788  OrthancPluginJobGetProgress getProgress;
6789  OrthancPluginJobGetContent2 getContent;
6790  OrthancPluginJobGetSerialized2 getSerialized;
6791  OrthancPluginJobStep step;
6792  OrthancPluginJobStop stop;
6793  OrthancPluginJobReset reset;
6794  } _OrthancPluginCreateJob2;
6795 
6828  OrthancPluginContext *context,
6829  void *job,
6830  OrthancPluginJobFinalize finalize,
6831  const char *type,
6832  OrthancPluginJobGetProgress getProgress,
6833  OrthancPluginJobGetContent2 getContent,
6834  OrthancPluginJobGetSerialized2 getSerialized,
6835  OrthancPluginJobStep step,
6836  OrthancPluginJobStop stop,
6837  OrthancPluginJobReset reset)
6838  {
6839  OrthancPluginJob* target = NULL;
6840 
6841  _OrthancPluginCreateJob2 params;
6842  memset(&params, 0, sizeof(params));
6843 
6844  params.target = &target;
6845  params.job = job;
6846  params.finalize = finalize;
6847  params.type = type;
6848  params.getProgress = getProgress;
6849  params.getContent = getContent;
6850  params.getSerialized = getSerialized;
6851  params.step = step;
6852  params.stop = stop;
6853  params.reset = reset;
6854 
6855  if (context->InvokeService(context, _OrthancPluginService_CreateJob2, &params) != OrthancPluginErrorCode_Success ||
6856  target == NULL)
6857  {
6858  /* Error */
6859  return NULL;
6860  }
6861  else
6862  {
6863  return target;
6864  }
6865  }
6866 
6867 
6868  typedef struct
6869  {
6870  OrthancPluginJob* job;
6871  } _OrthancPluginFreeJob;
6872 
6882  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6883  OrthancPluginContext* context,
6884  OrthancPluginJob* job)
6885  {
6886  _OrthancPluginFreeJob params;
6887  params.job = job;
6888 
6889  context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6890  }
6891 
6892 
6893 
6894  typedef struct
6895  {
6896  char** resultId;
6897  OrthancPluginJob *job;
6898  int priority;
6899  } _OrthancPluginSubmitJob;
6900 
6914  ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6915  OrthancPluginContext *context,
6916  OrthancPluginJob *job,
6917  int priority)
6918  {
6919  char* resultId = NULL;
6920 
6921  _OrthancPluginSubmitJob params;
6922  memset(&params, 0, sizeof(params));
6923 
6924  params.resultId = &resultId;
6925  params.job = job;
6926  params.priority = priority;
6927 
6928  if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6929  resultId == NULL)
6930  {
6931  /* Error */
6932  return NULL;
6933  }
6934  else
6935  {
6936  return resultId;
6937  }
6938  }
6939 
6940 
6941 
6942  typedef struct
6943  {
6944  OrthancPluginJobsUnserializer unserializer;
6945  } _OrthancPluginJobsUnserializer;
6946 
6959  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6960  OrthancPluginContext* context,
6961  OrthancPluginJobsUnserializer unserializer)
6962  {
6963  _OrthancPluginJobsUnserializer params;
6964  params.unserializer = unserializer;
6965 
6966  context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6967  }
6968 
6969 
6970 
6971  typedef struct
6972  {
6973  OrthancPluginRestOutput* output;
6974  const char* details;
6975  uint8_t log;
6976  } _OrthancPluginSetHttpErrorDetails;
6977 
6995  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
6996  OrthancPluginContext* context,
6997  OrthancPluginRestOutput* output,
6998  const char* details,
6999  uint8_t log)
7000  {
7001  _OrthancPluginSetHttpErrorDetails params;
7002  params.output = output;
7003  params.details = details;
7004  params.log = log;
7005  context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
7006  }
7007 
7008 
7009 
7010  typedef struct
7011  {
7012  const char** result;
7013  const char* argument;
7014  } _OrthancPluginRetrieveStaticString;
7015 
7027  ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
7028  OrthancPluginContext* context,
7029  const char* path)
7030  {
7031  const char* result = NULL;
7032 
7033  _OrthancPluginRetrieveStaticString params;
7034  params.result = &result;
7035  params.argument = path;
7036 
7037  if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
7038  {
7039  /* Error */
7040  return NULL;
7041  }
7042  else
7043  {
7044  return result;
7045  }
7046  }
7047 
7048 
7049 
7050  typedef struct
7051  {
7052  const char* name;
7053  float value;
7055  } _OrthancPluginSetMetricsValue;
7056 
7071  ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
7072  OrthancPluginContext* context,
7073  const char* name,
7074  float value,
7076  {
7077  _OrthancPluginSetMetricsValue params;
7078  params.name = name;
7079  params.value = value;
7080  params.type = type;
7081  context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
7082  }
7083 
7084 
7085 
7086  typedef struct
7087  {
7089  } _OrthancPluginRegisterRefreshMetricsCallback;
7090 
7102  OrthancPluginContext* context,
7104  {
7105  _OrthancPluginRegisterRefreshMetricsCallback params;
7106  params.callback = callback;
7107  context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
7108  }
7109 
7110 
7111 
7112 
7113  typedef struct
7114  {
7115  char** target;
7116  const void* dicom;
7117  uint32_t dicomSize;
7119  } _OrthancPluginEncodeDicomWeb;
7120 
7137  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
7138  OrthancPluginContext* context,
7139  const void* dicom,
7140  uint32_t dicomSize,
7142  {
7143  char* target = NULL;
7144 
7145  _OrthancPluginEncodeDicomWeb params;
7146  params.target = &target;
7147  params.dicom = dicom;
7148  params.dicomSize = dicomSize;
7149  params.callback = callback;
7150 
7151  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
7152  {
7153  /* Error */
7154  return NULL;
7155  }
7156  else
7157  {
7158  return target;
7159  }
7160  }
7161 
7162 
7179  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
7180  OrthancPluginContext* context,
7181  const void* dicom,
7182  uint32_t dicomSize,
7184  {
7185  char* target = NULL;
7186 
7187  _OrthancPluginEncodeDicomWeb params;
7188  params.target = &target;
7189  params.dicom = dicom;
7190  params.dicomSize = dicomSize;
7191  params.callback = callback;
7192 
7193  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
7194  {
7195  /* Error */
7196  return NULL;
7197  }
7198  else
7199  {
7200  return target;
7201  }
7202  }
7203 
7204 
7205 
7206  typedef struct
7207  {
7208  char** target;
7209  const void* dicom;
7210  uint32_t dicomSize;
7212  void* payload;
7213  } _OrthancPluginEncodeDicomWeb2;
7214 
7231  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson2(
7232  OrthancPluginContext* context,
7233  const void* dicom,
7234  uint32_t dicomSize,
7236  void* payload)
7237  {
7238  char* target = NULL;
7239 
7240  _OrthancPluginEncodeDicomWeb2 params;
7241  params.target = &target;
7242  params.dicom = dicom;
7243  params.dicomSize = dicomSize;
7244  params.callback = callback;
7245  params.payload = payload;
7246 
7247  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson2, &params) != OrthancPluginErrorCode_Success)
7248  {
7249  /* Error */
7250  return NULL;
7251  }
7252  else
7253  {
7254  return target;
7255  }
7256  }
7257 
7258 
7275  ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml2(
7276  OrthancPluginContext* context,
7277  const void* dicom,
7278  uint32_t dicomSize,
7280  void* payload)
7281  {
7282  char* target = NULL;
7283 
7284  _OrthancPluginEncodeDicomWeb2 params;
7285  params.target = &target;
7286  params.dicom = dicom;
7287  params.dicomSize = dicomSize;
7288  params.callback = callback;
7289  params.payload = payload;
7290 
7291  if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml2, &params) != OrthancPluginErrorCode_Success)
7292  {
7293  /* Error */
7294  return NULL;
7295  }
7296  else
7297  {
7298  return target;
7299  }
7300  }
7301 
7302 
7303 
7320  void* answer,
7321  const char* key,
7322  const char* value);
7323 
7324 
7341  void* answer,
7342  const void* data,
7343  uint32_t size);
7344 
7345 
7360  typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
7361 
7362 
7378 
7379 
7393  typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
7394 
7395 
7409  typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
7410 
7411 
7412  typedef struct
7413  {
7414  void* answer;
7417  uint16_t* httpStatus;
7418  OrthancPluginHttpMethod method;
7419  const char* url;
7420  uint32_t headersCount;
7421  const char* const* headersKeys;
7422  const char* const* headersValues;
7423  void* request;
7428  const char* username;
7429  const char* password;
7430  uint32_t timeout;
7431  const char* certificateFile;
7432  const char* certificateKeyFile;
7433  const char* certificateKeyPassword;
7434  uint8_t pkcs11;
7435  } _OrthancPluginChunkedHttpClient;
7436 
7437 
7489  OrthancPluginContext* context,
7490  void* answer,
7493  uint16_t* httpStatus,
7494  OrthancPluginHttpMethod method,
7495  const char* url,
7496  uint32_t headersCount,
7497  const char* const* headersKeys,
7498  const char* const* headersValues,
7499  void* request,
7504  const char* username,
7505  const char* password,
7506  uint32_t timeout,
7507  const char* certificateFile,
7508  const char* certificateKeyFile,
7509  const char* certificateKeyPassword,
7510  uint8_t pkcs11)
7511  {
7512  _OrthancPluginChunkedHttpClient params;
7513  memset(&params, 0, sizeof(params));
7514 
7515  /* In common with OrthancPluginHttpClient() */
7516  params.httpStatus = httpStatus;
7517  params.method = method;
7518  params.url = url;
7519  params.headersCount = headersCount;
7520  params.headersKeys = headersKeys;
7521  params.headersValues = headersValues;
7522  params.username = username;
7523  params.password = password;
7524  params.timeout = timeout;
7525  params.certificateFile = certificateFile;
7526  params.certificateKeyFile = certificateKeyFile;
7527  params.certificateKeyPassword = certificateKeyPassword;
7528  params.pkcs11 = pkcs11;
7529 
7530  /* For chunked body/answer */
7531  params.answer = answer;
7532  params.answerAddChunk = answerAddChunk;
7533  params.answerAddHeader = answerAddHeader;
7534  params.request = request;
7535  params.requestIsDone = requestIsDone;
7536  params.requestChunkData = requestChunkData;
7537  params.requestChunkSize = requestChunkSize;
7538  params.requestNext = requestNext;
7539 
7540  return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7541  }
7542 
7543 
7544 
7549  typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7550 
7551 
7552 
7570  const char* url,
7571  const OrthancPluginHttpRequest* request);
7572 
7573 
7589  const void* data,
7590  uint32_t size);
7591 
7592 
7609  OrthancPluginRestOutput* output);
7610 
7611 
7627 
7628  typedef struct
7629  {
7630  const char* pathRegularExpression;
7631  OrthancPluginRestCallback getHandler;
7633  OrthancPluginRestCallback deleteHandler;
7638  } _OrthancPluginChunkedRestCallback;
7639 
7640 
7670  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterChunkedRestCallback(
7671  OrthancPluginContext* context,
7672  const char* pathRegularExpression,
7673  OrthancPluginRestCallback getHandler,
7675  OrthancPluginRestCallback deleteHandler,
7680  {
7681  _OrthancPluginChunkedRestCallback params;
7682  params.pathRegularExpression = pathRegularExpression;
7683  params.getHandler = getHandler;
7684  params.postHandler = postHandler;
7685  params.deleteHandler = deleteHandler;
7686  params.putHandler = putHandler;
7687  params.addChunk = addChunk;
7688  params.execute = execute;
7689  params.finalize = finalize;
7690 
7691  context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
7692  }
7693 
7694 
7695 
7696 
7697 
7698  typedef struct
7699  {
7700  char** result;
7701  uint16_t group;
7702  uint16_t element;
7703  const char* privateCreator;
7704  } _OrthancPluginGetTagName;
7705 
7721  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
7722  OrthancPluginContext* context,
7723  uint16_t group,
7724  uint16_t element,
7725  const char* privateCreator)
7726  {
7727  char* result;
7728 
7729  _OrthancPluginGetTagName params;
7730  params.result = &result;
7731  params.group = group;
7732  params.element = element;
7733  params.privateCreator = privateCreator;
7734 
7735  if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
7736  {
7737  /* Error */
7738  return NULL;
7739  }
7740  else
7741  {
7742  return result;
7743  }
7744  }
7745 
7746 
7747 
7777  void** handler /* out */,
7778  const char* jobId,
7779  const char* transactionUid,
7780  const char* const* sopClassUids,
7781  const char* const* sopInstanceUids,
7782  uint32_t countInstances,
7783  const char* remoteAet,
7784  const char* calledAet);
7785 
7786 
7798  typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
7799 
7800 
7821  void* handler,
7822  const char* sopClassUid,
7823  const char* sopInstanceUid);
7824 
7825 
7826  typedef struct
7827  {
7831  } _OrthancPluginRegisterStorageCommitmentScpCallback;
7832 
7847  OrthancPluginContext* context,
7851  {
7852  _OrthancPluginRegisterStorageCommitmentScpCallback params;
7853  params.factory = factory;
7854  params.destructor = destructor;
7855  params.lookup = lookup;
7856  return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
7857  }
7858 
7859 
7860 
7887  const OrthancPluginDicomInstance* instance);
7888 
7889 
7890  typedef struct
7891  {
7893  } _OrthancPluginIncomingDicomInstanceFilter;
7894 
7908  OrthancPluginContext* context,
7910  {
7911  _OrthancPluginIncomingDicomInstanceFilter params;
7912  params.callback = callback;
7913 
7914  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, &params);
7915  }
7916 
7917 
7949  uint16_t* dimseStatus /* out */,
7950  const OrthancPluginDicomInstance* instance);
7951 
7952 
7953  typedef struct
7954  {
7956  } _OrthancPluginIncomingCStoreInstanceFilter;
7957 
7971  OrthancPluginContext* context,
7973  {
7974  _OrthancPluginIncomingCStoreInstanceFilter params;
7975  params.callback = callback;
7976 
7977  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingCStoreInstanceFilter, &params);
7978  }
7979 
8016  OrthancPluginMemoryBuffer64* modifiedDicomBuffer,
8017  const void* receivedDicomBuffer,
8018  uint64_t receivedDicomBufferSize,
8020 
8021 
8022  typedef struct
8023  {
8025  } _OrthancPluginReceivedInstanceCallback;
8026 
8048  OrthancPluginContext* context,
8050  {
8051  _OrthancPluginReceivedInstanceCallback params;
8052  params.callback = callback;
8053 
8054  return context->InvokeService(context, _OrthancPluginService_RegisterReceivedInstanceCallback, &params);
8055  }
8056 
8070  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceTransferSyntaxUid(
8071  OrthancPluginContext* context,
8072  const OrthancPluginDicomInstance* instance)
8073  {
8074  char* result;
8075 
8076  _OrthancPluginAccessDicomInstance params;
8077  memset(&params, 0, sizeof(params));
8078  params.resultStringToFree = &result;
8079  params.instance = instance;
8080 
8081  if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, &params) != OrthancPluginErrorCode_Success)
8082  {
8083  /* Error */
8084  return NULL;
8085  }
8086  else
8087  {
8088  return result;
8089  }
8090  }
8091 
8092 
8105  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData(
8106  OrthancPluginContext* context,
8107  const OrthancPluginDicomInstance* instance)
8108  {
8109  int64_t hasPixelData;
8110 
8111  _OrthancPluginAccessDicomInstance params;
8112  memset(&params, 0, sizeof(params));
8113  params.resultInt64 = &hasPixelData;
8114  params.instance = instance;
8115 
8116  if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, &params) != OrthancPluginErrorCode_Success ||
8117  hasPixelData < 0 ||
8118  hasPixelData > 1)
8119  {
8120  /* Error */
8121  return -1;
8122  }
8123  else
8124  {
8125  return (hasPixelData != 0);
8126  }
8127  }
8128 
8129 
8130 
8131 
8132 
8133 
8134  typedef struct
8135  {
8136  OrthancPluginDicomInstance** target;
8137  const void* buffer;
8138  uint32_t size;
8139  const char* transferSyntax;
8140  } _OrthancPluginCreateDicomInstance;
8141 
8156  OrthancPluginContext* context,
8157  const void* buffer,
8158  uint32_t size)
8159  {
8160  OrthancPluginDicomInstance* target = NULL;
8161 
8162  _OrthancPluginCreateDicomInstance params;
8163  params.target = &target;
8164  params.buffer = buffer;
8165  params.size = size;
8166 
8167  if (context->InvokeService(context, _OrthancPluginService_CreateDicomInstance, &params) != OrthancPluginErrorCode_Success)
8168  {
8169  /* Error */
8170  return NULL;
8171  }
8172  else
8173  {
8174  return target;
8175  }
8176  }
8177 
8178  typedef struct
8179  {
8181  } _OrthancPluginFreeDicomInstance;
8182 
8193  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeDicomInstance(
8194  OrthancPluginContext* context,
8196  {
8197  _OrthancPluginFreeDicomInstance params;
8198  params.dicom = dicom;
8199 
8200  context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, &params);
8201  }
8202 
8203 
8204  typedef struct
8205  {
8206  uint32_t* targetUint32;
8207  OrthancPluginMemoryBuffer* targetBuffer;
8208  OrthancPluginImage** targetImage;
8209  char** targetStringToFree;
8210  const OrthancPluginDicomInstance* instance;
8211  uint32_t frameIndex;
8214  uint32_t maxStringLength;
8215  OrthancPluginDicomWebBinaryCallback2 dicomWebCallback;
8216  void* dicomWebPayload;
8217  } _OrthancPluginAccessDicomInstance2;
8218 
8230  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetInstanceFramesCount(
8231  OrthancPluginContext* context,
8232  const OrthancPluginDicomInstance* instance)
8233  {
8234  uint32_t count;
8235 
8236  _OrthancPluginAccessDicomInstance2 params;
8237  memset(&params, 0, sizeof(params));
8238  params.targetUint32 = &count;
8239  params.instance = instance;
8240 
8241  if (context->InvokeService(context, _OrthancPluginService_GetInstanceFramesCount, &params) != OrthancPluginErrorCode_Success)
8242  {
8243  /* Error */
8244  return 0;
8245  }
8246  else
8247  {
8248  return count;
8249  }
8250  }
8251 
8252 
8271  OrthancPluginContext* context,
8272  OrthancPluginMemoryBuffer* target,
8273  const OrthancPluginDicomInstance* instance,
8274  uint32_t frameIndex)
8275  {
8276  _OrthancPluginAccessDicomInstance2 params;
8277  memset(&params, 0, sizeof(params));
8278  params.targetBuffer = target;
8279  params.instance = instance;
8280  params.frameIndex = frameIndex;
8281 
8282  return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, &params);
8283  }
8284 
8285 
8299  OrthancPluginContext* context,
8300  const OrthancPluginDicomInstance* instance,
8301  uint32_t frameIndex)
8302  {
8303  OrthancPluginImage* target = NULL;
8304 
8305  _OrthancPluginAccessDicomInstance2 params;
8306  memset(&params, 0, sizeof(params));
8307  params.targetImage = &target;
8308  params.instance = instance;
8309  params.frameIndex = frameIndex;
8310 
8311  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDecodedFrame, &params) != OrthancPluginErrorCode_Success)
8312  {
8313  return NULL;
8314  }
8315  else
8316  {
8317  return target;
8318  }
8319  }
8320 
8321 
8338  OrthancPluginContext* context,
8339  const void* buffer,
8340  uint32_t size,
8341  const char* transferSyntax)
8342  {
8343  OrthancPluginDicomInstance* target = NULL;
8344 
8345  _OrthancPluginCreateDicomInstance params;
8346  params.target = &target;
8347  params.buffer = buffer;
8348  params.size = size;
8349  params.transferSyntax = transferSyntax;
8350 
8351  if (context->InvokeService(context, _OrthancPluginService_TranscodeDicomInstance, &params) != OrthancPluginErrorCode_Success)
8352  {
8353  /* Error */
8354  return NULL;
8355  }
8356  else
8357  {
8358  return target;
8359  }
8360  }
8361 
8376  OrthancPluginContext* context,
8377  OrthancPluginMemoryBuffer* target,
8378  const OrthancPluginDicomInstance* instance)
8379  {
8380  _OrthancPluginAccessDicomInstance2 params;
8381  memset(&params, 0, sizeof(params));
8382  params.targetBuffer = target;
8383  params.instance = instance;
8384 
8385  return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, &params);
8386  }
8387 
8388 
8407  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceAdvancedJson(
8408  OrthancPluginContext* context,
8409  const OrthancPluginDicomInstance* instance,
8412  uint32_t maxStringLength)
8413  {
8414  char* result = NULL;
8415 
8416  _OrthancPluginAccessDicomInstance2 params;
8417  memset(&params, 0, sizeof(params));
8418  params.targetStringToFree = &result;
8419  params.instance = instance;
8420  params.format = format;
8421  params.flags = flags;
8422  params.maxStringLength = maxStringLength;
8423 
8424  if (context->InvokeService(context, _OrthancPluginService_GetInstanceAdvancedJson, &params) != OrthancPluginErrorCode_Success)
8425  {
8426  /* Error */
8427  return NULL;
8428  }
8429  else
8430  {
8431  return result;
8432  }
8433  }
8434 
8435 
8450  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebJson(
8451  OrthancPluginContext* context,
8452  const OrthancPluginDicomInstance* instance,
8454  void* payload)
8455  {
8456  char* target = NULL;
8457 
8458  _OrthancPluginAccessDicomInstance2 params;
8459  params.targetStringToFree = &target;
8460  params.instance = instance;
8461  params.dicomWebCallback = callback;
8462  params.dicomWebPayload = payload;
8463 
8464  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebJson, &params) != OrthancPluginErrorCode_Success)
8465  {
8466  /* Error */
8467  return NULL;
8468  }
8469  else
8470  {
8471  return target;
8472  }
8473  }
8474 
8475 
8490  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebXml(
8491  OrthancPluginContext* context,
8492  const OrthancPluginDicomInstance* instance,
8494  void* payload)
8495  {
8496  char* target = NULL;
8497 
8498  _OrthancPluginAccessDicomInstance2 params;
8499  params.targetStringToFree = &target;
8500  params.instance = instance;
8501  params.dicomWebCallback = callback;
8502  params.dicomWebPayload = payload;
8503 
8504  if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebXml, &params) != OrthancPluginErrorCode_Success)
8505  {
8506  /* Error */
8507  return NULL;
8508  }
8509  else
8510  {
8511  return target;
8512  }
8513  }
8514 
8515 
8516 
8536  OrthancPluginMemoryBuffer* transcoded /* out */,
8537  const void* buffer,
8538  uint64_t size,
8539  const char* const* allowedSyntaxes,
8540  uint32_t countSyntaxes,
8541  uint8_t allowNewSopInstanceUid);
8542 
8543 
8544  typedef struct
8545  {
8547  } _OrthancPluginTranscoderCallback;
8548 
8563  OrthancPluginContext* context,
8565  {
8566  _OrthancPluginTranscoderCallback params;
8567  params.callback = callback;
8568 
8569  return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, &params);
8570  }
8571 
8572 
8573 
8574  typedef struct
8575  {
8576  OrthancPluginMemoryBuffer* target;
8577  uint32_t size;
8578  } _OrthancPluginCreateMemoryBuffer;
8579 
8598  OrthancPluginContext* context,
8599  OrthancPluginMemoryBuffer* target,
8600  uint32_t size)
8601  {
8602  _OrthancPluginCreateMemoryBuffer params;
8603  params.target = target;
8604  params.size = size;
8605 
8606  return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, &params);
8607  }
8608 
8609 
8636  OrthancPluginContext* context)
8637  {
8638  char* result;
8639 
8640  _OrthancPluginRetrieveDynamicString params;
8641  params.result = &result;
8642  params.argument = NULL;
8643 
8644  if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
8645  &params) != OrthancPluginErrorCode_Success)
8646  {
8647  /* Error */
8648  return NULL;
8649  }
8650  else
8651  {
8652  return result;
8653  }
8654  }
8655 
8656 
8657 
8658  typedef struct
8659  {
8661  uint64_t size;
8662  } _OrthancPluginCreateMemoryBuffer64;
8663 
8682  OrthancPluginContext* context,
8684  uint64_t size)
8685  {
8686  _OrthancPluginCreateMemoryBuffer64 params;
8687  params.target = target;
8688  params.size = size;
8689 
8690  return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer64, &params);
8691  }
8692 
8693 
8694  typedef struct
8695  {
8700  } _OrthancPluginRegisterStorageArea2;
8701 
8718  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea2(
8719  OrthancPluginContext* context,
8724  {
8725  _OrthancPluginRegisterStorageArea2 params;
8726  params.create = create;
8727  params.readWhole = readWhole;
8728  params.readRange = readRange;
8729  params.remove = remove;
8730  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea2, &params);
8731  }
8732 
8733 
8734 
8735  typedef struct
8736  {
8737  _OrthancPluginCreateDicom createDicom;
8738  const char* privateCreator;
8739  } _OrthancPluginCreateDicom2;
8740 
8766  OrthancPluginContext* context,
8767  OrthancPluginMemoryBuffer* target,
8768  const char* json,
8769  const OrthancPluginImage* pixelData,
8771  const char* privateCreator)
8772  {
8773  _OrthancPluginCreateDicom2 params;
8774  params.createDicom.target = target;
8775  params.createDicom.json = json;
8776  params.createDicom.pixelData = pixelData;
8777  params.createDicom.flags = flags;
8778  params.privateCreator = privateCreator;
8779 
8780  return context->InvokeService(context, _OrthancPluginService_CreateDicom2, &params);
8781  }
8782 
8783 
8784 
8785 
8786 
8787 
8788  typedef struct
8789  {
8790  OrthancPluginMemoryBuffer* answerBody;
8791  OrthancPluginMemoryBuffer* answerHeaders;
8792  uint16_t* httpStatus;
8793  OrthancPluginHttpMethod method;
8794  const char* uri;
8795  uint32_t headersCount;
8796  const char* const* headersKeys;
8797  const char* const* headersValues;
8798  const void* body;
8799  uint32_t bodySize;
8800  uint8_t afterPlugins;
8801  } _OrthancPluginCallRestApi;
8802 
8834  OrthancPluginContext* context,
8835  OrthancPluginMemoryBuffer* answerBody,
8836  OrthancPluginMemoryBuffer* answerHeaders,
8837  uint16_t* httpStatus,
8838  OrthancPluginHttpMethod method,
8839  const char* uri,
8840  uint32_t headersCount,
8841  const char* const* headersKeys,
8842  const char* const* headersValues,
8843  const void* body,
8844  uint32_t bodySize,
8845  uint8_t afterPlugins)
8846  {
8847  _OrthancPluginCallRestApi params;
8848  memset(&params, 0, sizeof(params));
8849 
8850  params.answerBody = answerBody;
8851  params.answerHeaders = answerHeaders;
8852  params.httpStatus = httpStatus;
8853  params.method = method;
8854  params.uri = uri;
8855  params.headersCount = headersCount;
8856  params.headersKeys = headersKeys;
8857  params.headersValues = headersValues;
8858  params.body = body;
8859  params.bodySize = bodySize;
8860  params.afterPlugins = afterPlugins;
8861 
8862  return context->InvokeService(context, _OrthancPluginService_CallRestApi, &params);
8863  }
8864 
8865 
8866 
8871  typedef struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection;
8872 
8873 
8891  OrthancPluginWebDavCollection* collection,
8892  const char* name,
8893  uint64_t size,
8894  const char* mimeType,
8895  const char* dateTime);
8896 
8897 
8912  OrthancPluginWebDavCollection* collection,
8913  const char* name,
8914  const char* dateTime);
8915 
8916 
8939  OrthancPluginWebDavCollection* collection,
8940  const void* data,
8941  uint64_t size,
8942  const char* mimeType,
8943  const char* dateTime);
8944 
8945 
8960  uint8_t* isExisting, /* out */
8961  uint32_t pathSize,
8962  const char* const* pathItems,
8963  void* payload);
8964 
8965 
8985  uint8_t* isExisting, /* out */
8986  OrthancPluginWebDavCollection* collection,
8988  OrthancPluginWebDavAddFolder addFolder,
8989  uint32_t pathSize,
8990  const char* const* pathItems,
8991  void* payload);
8992 
8993 
9011  OrthancPluginWebDavCollection* collection,
9012  OrthancPluginWebDavRetrieveFile retrieveFile,
9013  uint32_t pathSize,
9014  const char* const* pathItems,
9015  void* payload);
9016 
9017 
9034  uint8_t* isReadOnly, /* out */
9035  uint32_t pathSize,
9036  const char* const* pathItems,
9037  const void* data,
9038  uint64_t size,
9039  void* payload);
9040 
9041 
9056  uint8_t* isReadOnly, /* out */
9057  uint32_t pathSize,
9058  const char* const* pathItems,
9059  void* payload);
9060 
9061 
9076  uint8_t* isReadOnly, /* out */
9077  uint32_t pathSize,
9078  const char* const* pathItems,
9079  void* payload);
9080 
9081 
9082  typedef struct
9083  {
9084  const char* uri;
9091  void* payload;
9092  } _OrthancPluginRegisterWebDavCollection;
9093 
9115  OrthancPluginContext* context,
9116  const char* uri,
9123  void* payload)
9124  {
9125  _OrthancPluginRegisterWebDavCollection params;
9126  params.uri = uri;
9127  params.isExistingFolder = isExistingFolder;
9128  params.listFolder = listFolder;
9129  params.retrieveFile = retrieveFile;
9130  params.storeFile = storeFile;
9131  params.createFolder = createFolder;
9132  params.deleteItem = deleteItem;
9133  params.payload = payload;
9134 
9135  return context->InvokeService(context, _OrthancPluginService_RegisterWebDavCollection, &params);
9136  }
9137 
9138 
9147  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetDatabaseServerIdentifier(
9148  OrthancPluginContext* context)
9149  {
9150  const char* result;
9151 
9152  _OrthancPluginRetrieveStaticString params;
9153  params.result = &result;
9154  params.argument = NULL;
9155 
9156  if (context->InvokeService(context, _OrthancPluginService_GetDatabaseServerIdentifier, &params) != OrthancPluginErrorCode_Success)
9157  {
9158  /* Error */
9159  return NULL;
9160  }
9161  else
9162  {
9163  return result;
9164  }
9165  }
9166 
9167 
9175  OrthancPluginMemoryBuffer64* response,
9176  void* backend,
9177  const void* request,
9178  uint64_t requestSize);
9179 
9185  typedef void (*OrthancPluginFinalizeDatabaseBackendV4) (void* backend);
9186 
9187  typedef struct
9188  {
9189  void* backend;
9190  uint32_t maxDatabaseRetries;
9193  } _OrthancPluginRegisterDatabaseBackendV4;
9194 
9213  OrthancPluginContext* context,
9214  void* backend,
9215  uint32_t maxDatabaseRetries,
9218  {
9219  _OrthancPluginRegisterDatabaseBackendV4 params;
9220  params.backend = backend;
9221  params.maxDatabaseRetries = maxDatabaseRetries;
9222  params.operations = operations;
9223  params.finalize = finalize;
9224 
9225  return context->InvokeService(context, _OrthancPluginService_RegisterDatabaseBackendV4, &params);
9226  }
9227 
9228 #ifdef __cplusplus
9229 }
9230 #endif
9231 
9232 
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition: OrthancCPlugin.h:8070
Definition: OrthancCPlugin.h:779
Definition: OrthancCPlugin.h:883
OrthancPluginChangeType
Definition: OrthancCPlugin.h:731
Definition: OrthancCPlugin.h:236
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2812
OrthancPluginErrorCode(* OrthancPluginWebDavCreateFolderCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback to create a folder.
Definition: OrthancCPlugin.h:9055
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6409
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5988
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2913
Definition: OrthancCPlugin.h:802
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:8984
Definition: OrthancCPlugin.h:973
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:8298
Definition: OrthancCPlugin.h:278
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:2069
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5444
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:5855
Definition: OrthancCPlugin.h:884
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:2595
OrthancPluginContentType
Definition: OrthancCPlugin.h:699
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2500
Definition: OrthancCPlugin.h:717
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:8490
A 64-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1055
OrthancPluginErrorCode(* OrthancPluginChunkedClientRequestNext)(void *request)
Callback to advance in the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7377
Definition: OrthancCPlugin.h:801
struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode
Opaque structure that represents a node in a JSON or XML document used in DICOMweb.
Definition: OrthancCPlugin.h:1164
Definition: OrthancCPlugin.h:915
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:4204
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:4296
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:926
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1986
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:6995
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition: OrthancCPlugin.h:8375
Definition: OrthancCPlugin.h:270
Definition: OrthancCPlugin.h:206
Definition: OrthancCPlugin.h:268
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:910
struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection
Opaque structure that represents a WebDAV collection.
Definition: OrthancCPlugin.h:8871
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1584
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition: OrthancCPlugin.h:8337
Definition: OrthancCPlugin.h:799
Definition: OrthancCPlugin.h:944
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:8407
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:4950
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:3089
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:2448
Definition: OrthancCPlugin.h:293
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:623
Definition: OrthancCPlugin.h:746
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:865
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5653
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:6741
Definition: OrthancCPlugin.h:284
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:607
Definition: OrthancCPlugin.h:916
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:6914
Definition: OrthancCPlugin.h:649
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:3218
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:7027
Definition: OrthancCPlugin.h:899
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2313
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:776
Definition: OrthancCPlugin.h:214
Definition: OrthancCPlugin.h:306
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1850
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:7846
OrthancPluginErrorCode(* OrthancPluginWebDavAddFolder)(OrthancPluginWebDavCollection *collection, const char *name, const char *dateTime)
Declare a subfolder while returning the content of a folder.
Definition: OrthancCPlugin.h:8911
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4580
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:7970
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:5742
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:5617
Definition: OrthancCPlugin.h:928
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:1155
void OrthancPluginFreeMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:2021
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4505
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:1352
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, uint32_t size)
Create a 32-bit memory buffer.
Definition: OrthancCPlugin.h:8597
Definition: OrthancCPlugin.h:740
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4763
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition: OrthancCPlugin.h:7907
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4540
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:3315
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:6078
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3361
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:647
Definition: OrthancCPlugin.h:847
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:844
Definition: OrthancCPlugin.h:945
Definition: OrthancCPlugin.h:216
OrthancPluginReceivedInstanceAction
Definition: OrthancCPlugin.h:1016
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2858
Definition: OrthancCPlugin.h:763
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:2525
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5910
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:1799
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1568
Definition: OrthancCPlugin.h:748
uint8_t(* OrthancPluginChunkedClientRequestIsDone)(void *request)
Callback to know whether the request body is entirely read during a chunked transfer.
Definition: OrthancCPlugin.h:7360
Definition: OrthancCPlugin.h:943
Definition: OrthancCPlugin.h:734
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:5571
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:1383
Definition: OrthancCPlugin.h:267
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:829
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5699
Definition: OrthancCPlugin.h:1018
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1682
Definition: OrthancCPlugin.h:831
const void *(* OrthancPluginChunkedClientRequestGetChunkData)(void *request)
Callback to read the current chunk of the request body during a chunked transfer. ...
Definition: OrthancCPlugin.h:7393
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4841
Definition: OrthancCPlugin.h:248
uint16_t group
Definition: OrthancCPlugin.h:1833
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:4074
int32_t(* OrthancPluginJobGetSerialized2)(OrthancPluginMemoryBuffer *target, void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1642
Definition: OrthancCPlugin.h:792
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:9114
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1836
Definition: OrthancCPlugin.h:833
Definition: OrthancCPlugin.h:804
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:5219
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:4429
Definition: OrthancCPlugin.h:942
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:940
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1107
Definition: OrthancCPlugin.h:778
Definition: OrthancCPlugin.h:260
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:1099
Definition: OrthancCPlugin.h:252
Definition: OrthancCPlugin.h:701
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:8959
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:3051
Definition: OrthancCPlugin.h:738
Color image in RGB48 format.
Definition: OrthancCPlugin.h:657
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3606
Definition: OrthancCPlugin.h:283
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:615
Definition: OrthancCPlugin.h:281
Definition: OrthancCPlugin.h:217
OrthancPluginConstraintType
Definition: OrthancCPlugin.h:895
Definition: OrthancCPlugin.h:750
OrthancPluginResourceType
Definition: OrthancCPlugin.h:714
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:1226
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition: OrthancCPlugin.h:8155
Definition: OrthancCPlugin.h:233
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:4005
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:790
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3639
Definition: OrthancCPlugin.h:204
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:4117
Definition: OrthancCPlugin.h:286
Definition: OrthancCPlugin.h:794
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:8718
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:7179
Definition: OrthancCPlugin.h:719
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1172
Definition: OrthancCPlugin.h:277
Definition: OrthancCPlugin.h:764
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:8270
Definition: OrthancCPlugin.h:797
Definition: OrthancCPlugin.h:294
Definition: OrthancCPlugin.h:930
void OrthancPluginSetMetricsValue(OrthancPluginContext *context, const char *name, float value, OrthancPluginMetricsType type)
Set the value of a metrics.
Definition: OrthancCPlugin.h:7071
int32_t(* OrthancPluginIncomingCStoreInstanceFilter)(uint16_t *dimseStatus, const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition: OrthancCPlugin.h:7948
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:3280
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:8015
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:2413
Definition: OrthancCPlugin.h:766
Definition: OrthancCPlugin.h:816
Definition: OrthancCPlugin.h:269
Color image in RGB24 format.
Definition: OrthancCPlugin.h:639
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6347
char * OrthancPluginGenerateRestApiAuthorizationToken(OrthancPluginContext *context)
Generate a token to grant full access to the REST API of Orthanc.
Definition: OrthancCPlugin.h:8635
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:9010
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:631
Definition: OrthancCPlugin.h:954
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1831
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:1139
Definition: OrthancCPlugin.h:733
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:761
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:3903
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:5145
Definition: OrthancCPlugin.h:850
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:8890
struct _OrthancPluginPeers_t OrthancPluginPeers
Opaque structure to the set of remote Orthanc Peers that are known to the local Orthanc server...
Definition: OrthancCPlugin.h:1147
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3939
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:4665
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *target, uint64_t size)
Create a 64-bit memory buffer.
Definition: OrthancCPlugin.h:8681
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:4040
Definition: OrthancCPlugin.h:702
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:2272
Definition: OrthancCPlugin.h:299
Definition: OrthancCPlugin.h:305
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1658
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1060
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1837
Definition: OrthancCPlugin.h:972
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:8833
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:1204
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:5038
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1216
Definition: OrthancCPlugin.h:900
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3540
Definition: OrthancCPlugin.h:250
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2835
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:6655
Definition: OrthancCPlugin.h:212
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:689
Definition: OrthancCPlugin.h:275
Definition: OrthancCPlugin.h:263
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:6272
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:8765
Definition: OrthancCPlugin.h:295
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:2037
Definition: OrthancCPlugin.h:231
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:6234
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1038
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:8047
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4612
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:3436
Definition: OrthancCPlugin.h:914
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1733
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2346
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3850
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:390
Definition: OrthancCPlugin.h:749
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:3015
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:6827
Definition: OrthancCPlugin.h:739
Definition: OrthancCPlugin.h:849
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:2005
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:5183
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1245
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:3128
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:1488
Definition: OrthancCPlugin.h:810
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:2477
Definition: OrthancCPlugin.h:814
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:7819
Definition: OrthancCPlugin.h:718
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3788
Definition: OrthancCPlugin.h:803
Definition: OrthancCPlugin.h:885
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1131
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:6195
Definition: OrthancCPlugin.h:329
Definition: OrthancCPlugin.h:747
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5482
Definition: OrthancCPlugin.h:805
Definition: OrthancCPlugin.h:255
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:3250
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3470
Definition: OrthancCPlugin.h:901
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1333
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:3169
Definition: OrthancCPlugin.h:832
Definition: OrthancCPlugin.h:264
Definition: OrthancCPlugin.h:854
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:9075
Definition: OrthancCPlugin.h:961
Definition: OrthancCPlugin.h:741
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:7549
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4994
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:6109
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6959
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition: OrthancCPlugin.h:8193
OrthancPluginErrorCode OrthancPluginRegisterDatabaseBackendV4(OrthancPluginContext *context, void *backend, uint32_t maxDatabaseRetries, OrthancPluginCallDatabaseBackendV4 operations, OrthancPluginFinalizeDatabaseBackendV4 finalize)
Definition: OrthancCPlugin.h:9212
char * OrthancPluginEncodeDicomWebJson2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7231
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3574
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:4349
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2982
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:5525
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:8450
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5780
Definition: OrthancCPlugin.h:917
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:5087
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:9174
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition: OrthancCPlugin.h:7886
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:6574
Definition: OrthancCPlugin.h:817
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:1193
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6375
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:3751
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:8535
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:7340
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5249
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:5408
Definition: OrthancCPlugin.h:258
Definition: OrthancCPlugin.h:780
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:2145
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:4387
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1445
Definition: OrthancCPlugin.h:744
void(* OrthancPluginFinalizeDatabaseBackendV4)(void *backend)
Signature of a callback function that is triggered when the database plugin must be finalized...
Definition: OrthancCPlugin.h:9185
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5949
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1091
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3680
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1115
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:5352
Definition: OrthancCPlugin.h:751
Definition: OrthancCPlugin.h:882
Definition: OrthancCPlugin.h:303
Definition: OrthancCPlugin.h:274
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1542
char * OrthancPluginEncodeDicomWebXml2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7275
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:3392
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:8105
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1622
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4802
Definition: OrthancCPlugin.h:929
Definition: OrthancCPlugin.h:704
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:1183
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6882
Definition: OrthancCPlugin.h:809
Definition: OrthancCPlugin.h:745
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:365
Definition: OrthancCPlugin.h:812
Definition: OrthancCPlugin.h:736
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2627
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:8938
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:1315
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition: OrthancCPlugin.h:1083
Definition: OrthancCPlugin.h:245
Definition: OrthancCPlugin.h:898
Definition: OrthancCPlugin.h:813
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:4159
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1835
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:7488
uint16_t element
Definition: OrthancCPlugin.h:1834
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2767
Definition: OrthancCPlugin.h:743
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3509
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1528
Definition: OrthancCPlugin.h:235
Definition: OrthancCPlugin.h:703
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:3819
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:1272
Definition: OrthancCPlugin.h:276
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2662
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1043
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:673
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2949
Definition: OrthancCPlugin.h:912
Definition: OrthancCPlugin.h:256
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1699
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7137
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:7568
Definition: OrthancCPlugin.h:720
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:2053
Definition: OrthancCPlugin.h:971
Definition: OrthancCPlugin.h:798
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:5287
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:1880
Definition: OrthancCPlugin.h:818
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:7607
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:880
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:6017
Definition: OrthancCPlugin.h:330
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1715
OrthancPluginMetricsType
Definition: OrthancCPlugin.h:952
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:2561
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:3709
OrthancPluginDicomWebBinaryMode
Definition: OrthancCPlugin.h:969
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:2888
Definition: OrthancCPlugin.h:735
char * OrthancPluginGetTagName(OrthancPluginContext *context, uint16_t group, uint16_t element, const char *privateCreator)
Returns the symbolic name of a DICOM tag.
Definition: OrthancCPlugin.h:7721
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6439
Definition: OrthancCPlugin.h:808
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6528
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:6041
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:1075
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:3414
Definition: OrthancCPlugin.h:304
Definition: OrthancCPlugin.h:237
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:2183
Definition: OrthancCPlugin.h:737
Definition: OrthancCPlugin.h:811
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:4897
Definition: OrthancCPlugin.h:259
Definition: OrthancCPlugin.h:1019
Definition: OrthancCPlugin.h:215
Definition: OrthancCPlugin.h:815
Definition: OrthancCPlugin.h:795
Definition: OrthancCPlugin.h:1020
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:665
Definition: OrthancCPlugin.h:897
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:2105
uint32_t(* OrthancPluginChunkedClientRequestGetChunkSize)(void *request)
Callback to read the size of the current request chunk during a chunked transfer. ...
Definition: OrthancCPlugin.h:7409
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2697
Definition: OrthancCPlugin.h:807
Definition: OrthancCPlugin.h:793
Definition: OrthancCPlugin.h:207
Definition: OrthancCPlugin.h:716
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:7670
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5326
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:2376
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:7319
Definition: OrthancCPlugin.h:913
Definition: OrthancCPlugin.h:226
Definition: OrthancCPlugin.h:297
Definition: OrthancCPlugin.h:208
Definition: OrthancCPlugin.h:213
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1123
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:9033
Definition: OrthancCPlugin.h:742
Definition: OrthancCPlugin.h:765
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:7101
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:1418
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:4719
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:2215
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4467
A 32-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1033
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:7776
uint64_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1065
void(* OrthancPluginServerChunkedRequestReaderFinalize)(OrthancPluginServerChunkedRequestReader *reader)
Callback invoked to release the resources associated with an incoming HTTP chunked transfer...
Definition: OrthancCPlugin.h:7625
const char * OrthancPluginGetDatabaseServerIdentifier(OrthancPluginContext *context)
Gets the DatabaseServerIdentifier.
Definition: OrthancCPlugin.h:9147
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6487
OrthancPluginErrorCode(* OrthancPluginStorageReadWhole)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type)
Callback for reading a whole file from the storage area.
Definition: OrthancCPlugin.h:1292
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:681
OrthancPluginStorageCommitmentFailureReason
Definition: OrthancCPlugin.h:982
Definition: OrthancCPlugin.h:800
Definition: OrthancCPlugin.h:848
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition: OrthancCPlugin.h:8230
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition: OrthancCPlugin.h:8562
Definition: OrthancCPlugin.h:219
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7798
Definition: OrthancCPlugin.h:853
OrthancPluginErrorCode(* OrthancPluginJobGetContent2)(OrthancPluginMemoryBuffer *target, void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1602
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:6305
Definition: OrthancCPlugin.h:806
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1555
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2732
Definition: OrthancCPlugin.h:209
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1513
Definition: OrthancCPlugin.h:796
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:1761
Definition: OrthancCPlugin.h:285
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3972
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:7587
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:4249
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:6147
Definition: OrthancCPlugin.h:239
Definition: OrthancCPlugin.h:232