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 1
116 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 0
117 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 0
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  _OrthancPluginService_SendMultipartItem2 = 2012,
428 
429  /* Access to the Orthanc database and API */
430  _OrthancPluginService_GetDicomForInstance = 3000,
431  _OrthancPluginService_RestApiGet = 3001,
432  _OrthancPluginService_RestApiPost = 3002,
433  _OrthancPluginService_RestApiDelete = 3003,
434  _OrthancPluginService_RestApiPut = 3004,
435  _OrthancPluginService_LookupPatient = 3005,
436  _OrthancPluginService_LookupStudy = 3006,
437  _OrthancPluginService_LookupSeries = 3007,
438  _OrthancPluginService_LookupInstance = 3008,
439  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
440  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
441  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
442  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
443  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
444  _OrthancPluginService_ReconstructMainDicomTags = 3014,
445  _OrthancPluginService_RestApiGet2 = 3015,
446 
447  /* Access to DICOM instances */
448  _OrthancPluginService_GetInstanceRemoteAet = 4000,
449  _OrthancPluginService_GetInstanceSize = 4001,
450  _OrthancPluginService_GetInstanceData = 4002,
451  _OrthancPluginService_GetInstanceJson = 4003,
452  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
453  _OrthancPluginService_HasInstanceMetadata = 4005,
454  _OrthancPluginService_GetInstanceMetadata = 4006,
455  _OrthancPluginService_GetInstanceOrigin = 4007,
456 
457  /* Services for plugins implementing a database back-end */
458  _OrthancPluginService_RegisterDatabaseBackend = 5000,
459  _OrthancPluginService_DatabaseAnswer = 5001,
460  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
461  _OrthancPluginService_StorageAreaCreate = 5003,
462  _OrthancPluginService_StorageAreaRead = 5004,
463  _OrthancPluginService_StorageAreaRemove = 5005,
464 
465  /* Primitives for handling images */
466  _OrthancPluginService_GetImagePixelFormat = 6000,
467  _OrthancPluginService_GetImageWidth = 6001,
468  _OrthancPluginService_GetImageHeight = 6002,
469  _OrthancPluginService_GetImagePitch = 6003,
470  _OrthancPluginService_GetImageBuffer = 6004,
471  _OrthancPluginService_UncompressImage = 6005,
472  _OrthancPluginService_FreeImage = 6006,
473  _OrthancPluginService_CompressImage = 6007,
474  _OrthancPluginService_ConvertPixelFormat = 6008,
475  _OrthancPluginService_GetFontsCount = 6009,
476  _OrthancPluginService_GetFontInfo = 6010,
477  _OrthancPluginService_DrawText = 6011,
478  _OrthancPluginService_CreateImage = 6012,
479  _OrthancPluginService_CreateImageAccessor = 6013,
480  _OrthancPluginService_DecodeDicomImage = 6014,
481 
482  /* Primitives for handling worklists */
483  _OrthancPluginService_WorklistAddAnswer = 7000,
484  _OrthancPluginService_WorklistMarkIncomplete = 7001,
485  _OrthancPluginService_WorklistIsMatch = 7002,
486  _OrthancPluginService_WorklistGetDicomQuery = 7003,
487 
488  _OrthancPluginService_INTERNAL = 0x7fffffff
489  } _OrthancPluginService;
490 
491 
492  typedef enum
493  {
494  _OrthancPluginProperty_Description = 1,
495  _OrthancPluginProperty_RootUri = 2,
496  _OrthancPluginProperty_OrthancExplorer = 3,
497 
498  _OrthancPluginProperty_INTERNAL = 0x7fffffff
499  } _OrthancPluginProperty;
500 
501 
502 
507  typedef enum
508  {
516 
524 
532 
540 
548 
551  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
553 
554 
555 
559  typedef enum
560  {
565  _OrthancPluginContentType_INTERNAL = 0x7fffffff
567 
568 
569 
573  typedef enum
574  {
581  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
583 
584 
585 
590  typedef enum
591  {
607  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
609 
610 
615  typedef enum
616  {
622  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
624 
625 
630  typedef enum
631  {
636  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
638 
639 
644  typedef enum
645  {
674  _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
676 
677 
683  typedef enum
684  {
689  _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
691 
692 
698  typedef enum
699  {
707  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
709 
710 
716  typedef enum
717  {
721  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
723 
724 
729  typedef enum
730  {
736  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
738 
739 
743  typedef enum
744  {
751  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
753 
754 
762  typedef struct
763  {
767  void* data;
768 
772  uint32_t size;
774 
775 
776 
777 
782  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
783 
784 
785 
789  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
790 
791 
792 
797  typedef struct _OrthancPluginImage_t OrthancPluginImage;
798 
799 
800 
805  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
806 
807 
808 
813  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
814 
815 
816 
821  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
822 
823 
824 
830  OrthancPluginRestOutput* output,
831  const char* url,
832  const OrthancPluginHttpRequest* request);
833 
834 
835 
841  OrthancPluginDicomInstance* instance,
842  const char* instanceId);
843 
844 
845 
851  OrthancPluginChangeType changeType,
852  OrthancPluginResourceType resourceType,
853  const char* resourceId);
854 
855 
856 
862  OrthancPluginImage** target,
863  const void* dicom,
864  const uint32_t size,
865  uint32_t frameIndex);
866 
867 
868 
872  typedef void (*OrthancPluginFree) (void* buffer);
873 
874 
875 
889  const char* uuid,
890  const void* content,
891  int64_t size,
893 
894 
895 
909  void** content,
910  int64_t* size,
911  const char* uuid,
913 
914 
915 
927  const char* uuid,
929 
930 
931 
947  const OrthancPluginWorklistQuery* query,
948  const char* remoteAet,
949  const char* calledAet);
950 
951 
952 
956  typedef struct _OrthancPluginContext_t
957  {
958  void* pluginsManager;
959  const char* orthancVersion;
960  OrthancPluginFree Free;
961  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
962  _OrthancPluginService service,
963  const void* params);
965 
966 
967 
971  typedef struct
972  {
973  uint16_t group;
974  uint16_t element;
976  uint32_t minMultiplicity;
977  uint32_t maxMultiplicity;
979 
980 
981 
990  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
991  OrthancPluginContext* context,
992  char* str)
993  {
994  if (str != NULL)
995  {
996  context->Free(str);
997  }
998  }
999 
1000 
1014  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1015  OrthancPluginContext* context)
1016  {
1017  int major, minor, revision;
1018 
1019  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1020  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1021  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1022  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1023  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1024  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1025  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1026  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1027  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1028  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1029  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1030  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1031  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1032  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1033  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1034  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin))
1035  {
1036  /* Mismatch in the size of the enumerations */
1037  return 0;
1038  }
1039 
1040  /* Assume compatibility with the mainline */
1041  if (!strcmp(context->orthancVersion, "mainline"))
1042  {
1043  return 1;
1044  }
1045 
1046  /* Parse the version of the Orthanc core */
1047  if (
1048 #ifdef _MSC_VER
1049  sscanf_s
1050 #else
1051  sscanf
1052 #endif
1053  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1054  {
1055  return 0;
1056  }
1057 
1058  /* Check the major number of the version */
1059 
1060  if (major > ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
1061  {
1062  return 1;
1063  }
1064 
1065  if (major < ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
1066  {
1067  return 0;
1068  }
1069 
1070  /* Check the minor number of the version */
1071 
1072  if (minor > ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
1073  {
1074  return 1;
1075  }
1076 
1077  if (minor < ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
1078  {
1079  return 0;
1080  }
1081 
1082  /* Check the revision number of the version */
1083 
1084  if (revision >= ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER)
1085  {
1086  return 1;
1087  }
1088  else
1089  {
1090  return 0;
1091  }
1092  }
1093 
1094 
1103  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1104  OrthancPluginContext* context,
1105  OrthancPluginMemoryBuffer* buffer)
1106  {
1107  context->Free(buffer->data);
1108  }
1109 
1110 
1119  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1120  OrthancPluginContext* context,
1121  const char* message)
1122  {
1123  context->InvokeService(context, _OrthancPluginService_LogError, message);
1124  }
1125 
1126 
1135  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
1136  OrthancPluginContext* context,
1137  const char* message)
1138  {
1139  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1140  }
1141 
1142 
1151  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
1152  OrthancPluginContext* context,
1153  const char* message)
1154  {
1155  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
1156  }
1157 
1158 
1159 
1160  typedef struct
1161  {
1162  const char* pathRegularExpression;
1163  OrthancPluginRestCallback callback;
1164  } _OrthancPluginRestCallback;
1165 
1182  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
1183  OrthancPluginContext* context,
1184  const char* pathRegularExpression,
1185  OrthancPluginRestCallback callback)
1186  {
1187  _OrthancPluginRestCallback params;
1188  params.pathRegularExpression = pathRegularExpression;
1189  params.callback = callback;
1190  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
1191  }
1192 
1193 
1194 
1216  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
1217  OrthancPluginContext* context,
1218  const char* pathRegularExpression,
1219  OrthancPluginRestCallback callback)
1220  {
1221  _OrthancPluginRestCallback params;
1222  params.pathRegularExpression = pathRegularExpression;
1223  params.callback = callback;
1224  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
1225  }
1226 
1227 
1228 
1229  typedef struct
1230  {
1232  } _OrthancPluginOnStoredInstanceCallback;
1233 
1245  OrthancPluginContext* context,
1247  {
1248  _OrthancPluginOnStoredInstanceCallback params;
1249  params.callback = callback;
1250 
1251  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
1252  }
1253 
1254 
1255 
1256  typedef struct
1257  {
1258  OrthancPluginRestOutput* output;
1259  const char* answer;
1260  uint32_t answerSize;
1261  const char* mimeType;
1262  } _OrthancPluginAnswerBuffer;
1263 
1276  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
1277  OrthancPluginContext* context,
1278  OrthancPluginRestOutput* output,
1279  const char* answer,
1280  uint32_t answerSize,
1281  const char* mimeType)
1282  {
1283  _OrthancPluginAnswerBuffer params;
1284  params.output = output;
1285  params.answer = answer;
1286  params.answerSize = answerSize;
1287  params.mimeType = mimeType;
1288  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
1289  }
1290 
1291 
1292  typedef struct
1293  {
1294  OrthancPluginRestOutput* output;
1295  OrthancPluginPixelFormat format;
1296  uint32_t width;
1297  uint32_t height;
1298  uint32_t pitch;
1299  const void* buffer;
1300  } _OrthancPluginCompressAndAnswerPngImage;
1301 
1302  typedef struct
1303  {
1304  OrthancPluginRestOutput* output;
1305  OrthancPluginImageFormat imageFormat;
1306  OrthancPluginPixelFormat pixelFormat;
1307  uint32_t width;
1308  uint32_t height;
1309  uint32_t pitch;
1310  const void* buffer;
1311  uint8_t quality;
1312  } _OrthancPluginCompressAndAnswerImage;
1313 
1314 
1333  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
1334  OrthancPluginContext* context,
1335  OrthancPluginRestOutput* output,
1336  OrthancPluginPixelFormat format,
1337  uint32_t width,
1338  uint32_t height,
1339  uint32_t pitch,
1340  const void* buffer)
1341  {
1342  _OrthancPluginCompressAndAnswerImage params;
1343  params.output = output;
1344  params.imageFormat = OrthancPluginImageFormat_Png;
1345  params.pixelFormat = format;
1346  params.width = width;
1347  params.height = height;
1348  params.pitch = pitch;
1349  params.buffer = buffer;
1350  params.quality = 0; /* No quality for PNG */
1351  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
1352  }
1353 
1354 
1355 
1356  typedef struct
1357  {
1358  OrthancPluginMemoryBuffer* target;
1359  const char* instanceId;
1360  } _OrthancPluginGetDicomForInstance;
1361 
1375  OrthancPluginContext* context,
1376  OrthancPluginMemoryBuffer* target,
1377  const char* instanceId)
1378  {
1379  _OrthancPluginGetDicomForInstance params;
1380  params.target = target;
1381  params.instanceId = instanceId;
1382  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
1383  }
1384 
1385 
1386 
1387  typedef struct
1388  {
1389  OrthancPluginMemoryBuffer* target;
1390  const char* uri;
1391  } _OrthancPluginRestApiGet;
1392 
1407  OrthancPluginContext* context,
1408  OrthancPluginMemoryBuffer* target,
1409  const char* uri)
1410  {
1411  _OrthancPluginRestApiGet params;
1412  params.target = target;
1413  params.uri = uri;
1414  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
1415  }
1416 
1417 
1418 
1436  OrthancPluginContext* context,
1437  OrthancPluginMemoryBuffer* target,
1438  const char* uri)
1439  {
1440  _OrthancPluginRestApiGet params;
1441  params.target = target;
1442  params.uri = uri;
1443  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
1444  }
1445 
1446 
1447 
1448  typedef struct
1449  {
1450  OrthancPluginMemoryBuffer* target;
1451  const char* uri;
1452  const char* body;
1453  uint32_t bodySize;
1454  } _OrthancPluginRestApiPostPut;
1455 
1472  OrthancPluginContext* context,
1473  OrthancPluginMemoryBuffer* target,
1474  const char* uri,
1475  const char* body,
1476  uint32_t bodySize)
1477  {
1478  _OrthancPluginRestApiPostPut params;
1479  params.target = target;
1480  params.uri = uri;
1481  params.body = body;
1482  params.bodySize = bodySize;
1483  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
1484  }
1485 
1486 
1506  OrthancPluginContext* context,
1507  OrthancPluginMemoryBuffer* target,
1508  const char* uri,
1509  const char* body,
1510  uint32_t bodySize)
1511  {
1512  _OrthancPluginRestApiPostPut params;
1513  params.target = target;
1514  params.uri = uri;
1515  params.body = body;
1516  params.bodySize = bodySize;
1517  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
1518  }
1519 
1520 
1521 
1534  OrthancPluginContext* context,
1535  const char* uri)
1536  {
1537  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
1538  }
1539 
1540 
1556  OrthancPluginContext* context,
1557  const char* uri)
1558  {
1559  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
1560  }
1561 
1562 
1563 
1580  OrthancPluginContext* context,
1581  OrthancPluginMemoryBuffer* target,
1582  const char* uri,
1583  const char* body,
1584  uint32_t bodySize)
1585  {
1586  _OrthancPluginRestApiPostPut params;
1587  params.target = target;
1588  params.uri = uri;
1589  params.body = body;
1590  params.bodySize = bodySize;
1591  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
1592  }
1593 
1594 
1595 
1615  OrthancPluginContext* context,
1616  OrthancPluginMemoryBuffer* target,
1617  const char* uri,
1618  const char* body,
1619  uint32_t bodySize)
1620  {
1621  _OrthancPluginRestApiPostPut params;
1622  params.target = target;
1623  params.uri = uri;
1624  params.body = body;
1625  params.bodySize = bodySize;
1626  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
1627  }
1628 
1629 
1630 
1631  typedef struct
1632  {
1633  OrthancPluginRestOutput* output;
1634  const char* argument;
1635  } _OrthancPluginOutputPlusArgument;
1636 
1648  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
1649  OrthancPluginContext* context,
1650  OrthancPluginRestOutput* output,
1651  const char* redirection)
1652  {
1653  _OrthancPluginOutputPlusArgument params;
1654  params.output = output;
1655  params.argument = redirection;
1656  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
1657  }
1658 
1659 
1660 
1661  typedef struct
1662  {
1663  char** result;
1664  const char* argument;
1665  } _OrthancPluginRetrieveDynamicString;
1666 
1680  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
1681  OrthancPluginContext* context,
1682  const char* patientID)
1683  {
1684  char* result;
1685 
1686  _OrthancPluginRetrieveDynamicString params;
1687  params.result = &result;
1688  params.argument = patientID;
1689 
1690  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
1691  {
1692  /* Error */
1693  return NULL;
1694  }
1695  else
1696  {
1697  return result;
1698  }
1699  }
1700 
1701 
1715  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
1716  OrthancPluginContext* context,
1717  const char* studyUID)
1718  {
1719  char* result;
1720 
1721  _OrthancPluginRetrieveDynamicString params;
1722  params.result = &result;
1723  params.argument = studyUID;
1724 
1725  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
1726  {
1727  /* Error */
1728  return NULL;
1729  }
1730  else
1731  {
1732  return result;
1733  }
1734  }
1735 
1736 
1750  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
1751  OrthancPluginContext* context,
1752  const char* accessionNumber)
1753  {
1754  char* result;
1755 
1756  _OrthancPluginRetrieveDynamicString params;
1757  params.result = &result;
1758  params.argument = accessionNumber;
1759 
1760  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
1761  {
1762  /* Error */
1763  return NULL;
1764  }
1765  else
1766  {
1767  return result;
1768  }
1769  }
1770 
1771 
1785  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
1786  OrthancPluginContext* context,
1787  const char* seriesUID)
1788  {
1789  char* result;
1790 
1791  _OrthancPluginRetrieveDynamicString params;
1792  params.result = &result;
1793  params.argument = seriesUID;
1794 
1795  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
1796  {
1797  /* Error */
1798  return NULL;
1799  }
1800  else
1801  {
1802  return result;
1803  }
1804  }
1805 
1806 
1820  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
1821  OrthancPluginContext* context,
1822  const char* sopInstanceUID)
1823  {
1824  char* result;
1825 
1826  _OrthancPluginRetrieveDynamicString params;
1827  params.result = &result;
1828  params.argument = sopInstanceUID;
1829 
1830  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
1831  {
1832  /* Error */
1833  return NULL;
1834  }
1835  else
1836  {
1837  return result;
1838  }
1839  }
1840 
1841 
1842 
1843  typedef struct
1844  {
1845  OrthancPluginRestOutput* output;
1846  uint16_t status;
1847  } _OrthancPluginSendHttpStatusCode;
1848 
1865  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
1866  OrthancPluginContext* context,
1867  OrthancPluginRestOutput* output,
1868  uint16_t status)
1869  {
1870  _OrthancPluginSendHttpStatusCode params;
1871  params.output = output;
1872  params.status = status;
1873  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
1874  }
1875 
1876 
1888  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
1889  OrthancPluginContext* context,
1890  OrthancPluginRestOutput* output,
1891  const char* realm)
1892  {
1893  _OrthancPluginOutputPlusArgument params;
1894  params.output = output;
1895  params.argument = realm;
1896  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
1897  }
1898 
1899 
1911  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
1912  OrthancPluginContext* context,
1913  OrthancPluginRestOutput* output,
1914  const char* allowedMethods)
1915  {
1916  _OrthancPluginOutputPlusArgument params;
1917  params.output = output;
1918  params.argument = allowedMethods;
1919  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
1920  }
1921 
1922 
1923  typedef struct
1924  {
1925  OrthancPluginRestOutput* output;
1926  const char* key;
1927  const char* value;
1928  } _OrthancPluginSetHttpHeader;
1929 
1941  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
1942  OrthancPluginContext* context,
1943  OrthancPluginRestOutput* output,
1944  const char* cookie,
1945  const char* value)
1946  {
1947  _OrthancPluginSetHttpHeader params;
1948  params.output = output;
1949  params.key = cookie;
1950  params.value = value;
1951  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
1952  }
1953 
1954 
1966  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
1967  OrthancPluginContext* context,
1968  OrthancPluginRestOutput* output,
1969  const char* key,
1970  const char* value)
1971  {
1972  _OrthancPluginSetHttpHeader params;
1973  params.output = output;
1974  params.key = key;
1975  params.value = value;
1976  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
1977  }
1978 
1979 
1980  typedef struct
1981  {
1982  char** resultStringToFree;
1983  const char** resultString;
1984  int64_t* resultInt64;
1985  const char* key;
1986  OrthancPluginDicomInstance* instance;
1987  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
1988  } _OrthancPluginAccessDicomInstance;
1989 
1990 
2002  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2003  OrthancPluginContext* context,
2004  OrthancPluginDicomInstance* instance)
2005  {
2006  const char* result;
2007 
2008  _OrthancPluginAccessDicomInstance params;
2009  memset(&params, 0, sizeof(params));
2010  params.resultString = &result;
2011  params.instance = instance;
2012 
2013  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2014  {
2015  /* Error */
2016  return NULL;
2017  }
2018  else
2019  {
2020  return result;
2021  }
2022  }
2023 
2024 
2035  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2036  OrthancPluginContext* context,
2037  OrthancPluginDicomInstance* instance)
2038  {
2039  int64_t size;
2040 
2041  _OrthancPluginAccessDicomInstance params;
2042  memset(&params, 0, sizeof(params));
2043  params.resultInt64 = &size;
2044  params.instance = instance;
2045 
2046  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2047  {
2048  /* Error */
2049  return -1;
2050  }
2051  else
2052  {
2053  return size;
2054  }
2055  }
2056 
2057 
2068  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceData(
2069  OrthancPluginContext* context,
2070  OrthancPluginDicomInstance* instance)
2071  {
2072  const char* result;
2073 
2074  _OrthancPluginAccessDicomInstance params;
2075  memset(&params, 0, sizeof(params));
2076  params.resultString = &result;
2077  params.instance = instance;
2078 
2079  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2080  {
2081  /* Error */
2082  return NULL;
2083  }
2084  else
2085  {
2086  return result;
2087  }
2088  }
2089 
2090 
2104  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
2105  OrthancPluginContext* context,
2106  OrthancPluginDicomInstance* instance)
2107  {
2108  char* result;
2109 
2110  _OrthancPluginAccessDicomInstance params;
2111  memset(&params, 0, sizeof(params));
2112  params.resultStringToFree = &result;
2113  params.instance = instance;
2114 
2115  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
2116  {
2117  /* Error */
2118  return NULL;
2119  }
2120  else
2121  {
2122  return result;
2123  }
2124  }
2125 
2126 
2142  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
2143  OrthancPluginContext* context,
2144  OrthancPluginDicomInstance* instance)
2145  {
2146  char* result;
2147 
2148  _OrthancPluginAccessDicomInstance params;
2149  memset(&params, 0, sizeof(params));
2150  params.resultStringToFree = &result;
2151  params.instance = instance;
2152 
2153  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
2154  {
2155  /* Error */
2156  return NULL;
2157  }
2158  else
2159  {
2160  return result;
2161  }
2162  }
2163 
2164 
2181  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
2182  OrthancPluginContext* context,
2183  OrthancPluginDicomInstance* instance,
2184  const char* metadata)
2185  {
2186  int64_t result;
2187 
2188  _OrthancPluginAccessDicomInstance params;
2189  memset(&params, 0, sizeof(params));
2190  params.resultInt64 = &result;
2191  params.instance = instance;
2192  params.key = metadata;
2193 
2194  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2195  {
2196  /* Error */
2197  return -1;
2198  }
2199  else
2200  {
2201  return (result != 0);
2202  }
2203  }
2204 
2205 
2219  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
2220  OrthancPluginContext* context,
2221  OrthancPluginDicomInstance* instance,
2222  const char* metadata)
2223  {
2224  const char* result;
2225 
2226  _OrthancPluginAccessDicomInstance params;
2227  memset(&params, 0, sizeof(params));
2228  params.resultString = &result;
2229  params.instance = instance;
2230  params.key = metadata;
2231 
2232  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2233  {
2234  /* Error */
2235  return NULL;
2236  }
2237  else
2238  {
2239  return result;
2240  }
2241  }
2242 
2243 
2244 
2245  typedef struct
2246  {
2250  OrthancPluginFree free;
2251  } _OrthancPluginRegisterStorageArea;
2252 
2267  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
2268  OrthancPluginContext* context,
2272  {
2273  _OrthancPluginRegisterStorageArea params;
2274  params.create = create;
2275  params.read = read;
2276  params.remove = remove;
2277 
2278 #ifdef __cplusplus
2279  params.free = ::free;
2280 #else
2281  params.free = free;
2282 #endif
2283 
2284  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
2285  }
2286 
2287 
2288 
2299  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
2300  {
2301  char* result;
2302 
2303  _OrthancPluginRetrieveDynamicString params;
2304  params.result = &result;
2305  params.argument = NULL;
2306 
2307  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
2308  {
2309  /* Error */
2310  return NULL;
2311  }
2312  else
2313  {
2314  return result;
2315  }
2316  }
2317 
2318 
2329  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
2330  {
2331  char* result;
2332 
2333  _OrthancPluginRetrieveDynamicString params;
2334  params.result = &result;
2335  params.argument = NULL;
2336 
2337  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
2338  {
2339  /* Error */
2340  return NULL;
2341  }
2342  else
2343  {
2344  return result;
2345  }
2346  }
2347 
2348 
2364  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
2365  {
2366  char* result;
2367 
2368  _OrthancPluginRetrieveDynamicString params;
2369  params.result = &result;
2370  params.argument = NULL;
2371 
2372  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
2373  {
2374  /* Error */
2375  return NULL;
2376  }
2377  else
2378  {
2379  return result;
2380  }
2381  }
2382 
2383 
2384 
2385  typedef struct
2386  {
2388  } _OrthancPluginOnChangeCallback;
2389 
2406  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
2407  OrthancPluginContext* context,
2409  {
2410  _OrthancPluginOnChangeCallback params;
2411  params.callback = callback;
2412 
2413  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
2414  }
2415 
2416 
2417 
2418  typedef struct
2419  {
2420  const char* plugin;
2421  _OrthancPluginProperty property;
2422  const char* value;
2423  } _OrthancPluginSetPluginProperty;
2424 
2425 
2437  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
2438  OrthancPluginContext* context,
2439  const char* uri)
2440  {
2441  _OrthancPluginSetPluginProperty params;
2442  params.plugin = OrthancPluginGetName();
2443  params.property = _OrthancPluginProperty_RootUri;
2444  params.value = uri;
2445 
2446  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2447  }
2448 
2449 
2459  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
2460  OrthancPluginContext* context,
2461  const char* description)
2462  {
2463  _OrthancPluginSetPluginProperty params;
2464  params.plugin = OrthancPluginGetName();
2465  params.property = _OrthancPluginProperty_Description;
2466  params.value = description;
2467 
2468  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2469  }
2470 
2471 
2481  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
2482  OrthancPluginContext* context,
2483  const char* javascript)
2484  {
2485  _OrthancPluginSetPluginProperty params;
2486  params.plugin = OrthancPluginGetName();
2487  params.property = _OrthancPluginProperty_OrthancExplorer;
2488  params.value = javascript;
2489 
2490  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2491  }
2492 
2493 
2494  typedef struct
2495  {
2496  char** result;
2497  int32_t property;
2498  const char* value;
2499  } _OrthancPluginGlobalProperty;
2500 
2501 
2515  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
2516  OrthancPluginContext* context,
2517  int32_t property,
2518  const char* defaultValue)
2519  {
2520  char* result;
2521 
2522  _OrthancPluginGlobalProperty params;
2523  params.result = &result;
2524  params.property = property;
2525  params.value = defaultValue;
2526 
2527  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
2528  {
2529  /* Error */
2530  return NULL;
2531  }
2532  else
2533  {
2534  return result;
2535  }
2536  }
2537 
2538 
2555  OrthancPluginContext* context,
2556  int32_t property,
2557  const char* value)
2558  {
2559  _OrthancPluginGlobalProperty params;
2560  params.result = NULL;
2561  params.property = property;
2562  params.value = value;
2563 
2564  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
2565  }
2566 
2567 
2568 
2569  typedef struct
2570  {
2571  int32_t *resultInt32;
2572  uint32_t *resultUint32;
2573  int64_t *resultInt64;
2574  uint64_t *resultUint64;
2575  } _OrthancPluginReturnSingleValue;
2576 
2585  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
2586  OrthancPluginContext* context)
2587  {
2588  uint32_t count = 0;
2589 
2590  _OrthancPluginReturnSingleValue params;
2591  memset(&params, 0, sizeof(params));
2592  params.resultUint32 = &count;
2593 
2594  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
2595  {
2596  /* Error */
2597  return 0;
2598  }
2599  else
2600  {
2601  return count;
2602  }
2603  }
2604 
2605 
2606 
2619  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
2620  OrthancPluginContext* context,
2621  uint32_t argument)
2622  {
2623  char* result;
2624 
2625  _OrthancPluginGlobalProperty params;
2626  params.result = &result;
2627  params.property = (int32_t) argument;
2628  params.value = NULL;
2629 
2630  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
2631  {
2632  /* Error */
2633  return NULL;
2634  }
2635  else
2636  {
2637  return result;
2638  }
2639  }
2640 
2641 
2652  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
2653  OrthancPluginContext* context)
2654  {
2655  uint32_t count = 0;
2656 
2657  _OrthancPluginReturnSingleValue params;
2658  memset(&params, 0, sizeof(params));
2659  params.resultUint32 = &count;
2660 
2661  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
2662  {
2663  /* Error */
2664  return 0;
2665  }
2666  else
2667  {
2668  return count;
2669  }
2670  }
2671 
2672 
2673 
2685  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
2686  {
2687  char* result;
2688 
2689  _OrthancPluginRetrieveDynamicString params;
2690  params.result = &result;
2691  params.argument = NULL;
2692 
2693  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
2694  {
2695  /* Error */
2696  return NULL;
2697  }
2698  else
2699  {
2700  return result;
2701  }
2702  }
2703 
2704 
2705 
2706  typedef struct
2707  {
2708  OrthancPluginRestOutput* output;
2709  const char* subType;
2710  const char* contentType;
2711  } _OrthancPluginStartMultipartAnswer;
2712 
2727  OrthancPluginContext* context,
2728  OrthancPluginRestOutput* output,
2729  const char* subType,
2730  const char* contentType)
2731  {
2732  _OrthancPluginStartMultipartAnswer params;
2733  params.output = output;
2734  params.subType = subType;
2735  params.contentType = contentType;
2736  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
2737  }
2738 
2739 
2756  OrthancPluginContext* context,
2757  OrthancPluginRestOutput* output,
2758  const char* answer,
2759  uint32_t answerSize)
2760  {
2761  _OrthancPluginAnswerBuffer params;
2762  params.output = output;
2763  params.answer = answer;
2764  params.answerSize = answerSize;
2765  params.mimeType = NULL;
2766  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
2767  }
2768 
2769 
2770 
2771  typedef struct
2772  {
2773  OrthancPluginMemoryBuffer* target;
2774  const void* source;
2775  uint32_t size;
2776  OrthancPluginCompressionType compression;
2777  uint8_t uncompress;
2778  } _OrthancPluginBufferCompression;
2779 
2780 
2798  OrthancPluginContext* context,
2799  OrthancPluginMemoryBuffer* target,
2800  const void* source,
2801  uint32_t size,
2802  OrthancPluginCompressionType compression,
2803  uint8_t uncompress)
2804  {
2805  _OrthancPluginBufferCompression params;
2806  params.target = target;
2807  params.source = source;
2808  params.size = size;
2809  params.compression = compression;
2810  params.uncompress = uncompress;
2811 
2812  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
2813  }
2814 
2815 
2816 
2817  typedef struct
2818  {
2819  OrthancPluginMemoryBuffer* target;
2820  const char* path;
2821  } _OrthancPluginReadFile;
2822 
2835  OrthancPluginContext* context,
2836  OrthancPluginMemoryBuffer* target,
2837  const char* path)
2838  {
2839  _OrthancPluginReadFile params;
2840  params.target = target;
2841  params.path = path;
2842  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
2843  }
2844 
2845 
2846 
2847  typedef struct
2848  {
2849  const char* path;
2850  const void* data;
2851  uint32_t size;
2852  } _OrthancPluginWriteFile;
2853 
2866  OrthancPluginContext* context,
2867  const char* path,
2868  const void* data,
2869  uint32_t size)
2870  {
2871  _OrthancPluginWriteFile params;
2872  params.path = path;
2873  params.data = data;
2874  params.size = size;
2875  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
2876  }
2877 
2878 
2879 
2880  typedef struct
2881  {
2882  const char** target;
2883  OrthancPluginErrorCode error;
2884  } _OrthancPluginGetErrorDescription;
2885 
2896  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
2897  OrthancPluginContext* context,
2898  OrthancPluginErrorCode error)
2899  {
2900  const char* result = NULL;
2901 
2902  _OrthancPluginGetErrorDescription params;
2903  params.target = &result;
2904  params.error = error;
2905 
2906  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
2907  result == NULL)
2908  {
2909  return "Unknown error code";
2910  }
2911  else
2912  {
2913  return result;
2914  }
2915  }
2916 
2917 
2918 
2919  typedef struct
2920  {
2921  OrthancPluginRestOutput* output;
2922  uint16_t status;
2923  const char* body;
2924  uint32_t bodySize;
2925  } _OrthancPluginSendHttpStatus;
2926 
2949  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
2950  OrthancPluginContext* context,
2951  OrthancPluginRestOutput* output,
2952  uint16_t status,
2953  const char* body,
2954  uint32_t bodySize)
2955  {
2956  _OrthancPluginSendHttpStatus params;
2957  params.output = output;
2958  params.status = status;
2959  params.body = body;
2960  params.bodySize = bodySize;
2961  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
2962  }
2963 
2964 
2965 
2966  typedef struct
2967  {
2968  const OrthancPluginImage* image;
2969  uint32_t* resultUint32;
2970  OrthancPluginPixelFormat* resultPixelFormat;
2971  void** resultBuffer;
2972  } _OrthancPluginGetImageInfo;
2973 
2974 
2986  OrthancPluginContext* context,
2987  const OrthancPluginImage* image)
2988  {
2989  OrthancPluginPixelFormat target;
2990 
2991  _OrthancPluginGetImageInfo params;
2992  memset(&params, 0, sizeof(params));
2993  params.image = image;
2994  params.resultPixelFormat = &target;
2995 
2996  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
2997  {
2999  }
3000  else
3001  {
3002  return (OrthancPluginPixelFormat) target;
3003  }
3004  }
3005 
3006 
3007 
3018  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3019  OrthancPluginContext* context,
3020  const OrthancPluginImage* image)
3021  {
3022  uint32_t width;
3023 
3024  _OrthancPluginGetImageInfo params;
3025  memset(&params, 0, sizeof(params));
3026  params.image = image;
3027  params.resultUint32 = &width;
3028 
3029  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3030  {
3031  return 0;
3032  }
3033  else
3034  {
3035  return width;
3036  }
3037  }
3038 
3039 
3040 
3051  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3052  OrthancPluginContext* context,
3053  const OrthancPluginImage* image)
3054  {
3055  uint32_t height;
3056 
3057  _OrthancPluginGetImageInfo params;
3058  memset(&params, 0, sizeof(params));
3059  params.image = image;
3060  params.resultUint32 = &height;
3061 
3062  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3063  {
3064  return 0;
3065  }
3066  else
3067  {
3068  return height;
3069  }
3070  }
3071 
3072 
3073 
3086  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3087  OrthancPluginContext* context,
3088  const OrthancPluginImage* image)
3089  {
3090  uint32_t pitch;
3091 
3092  _OrthancPluginGetImageInfo params;
3093  memset(&params, 0, sizeof(params));
3094  params.image = image;
3095  params.resultUint32 = &pitch;
3096 
3097  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
3098  {
3099  return 0;
3100  }
3101  else
3102  {
3103  return pitch;
3104  }
3105  }
3106 
3107 
3108 
3120  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
3121  OrthancPluginContext* context,
3122  const OrthancPluginImage* image)
3123  {
3124  void* target = NULL;
3125 
3126  _OrthancPluginGetImageInfo params;
3127  memset(&params, 0, sizeof(params));
3128  params.resultBuffer = &target;
3129  params.image = image;
3130 
3131  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
3132  {
3133  return NULL;
3134  }
3135  else
3136  {
3137  return target;
3138  }
3139  }
3140 
3141 
3142  typedef struct
3143  {
3144  OrthancPluginImage** target;
3145  const void* data;
3146  uint32_t size;
3147  OrthancPluginImageFormat format;
3148  } _OrthancPluginUncompressImage;
3149 
3150 
3164  OrthancPluginContext* context,
3165  const void* data,
3166  uint32_t size,
3167  OrthancPluginImageFormat format)
3168  {
3169  OrthancPluginImage* target = NULL;
3170 
3171  _OrthancPluginUncompressImage params;
3172  memset(&params, 0, sizeof(params));
3173  params.target = &target;
3174  params.data = data;
3175  params.size = size;
3176  params.format = format;
3177 
3178  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
3179  {
3180  return NULL;
3181  }
3182  else
3183  {
3184  return target;
3185  }
3186  }
3187 
3188 
3189 
3190 
3191  typedef struct
3192  {
3193  OrthancPluginImage* image;
3194  } _OrthancPluginFreeImage;
3195 
3205  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
3206  OrthancPluginContext* context,
3207  OrthancPluginImage* image)
3208  {
3209  _OrthancPluginFreeImage params;
3210  params.image = image;
3211 
3212  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
3213  }
3214 
3215 
3216 
3217 
3218  typedef struct
3219  {
3220  OrthancPluginMemoryBuffer* target;
3221  OrthancPluginImageFormat imageFormat;
3222  OrthancPluginPixelFormat pixelFormat;
3223  uint32_t width;
3224  uint32_t height;
3225  uint32_t pitch;
3226  const void* buffer;
3227  uint8_t quality;
3228  } _OrthancPluginCompressImage;
3229 
3230 
3251  OrthancPluginContext* context,
3252  OrthancPluginMemoryBuffer* target,
3253  OrthancPluginPixelFormat format,
3254  uint32_t width,
3255  uint32_t height,
3256  uint32_t pitch,
3257  const void* buffer)
3258  {
3259  _OrthancPluginCompressImage params;
3260  memset(&params, 0, sizeof(params));
3261  params.target = target;
3262  params.imageFormat = OrthancPluginImageFormat_Png;
3263  params.pixelFormat = format;
3264  params.width = width;
3265  params.height = height;
3266  params.pitch = pitch;
3267  params.buffer = buffer;
3268  params.quality = 0; /* Unused for PNG */
3269 
3270  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3271  }
3272 
3273 
3296  OrthancPluginContext* context,
3297  OrthancPluginMemoryBuffer* target,
3298  OrthancPluginPixelFormat format,
3299  uint32_t width,
3300  uint32_t height,
3301  uint32_t pitch,
3302  const void* buffer,
3303  uint8_t quality)
3304  {
3305  _OrthancPluginCompressImage params;
3306  memset(&params, 0, sizeof(params));
3307  params.target = target;
3308  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3309  params.pixelFormat = format;
3310  params.width = width;
3311  params.height = height;
3312  params.pitch = pitch;
3313  params.buffer = buffer;
3314  params.quality = quality;
3315 
3316  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3317  }
3318 
3319 
3320 
3342  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
3343  OrthancPluginContext* context,
3344  OrthancPluginRestOutput* output,
3345  OrthancPluginPixelFormat format,
3346  uint32_t width,
3347  uint32_t height,
3348  uint32_t pitch,
3349  const void* buffer,
3350  uint8_t quality)
3351  {
3352  _OrthancPluginCompressAndAnswerImage params;
3353  params.output = output;
3354  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3355  params.pixelFormat = format;
3356  params.width = width;
3357  params.height = height;
3358  params.pitch = pitch;
3359  params.buffer = buffer;
3360  params.quality = quality;
3361  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
3362  }
3363 
3364 
3365 
3366 
3367  typedef struct
3368  {
3369  OrthancPluginMemoryBuffer* target;
3370  OrthancPluginHttpMethod method;
3371  const char* url;
3372  const char* username;
3373  const char* password;
3374  const char* body;
3375  uint32_t bodySize;
3376  } _OrthancPluginCallHttpClient;
3377 
3378 
3395  OrthancPluginContext* context,
3396  OrthancPluginMemoryBuffer* target,
3397  const char* url,
3398  const char* username,
3399  const char* password)
3400  {
3401  _OrthancPluginCallHttpClient params;
3402  memset(&params, 0, sizeof(params));
3403 
3404  params.target = target;
3405  params.method = OrthancPluginHttpMethod_Get;
3406  params.url = url;
3407  params.username = username;
3408  params.password = password;
3409 
3410  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3411  }
3412 
3413 
3432  OrthancPluginContext* context,
3433  OrthancPluginMemoryBuffer* target,
3434  const char* url,
3435  const char* body,
3436  uint32_t bodySize,
3437  const char* username,
3438  const char* password)
3439  {
3440  _OrthancPluginCallHttpClient params;
3441  memset(&params, 0, sizeof(params));
3442 
3443  params.target = target;
3444  params.method = OrthancPluginHttpMethod_Post;
3445  params.url = url;
3446  params.body = body;
3447  params.bodySize = bodySize;
3448  params.username = username;
3449  params.password = password;
3450 
3451  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3452  }
3453 
3454 
3473  OrthancPluginContext* context,
3474  OrthancPluginMemoryBuffer* target,
3475  const char* url,
3476  const char* body,
3477  uint32_t bodySize,
3478  const char* username,
3479  const char* password)
3480  {
3481  _OrthancPluginCallHttpClient params;
3482  memset(&params, 0, sizeof(params));
3483 
3484  params.target = target;
3485  params.method = OrthancPluginHttpMethod_Put;
3486  params.url = url;
3487  params.body = body;
3488  params.bodySize = bodySize;
3489  params.username = username;
3490  params.password = password;
3491 
3492  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3493  }
3494 
3495 
3510  OrthancPluginContext* context,
3511  const char* url,
3512  const char* username,
3513  const char* password)
3514  {
3515  _OrthancPluginCallHttpClient params;
3516  memset(&params, 0, sizeof(params));
3517 
3518  params.method = OrthancPluginHttpMethod_Delete;
3519  params.url = url;
3520  params.username = username;
3521  params.password = password;
3522 
3523  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3524  }
3525 
3526 
3527 
3528  typedef struct
3529  {
3530  OrthancPluginImage** target;
3531  const OrthancPluginImage* source;
3532  OrthancPluginPixelFormat targetFormat;
3533  } _OrthancPluginConvertPixelFormat;
3534 
3535 
3548  OrthancPluginContext* context,
3549  const OrthancPluginImage* source,
3550  OrthancPluginPixelFormat targetFormat)
3551  {
3552  OrthancPluginImage* target = NULL;
3553 
3554  _OrthancPluginConvertPixelFormat params;
3555  params.target = &target;
3556  params.source = source;
3557  params.targetFormat = targetFormat;
3558 
3559  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
3560  {
3561  return NULL;
3562  }
3563  else
3564  {
3565  return target;
3566  }
3567  }
3568 
3569 
3570 
3582  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
3583  OrthancPluginContext* context)
3584  {
3585  uint32_t count = 0;
3586 
3587  _OrthancPluginReturnSingleValue params;
3588  memset(&params, 0, sizeof(params));
3589  params.resultUint32 = &count;
3590 
3591  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
3592  {
3593  /* Error */
3594  return 0;
3595  }
3596  else
3597  {
3598  return count;
3599  }
3600  }
3601 
3602 
3603 
3604 
3605  typedef struct
3606  {
3607  uint32_t fontIndex; /* in */
3608  const char** name; /* out */
3609  uint32_t* size; /* out */
3610  } _OrthancPluginGetFontInfo;
3611 
3622  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
3623  OrthancPluginContext* context,
3624  uint32_t fontIndex)
3625  {
3626  const char* result = NULL;
3627 
3628  _OrthancPluginGetFontInfo params;
3629  memset(&params, 0, sizeof(params));
3630  params.name = &result;
3631  params.fontIndex = fontIndex;
3632 
3633  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
3634  {
3635  return NULL;
3636  }
3637  else
3638  {
3639  return result;
3640  }
3641  }
3642 
3643 
3654  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
3655  OrthancPluginContext* context,
3656  uint32_t fontIndex)
3657  {
3658  uint32_t result;
3659 
3660  _OrthancPluginGetFontInfo params;
3661  memset(&params, 0, sizeof(params));
3662  params.size = &result;
3663  params.fontIndex = fontIndex;
3664 
3665  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
3666  {
3667  return 0;
3668  }
3669  else
3670  {
3671  return result;
3672  }
3673  }
3674 
3675 
3676 
3677  typedef struct
3678  {
3679  OrthancPluginImage* image;
3680  uint32_t fontIndex;
3681  const char* utf8Text;
3682  int32_t x;
3683  int32_t y;
3684  uint8_t r;
3685  uint8_t g;
3686  uint8_t b;
3687  } _OrthancPluginDrawText;
3688 
3689 
3708  OrthancPluginContext* context,
3709  OrthancPluginImage* image,
3710  uint32_t fontIndex,
3711  const char* utf8Text,
3712  int32_t x,
3713  int32_t y,
3714  uint8_t r,
3715  uint8_t g,
3716  uint8_t b)
3717  {
3718  _OrthancPluginDrawText params;
3719  memset(&params, 0, sizeof(params));
3720  params.image = image;
3721  params.fontIndex = fontIndex;
3722  params.utf8Text = utf8Text;
3723  params.x = x;
3724  params.y = y;
3725  params.r = r;
3726  params.g = g;
3727  params.b = b;
3728 
3729  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
3730  }
3731 
3732 
3733 
3734  typedef struct
3735  {
3736  OrthancPluginStorageArea* storageArea;
3737  const char* uuid;
3738  const void* content;
3739  uint64_t size;
3741  } _OrthancPluginStorageAreaCreate;
3742 
3743 
3760  OrthancPluginContext* context,
3761  OrthancPluginStorageArea* storageArea,
3762  const char* uuid,
3763  const void* content,
3764  uint64_t size,
3766  {
3767  _OrthancPluginStorageAreaCreate params;
3768  params.storageArea = storageArea;
3769  params.uuid = uuid;
3770  params.content = content;
3771  params.size = size;
3772  params.type = type;
3773 
3774  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
3775  }
3776 
3777 
3778  typedef struct
3779  {
3780  OrthancPluginMemoryBuffer* target;
3781  OrthancPluginStorageArea* storageArea;
3782  const char* uuid;
3784  } _OrthancPluginStorageAreaRead;
3785 
3786 
3802  OrthancPluginContext* context,
3803  OrthancPluginMemoryBuffer* target,
3804  OrthancPluginStorageArea* storageArea,
3805  const char* uuid,
3807  {
3808  _OrthancPluginStorageAreaRead params;
3809  params.target = target;
3810  params.storageArea = storageArea;
3811  params.uuid = uuid;
3812  params.type = type;
3813 
3814  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
3815  }
3816 
3817 
3818  typedef struct
3819  {
3820  OrthancPluginStorageArea* storageArea;
3821  const char* uuid;
3823  } _OrthancPluginStorageAreaRemove;
3824 
3839  OrthancPluginContext* context,
3840  OrthancPluginStorageArea* storageArea,
3841  const char* uuid,
3843  {
3844  _OrthancPluginStorageAreaRemove params;
3845  params.storageArea = storageArea;
3846  params.uuid = uuid;
3847  params.type = type;
3848 
3849  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
3850  }
3851 
3852 
3853 
3854  typedef struct
3855  {
3856  OrthancPluginErrorCode* target;
3857  int32_t code;
3858  uint16_t httpStatus;
3859  const char* message;
3860  } _OrthancPluginRegisterErrorCode;
3861 
3878  OrthancPluginContext* context,
3879  int32_t code,
3880  uint16_t httpStatus,
3881  const char* message)
3882  {
3883  OrthancPluginErrorCode target;
3884 
3885  _OrthancPluginRegisterErrorCode params;
3886  params.target = &target;
3887  params.code = code;
3888  params.httpStatus = httpStatus;
3889  params.message = message;
3890 
3891  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
3892  {
3893  return target;
3894  }
3895  else
3896  {
3897  /* There was an error while assigned the error. Use a generic code. */
3899  }
3900  }
3901 
3902 
3903 
3904  typedef struct
3905  {
3906  uint16_t group;
3907  uint16_t element;
3909  const char* name;
3910  uint32_t minMultiplicity;
3911  uint32_t maxMultiplicity;
3912  } _OrthancPluginRegisterDictionaryTag;
3913 
3933  OrthancPluginContext* context,
3934  uint16_t group,
3935  uint16_t element,
3937  const char* name,
3938  uint32_t minMultiplicity,
3939  uint32_t maxMultiplicity)
3940  {
3941  _OrthancPluginRegisterDictionaryTag params;
3942  params.group = group;
3943  params.element = element;
3944  params.vr = vr;
3945  params.name = name;
3946  params.minMultiplicity = minMultiplicity;
3947  params.maxMultiplicity = maxMultiplicity;
3948 
3949  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
3950  }
3951 
3952 
3953 
3954 
3955  typedef struct
3956  {
3957  OrthancPluginStorageArea* storageArea;
3959  } _OrthancPluginReconstructMainDicomTags;
3960 
3978  OrthancPluginContext* context,
3979  OrthancPluginStorageArea* storageArea,
3981  {
3982  _OrthancPluginReconstructMainDicomTags params;
3983  params.level = level;
3984  params.storageArea = storageArea;
3985 
3986  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
3987  }
3988 
3989 
3990  typedef struct
3991  {
3992  char** result;
3993  const char* instanceId;
3994  const char* buffer;
3995  uint32_t size;
3998  uint32_t maxStringLength;
3999  } _OrthancPluginDicomToJson;
4000 
4001 
4021  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4022  OrthancPluginContext* context,
4023  const char* buffer,
4024  uint32_t size,
4027  uint32_t maxStringLength)
4028  {
4029  char* result;
4030 
4031  _OrthancPluginDicomToJson params;
4032  memset(&params, 0, sizeof(params));
4033  params.result = &result;
4034  params.buffer = buffer;
4035  params.size = size;
4036  params.format = format;
4037  params.flags = flags;
4038  params.maxStringLength = maxStringLength;
4039 
4040  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
4041  {
4042  /* Error */
4043  return NULL;
4044  }
4045  else
4046  {
4047  return result;
4048  }
4049  }
4050 
4051 
4070  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
4071  OrthancPluginContext* context,
4072  const char* instanceId,
4075  uint32_t maxStringLength)
4076  {
4077  char* result;
4078 
4079  _OrthancPluginDicomToJson params;
4080  memset(&params, 0, sizeof(params));
4081  params.result = &result;
4082  params.instanceId = instanceId;
4083  params.format = format;
4084  params.flags = flags;
4085  params.maxStringLength = maxStringLength;
4086 
4087  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
4088  {
4089  /* Error */
4090  return NULL;
4091  }
4092  else
4093  {
4094  return result;
4095  }
4096  }
4097 
4098 
4099  typedef struct
4100  {
4101  OrthancPluginMemoryBuffer* target;
4102  const char* uri;
4103  uint32_t headersCount;
4104  const char* const* headersKeys;
4105  const char* const* headersValues;
4106  int32_t afterPlugins;
4107  } _OrthancPluginRestApiGet2;
4108 
4129  OrthancPluginContext* context,
4130  OrthancPluginMemoryBuffer* target,
4131  const char* uri,
4132  uint32_t headersCount,
4133  const char* const* headersKeys,
4134  const char* const* headersValues,
4135  int32_t afterPlugins)
4136  {
4137  _OrthancPluginRestApiGet2 params;
4138  params.target = target;
4139  params.uri = uri;
4140  params.headersCount = headersCount;
4141  params.headersKeys = headersKeys;
4142  params.headersValues = headersValues;
4143  params.afterPlugins = afterPlugins;
4144 
4145  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
4146  }
4147 
4148 
4149 
4150  typedef struct
4151  {
4153  } _OrthancPluginWorklistCallback;
4154 
4167  OrthancPluginContext* context,
4169  {
4170  _OrthancPluginWorklistCallback params;
4171  params.callback = callback;
4172 
4173  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
4174  }
4175 
4176 
4177 
4178  typedef struct
4179  {
4181  const OrthancPluginWorklistQuery* query;
4182  const void* dicom;
4183  uint32_t size;
4184  } _OrthancPluginWorklistAnswersOperation;
4185 
4202  OrthancPluginContext* context,
4204  const OrthancPluginWorklistQuery* query,
4205  const void* dicom,
4206  uint32_t size)
4207  {
4208  _OrthancPluginWorklistAnswersOperation params;
4209  params.answers = answers;
4210  params.query = query;
4211  params.dicom = dicom;
4212  params.size = size;
4213 
4214  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
4215  }
4216 
4217 
4232  OrthancPluginContext* context,
4234  {
4235  _OrthancPluginWorklistAnswersOperation params;
4236  params.answers = answers;
4237  params.query = NULL;
4238  params.dicom = NULL;
4239  params.size = 0;
4240 
4241  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
4242  }
4243 
4244 
4245  typedef struct
4246  {
4247  const OrthancPluginWorklistQuery* query;
4248  const void* dicom;
4249  uint32_t size;
4250  int32_t* isMatch;
4251  OrthancPluginMemoryBuffer* target;
4252  } _OrthancPluginWorklistQueryOperation;
4253 
4269  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
4270  OrthancPluginContext* context,
4271  const OrthancPluginWorklistQuery* query,
4272  const void* dicom,
4273  uint32_t size)
4274  {
4275  int32_t isMatch = 0;
4276 
4277  _OrthancPluginWorklistQueryOperation params;
4278  params.query = query;
4279  params.dicom = dicom;
4280  params.size = size;
4281  params.isMatch = &isMatch;
4282  params.target = NULL;
4283 
4284  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
4285  {
4286  return isMatch;
4287  }
4288  else
4289  {
4290  /* Error: Assume non-match */
4291  return 0;
4292  }
4293  }
4294 
4295 
4309  OrthancPluginContext* context,
4310  OrthancPluginMemoryBuffer* target,
4311  const OrthancPluginWorklistQuery* query)
4312  {
4313  _OrthancPluginWorklistQueryOperation params;
4314  params.query = query;
4315  params.dicom = NULL;
4316  params.size = 0;
4317  params.isMatch = NULL;
4318  params.target = target;
4319 
4320  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
4321  }
4322 
4323 
4335  OrthancPluginContext* context,
4336  OrthancPluginDicomInstance* instance)
4337  {
4339 
4340  _OrthancPluginAccessDicomInstance params;
4341  memset(&params, 0, sizeof(params));
4342  params.resultOrigin = &origin;
4343  params.instance = instance;
4344 
4345  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
4346  {
4347  /* Error */
4349  }
4350  else
4351  {
4352  return origin;
4353  }
4354  }
4355 
4356 
4357  typedef struct
4358  {
4359  OrthancPluginMemoryBuffer* target;
4360  const char* json;
4361  const OrthancPluginImage* pixelData;
4363  } _OrthancPluginCreateDicom;
4364 
4384  OrthancPluginContext* context,
4385  OrthancPluginMemoryBuffer* target,
4386  const char* json,
4387  const OrthancPluginImage* pixelData,
4389  {
4390  _OrthancPluginCreateDicom params;
4391  params.target = target;
4392  params.json = json;
4393  params.pixelData = pixelData;
4394  params.flags = flags;
4395 
4396  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
4397  }
4398 
4399 
4400  typedef struct
4401  {
4403  } _OrthancPluginDecodeImageCallback;
4404 
4417  OrthancPluginContext* context,
4419  {
4420  _OrthancPluginDecodeImageCallback params;
4421  params.callback = callback;
4422 
4423  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
4424  }
4425 
4426 
4427 
4428  typedef struct
4429  {
4430  OrthancPluginImage** target;
4431  OrthancPluginPixelFormat format;
4432  uint32_t width;
4433  uint32_t height;
4434  uint32_t pitch;
4435  void* buffer;
4436  const void* constBuffer;
4437  uint32_t bufferSize;
4438  uint32_t frameIndex;
4439  } _OrthancPluginCreateImage;
4440 
4441 
4455  OrthancPluginContext* context,
4456  OrthancPluginPixelFormat format,
4457  uint32_t width,
4458  uint32_t height)
4459  {
4460  OrthancPluginImage* target = NULL;
4461 
4462  _OrthancPluginCreateImage params;
4463  memset(&params, 0, sizeof(params));
4464  params.target = &target;
4465  params.format = format;
4466  params.width = width;
4467  params.height = height;
4468 
4469  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
4470  {
4471  return NULL;
4472  }
4473  else
4474  {
4475  return target;
4476  }
4477  }
4478 
4479 
4498  OrthancPluginContext* context,
4499  OrthancPluginPixelFormat format,
4500  uint32_t width,
4501  uint32_t height,
4502  uint32_t pitch,
4503  void* buffer)
4504  {
4505  OrthancPluginImage* target = NULL;
4506 
4507  _OrthancPluginCreateImage params;
4508  memset(&params, 0, sizeof(params));
4509  params.target = &target;
4510  params.format = format;
4511  params.width = width;
4512  params.height = height;
4513  params.pitch = pitch;
4514  params.buffer = buffer;
4515 
4516  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
4517  {
4518  return NULL;
4519  }
4520  else
4521  {
4522  return target;
4523  }
4524  }
4525 
4526 
4527 
4543  OrthancPluginContext* context,
4544  const void* buffer,
4545  uint32_t bufferSize,
4546  uint32_t frameIndex)
4547  {
4548  OrthancPluginImage* target = NULL;
4549 
4550  _OrthancPluginCreateImage params;
4551  memset(&params, 0, sizeof(params));
4552  params.target = &target;
4553  params.constBuffer = buffer;
4554  params.bufferSize = bufferSize;
4555  params.frameIndex = frameIndex;
4556 
4557  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
4558  {
4559  return NULL;
4560  }
4561  else
4562  {
4563  return target;
4564  }
4565  }
4566 
4567 
4568 
4569  typedef struct
4570  {
4571  char** result;
4572  const void* buffer;
4573  uint32_t size;
4574  } _OrthancPluginComputeHash;
4575 
4588  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
4589  OrthancPluginContext* context,
4590  const void* buffer,
4591  uint32_t size)
4592  {
4593  char* result;
4594 
4595  _OrthancPluginComputeHash params;
4596  params.result = &result;
4597  params.buffer = buffer;
4598  params.size = size;
4599 
4600  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
4601  {
4602  /* Error */
4603  return NULL;
4604  }
4605  else
4606  {
4607  return result;
4608  }
4609  }
4610 
4611 
4624  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
4625  OrthancPluginContext* context,
4626  const void* buffer,
4627  uint32_t size)
4628  {
4629  char* result;
4630 
4631  _OrthancPluginComputeHash params;
4632  params.result = &result;
4633  params.buffer = buffer;
4634  params.size = size;
4635 
4636  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
4637  {
4638  /* Error */
4639  return NULL;
4640  }
4641  else
4642  {
4643  return result;
4644  }
4645  }
4646 
4647 
4648 
4649  typedef struct
4650  {
4652  const char* name;
4653  } _OrthancPluginLookupDictionary;
4654 
4671  OrthancPluginContext* context,
4673  const char* name)
4674  {
4675  _OrthancPluginLookupDictionary params;
4676  params.target = target;
4677  params.name = name;
4678  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
4679  }
4680 
4681 
4682 
4683  typedef struct
4684  {
4685  OrthancPluginRestOutput* output;
4686  const char* answer;
4687  uint32_t answerSize;
4688  uint32_t headersCount;
4689  const char* const* headersKeys;
4690  const char* const* headersValues;
4691  } _OrthancPluginSendMultipartItem2;
4692 
4714  OrthancPluginContext* context,
4715  OrthancPluginRestOutput* output,
4716  const char* answer,
4717  uint32_t answerSize,
4718  uint32_t headersCount,
4719  const char* const* headersKeys,
4720  const char* const* headersValues)
4721  {
4722  _OrthancPluginSendMultipartItem2 params;
4723  params.output = output;
4724  params.answer = answer;
4725  params.answerSize = answerSize;
4726  params.headersCount = headersCount;
4727  params.headersKeys = headersKeys;
4728  params.headersValues = headersValues;
4729 
4730  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
4731  }
4732 
4733 
4734 #ifdef __cplusplus
4735 }
4736 #endif
4737 
4738 
Definition: OrthancCPlugin.h:633
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2002
Definition: OrthancCPlugin.h:732
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:2181
OrthancPluginChangeType
Definition: OrthancCPlugin.h:590
Definition: OrthancCPlugin.h:220
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:1865
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:782
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:1966
Definition: OrthancCPlugin.h:656
Definition: OrthancCPlugin.h:252
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:1151
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:4416
Definition: OrthancCPlugin.h:733
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:4231
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:1648
OrthancPluginContentType
Definition: OrthancCPlugin.h:559
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:1555
Definition: OrthancCPlugin.h:576
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:945
Definition: OrthancCPlugin.h:655
Definition: OrthancCPlugin.h:748
const char * OrthancPluginGetInstanceData(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2068
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:3250
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:3342
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:4269
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1014
Definition: OrthancCPlugin.h:244
Definition: OrthancCPlugin.h:190
Definition: OrthancCPlugin.h:242
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:743
Definition: OrthancCPlugin.h:653
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2035
Definition: OrthancCPlugin.h:267
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:523
Definition: OrthancCPlugin.h:605
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:716
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:4624
Definition: OrthancCPlugin.h:258
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:507
Definition: OrthancCPlugin.h:749
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:330
Definition: OrthancCPlugin.h:549
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:2267
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:1374
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:630
Definition: OrthancCPlugin.h:198
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:990
Definition: OrthancCPlugin.h:264
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:3622
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:872
Definition: OrthancCPlugin.h:209
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:4588
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:3547
Definition: OrthancCPlugin.h:265
Definition: OrthancCPlugin.h:599
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:3801
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:3582
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:2364
Definition: OrthancCPlugin.h:207
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:2406
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:547
Definition: OrthancCPlugin.h:700
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:698
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:4201
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:1911
Definition: OrthancCPlugin.h:617
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:1276
Definition: OrthancCPlugin.h:593
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:4166
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:4542
Definition: OrthancCPlugin.h:241
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:683
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:4670
Definition: OrthancCPlugin.h:685
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:3877
Definition: OrthancCPlugin.h:222
uint16_t group
Definition: OrthancCPlugin.h:973
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:3120
Definition: OrthancCPlugin.h:646
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:976
Definition: OrthancCPlugin.h:687
Definition: OrthancCPlugin.h:658
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:2219
Definition: OrthancCPlugin.h:632
Definition: OrthancCPlugin.h:234
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:805
Definition: OrthancCPlugin.h:226
Definition: OrthancCPlugin.h:561
Definition: OrthancCPlugin.h:597
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:1614
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:2652
Definition: OrthancCPlugin.h:257
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:515
Definition: OrthancCPlugin.h:255
Definition: OrthancCPlugin.h:201
OrthancPluginResourceType
Definition: OrthancCPlugin.h:573
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:3051
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:644
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:2685
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:2949
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:3163
Definition: OrthancCPlugin.h:260
Definition: OrthancCPlugin.h:648
Definition: OrthancCPlugin.h:204
Definition: OrthancCPlugin.h:578
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:829
Definition: OrthancCPlugin.h:251
Definition: OrthancCPlugin.h:618
Definition: OrthancCPlugin.h:651
Definition: OrthancCPlugin.h:268
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:2329
Definition: OrthancCPlugin.h:620
Definition: OrthancCPlugin.h:670
Definition: OrthancCPlugin.h:243
Color image in RGB24 format.
Definition: OrthancCPlugin.h:539
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:531
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:971
Definition: OrthancCPlugin.h:253
Definition: OrthancCPlugin.h:194
Definition: OrthancCPlugin.h:592
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:615
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:3472
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:4128
Definition: OrthancCPlugin.h:703
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:2985
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:3707
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3086
Definition: OrthancCPlugin.h:562
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:1333
Definition: OrthancCPlugin.h:273
Definition: OrthancCPlugin.h:279
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:977
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:861
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:2585
Definition: OrthancCPlugin.h:224
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:1888
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:1119
Definition: OrthancCPlugin.h:215
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:767
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:3654
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:2481
Definition: OrthancCPlugin.h:747
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1406
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:2896
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:360
Definition: OrthancCPlugin.h:598
Definition: OrthancCPlugin.h:702
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1103
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:888
Definition: OrthancCPlugin.h:664
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1533
Definition: OrthancCPlugin.h:668
Definition: OrthancCPlugin.h:577
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:2834
Definition: OrthancCPlugin.h:657
Definition: OrthancCPlugin.h:734
Definition: OrthancCPlugin.h:299
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:4454
Definition: OrthancCPlugin.h:659
Definition: OrthancCPlugin.h:229
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:2299
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:2515
OrthancPluginErrorCode OrthancPluginSendMultipartItem2(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues)
Send an item as a part of some HTTP multipart answer, with custom headers.
Definition: OrthancCPlugin.h:4713
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:926
Definition: OrthancCPlugin.h:686
Definition: OrthancCPlugin.h:238
Definition: OrthancCPlugin.h:276
Definition: OrthancCPlugin.h:297
Definition: OrthancCPlugin.h:600
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:3977
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:2619
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:3394
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:4497
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:4070
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:340
Definition: OrthancCPlugin.h:671
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:850
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:2142
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:2797
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:4383
Definition: OrthancCPlugin.h:232
Definition: OrthancCPlugin.h:634
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:1216
Definition: OrthancCPlugin.h:603
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:797
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:1579
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:2726
Definition: OrthancCPlugin.h:187
Definition: OrthancCPlugin.h:213
Definition: OrthancCPlugin.h:206
Definition: OrthancCPlugin.h:731
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:2437
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:3838
Definition: OrthancCPlugin.h:663
Definition: OrthancCPlugin.h:604
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:335
Definition: OrthancCPlugin.h:666
Definition: OrthancCPlugin.h:595
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:1680
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:4334
Definition: OrthancCPlugin.h:667
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:3205
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:975
uint16_t element
Definition: OrthancCPlugin.h:974
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:1820
Definition: OrthancCPlugin.h:602
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:2554
Definition: OrthancCPlugin.h:219
Definition: OrthancCPlugin.h:563
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:2755
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:813
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:2865
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:908
Definition: OrthancCPlugin.h:250
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:1715
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:772
Definition: OrthancCPlugin.h:745
Definition: OrthancCPlugin.h:230
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance received by Orthanc.
Definition: OrthancCPlugin.h:789
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:320
Definition: OrthancCPlugin.h:231
Definition: OrthancCPlugin.h:579
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:1135
Definition: OrthancCPlugin.h:652
Definition: OrthancCPlugin.h:236
Definition: OrthancCPlugin.h:672
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:729
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:821
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:1941
Definition: OrthancCPlugin.h:594
Definition: OrthancCPlugin.h:662
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2104
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:2459
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:1471
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:1244
Definition: OrthancCPlugin.h:596
Definition: OrthancCPlugin.h:665
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:3932
Definition: OrthancCPlugin.h:233
Definition: OrthancCPlugin.h:199
Definition: OrthancCPlugin.h:669
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:3431
Definition: OrthancCPlugin.h:649
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:1182
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:1750
Definition: OrthancCPlugin.h:661
Definition: OrthancCPlugin.h:647
Definition: OrthancCPlugin.h:191
Definition: OrthancCPlugin.h:575
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:1435
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:4021
Definition: OrthancCPlugin.h:746
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:840
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:1505
Definition: OrthancCPlugin.h:189
Definition: OrthancCPlugin.h:214
Definition: OrthancCPlugin.h:601
Definition: OrthancCPlugin.h:619
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:3759
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:3509
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:762
Definition: OrthancCPlugin.h:654
Definition: OrthancCPlugin.h:701
Definition: OrthancCPlugin.h:203
Definition: OrthancCPlugin.h:660
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:1785
Definition: OrthancCPlugin.h:193
Definition: OrthancCPlugin.h:650
Definition: OrthancCPlugin.h:259
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3018
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:3295
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:4308
Definition: OrthancCPlugin.h:216