Orthanc Plugin SDK
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1 
103 #pragma once
104 
105 
106 #include <stdio.h>
107 #include <string.h>
108 
109 #ifdef WIN32
110 #define ORTHANC_PLUGINS_API __declspec(dllexport)
111 #else
112 #define ORTHANC_PLUGINS_API
113 #endif
114 
115 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 0
116 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 9
117 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 5
118 
119 
120 
121 /********************************************************************
122  ** Check that function inlining is properly supported. The use of
123  ** inlining is required, to avoid the duplication of object code
124  ** between two compilation modules that would use the Orthanc Plugin
125  ** API.
126  ********************************************************************/
127 
128 /* If the auto-detection of the "inline" keyword below does not work
129  automatically and that your compiler is known to properly support
130  inlining, uncomment the following #define and adapt the definition
131  of "static inline". */
132 
133 /* #define ORTHANC_PLUGIN_INLINE static inline */
134 
135 #ifndef ORTHANC_PLUGIN_INLINE
136 # if __STDC_VERSION__ >= 199901L
137 /* This is C99 or above: http://predef.sourceforge.net/prestd.html */
138 # define ORTHANC_PLUGIN_INLINE static inline
139 # elif defined(__cplusplus)
140 /* This is C++ */
141 # define ORTHANC_PLUGIN_INLINE static inline
142 # elif defined(__GNUC__)
143 /* This is GCC running in C89 mode */
144 # define ORTHANC_PLUGIN_INLINE static __inline
145 # elif defined(_MSC_VER)
146 /* This is Visual Studio running in C89 mode */
147 # define ORTHANC_PLUGIN_INLINE static __inline
148 # else
149 # error Your compiler is not known to support the "inline" keyword
150 # endif
151 #endif
152 
153 
154 
155 /********************************************************************
156  ** Inclusion of standard libraries.
157  ********************************************************************/
158 
164 #include <stdint.h>
165 
166 #include <stdlib.h>
167 
168 
169 
170 /********************************************************************
171  ** Definition of the Orthanc Plugin API.
172  ********************************************************************/
173 
176 #ifdef __cplusplus
177 extern "C"
178 {
179 #endif
180 
184  typedef enum
185  {
280 
281  _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
283 
284 
289  ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
290 
291 
295  typedef enum
296  {
302  _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
304 
305 
310  typedef struct
311  {
316 
320  uint32_t groupsCount;
321 
325  const char* const* groups;
326 
330  uint32_t getCount;
331 
335  const char* const* getKeys;
336 
340  const char* const* getValues;
341 
345  const char* body;
346 
350  uint32_t bodySize;
351 
352 
353  /* --------------------------------------------------
354  New in version 0.8.1
355  -------------------------------------------------- */
356 
360  uint32_t headersCount;
361 
365  const char* const* headersKeys;
366 
370  const char* const* headersValues;
371 
373 
374 
375  typedef enum
376  {
377  /* Generic services */
378  _OrthancPluginService_LogInfo = 1,
379  _OrthancPluginService_LogWarning = 2,
380  _OrthancPluginService_LogError = 3,
381  _OrthancPluginService_GetOrthancPath = 4,
382  _OrthancPluginService_GetOrthancDirectory = 5,
383  _OrthancPluginService_GetConfigurationPath = 6,
384  _OrthancPluginService_SetPluginProperty = 7,
385  _OrthancPluginService_GetGlobalProperty = 8,
386  _OrthancPluginService_SetGlobalProperty = 9,
387  _OrthancPluginService_GetCommandLineArgumentsCount = 10,
388  _OrthancPluginService_GetCommandLineArgument = 11,
389  _OrthancPluginService_GetExpectedDatabaseVersion = 12,
390  _OrthancPluginService_GetConfiguration = 13,
391  _OrthancPluginService_BufferCompression = 14,
392  _OrthancPluginService_ReadFile = 15,
393  _OrthancPluginService_WriteFile = 16,
394  _OrthancPluginService_GetErrorDescription = 17,
395  _OrthancPluginService_CallHttpClient = 18,
396  _OrthancPluginService_RegisterErrorCode = 19,
397  _OrthancPluginService_RegisterDictionaryTag = 20,
398  _OrthancPluginService_DicomBufferToJson = 21,
399  _OrthancPluginService_DicomInstanceToJson = 22,
400  _OrthancPluginService_CreateDicom = 23,
401  _OrthancPluginService_ComputeMd5 = 24,
402  _OrthancPluginService_ComputeSha1 = 25,
403  _OrthancPluginService_LookupDictionary = 26,
404 
405  /* Registration of callbacks */
406  _OrthancPluginService_RegisterRestCallback = 1000,
407  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
408  _OrthancPluginService_RegisterStorageArea = 1002,
409  _OrthancPluginService_RegisterOnChangeCallback = 1003,
410  _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
411  _OrthancPluginService_RegisterWorklistCallback = 1005,
412  _OrthancPluginService_RegisterDecodeImageCallback = 1006,
413 
414  /* Sending answers to REST calls */
415  _OrthancPluginService_AnswerBuffer = 2000,
416  _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
417  _OrthancPluginService_Redirect = 2002,
418  _OrthancPluginService_SendHttpStatusCode = 2003,
419  _OrthancPluginService_SendUnauthorized = 2004,
420  _OrthancPluginService_SendMethodNotAllowed = 2005,
421  _OrthancPluginService_SetCookie = 2006,
422  _OrthancPluginService_SetHttpHeader = 2007,
423  _OrthancPluginService_StartMultipartAnswer = 2008,
424  _OrthancPluginService_SendMultipartItem = 2009,
425  _OrthancPluginService_SendHttpStatus = 2010,
426  _OrthancPluginService_CompressAndAnswerImage = 2011,
427 
428  /* Access to the Orthanc database and API */
429  _OrthancPluginService_GetDicomForInstance = 3000,
430  _OrthancPluginService_RestApiGet = 3001,
431  _OrthancPluginService_RestApiPost = 3002,
432  _OrthancPluginService_RestApiDelete = 3003,
433  _OrthancPluginService_RestApiPut = 3004,
434  _OrthancPluginService_LookupPatient = 3005,
435  _OrthancPluginService_LookupStudy = 3006,
436  _OrthancPluginService_LookupSeries = 3007,
437  _OrthancPluginService_LookupInstance = 3008,
438  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
439  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
440  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
441  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
442  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
443  _OrthancPluginService_ReconstructMainDicomTags = 3014,
444  _OrthancPluginService_RestApiGet2 = 3015,
445 
446  /* Access to DICOM instances */
447  _OrthancPluginService_GetInstanceRemoteAet = 4000,
448  _OrthancPluginService_GetInstanceSize = 4001,
449  _OrthancPluginService_GetInstanceData = 4002,
450  _OrthancPluginService_GetInstanceJson = 4003,
451  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
452  _OrthancPluginService_HasInstanceMetadata = 4005,
453  _OrthancPluginService_GetInstanceMetadata = 4006,
454  _OrthancPluginService_GetInstanceOrigin = 4007,
455 
456  /* Services for plugins implementing a database back-end */
457  _OrthancPluginService_RegisterDatabaseBackend = 5000,
458  _OrthancPluginService_DatabaseAnswer = 5001,
459  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
460  _OrthancPluginService_StorageAreaCreate = 5003,
461  _OrthancPluginService_StorageAreaRead = 5004,
462  _OrthancPluginService_StorageAreaRemove = 5005,
463 
464  /* Primitives for handling images */
465  _OrthancPluginService_GetImagePixelFormat = 6000,
466  _OrthancPluginService_GetImageWidth = 6001,
467  _OrthancPluginService_GetImageHeight = 6002,
468  _OrthancPluginService_GetImagePitch = 6003,
469  _OrthancPluginService_GetImageBuffer = 6004,
470  _OrthancPluginService_UncompressImage = 6005,
471  _OrthancPluginService_FreeImage = 6006,
472  _OrthancPluginService_CompressImage = 6007,
473  _OrthancPluginService_ConvertPixelFormat = 6008,
474  _OrthancPluginService_GetFontsCount = 6009,
475  _OrthancPluginService_GetFontInfo = 6010,
476  _OrthancPluginService_DrawText = 6011,
477  _OrthancPluginService_CreateImage = 6012,
478  _OrthancPluginService_CreateImageAccessor = 6013,
479  _OrthancPluginService_DecodeDicomImage = 6014,
480 
481  /* Primitives for handling worklists */
482  _OrthancPluginService_WorklistAddAnswer = 7000,
483  _OrthancPluginService_WorklistMarkIncomplete = 7001,
484  _OrthancPluginService_WorklistIsMatch = 7002,
485  _OrthancPluginService_WorklistGetDicomQuery = 7003,
486 
487  _OrthancPluginService_INTERNAL = 0x7fffffff
488  } _OrthancPluginService;
489 
490 
491  typedef enum
492  {
493  _OrthancPluginProperty_Description = 1,
494  _OrthancPluginProperty_RootUri = 2,
495  _OrthancPluginProperty_OrthancExplorer = 3,
496 
497  _OrthancPluginProperty_INTERNAL = 0x7fffffff
498  } _OrthancPluginProperty;
499 
500 
501 
506  typedef enum
507  {
515 
523 
531 
539 
547 
550  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
552 
553 
554 
558  typedef enum
559  {
564  _OrthancPluginContentType_INTERNAL = 0x7fffffff
566 
567 
568 
572  typedef enum
573  {
580  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
582 
583 
584 
589  typedef enum
590  {
606  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
608 
609 
614  typedef enum
615  {
621  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
623 
624 
629  typedef enum
630  {
635  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
637 
638 
643  typedef enum
644  {
673  _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
675 
676 
682  typedef enum
683  {
688  _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
690 
691 
697  typedef enum
698  {
706  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
708 
709 
715  typedef enum
716  {
720  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
722 
723 
728  typedef enum
729  {
735  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
737 
738 
742  typedef enum
743  {
750  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
752 
753 
761  typedef struct
762  {
766  void* data;
767 
771  uint32_t size;
773 
774 
775 
776 
781  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
782 
783 
784 
788  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
789 
790 
791 
796  typedef struct _OrthancPluginImage_t OrthancPluginImage;
797 
798 
799 
804  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
805 
806 
807 
812  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
813 
814 
815 
820  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
821 
822 
823 
829  OrthancPluginRestOutput* output,
830  const char* url,
831  const OrthancPluginHttpRequest* request);
832 
833 
834 
840  OrthancPluginDicomInstance* instance,
841  const char* instanceId);
842 
843 
844 
850  OrthancPluginChangeType changeType,
851  OrthancPluginResourceType resourceType,
852  const char* resourceId);
853 
854 
855 
861  OrthancPluginImage** target,
862  const void* dicom,
863  const uint32_t size,
864  uint32_t frameIndex);
865 
866 
867 
871  typedef void (*OrthancPluginFree) (void* buffer);
872 
873 
874 
888  const char* uuid,
889  const void* content,
890  int64_t size,
892 
893 
894 
908  void** content,
909  int64_t* size,
910  const char* uuid,
912 
913 
914 
926  const char* uuid,
928 
929 
930 
946  const OrthancPluginWorklistQuery* query,
947  const char* remoteAet,
948  const char* calledAet);
949 
950 
951 
955  typedef struct _OrthancPluginContext_t
956  {
957  void* pluginsManager;
958  const char* orthancVersion;
959  OrthancPluginFree Free;
960  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
961  _OrthancPluginService service,
962  const void* params);
964 
965 
966 
970  typedef struct
971  {
972  uint16_t group;
973  uint16_t element;
975  uint32_t minMultiplicity;
976  uint32_t maxMultiplicity;
978 
979 
980 
989  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
990  OrthancPluginContext* context,
991  char* str)
992  {
993  if (str != NULL)
994  {
995  context->Free(str);
996  }
997  }
998 
999 
1013  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1014  OrthancPluginContext* context)
1015  {
1016  int major, minor, revision;
1017 
1018  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1019  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1020  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1021  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1022  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1023  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1024  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1025  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1026  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1027  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1028  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1029  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1030  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1031  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1032  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1033  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin))
1034  {
1035  /* Mismatch in the size of the enumerations */
1036  return 0;
1037  }
1038 
1039  /* Assume compatibility with the mainline */
1040  if (!strcmp(context->orthancVersion, "mainline"))
1041  {
1042  return 1;
1043  }
1044 
1045  /* Parse the version of the Orthanc core */
1046  if (
1047 #ifdef _MSC_VER
1048  sscanf_s
1049 #else
1050  sscanf
1051 #endif
1052  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1053  {
1054  return 0;
1055  }
1056 
1057  /* Check the major number of the version */
1058 
1059  if (major > ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
1060  {
1061  return 1;
1062  }
1063 
1064  if (major < ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
1065  {
1066  return 0;
1067  }
1068 
1069  /* Check the minor number of the version */
1070 
1071  if (minor > ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
1072  {
1073  return 1;
1074  }
1075 
1076  if (minor < ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
1077  {
1078  return 0;
1079  }
1080 
1081  /* Check the revision number of the version */
1082 
1083  if (revision >= ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER)
1084  {
1085  return 1;
1086  }
1087  else
1088  {
1089  return 0;
1090  }
1091  }
1092 
1093 
1102  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1103  OrthancPluginContext* context,
1104  OrthancPluginMemoryBuffer* buffer)
1105  {
1106  context->Free(buffer->data);
1107  }
1108 
1109 
1118  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1119  OrthancPluginContext* context,
1120  const char* message)
1121  {
1122  context->InvokeService(context, _OrthancPluginService_LogError, message);
1123  }
1124 
1125 
1134  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
1135  OrthancPluginContext* context,
1136  const char* message)
1137  {
1138  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1139  }
1140 
1141 
1150  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
1151  OrthancPluginContext* context,
1152  const char* message)
1153  {
1154  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
1155  }
1156 
1157 
1158 
1159  typedef struct
1160  {
1161  const char* pathRegularExpression;
1162  OrthancPluginRestCallback callback;
1163  } _OrthancPluginRestCallback;
1164 
1181  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
1182  OrthancPluginContext* context,
1183  const char* pathRegularExpression,
1184  OrthancPluginRestCallback callback)
1185  {
1186  _OrthancPluginRestCallback params;
1187  params.pathRegularExpression = pathRegularExpression;
1188  params.callback = callback;
1189  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
1190  }
1191 
1192 
1193 
1215  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
1216  OrthancPluginContext* context,
1217  const char* pathRegularExpression,
1218  OrthancPluginRestCallback callback)
1219  {
1220  _OrthancPluginRestCallback params;
1221  params.pathRegularExpression = pathRegularExpression;
1222  params.callback = callback;
1223  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
1224  }
1225 
1226 
1227 
1228  typedef struct
1229  {
1231  } _OrthancPluginOnStoredInstanceCallback;
1232 
1244  OrthancPluginContext* context,
1246  {
1247  _OrthancPluginOnStoredInstanceCallback params;
1248  params.callback = callback;
1249 
1250  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
1251  }
1252 
1253 
1254 
1255  typedef struct
1256  {
1257  OrthancPluginRestOutput* output;
1258  const char* answer;
1259  uint32_t answerSize;
1260  const char* mimeType;
1261  } _OrthancPluginAnswerBuffer;
1262 
1275  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
1276  OrthancPluginContext* context,
1277  OrthancPluginRestOutput* output,
1278  const char* answer,
1279  uint32_t answerSize,
1280  const char* mimeType)
1281  {
1282  _OrthancPluginAnswerBuffer params;
1283  params.output = output;
1284  params.answer = answer;
1285  params.answerSize = answerSize;
1286  params.mimeType = mimeType;
1287  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
1288  }
1289 
1290 
1291  typedef struct
1292  {
1293  OrthancPluginRestOutput* output;
1294  OrthancPluginPixelFormat format;
1295  uint32_t width;
1296  uint32_t height;
1297  uint32_t pitch;
1298  const void* buffer;
1299  } _OrthancPluginCompressAndAnswerPngImage;
1300 
1301  typedef struct
1302  {
1303  OrthancPluginRestOutput* output;
1304  OrthancPluginImageFormat imageFormat;
1305  OrthancPluginPixelFormat pixelFormat;
1306  uint32_t width;
1307  uint32_t height;
1308  uint32_t pitch;
1309  const void* buffer;
1310  uint8_t quality;
1311  } _OrthancPluginCompressAndAnswerImage;
1312 
1313 
1332  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
1333  OrthancPluginContext* context,
1334  OrthancPluginRestOutput* output,
1335  OrthancPluginPixelFormat format,
1336  uint32_t width,
1337  uint32_t height,
1338  uint32_t pitch,
1339  const void* buffer)
1340  {
1341  _OrthancPluginCompressAndAnswerImage params;
1342  params.output = output;
1343  params.imageFormat = OrthancPluginImageFormat_Png;
1344  params.pixelFormat = format;
1345  params.width = width;
1346  params.height = height;
1347  params.pitch = pitch;
1348  params.buffer = buffer;
1349  params.quality = 0; /* No quality for PNG */
1350  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
1351  }
1352 
1353 
1354 
1355  typedef struct
1356  {
1357  OrthancPluginMemoryBuffer* target;
1358  const char* instanceId;
1359  } _OrthancPluginGetDicomForInstance;
1360 
1374  OrthancPluginContext* context,
1375  OrthancPluginMemoryBuffer* target,
1376  const char* instanceId)
1377  {
1378  _OrthancPluginGetDicomForInstance params;
1379  params.target = target;
1380  params.instanceId = instanceId;
1381  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
1382  }
1383 
1384 
1385 
1386  typedef struct
1387  {
1388  OrthancPluginMemoryBuffer* target;
1389  const char* uri;
1390  } _OrthancPluginRestApiGet;
1391 
1406  OrthancPluginContext* context,
1407  OrthancPluginMemoryBuffer* target,
1408  const char* uri)
1409  {
1410  _OrthancPluginRestApiGet params;
1411  params.target = target;
1412  params.uri = uri;
1413  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
1414  }
1415 
1416 
1417 
1435  OrthancPluginContext* context,
1436  OrthancPluginMemoryBuffer* target,
1437  const char* uri)
1438  {
1439  _OrthancPluginRestApiGet params;
1440  params.target = target;
1441  params.uri = uri;
1442  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
1443  }
1444 
1445 
1446 
1447  typedef struct
1448  {
1449  OrthancPluginMemoryBuffer* target;
1450  const char* uri;
1451  const char* body;
1452  uint32_t bodySize;
1453  } _OrthancPluginRestApiPostPut;
1454 
1471  OrthancPluginContext* context,
1472  OrthancPluginMemoryBuffer* target,
1473  const char* uri,
1474  const char* body,
1475  uint32_t bodySize)
1476  {
1477  _OrthancPluginRestApiPostPut params;
1478  params.target = target;
1479  params.uri = uri;
1480  params.body = body;
1481  params.bodySize = bodySize;
1482  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
1483  }
1484 
1485 
1505  OrthancPluginContext* context,
1506  OrthancPluginMemoryBuffer* target,
1507  const char* uri,
1508  const char* body,
1509  uint32_t bodySize)
1510  {
1511  _OrthancPluginRestApiPostPut params;
1512  params.target = target;
1513  params.uri = uri;
1514  params.body = body;
1515  params.bodySize = bodySize;
1516  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
1517  }
1518 
1519 
1520 
1533  OrthancPluginContext* context,
1534  const char* uri)
1535  {
1536  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
1537  }
1538 
1539 
1555  OrthancPluginContext* context,
1556  const char* uri)
1557  {
1558  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
1559  }
1560 
1561 
1562 
1579  OrthancPluginContext* context,
1580  OrthancPluginMemoryBuffer* target,
1581  const char* uri,
1582  const char* body,
1583  uint32_t bodySize)
1584  {
1585  _OrthancPluginRestApiPostPut params;
1586  params.target = target;
1587  params.uri = uri;
1588  params.body = body;
1589  params.bodySize = bodySize;
1590  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
1591  }
1592 
1593 
1594 
1614  OrthancPluginContext* context,
1615  OrthancPluginMemoryBuffer* target,
1616  const char* uri,
1617  const char* body,
1618  uint32_t bodySize)
1619  {
1620  _OrthancPluginRestApiPostPut params;
1621  params.target = target;
1622  params.uri = uri;
1623  params.body = body;
1624  params.bodySize = bodySize;
1625  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
1626  }
1627 
1628 
1629 
1630  typedef struct
1631  {
1632  OrthancPluginRestOutput* output;
1633  const char* argument;
1634  } _OrthancPluginOutputPlusArgument;
1635 
1647  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
1648  OrthancPluginContext* context,
1649  OrthancPluginRestOutput* output,
1650  const char* redirection)
1651  {
1652  _OrthancPluginOutputPlusArgument params;
1653  params.output = output;
1654  params.argument = redirection;
1655  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
1656  }
1657 
1658 
1659 
1660  typedef struct
1661  {
1662  char** result;
1663  const char* argument;
1664  } _OrthancPluginRetrieveDynamicString;
1665 
1679  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
1680  OrthancPluginContext* context,
1681  const char* patientID)
1682  {
1683  char* result;
1684 
1685  _OrthancPluginRetrieveDynamicString params;
1686  params.result = &result;
1687  params.argument = patientID;
1688 
1689  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
1690  {
1691  /* Error */
1692  return NULL;
1693  }
1694  else
1695  {
1696  return result;
1697  }
1698  }
1699 
1700 
1714  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
1715  OrthancPluginContext* context,
1716  const char* studyUID)
1717  {
1718  char* result;
1719 
1720  _OrthancPluginRetrieveDynamicString params;
1721  params.result = &result;
1722  params.argument = studyUID;
1723 
1724  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
1725  {
1726  /* Error */
1727  return NULL;
1728  }
1729  else
1730  {
1731  return result;
1732  }
1733  }
1734 
1735 
1749  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
1750  OrthancPluginContext* context,
1751  const char* accessionNumber)
1752  {
1753  char* result;
1754 
1755  _OrthancPluginRetrieveDynamicString params;
1756  params.result = &result;
1757  params.argument = accessionNumber;
1758 
1759  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
1760  {
1761  /* Error */
1762  return NULL;
1763  }
1764  else
1765  {
1766  return result;
1767  }
1768  }
1769 
1770 
1784  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
1785  OrthancPluginContext* context,
1786  const char* seriesUID)
1787  {
1788  char* result;
1789 
1790  _OrthancPluginRetrieveDynamicString params;
1791  params.result = &result;
1792  params.argument = seriesUID;
1793 
1794  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
1795  {
1796  /* Error */
1797  return NULL;
1798  }
1799  else
1800  {
1801  return result;
1802  }
1803  }
1804 
1805 
1819  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
1820  OrthancPluginContext* context,
1821  const char* sopInstanceUID)
1822  {
1823  char* result;
1824 
1825  _OrthancPluginRetrieveDynamicString params;
1826  params.result = &result;
1827  params.argument = sopInstanceUID;
1828 
1829  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
1830  {
1831  /* Error */
1832  return NULL;
1833  }
1834  else
1835  {
1836  return result;
1837  }
1838  }
1839 
1840 
1841 
1842  typedef struct
1843  {
1844  OrthancPluginRestOutput* output;
1845  uint16_t status;
1846  } _OrthancPluginSendHttpStatusCode;
1847 
1864  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
1865  OrthancPluginContext* context,
1866  OrthancPluginRestOutput* output,
1867  uint16_t status)
1868  {
1869  _OrthancPluginSendHttpStatusCode params;
1870  params.output = output;
1871  params.status = status;
1872  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
1873  }
1874 
1875 
1887  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
1888  OrthancPluginContext* context,
1889  OrthancPluginRestOutput* output,
1890  const char* realm)
1891  {
1892  _OrthancPluginOutputPlusArgument params;
1893  params.output = output;
1894  params.argument = realm;
1895  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
1896  }
1897 
1898 
1910  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
1911  OrthancPluginContext* context,
1912  OrthancPluginRestOutput* output,
1913  const char* allowedMethods)
1914  {
1915  _OrthancPluginOutputPlusArgument params;
1916  params.output = output;
1917  params.argument = allowedMethods;
1918  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
1919  }
1920 
1921 
1922  typedef struct
1923  {
1924  OrthancPluginRestOutput* output;
1925  const char* key;
1926  const char* value;
1927  } _OrthancPluginSetHttpHeader;
1928 
1940  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
1941  OrthancPluginContext* context,
1942  OrthancPluginRestOutput* output,
1943  const char* cookie,
1944  const char* value)
1945  {
1946  _OrthancPluginSetHttpHeader params;
1947  params.output = output;
1948  params.key = cookie;
1949  params.value = value;
1950  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
1951  }
1952 
1953 
1965  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
1966  OrthancPluginContext* context,
1967  OrthancPluginRestOutput* output,
1968  const char* key,
1969  const char* value)
1970  {
1971  _OrthancPluginSetHttpHeader params;
1972  params.output = output;
1973  params.key = key;
1974  params.value = value;
1975  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
1976  }
1977 
1978 
1979  typedef struct
1980  {
1981  char** resultStringToFree;
1982  const char** resultString;
1983  int64_t* resultInt64;
1984  const char* key;
1985  OrthancPluginDicomInstance* instance;
1986  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
1987  } _OrthancPluginAccessDicomInstance;
1988 
1989 
2001  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2002  OrthancPluginContext* context,
2003  OrthancPluginDicomInstance* instance)
2004  {
2005  const char* result;
2006 
2007  _OrthancPluginAccessDicomInstance params;
2008  memset(&params, 0, sizeof(params));
2009  params.resultString = &result;
2010  params.instance = instance;
2011 
2012  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2013  {
2014  /* Error */
2015  return NULL;
2016  }
2017  else
2018  {
2019  return result;
2020  }
2021  }
2022 
2023 
2034  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2035  OrthancPluginContext* context,
2036  OrthancPluginDicomInstance* instance)
2037  {
2038  int64_t size;
2039 
2040  _OrthancPluginAccessDicomInstance params;
2041  memset(&params, 0, sizeof(params));
2042  params.resultInt64 = &size;
2043  params.instance = instance;
2044 
2045  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2046  {
2047  /* Error */
2048  return -1;
2049  }
2050  else
2051  {
2052  return size;
2053  }
2054  }
2055 
2056 
2067  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceData(
2068  OrthancPluginContext* context,
2069  OrthancPluginDicomInstance* instance)
2070  {
2071  const char* result;
2072 
2073  _OrthancPluginAccessDicomInstance params;
2074  memset(&params, 0, sizeof(params));
2075  params.resultString = &result;
2076  params.instance = instance;
2077 
2078  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2079  {
2080  /* Error */
2081  return NULL;
2082  }
2083  else
2084  {
2085  return result;
2086  }
2087  }
2088 
2089 
2103  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
2104  OrthancPluginContext* context,
2105  OrthancPluginDicomInstance* instance)
2106  {
2107  char* result;
2108 
2109  _OrthancPluginAccessDicomInstance params;
2110  memset(&params, 0, sizeof(params));
2111  params.resultStringToFree = &result;
2112  params.instance = instance;
2113 
2114  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
2115  {
2116  /* Error */
2117  return NULL;
2118  }
2119  else
2120  {
2121  return result;
2122  }
2123  }
2124 
2125 
2141  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
2142  OrthancPluginContext* context,
2143  OrthancPluginDicomInstance* instance)
2144  {
2145  char* result;
2146 
2147  _OrthancPluginAccessDicomInstance params;
2148  memset(&params, 0, sizeof(params));
2149  params.resultStringToFree = &result;
2150  params.instance = instance;
2151 
2152  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
2153  {
2154  /* Error */
2155  return NULL;
2156  }
2157  else
2158  {
2159  return result;
2160  }
2161  }
2162 
2163 
2180  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
2181  OrthancPluginContext* context,
2182  OrthancPluginDicomInstance* instance,
2183  const char* metadata)
2184  {
2185  int64_t result;
2186 
2187  _OrthancPluginAccessDicomInstance params;
2188  memset(&params, 0, sizeof(params));
2189  params.resultInt64 = &result;
2190  params.instance = instance;
2191  params.key = metadata;
2192 
2193  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2194  {
2195  /* Error */
2196  return -1;
2197  }
2198  else
2199  {
2200  return (result != 0);
2201  }
2202  }
2203 
2204 
2218  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
2219  OrthancPluginContext* context,
2220  OrthancPluginDicomInstance* instance,
2221  const char* metadata)
2222  {
2223  const char* result;
2224 
2225  _OrthancPluginAccessDicomInstance params;
2226  memset(&params, 0, sizeof(params));
2227  params.resultString = &result;
2228  params.instance = instance;
2229  params.key = metadata;
2230 
2231  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2232  {
2233  /* Error */
2234  return NULL;
2235  }
2236  else
2237  {
2238  return result;
2239  }
2240  }
2241 
2242 
2243 
2244  typedef struct
2245  {
2249  OrthancPluginFree free;
2250  } _OrthancPluginRegisterStorageArea;
2251 
2266  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
2267  OrthancPluginContext* context,
2271  {
2272  _OrthancPluginRegisterStorageArea params;
2273  params.create = create;
2274  params.read = read;
2275  params.remove = remove;
2276 
2277 #ifdef __cplusplus
2278  params.free = ::free;
2279 #else
2280  params.free = free;
2281 #endif
2282 
2283  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
2284  }
2285 
2286 
2287 
2298  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
2299  {
2300  char* result;
2301 
2302  _OrthancPluginRetrieveDynamicString params;
2303  params.result = &result;
2304  params.argument = NULL;
2305 
2306  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
2307  {
2308  /* Error */
2309  return NULL;
2310  }
2311  else
2312  {
2313  return result;
2314  }
2315  }
2316 
2317 
2328  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
2329  {
2330  char* result;
2331 
2332  _OrthancPluginRetrieveDynamicString params;
2333  params.result = &result;
2334  params.argument = NULL;
2335 
2336  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
2337  {
2338  /* Error */
2339  return NULL;
2340  }
2341  else
2342  {
2343  return result;
2344  }
2345  }
2346 
2347 
2363  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
2364  {
2365  char* result;
2366 
2367  _OrthancPluginRetrieveDynamicString params;
2368  params.result = &result;
2369  params.argument = NULL;
2370 
2371  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
2372  {
2373  /* Error */
2374  return NULL;
2375  }
2376  else
2377  {
2378  return result;
2379  }
2380  }
2381 
2382 
2383 
2384  typedef struct
2385  {
2387  } _OrthancPluginOnChangeCallback;
2388 
2405  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
2406  OrthancPluginContext* context,
2408  {
2409  _OrthancPluginOnChangeCallback params;
2410  params.callback = callback;
2411 
2412  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
2413  }
2414 
2415 
2416 
2417  typedef struct
2418  {
2419  const char* plugin;
2420  _OrthancPluginProperty property;
2421  const char* value;
2422  } _OrthancPluginSetPluginProperty;
2423 
2424 
2436  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
2437  OrthancPluginContext* context,
2438  const char* uri)
2439  {
2440  _OrthancPluginSetPluginProperty params;
2441  params.plugin = OrthancPluginGetName();
2442  params.property = _OrthancPluginProperty_RootUri;
2443  params.value = uri;
2444 
2445  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2446  }
2447 
2448 
2458  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
2459  OrthancPluginContext* context,
2460  const char* description)
2461  {
2462  _OrthancPluginSetPluginProperty params;
2463  params.plugin = OrthancPluginGetName();
2464  params.property = _OrthancPluginProperty_Description;
2465  params.value = description;
2466 
2467  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2468  }
2469 
2470 
2480  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
2481  OrthancPluginContext* context,
2482  const char* javascript)
2483  {
2484  _OrthancPluginSetPluginProperty params;
2485  params.plugin = OrthancPluginGetName();
2486  params.property = _OrthancPluginProperty_OrthancExplorer;
2487  params.value = javascript;
2488 
2489  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2490  }
2491 
2492 
2493  typedef struct
2494  {
2495  char** result;
2496  int32_t property;
2497  const char* value;
2498  } _OrthancPluginGlobalProperty;
2499 
2500 
2514  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
2515  OrthancPluginContext* context,
2516  int32_t property,
2517  const char* defaultValue)
2518  {
2519  char* result;
2520 
2521  _OrthancPluginGlobalProperty params;
2522  params.result = &result;
2523  params.property = property;
2524  params.value = defaultValue;
2525 
2526  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
2527  {
2528  /* Error */
2529  return NULL;
2530  }
2531  else
2532  {
2533  return result;
2534  }
2535  }
2536 
2537 
2554  OrthancPluginContext* context,
2555  int32_t property,
2556  const char* value)
2557  {
2558  _OrthancPluginGlobalProperty params;
2559  params.result = NULL;
2560  params.property = property;
2561  params.value = value;
2562 
2563  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
2564  }
2565 
2566 
2567 
2568  typedef struct
2569  {
2570  int32_t *resultInt32;
2571  uint32_t *resultUint32;
2572  int64_t *resultInt64;
2573  uint64_t *resultUint64;
2574  } _OrthancPluginReturnSingleValue;
2575 
2584  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
2585  OrthancPluginContext* context)
2586  {
2587  uint32_t count = 0;
2588 
2589  _OrthancPluginReturnSingleValue params;
2590  memset(&params, 0, sizeof(params));
2591  params.resultUint32 = &count;
2592 
2593  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
2594  {
2595  /* Error */
2596  return 0;
2597  }
2598  else
2599  {
2600  return count;
2601  }
2602  }
2603 
2604 
2605 
2618  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
2619  OrthancPluginContext* context,
2620  uint32_t argument)
2621  {
2622  char* result;
2623 
2624  _OrthancPluginGlobalProperty params;
2625  params.result = &result;
2626  params.property = (int32_t) argument;
2627  params.value = NULL;
2628 
2629  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
2630  {
2631  /* Error */
2632  return NULL;
2633  }
2634  else
2635  {
2636  return result;
2637  }
2638  }
2639 
2640 
2651  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
2652  OrthancPluginContext* context)
2653  {
2654  uint32_t count = 0;
2655 
2656  _OrthancPluginReturnSingleValue params;
2657  memset(&params, 0, sizeof(params));
2658  params.resultUint32 = &count;
2659 
2660  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
2661  {
2662  /* Error */
2663  return 0;
2664  }
2665  else
2666  {
2667  return count;
2668  }
2669  }
2670 
2671 
2672 
2684  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
2685  {
2686  char* result;
2687 
2688  _OrthancPluginRetrieveDynamicString params;
2689  params.result = &result;
2690  params.argument = NULL;
2691 
2692  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
2693  {
2694  /* Error */
2695  return NULL;
2696  }
2697  else
2698  {
2699  return result;
2700  }
2701  }
2702 
2703 
2704 
2705  typedef struct
2706  {
2707  OrthancPluginRestOutput* output;
2708  const char* subType;
2709  const char* contentType;
2710  } _OrthancPluginStartMultipartAnswer;
2711 
2726  OrthancPluginContext* context,
2727  OrthancPluginRestOutput* output,
2728  const char* subType,
2729  const char* contentType)
2730  {
2731  _OrthancPluginStartMultipartAnswer params;
2732  params.output = output;
2733  params.subType = subType;
2734  params.contentType = contentType;
2735  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
2736  }
2737 
2738 
2754  OrthancPluginContext* context,
2755  OrthancPluginRestOutput* output,
2756  const char* answer,
2757  uint32_t answerSize)
2758  {
2759  _OrthancPluginAnswerBuffer params;
2760  params.output = output;
2761  params.answer = answer;
2762  params.answerSize = answerSize;
2763  params.mimeType = NULL;
2764  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
2765  }
2766 
2767 
2768 
2769  typedef struct
2770  {
2771  OrthancPluginMemoryBuffer* target;
2772  const void* source;
2773  uint32_t size;
2774  OrthancPluginCompressionType compression;
2775  uint8_t uncompress;
2776  } _OrthancPluginBufferCompression;
2777 
2778 
2796  OrthancPluginContext* context,
2797  OrthancPluginMemoryBuffer* target,
2798  const void* source,
2799  uint32_t size,
2800  OrthancPluginCompressionType compression,
2801  uint8_t uncompress)
2802  {
2803  _OrthancPluginBufferCompression params;
2804  params.target = target;
2805  params.source = source;
2806  params.size = size;
2807  params.compression = compression;
2808  params.uncompress = uncompress;
2809 
2810  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
2811  }
2812 
2813 
2814 
2815  typedef struct
2816  {
2817  OrthancPluginMemoryBuffer* target;
2818  const char* path;
2819  } _OrthancPluginReadFile;
2820 
2833  OrthancPluginContext* context,
2834  OrthancPluginMemoryBuffer* target,
2835  const char* path)
2836  {
2837  _OrthancPluginReadFile params;
2838  params.target = target;
2839  params.path = path;
2840  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
2841  }
2842 
2843 
2844 
2845  typedef struct
2846  {
2847  const char* path;
2848  const void* data;
2849  uint32_t size;
2850  } _OrthancPluginWriteFile;
2851 
2864  OrthancPluginContext* context,
2865  const char* path,
2866  const void* data,
2867  uint32_t size)
2868  {
2869  _OrthancPluginWriteFile params;
2870  params.path = path;
2871  params.data = data;
2872  params.size = size;
2873  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
2874  }
2875 
2876 
2877 
2878  typedef struct
2879  {
2880  const char** target;
2881  OrthancPluginErrorCode error;
2882  } _OrthancPluginGetErrorDescription;
2883 
2894  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
2895  OrthancPluginContext* context,
2896  OrthancPluginErrorCode error)
2897  {
2898  const char* result = NULL;
2899 
2900  _OrthancPluginGetErrorDescription params;
2901  params.target = &result;
2902  params.error = error;
2903 
2904  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
2905  result == NULL)
2906  {
2907  return "Unknown error code";
2908  }
2909  else
2910  {
2911  return result;
2912  }
2913  }
2914 
2915 
2916 
2917  typedef struct
2918  {
2919  OrthancPluginRestOutput* output;
2920  uint16_t status;
2921  const char* body;
2922  uint32_t bodySize;
2923  } _OrthancPluginSendHttpStatus;
2924 
2947  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
2948  OrthancPluginContext* context,
2949  OrthancPluginRestOutput* output,
2950  uint16_t status,
2951  const char* body,
2952  uint32_t bodySize)
2953  {
2954  _OrthancPluginSendHttpStatus params;
2955  params.output = output;
2956  params.status = status;
2957  params.body = body;
2958  params.bodySize = bodySize;
2959  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
2960  }
2961 
2962 
2963 
2964  typedef struct
2965  {
2966  const OrthancPluginImage* image;
2967  uint32_t* resultUint32;
2968  OrthancPluginPixelFormat* resultPixelFormat;
2969  void** resultBuffer;
2970  } _OrthancPluginGetImageInfo;
2971 
2972 
2984  OrthancPluginContext* context,
2985  const OrthancPluginImage* image)
2986  {
2987  OrthancPluginPixelFormat target;
2988 
2989  _OrthancPluginGetImageInfo params;
2990  memset(&params, 0, sizeof(params));
2991  params.image = image;
2992  params.resultPixelFormat = &target;
2993 
2994  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
2995  {
2997  }
2998  else
2999  {
3000  return (OrthancPluginPixelFormat) target;
3001  }
3002  }
3003 
3004 
3005 
3016  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3017  OrthancPluginContext* context,
3018  const OrthancPluginImage* image)
3019  {
3020  uint32_t width;
3021 
3022  _OrthancPluginGetImageInfo params;
3023  memset(&params, 0, sizeof(params));
3024  params.image = image;
3025  params.resultUint32 = &width;
3026 
3027  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3028  {
3029  return 0;
3030  }
3031  else
3032  {
3033  return width;
3034  }
3035  }
3036 
3037 
3038 
3049  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3050  OrthancPluginContext* context,
3051  const OrthancPluginImage* image)
3052  {
3053  uint32_t height;
3054 
3055  _OrthancPluginGetImageInfo params;
3056  memset(&params, 0, sizeof(params));
3057  params.image = image;
3058  params.resultUint32 = &height;
3059 
3060  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3061  {
3062  return 0;
3063  }
3064  else
3065  {
3066  return height;
3067  }
3068  }
3069 
3070 
3071 
3084  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3085  OrthancPluginContext* context,
3086  const OrthancPluginImage* image)
3087  {
3088  uint32_t pitch;
3089 
3090  _OrthancPluginGetImageInfo params;
3091  memset(&params, 0, sizeof(params));
3092  params.image = image;
3093  params.resultUint32 = &pitch;
3094 
3095  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
3096  {
3097  return 0;
3098  }
3099  else
3100  {
3101  return pitch;
3102  }
3103  }
3104 
3105 
3106 
3118  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
3119  OrthancPluginContext* context,
3120  const OrthancPluginImage* image)
3121  {
3122  void* target = NULL;
3123 
3124  _OrthancPluginGetImageInfo params;
3125  memset(&params, 0, sizeof(params));
3126  params.resultBuffer = &target;
3127  params.image = image;
3128 
3129  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
3130  {
3131  return NULL;
3132  }
3133  else
3134  {
3135  return target;
3136  }
3137  }
3138 
3139 
3140  typedef struct
3141  {
3142  OrthancPluginImage** target;
3143  const void* data;
3144  uint32_t size;
3145  OrthancPluginImageFormat format;
3146  } _OrthancPluginUncompressImage;
3147 
3148 
3162  OrthancPluginContext* context,
3163  const void* data,
3164  uint32_t size,
3165  OrthancPluginImageFormat format)
3166  {
3167  OrthancPluginImage* target = NULL;
3168 
3169  _OrthancPluginUncompressImage params;
3170  memset(&params, 0, sizeof(params));
3171  params.target = &target;
3172  params.data = data;
3173  params.size = size;
3174  params.format = format;
3175 
3176  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
3177  {
3178  return NULL;
3179  }
3180  else
3181  {
3182  return target;
3183  }
3184  }
3185 
3186 
3187 
3188 
3189  typedef struct
3190  {
3191  OrthancPluginImage* image;
3192  } _OrthancPluginFreeImage;
3193 
3203  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
3204  OrthancPluginContext* context,
3205  OrthancPluginImage* image)
3206  {
3207  _OrthancPluginFreeImage params;
3208  params.image = image;
3209 
3210  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
3211  }
3212 
3213 
3214 
3215 
3216  typedef struct
3217  {
3218  OrthancPluginMemoryBuffer* target;
3219  OrthancPluginImageFormat imageFormat;
3220  OrthancPluginPixelFormat pixelFormat;
3221  uint32_t width;
3222  uint32_t height;
3223  uint32_t pitch;
3224  const void* buffer;
3225  uint8_t quality;
3226  } _OrthancPluginCompressImage;
3227 
3228 
3249  OrthancPluginContext* context,
3250  OrthancPluginMemoryBuffer* target,
3251  OrthancPluginPixelFormat format,
3252  uint32_t width,
3253  uint32_t height,
3254  uint32_t pitch,
3255  const void* buffer)
3256  {
3257  _OrthancPluginCompressImage params;
3258  memset(&params, 0, sizeof(params));
3259  params.target = target;
3260  params.imageFormat = OrthancPluginImageFormat_Png;
3261  params.pixelFormat = format;
3262  params.width = width;
3263  params.height = height;
3264  params.pitch = pitch;
3265  params.buffer = buffer;
3266  params.quality = 0; /* Unused for PNG */
3267 
3268  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3269  }
3270 
3271 
3294  OrthancPluginContext* context,
3295  OrthancPluginMemoryBuffer* target,
3296  OrthancPluginPixelFormat format,
3297  uint32_t width,
3298  uint32_t height,
3299  uint32_t pitch,
3300  const void* buffer,
3301  uint8_t quality)
3302  {
3303  _OrthancPluginCompressImage params;
3304  memset(&params, 0, sizeof(params));
3305  params.target = target;
3306  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3307  params.pixelFormat = format;
3308  params.width = width;
3309  params.height = height;
3310  params.pitch = pitch;
3311  params.buffer = buffer;
3312  params.quality = quality;
3313 
3314  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3315  }
3316 
3317 
3318 
3340  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
3341  OrthancPluginContext* context,
3342  OrthancPluginRestOutput* output,
3343  OrthancPluginPixelFormat format,
3344  uint32_t width,
3345  uint32_t height,
3346  uint32_t pitch,
3347  const void* buffer,
3348  uint8_t quality)
3349  {
3350  _OrthancPluginCompressAndAnswerImage params;
3351  params.output = output;
3352  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3353  params.pixelFormat = format;
3354  params.width = width;
3355  params.height = height;
3356  params.pitch = pitch;
3357  params.buffer = buffer;
3358  params.quality = quality;
3359  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
3360  }
3361 
3362 
3363 
3364 
3365  typedef struct
3366  {
3367  OrthancPluginMemoryBuffer* target;
3368  OrthancPluginHttpMethod method;
3369  const char* url;
3370  const char* username;
3371  const char* password;
3372  const char* body;
3373  uint32_t bodySize;
3374  } _OrthancPluginCallHttpClient;
3375 
3376 
3393  OrthancPluginContext* context,
3394  OrthancPluginMemoryBuffer* target,
3395  const char* url,
3396  const char* username,
3397  const char* password)
3398  {
3399  _OrthancPluginCallHttpClient params;
3400  memset(&params, 0, sizeof(params));
3401 
3402  params.target = target;
3403  params.method = OrthancPluginHttpMethod_Get;
3404  params.url = url;
3405  params.username = username;
3406  params.password = password;
3407 
3408  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3409  }
3410 
3411 
3430  OrthancPluginContext* context,
3431  OrthancPluginMemoryBuffer* target,
3432  const char* url,
3433  const char* body,
3434  uint32_t bodySize,
3435  const char* username,
3436  const char* password)
3437  {
3438  _OrthancPluginCallHttpClient params;
3439  memset(&params, 0, sizeof(params));
3440 
3441  params.target = target;
3442  params.method = OrthancPluginHttpMethod_Post;
3443  params.url = url;
3444  params.body = body;
3445  params.bodySize = bodySize;
3446  params.username = username;
3447  params.password = password;
3448 
3449  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3450  }
3451 
3452 
3471  OrthancPluginContext* context,
3472  OrthancPluginMemoryBuffer* target,
3473  const char* url,
3474  const char* body,
3475  uint32_t bodySize,
3476  const char* username,
3477  const char* password)
3478  {
3479  _OrthancPluginCallHttpClient params;
3480  memset(&params, 0, sizeof(params));
3481 
3482  params.target = target;
3483  params.method = OrthancPluginHttpMethod_Put;
3484  params.url = url;
3485  params.body = body;
3486  params.bodySize = bodySize;
3487  params.username = username;
3488  params.password = password;
3489 
3490  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3491  }
3492 
3493 
3508  OrthancPluginContext* context,
3509  const char* url,
3510  const char* username,
3511  const char* password)
3512  {
3513  _OrthancPluginCallHttpClient params;
3514  memset(&params, 0, sizeof(params));
3515 
3516  params.method = OrthancPluginHttpMethod_Delete;
3517  params.url = url;
3518  params.username = username;
3519  params.password = password;
3520 
3521  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3522  }
3523 
3524 
3525 
3526  typedef struct
3527  {
3528  OrthancPluginImage** target;
3529  const OrthancPluginImage* source;
3530  OrthancPluginPixelFormat targetFormat;
3531  } _OrthancPluginConvertPixelFormat;
3532 
3533 
3546  OrthancPluginContext* context,
3547  const OrthancPluginImage* source,
3548  OrthancPluginPixelFormat targetFormat)
3549  {
3550  OrthancPluginImage* target = NULL;
3551 
3552  _OrthancPluginConvertPixelFormat params;
3553  params.target = &target;
3554  params.source = source;
3555  params.targetFormat = targetFormat;
3556 
3557  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
3558  {
3559  return NULL;
3560  }
3561  else
3562  {
3563  return target;
3564  }
3565  }
3566 
3567 
3568 
3580  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
3581  OrthancPluginContext* context)
3582  {
3583  uint32_t count = 0;
3584 
3585  _OrthancPluginReturnSingleValue params;
3586  memset(&params, 0, sizeof(params));
3587  params.resultUint32 = &count;
3588 
3589  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
3590  {
3591  /* Error */
3592  return 0;
3593  }
3594  else
3595  {
3596  return count;
3597  }
3598  }
3599 
3600 
3601 
3602 
3603  typedef struct
3604  {
3605  uint32_t fontIndex; /* in */
3606  const char** name; /* out */
3607  uint32_t* size; /* out */
3608  } _OrthancPluginGetFontInfo;
3609 
3620  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
3621  OrthancPluginContext* context,
3622  uint32_t fontIndex)
3623  {
3624  const char* result = NULL;
3625 
3626  _OrthancPluginGetFontInfo params;
3627  memset(&params, 0, sizeof(params));
3628  params.name = &result;
3629  params.fontIndex = fontIndex;
3630 
3631  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
3632  {
3633  return NULL;
3634  }
3635  else
3636  {
3637  return result;
3638  }
3639  }
3640 
3641 
3652  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
3653  OrthancPluginContext* context,
3654  uint32_t fontIndex)
3655  {
3656  uint32_t result;
3657 
3658  _OrthancPluginGetFontInfo params;
3659  memset(&params, 0, sizeof(params));
3660  params.size = &result;
3661  params.fontIndex = fontIndex;
3662 
3663  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
3664  {
3665  return 0;
3666  }
3667  else
3668  {
3669  return result;
3670  }
3671  }
3672 
3673 
3674 
3675  typedef struct
3676  {
3677  OrthancPluginImage* image;
3678  uint32_t fontIndex;
3679  const char* utf8Text;
3680  int32_t x;
3681  int32_t y;
3682  uint8_t r;
3683  uint8_t g;
3684  uint8_t b;
3685  } _OrthancPluginDrawText;
3686 
3687 
3706  OrthancPluginContext* context,
3707  OrthancPluginImage* image,
3708  uint32_t fontIndex,
3709  const char* utf8Text,
3710  int32_t x,
3711  int32_t y,
3712  uint8_t r,
3713  uint8_t g,
3714  uint8_t b)
3715  {
3716  _OrthancPluginDrawText params;
3717  memset(&params, 0, sizeof(params));
3718  params.image = image;
3719  params.fontIndex = fontIndex;
3720  params.utf8Text = utf8Text;
3721  params.x = x;
3722  params.y = y;
3723  params.r = r;
3724  params.g = g;
3725  params.b = b;
3726 
3727  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
3728  }
3729 
3730 
3731 
3732  typedef struct
3733  {
3734  OrthancPluginStorageArea* storageArea;
3735  const char* uuid;
3736  const void* content;
3737  uint64_t size;
3739  } _OrthancPluginStorageAreaCreate;
3740 
3741 
3758  OrthancPluginContext* context,
3759  OrthancPluginStorageArea* storageArea,
3760  const char* uuid,
3761  const void* content,
3762  uint64_t size,
3764  {
3765  _OrthancPluginStorageAreaCreate params;
3766  params.storageArea = storageArea;
3767  params.uuid = uuid;
3768  params.content = content;
3769  params.size = size;
3770  params.type = type;
3771 
3772  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
3773  }
3774 
3775 
3776  typedef struct
3777  {
3778  OrthancPluginMemoryBuffer* target;
3779  OrthancPluginStorageArea* storageArea;
3780  const char* uuid;
3782  } _OrthancPluginStorageAreaRead;
3783 
3784 
3800  OrthancPluginContext* context,
3801  OrthancPluginMemoryBuffer* target,
3802  OrthancPluginStorageArea* storageArea,
3803  const char* uuid,
3805  {
3806  _OrthancPluginStorageAreaRead params;
3807  params.target = target;
3808  params.storageArea = storageArea;
3809  params.uuid = uuid;
3810  params.type = type;
3811 
3812  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
3813  }
3814 
3815 
3816  typedef struct
3817  {
3818  OrthancPluginStorageArea* storageArea;
3819  const char* uuid;
3821  } _OrthancPluginStorageAreaRemove;
3822 
3837  OrthancPluginContext* context,
3838  OrthancPluginStorageArea* storageArea,
3839  const char* uuid,
3841  {
3842  _OrthancPluginStorageAreaRemove params;
3843  params.storageArea = storageArea;
3844  params.uuid = uuid;
3845  params.type = type;
3846 
3847  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
3848  }
3849 
3850 
3851 
3852  typedef struct
3853  {
3854  OrthancPluginErrorCode* target;
3855  int32_t code;
3856  uint16_t httpStatus;
3857  const char* message;
3858  } _OrthancPluginRegisterErrorCode;
3859 
3876  OrthancPluginContext* context,
3877  int32_t code,
3878  uint16_t httpStatus,
3879  const char* message)
3880  {
3881  OrthancPluginErrorCode target;
3882 
3883  _OrthancPluginRegisterErrorCode params;
3884  params.target = &target;
3885  params.code = code;
3886  params.httpStatus = httpStatus;
3887  params.message = message;
3888 
3889  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
3890  {
3891  return target;
3892  }
3893  else
3894  {
3895  /* There was an error while assigned the error. Use a generic code. */
3897  }
3898  }
3899 
3900 
3901 
3902  typedef struct
3903  {
3904  uint16_t group;
3905  uint16_t element;
3907  const char* name;
3908  uint32_t minMultiplicity;
3909  uint32_t maxMultiplicity;
3910  } _OrthancPluginRegisterDictionaryTag;
3911 
3931  OrthancPluginContext* context,
3932  uint16_t group,
3933  uint16_t element,
3935  const char* name,
3936  uint32_t minMultiplicity,
3937  uint32_t maxMultiplicity)
3938  {
3939  _OrthancPluginRegisterDictionaryTag params;
3940  params.group = group;
3941  params.element = element;
3942  params.vr = vr;
3943  params.name = name;
3944  params.minMultiplicity = minMultiplicity;
3945  params.maxMultiplicity = maxMultiplicity;
3946 
3947  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
3948  }
3949 
3950 
3951 
3952 
3953  typedef struct
3954  {
3955  OrthancPluginStorageArea* storageArea;
3957  } _OrthancPluginReconstructMainDicomTags;
3958 
3976  OrthancPluginContext* context,
3977  OrthancPluginStorageArea* storageArea,
3979  {
3980  _OrthancPluginReconstructMainDicomTags params;
3981  params.level = level;
3982  params.storageArea = storageArea;
3983 
3984  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
3985  }
3986 
3987 
3988  typedef struct
3989  {
3990  char** result;
3991  const char* instanceId;
3992  const char* buffer;
3993  uint32_t size;
3996  uint32_t maxStringLength;
3997  } _OrthancPluginDicomToJson;
3998 
3999 
4019  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4020  OrthancPluginContext* context,
4021  const char* buffer,
4022  uint32_t size,
4025  uint32_t maxStringLength)
4026  {
4027  char* result;
4028 
4029  _OrthancPluginDicomToJson params;
4030  memset(&params, 0, sizeof(params));
4031  params.result = &result;
4032  params.buffer = buffer;
4033  params.size = size;
4034  params.format = format;
4035  params.flags = flags;
4036  params.maxStringLength = maxStringLength;
4037 
4038  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
4039  {
4040  /* Error */
4041  return NULL;
4042  }
4043  else
4044  {
4045  return result;
4046  }
4047  }
4048 
4049 
4068  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
4069  OrthancPluginContext* context,
4070  const char* instanceId,
4073  uint32_t maxStringLength)
4074  {
4075  char* result;
4076 
4077  _OrthancPluginDicomToJson params;
4078  memset(&params, 0, sizeof(params));
4079  params.result = &result;
4080  params.instanceId = instanceId;
4081  params.format = format;
4082  params.flags = flags;
4083  params.maxStringLength = maxStringLength;
4084 
4085  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
4086  {
4087  /* Error */
4088  return NULL;
4089  }
4090  else
4091  {
4092  return result;
4093  }
4094  }
4095 
4096 
4097  typedef struct
4098  {
4099  OrthancPluginMemoryBuffer* target;
4100  const char* uri;
4101  uint32_t headersCount;
4102  const char* const* headersKeys;
4103  const char* const* headersValues;
4104  int32_t afterPlugins;
4105  } _OrthancPluginRestApiGet2;
4106 
4127  OrthancPluginContext* context,
4128  OrthancPluginMemoryBuffer* target,
4129  const char* uri,
4130  uint32_t headersCount,
4131  const char* const* headersKeys,
4132  const char* const* headersValues,
4133  int32_t afterPlugins)
4134  {
4135  _OrthancPluginRestApiGet2 params;
4136  params.target = target;
4137  params.uri = uri;
4138  params.headersCount = headersCount;
4139  params.headersKeys = headersKeys;
4140  params.headersValues = headersValues;
4141  params.afterPlugins = afterPlugins;
4142 
4143  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
4144  }
4145 
4146 
4147 
4148  typedef struct
4149  {
4151  } _OrthancPluginWorklistCallback;
4152 
4165  OrthancPluginContext* context,
4167  {
4168  _OrthancPluginWorklistCallback params;
4169  params.callback = callback;
4170 
4171  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
4172  }
4173 
4174 
4175 
4176  typedef struct
4177  {
4179  const OrthancPluginWorklistQuery* query;
4180  const void* dicom;
4181  uint32_t size;
4182  } _OrthancPluginWorklistAnswersOperation;
4183 
4200  OrthancPluginContext* context,
4202  const OrthancPluginWorklistQuery* query,
4203  const void* dicom,
4204  uint32_t size)
4205  {
4206  _OrthancPluginWorklistAnswersOperation params;
4207  params.answers = answers;
4208  params.query = query;
4209  params.dicom = dicom;
4210  params.size = size;
4211 
4212  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
4213  }
4214 
4215 
4230  OrthancPluginContext* context,
4232  {
4233  _OrthancPluginWorklistAnswersOperation params;
4234  params.answers = answers;
4235  params.query = NULL;
4236  params.dicom = NULL;
4237  params.size = 0;
4238 
4239  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
4240  }
4241 
4242 
4243  typedef struct
4244  {
4245  const OrthancPluginWorklistQuery* query;
4246  const void* dicom;
4247  uint32_t size;
4248  int32_t* isMatch;
4249  OrthancPluginMemoryBuffer* target;
4250  } _OrthancPluginWorklistQueryOperation;
4251 
4267  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
4268  OrthancPluginContext* context,
4269  const OrthancPluginWorklistQuery* query,
4270  const void* dicom,
4271  uint32_t size)
4272  {
4273  int32_t isMatch = 0;
4274 
4275  _OrthancPluginWorklistQueryOperation params;
4276  params.query = query;
4277  params.dicom = dicom;
4278  params.size = size;
4279  params.isMatch = &isMatch;
4280  params.target = NULL;
4281 
4282  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
4283  {
4284  return isMatch;
4285  }
4286  else
4287  {
4288  /* Error: Assume non-match */
4289  return 0;
4290  }
4291  }
4292 
4293 
4307  OrthancPluginContext* context,
4308  OrthancPluginMemoryBuffer* target,
4309  const OrthancPluginWorklistQuery* query)
4310  {
4311  _OrthancPluginWorklistQueryOperation params;
4312  params.query = query;
4313  params.dicom = NULL;
4314  params.size = 0;
4315  params.isMatch = NULL;
4316  params.target = target;
4317 
4318  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
4319  }
4320 
4321 
4333  OrthancPluginContext* context,
4334  OrthancPluginDicomInstance* instance)
4335  {
4337 
4338  _OrthancPluginAccessDicomInstance params;
4339  memset(&params, 0, sizeof(params));
4340  params.resultOrigin = &origin;
4341  params.instance = instance;
4342 
4343  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
4344  {
4345  /* Error */
4347  }
4348  else
4349  {
4350  return origin;
4351  }
4352  }
4353 
4354 
4355  typedef struct
4356  {
4357  OrthancPluginMemoryBuffer* target;
4358  const char* json;
4359  const OrthancPluginImage* pixelData;
4361  } _OrthancPluginCreateDicom;
4362 
4382  OrthancPluginContext* context,
4383  OrthancPluginMemoryBuffer* target,
4384  const char* json,
4385  const OrthancPluginImage* pixelData,
4387  {
4388  _OrthancPluginCreateDicom params;
4389  params.target = target;
4390  params.json = json;
4391  params.pixelData = pixelData;
4392  params.flags = flags;
4393 
4394  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
4395  }
4396 
4397 
4398  typedef struct
4399  {
4401  } _OrthancPluginDecodeImageCallback;
4402 
4415  OrthancPluginContext* context,
4417  {
4418  _OrthancPluginDecodeImageCallback params;
4419  params.callback = callback;
4420 
4421  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
4422  }
4423 
4424 
4425 
4426  typedef struct
4427  {
4428  OrthancPluginImage** target;
4429  OrthancPluginPixelFormat format;
4430  uint32_t width;
4431  uint32_t height;
4432  uint32_t pitch;
4433  void* buffer;
4434  const void* constBuffer;
4435  uint32_t bufferSize;
4436  uint32_t frameIndex;
4437  } _OrthancPluginCreateImage;
4438 
4439 
4453  OrthancPluginContext* context,
4454  OrthancPluginPixelFormat format,
4455  uint32_t width,
4456  uint32_t height)
4457  {
4458  OrthancPluginImage* target = NULL;
4459 
4460  _OrthancPluginCreateImage params;
4461  memset(&params, 0, sizeof(params));
4462  params.target = &target;
4463  params.format = format;
4464  params.width = width;
4465  params.height = height;
4466 
4467  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
4468  {
4469  return NULL;
4470  }
4471  else
4472  {
4473  return target;
4474  }
4475  }
4476 
4477 
4496  OrthancPluginContext* context,
4497  OrthancPluginPixelFormat format,
4498  uint32_t width,
4499  uint32_t height,
4500  uint32_t pitch,
4501  void* buffer)
4502  {
4503  OrthancPluginImage* target = NULL;
4504 
4505  _OrthancPluginCreateImage params;
4506  memset(&params, 0, sizeof(params));
4507  params.target = &target;
4508  params.format = format;
4509  params.width = width;
4510  params.height = height;
4511  params.pitch = pitch;
4512  params.buffer = buffer;
4513 
4514  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
4515  {
4516  return NULL;
4517  }
4518  else
4519  {
4520  return target;
4521  }
4522  }
4523 
4524 
4525 
4541  OrthancPluginContext* context,
4542  const void* buffer,
4543  uint32_t bufferSize,
4544  uint32_t frameIndex)
4545  {
4546  OrthancPluginImage* target = NULL;
4547 
4548  _OrthancPluginCreateImage params;
4549  memset(&params, 0, sizeof(params));
4550  params.target = &target;
4551  params.constBuffer = buffer;
4552  params.bufferSize = bufferSize;
4553  params.frameIndex = frameIndex;
4554 
4555  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
4556  {
4557  return NULL;
4558  }
4559  else
4560  {
4561  return target;
4562  }
4563  }
4564 
4565 
4566 
4567  typedef struct
4568  {
4569  char** result;
4570  const void* buffer;
4571  uint32_t size;
4572  } _OrthancPluginComputeHash;
4573 
4586  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
4587  OrthancPluginContext* context,
4588  const void* buffer,
4589  uint32_t size)
4590  {
4591  char* result;
4592 
4593  _OrthancPluginComputeHash params;
4594  params.result = &result;
4595  params.buffer = buffer;
4596  params.size = size;
4597 
4598  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
4599  {
4600  /* Error */
4601  return NULL;
4602  }
4603  else
4604  {
4605  return result;
4606  }
4607  }
4608 
4609 
4622  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
4623  OrthancPluginContext* context,
4624  const void* buffer,
4625  uint32_t size)
4626  {
4627  char* result;
4628 
4629  _OrthancPluginComputeHash params;
4630  params.result = &result;
4631  params.buffer = buffer;
4632  params.size = size;
4633 
4634  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
4635  {
4636  /* Error */
4637  return NULL;
4638  }
4639  else
4640  {
4641  return result;
4642  }
4643  }
4644 
4645 
4646 
4647  typedef struct
4648  {
4650  const char* name;
4651  } _OrthancPluginLookupDictionary;
4652 
4669  OrthancPluginContext* context,
4671  const char* name)
4672  {
4673  _OrthancPluginLookupDictionary params;
4674  params.target = target;
4675  params.name = name;
4676  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
4677  }
4678 
4679 
4680 #ifdef __cplusplus
4681 }
4682 #endif
4683 
4684 
Definition: OrthancCPlugin.h:632
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2001
Definition: OrthancCPlugin.h:731
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:2180
OrthancPluginChangeType
Definition: OrthancCPlugin.h:589
Definition: OrthancCPlugin.h:220
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:1864
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:781
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:1965
Definition: OrthancCPlugin.h:655
Definition: OrthancCPlugin.h:252
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:1150
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:4414
Definition: OrthancCPlugin.h:732
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:4229
The parameters of a REST request.
Definition: OrthancCPlugin.h:310
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:1647
OrthancPluginContentType
Definition: OrthancCPlugin.h:558
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:1554
Definition: OrthancCPlugin.h:575
OrthancPluginErrorCode(* OrthancPluginWorklistCallback)(OrthancPluginWorklistAnswers *answers, const OrthancPluginWorklistQuery *query, const char *remoteAet, const char *calledAet)
Callback to handle the C-Find SCP requests received by Orthanc.
Definition: OrthancCPlugin.h:944
Definition: OrthancCPlugin.h:654
Definition: OrthancCPlugin.h:747
const char * OrthancPluginGetInstanceData(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2067
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:3248
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:3340
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:4267
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1013
Definition: OrthancCPlugin.h:244
Definition: OrthancCPlugin.h:190
Definition: OrthancCPlugin.h:242
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:742
Definition: OrthancCPlugin.h:652
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2034
Definition: OrthancCPlugin.h:267
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:522
Definition: OrthancCPlugin.h:604
Definition: OrthancCPlugin.h:212
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:370
Definition: OrthancCPlugin.h:254
Definition: OrthancCPlugin.h:256
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:365
Definition: OrthancCPlugin.h:240
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:715
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:4622
Definition: OrthancCPlugin.h:258
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:506
Definition: OrthancCPlugin.h:748
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:330
Definition: OrthancCPlugin.h:548
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:2266
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:1373
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:629
Definition: OrthancCPlugin.h:198
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:989
Definition: OrthancCPlugin.h:264
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:3620
Definition: OrthancCPlugin.h:218
Definition: OrthancCPlugin.h:270
Definition: OrthancCPlugin.h:262
Definition: OrthancCPlugin.h:298
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:871
Definition: OrthancCPlugin.h:209
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:4586
Definition: OrthancCPlugin.h:211
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:184
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:3545
Definition: OrthancCPlugin.h:265
Definition: OrthancCPlugin.h:598
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:3799
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:3580
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:2363
Definition: OrthancCPlugin.h:207
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:2405
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:546
Definition: OrthancCPlugin.h:699
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:697
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:4199
Definition: OrthancCPlugin.h:200
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:1910
Definition: OrthancCPlugin.h:616
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:1275
Definition: OrthancCPlugin.h:592
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:4164
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:4540
Definition: OrthancCPlugin.h:241
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:682
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:4668
Definition: OrthancCPlugin.h:684
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:3875
Definition: OrthancCPlugin.h:222
uint16_t group
Definition: OrthancCPlugin.h:972
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:3118
Definition: OrthancCPlugin.h:645
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:975
Definition: OrthancCPlugin.h:686
Definition: OrthancCPlugin.h:657
const char * OrthancPluginGetInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Get the value of some metadata associated with a given DICOM instance.
Definition: OrthancCPlugin.h:2218
Definition: OrthancCPlugin.h:631
Definition: OrthancCPlugin.h:234
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:804
Definition: OrthancCPlugin.h:226
Definition: OrthancCPlugin.h:560
Definition: OrthancCPlugin.h:596
OrthancPluginErrorCode OrthancPluginRestApiPutAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const char *body, uint32_t bodySize)
Make a PUT call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:1613
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:2651
Definition: OrthancCPlugin.h:257
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:514
Definition: OrthancCPlugin.h:255
Definition: OrthancCPlugin.h:201
OrthancPluginResourceType
Definition: OrthancCPlugin.h:572
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:295
Definition: OrthancCPlugin.h:217
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:3049
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:643
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:2684
Definition: OrthancCPlugin.h:188
void OrthancPluginSendHttpStatus(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status, const char *body, uint32_t bodySize)
Send a HTTP status, with a custom body.
Definition: OrthancCPlugin.h:2947
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:3161
Definition: OrthancCPlugin.h:260
Definition: OrthancCPlugin.h:647
Definition: OrthancCPlugin.h:204
Definition: OrthancCPlugin.h:577
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:828
Definition: OrthancCPlugin.h:251
Definition: OrthancCPlugin.h:617
Definition: OrthancCPlugin.h:650
Definition: OrthancCPlugin.h:268
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:2328
Definition: OrthancCPlugin.h:619
Definition: OrthancCPlugin.h:669
Definition: OrthancCPlugin.h:243
Color image in RGB24 format.
Definition: OrthancCPlugin.h:538
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:530
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:970
Definition: OrthancCPlugin.h:253
Definition: OrthancCPlugin.h:194
Definition: OrthancCPlugin.h:591
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:614
OrthancPluginErrorCode OrthancPluginHttpPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *body, uint32_t bodySize, const char *username, const char *password)
Issue a HTTP PUT call.
Definition: OrthancCPlugin.h:3470
Definition: OrthancCPlugin.h:186
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:4126
Definition: OrthancCPlugin.h:702
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:2983
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:3705
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3084
Definition: OrthancCPlugin.h:561
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:1332
Definition: OrthancCPlugin.h:273
Definition: OrthancCPlugin.h:279
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:976
Definition: OrthancCPlugin.h:272
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:860
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:2584
Definition: OrthancCPlugin.h:224
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:1887
Definition: OrthancCPlugin.h:196
Definition: OrthancCPlugin.h:249
Definition: OrthancCPlugin.h:237
Definition: OrthancCPlugin.h:269
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:1118
Definition: OrthancCPlugin.h:215
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:766
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:3652
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:2480
Definition: OrthancCPlugin.h:746
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1405
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:2894
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:360
Definition: OrthancCPlugin.h:597
Definition: OrthancCPlugin.h:701
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1102
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:887
Definition: OrthancCPlugin.h:663
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1532
Definition: OrthancCPlugin.h:667
Definition: OrthancCPlugin.h:576
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:2832
Definition: OrthancCPlugin.h:656
Definition: OrthancCPlugin.h:733
Definition: OrthancCPlugin.h:299
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:4452
Definition: OrthancCPlugin.h:658
Definition: OrthancCPlugin.h:229
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:2298
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:2514
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:925
Definition: OrthancCPlugin.h:685
Definition: OrthancCPlugin.h:238
Definition: OrthancCPlugin.h:276
Definition: OrthancCPlugin.h:297
Definition: OrthancCPlugin.h:599
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:3975
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:2618
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:3392
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:4495
Definition: OrthancCPlugin.h:246
Definition: OrthancCPlugin.h:208
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:4068
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:340
Definition: OrthancCPlugin.h:670
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:849
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:2141
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:2795
Definition: OrthancCPlugin.h:239
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:4381
Definition: OrthancCPlugin.h:232
Definition: OrthancCPlugin.h:633
Definition: OrthancCPlugin.h:195
const char * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:345
Definition: OrthancCPlugin.h:245
Definition: OrthancCPlugin.h:202
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:1215
Definition: OrthancCPlugin.h:602
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:796
OrthancPluginErrorCode OrthancPluginRestApiPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const char *body, uint32_t bodySize)
Make a PUT call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1578
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:2725
Definition: OrthancCPlugin.h:187
Definition: OrthancCPlugin.h:213
Definition: OrthancCPlugin.h:206
Definition: OrthancCPlugin.h:730
Definition: OrthancCPlugin.h:277
Definition: OrthancCPlugin.h:248
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:2436
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:3836
Definition: OrthancCPlugin.h:662
Definition: OrthancCPlugin.h:603
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:335
Definition: OrthancCPlugin.h:665
Definition: OrthancCPlugin.h:594
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:1679
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:4332
Definition: OrthancCPlugin.h:666
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:3203
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:974
uint16_t element
Definition: OrthancCPlugin.h:973
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:1819
Definition: OrthancCPlugin.h:601
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:2553
Definition: OrthancCPlugin.h:219
Definition: OrthancCPlugin.h:562
OrthancPluginErrorCode OrthancPluginSendMultipartItem(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize)
Send an item as a part of some HTTP multipart answer.
Definition: OrthancCPlugin.h:2753
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:812
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:325
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:2863
Definition: OrthancCPlugin.h:247
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:907
Definition: OrthancCPlugin.h:250
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:1714
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:771
Definition: OrthancCPlugin.h:744
Definition: OrthancCPlugin.h:230
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance received by Orthanc.
Definition: OrthancCPlugin.h:788
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:320
Definition: OrthancCPlugin.h:231
Definition: OrthancCPlugin.h:578
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:1134
Definition: OrthancCPlugin.h:651
Definition: OrthancCPlugin.h:236
Definition: OrthancCPlugin.h:671
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:728
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:350
Definition: OrthancCPlugin.h:300
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query.
Definition: OrthancCPlugin.h:820
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:1940
Definition: OrthancCPlugin.h:593
Definition: OrthancCPlugin.h:661
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2103
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:2458
Definition: OrthancCPlugin.h:278
Definition: OrthancCPlugin.h:221
OrthancPluginErrorCode OrthancPluginRestApiPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const char *body, uint32_t bodySize)
Make a POST call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1470
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:1243
Definition: OrthancCPlugin.h:595
Definition: OrthancCPlugin.h:664
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:3930
Definition: OrthancCPlugin.h:233
Definition: OrthancCPlugin.h:199
Definition: OrthancCPlugin.h:668
OrthancPluginErrorCode OrthancPluginHttpPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *body, uint32_t bodySize, const char *username, const char *password)
Issue a HTTP POST call.
Definition: OrthancCPlugin.h:3429
Definition: OrthancCPlugin.h:648
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:1181
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:1749
Definition: OrthancCPlugin.h:660
Definition: OrthancCPlugin.h:646
Definition: OrthancCPlugin.h:191
Definition: OrthancCPlugin.h:574
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:1434
char * OrthancPluginDicomBufferToJson(OrthancPluginContext *context, const char *buffer, uint32_t size, OrthancPluginDicomToJsonFormat format, OrthancPluginDicomToJsonFlags flags, uint32_t maxStringLength)
Format a DICOM memory buffer as a JSON string.
Definition: OrthancCPlugin.h:4019
Definition: OrthancCPlugin.h:745
Definition: OrthancCPlugin.h:210
OrthancPluginErrorCode(* OrthancPluginOnStoredInstanceCallback)(OrthancPluginDicomInstance *instance, const char *instanceId)
Signature of a callback function that is triggered when Orthanc receives a DICOM instance.
Definition: OrthancCPlugin.h:839
Definition: OrthancCPlugin.h:271
Definition: OrthancCPlugin.h:192
Definition: OrthancCPlugin.h:197
OrthancPluginErrorCode OrthancPluginRestApiPostAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const char *body, uint32_t bodySize)
Make a POST call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:1504
Definition: OrthancCPlugin.h:189
Definition: OrthancCPlugin.h:214
Definition: OrthancCPlugin.h:600
Definition: OrthancCPlugin.h:618
Definition: OrthancCPlugin.h:223
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:315
Definition: OrthancCPlugin.h:266
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:3757
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:3507
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:761
Definition: OrthancCPlugin.h:653
Definition: OrthancCPlugin.h:700
Definition: OrthancCPlugin.h:203
Definition: OrthancCPlugin.h:659
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:1784
Definition: OrthancCPlugin.h:193
Definition: OrthancCPlugin.h:649
Definition: OrthancCPlugin.h:259
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3016
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:3293
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:4306
Definition: OrthancCPlugin.h:216