Orthanc Plugin SDK  1.2.0
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1 
106 #pragma once
107 
108 
109 #include <stdio.h>
110 #include <string.h>
111 
112 #ifdef WIN32
113 #define ORTHANC_PLUGINS_API __declspec(dllexport)
114 #else
115 #define ORTHANC_PLUGINS_API
116 #endif
117 
118 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
119 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 2
120 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 0
121 
122 
123 
124 /********************************************************************
125  ** Check that function inlining is properly supported. The use of
126  ** inlining is required, to avoid the duplication of object code
127  ** between two compilation modules that would use the Orthanc Plugin
128  ** API.
129  ********************************************************************/
130 
131 /* If the auto-detection of the "inline" keyword below does not work
132  automatically and that your compiler is known to properly support
133  inlining, uncomment the following #define and adapt the definition
134  of "static inline". */
135 
136 /* #define ORTHANC_PLUGIN_INLINE static inline */
137 
138 #ifndef ORTHANC_PLUGIN_INLINE
139 # if __STDC_VERSION__ >= 199901L
140 /* This is C99 or above: http://predef.sourceforge.net/prestd.html */
141 # define ORTHANC_PLUGIN_INLINE static inline
142 # elif defined(__cplusplus)
143 /* This is C++ */
144 # define ORTHANC_PLUGIN_INLINE static inline
145 # elif defined(__GNUC__)
146 /* This is GCC running in C89 mode */
147 # define ORTHANC_PLUGIN_INLINE static __inline
148 # elif defined(_MSC_VER)
149 /* This is Visual Studio running in C89 mode */
150 # define ORTHANC_PLUGIN_INLINE static __inline
151 # else
152 # error Your compiler is not known to support the "inline" keyword
153 # endif
154 #endif
155 
156 
157 
158 /********************************************************************
159  ** Inclusion of standard libraries.
160  ********************************************************************/
161 
167 #include <stdint.h>
168 
169 #include <stdlib.h>
170 
171 
172 
173 /********************************************************************
174  ** Definition of the Orthanc Plugin API.
175  ********************************************************************/
176 
179 #ifdef __cplusplus
180 extern "C"
181 {
182 #endif
183 
187  typedef enum
188  {
285 
286  _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
288 
289 
294  ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
295 
296 
300  typedef enum
301  {
307  _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
309 
310 
315  typedef struct
316  {
321 
325  uint32_t groupsCount;
326 
330  const char* const* groups;
331 
335  uint32_t getCount;
336 
340  const char* const* getKeys;
341 
345  const char* const* getValues;
346 
350  const char* body;
351 
355  uint32_t bodySize;
356 
357 
358  /* --------------------------------------------------
359  New in version 0.8.1
360  -------------------------------------------------- */
361 
365  uint32_t headersCount;
366 
370  const char* const* headersKeys;
371 
375  const char* const* headersValues;
376 
378 
379 
380  typedef enum
381  {
382  /* Generic services */
383  _OrthancPluginService_LogInfo = 1,
384  _OrthancPluginService_LogWarning = 2,
385  _OrthancPluginService_LogError = 3,
386  _OrthancPluginService_GetOrthancPath = 4,
387  _OrthancPluginService_GetOrthancDirectory = 5,
388  _OrthancPluginService_GetConfigurationPath = 6,
389  _OrthancPluginService_SetPluginProperty = 7,
390  _OrthancPluginService_GetGlobalProperty = 8,
391  _OrthancPluginService_SetGlobalProperty = 9,
392  _OrthancPluginService_GetCommandLineArgumentsCount = 10,
393  _OrthancPluginService_GetCommandLineArgument = 11,
394  _OrthancPluginService_GetExpectedDatabaseVersion = 12,
395  _OrthancPluginService_GetConfiguration = 13,
396  _OrthancPluginService_BufferCompression = 14,
397  _OrthancPluginService_ReadFile = 15,
398  _OrthancPluginService_WriteFile = 16,
399  _OrthancPluginService_GetErrorDescription = 17,
400  _OrthancPluginService_CallHttpClient = 18,
401  _OrthancPluginService_RegisterErrorCode = 19,
402  _OrthancPluginService_RegisterDictionaryTag = 20,
403  _OrthancPluginService_DicomBufferToJson = 21,
404  _OrthancPluginService_DicomInstanceToJson = 22,
405  _OrthancPluginService_CreateDicom = 23,
406  _OrthancPluginService_ComputeMd5 = 24,
407  _OrthancPluginService_ComputeSha1 = 25,
408  _OrthancPluginService_LookupDictionary = 26,
409  _OrthancPluginService_CallHttpClient2 = 27,
410  _OrthancPluginService_GenerateUuid = 28,
411  _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
412 
413  /* Registration of callbacks */
414  _OrthancPluginService_RegisterRestCallback = 1000,
415  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
416  _OrthancPluginService_RegisterStorageArea = 1002,
417  _OrthancPluginService_RegisterOnChangeCallback = 1003,
418  _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
419  _OrthancPluginService_RegisterWorklistCallback = 1005,
420  _OrthancPluginService_RegisterDecodeImageCallback = 1006,
421  _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
422  _OrthancPluginService_RegisterFindCallback = 1008,
423  _OrthancPluginService_RegisterMoveCallback = 1009,
424 
425  /* Sending answers to REST calls */
426  _OrthancPluginService_AnswerBuffer = 2000,
427  _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
428  _OrthancPluginService_Redirect = 2002,
429  _OrthancPluginService_SendHttpStatusCode = 2003,
430  _OrthancPluginService_SendUnauthorized = 2004,
431  _OrthancPluginService_SendMethodNotAllowed = 2005,
432  _OrthancPluginService_SetCookie = 2006,
433  _OrthancPluginService_SetHttpHeader = 2007,
434  _OrthancPluginService_StartMultipartAnswer = 2008,
435  _OrthancPluginService_SendMultipartItem = 2009,
436  _OrthancPluginService_SendHttpStatus = 2010,
437  _OrthancPluginService_CompressAndAnswerImage = 2011,
438  _OrthancPluginService_SendMultipartItem2 = 2012,
439 
440  /* Access to the Orthanc database and API */
441  _OrthancPluginService_GetDicomForInstance = 3000,
442  _OrthancPluginService_RestApiGet = 3001,
443  _OrthancPluginService_RestApiPost = 3002,
444  _OrthancPluginService_RestApiDelete = 3003,
445  _OrthancPluginService_RestApiPut = 3004,
446  _OrthancPluginService_LookupPatient = 3005,
447  _OrthancPluginService_LookupStudy = 3006,
448  _OrthancPluginService_LookupSeries = 3007,
449  _OrthancPluginService_LookupInstance = 3008,
450  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
451  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
452  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
453  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
454  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
455  _OrthancPluginService_ReconstructMainDicomTags = 3014,
456  _OrthancPluginService_RestApiGet2 = 3015,
457 
458  /* Access to DICOM instances */
459  _OrthancPluginService_GetInstanceRemoteAet = 4000,
460  _OrthancPluginService_GetInstanceSize = 4001,
461  _OrthancPluginService_GetInstanceData = 4002,
462  _OrthancPluginService_GetInstanceJson = 4003,
463  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
464  _OrthancPluginService_HasInstanceMetadata = 4005,
465  _OrthancPluginService_GetInstanceMetadata = 4006,
466  _OrthancPluginService_GetInstanceOrigin = 4007,
467 
468  /* Services for plugins implementing a database back-end */
469  _OrthancPluginService_RegisterDatabaseBackend = 5000,
470  _OrthancPluginService_DatabaseAnswer = 5001,
471  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
472  _OrthancPluginService_StorageAreaCreate = 5003,
473  _OrthancPluginService_StorageAreaRead = 5004,
474  _OrthancPluginService_StorageAreaRemove = 5005,
475 
476  /* Primitives for handling images */
477  _OrthancPluginService_GetImagePixelFormat = 6000,
478  _OrthancPluginService_GetImageWidth = 6001,
479  _OrthancPluginService_GetImageHeight = 6002,
480  _OrthancPluginService_GetImagePitch = 6003,
481  _OrthancPluginService_GetImageBuffer = 6004,
482  _OrthancPluginService_UncompressImage = 6005,
483  _OrthancPluginService_FreeImage = 6006,
484  _OrthancPluginService_CompressImage = 6007,
485  _OrthancPluginService_ConvertPixelFormat = 6008,
486  _OrthancPluginService_GetFontsCount = 6009,
487  _OrthancPluginService_GetFontInfo = 6010,
488  _OrthancPluginService_DrawText = 6011,
489  _OrthancPluginService_CreateImage = 6012,
490  _OrthancPluginService_CreateImageAccessor = 6013,
491  _OrthancPluginService_DecodeDicomImage = 6014,
492 
493  /* Primitives for handling C-Find, C-Move and worklists */
494  _OrthancPluginService_WorklistAddAnswer = 7000,
495  _OrthancPluginService_WorklistMarkIncomplete = 7001,
496  _OrthancPluginService_WorklistIsMatch = 7002,
497  _OrthancPluginService_WorklistGetDicomQuery = 7003,
498  _OrthancPluginService_FindAddAnswer = 7004,
499  _OrthancPluginService_FindMarkIncomplete = 7005,
500  _OrthancPluginService_GetFindQuerySize = 7006,
501  _OrthancPluginService_GetFindQueryTag = 7007,
502  _OrthancPluginService_GetFindQueryTagName = 7008,
503  _OrthancPluginService_GetFindQueryValue = 7009,
504  _OrthancPluginService_CreateFindMatcher = 7010,
505  _OrthancPluginService_FreeFindMatcher = 7011,
506  _OrthancPluginService_FindMatcherIsMatch = 7012,
507 
508  _OrthancPluginService_INTERNAL = 0x7fffffff
509  } _OrthancPluginService;
510 
511 
512  typedef enum
513  {
514  _OrthancPluginProperty_Description = 1,
515  _OrthancPluginProperty_RootUri = 2,
516  _OrthancPluginProperty_OrthancExplorer = 3,
517 
518  _OrthancPluginProperty_INTERNAL = 0x7fffffff
519  } _OrthancPluginProperty;
520 
521 
522 
527  typedef enum
528  {
536 
544 
552 
560 
568 
571  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
573 
574 
575 
579  typedef enum
580  {
585  _OrthancPluginContentType_INTERNAL = 0x7fffffff
587 
588 
589 
593  typedef enum
594  {
601  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
603 
604 
605 
610  typedef enum
611  {
627  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
629 
630 
635  typedef enum
636  {
642  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
644 
645 
650  typedef enum
651  {
656  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
658 
659 
664  typedef enum
665  {
694  _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
696 
697 
703  typedef enum
704  {
709  _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
711 
712 
718  typedef enum
719  {
720  OrthancPluginDicomToJsonFlags_None = 0,
728  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
730 
731 
737  typedef enum
738  {
739  OrthancPluginCreateDicomFlags_None = 0,
743  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
745 
746 
751  typedef enum
752  {
758  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
760 
761 
765  typedef enum
766  {
773  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
775 
776 
784  typedef struct
785  {
789  void* data;
790 
794  uint32_t size;
796 
797 
798 
799 
804  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
805 
806 
807 
811  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
812 
813 
814 
819  typedef struct _OrthancPluginImage_t OrthancPluginImage;
820 
821 
822 
827  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
828 
829 
830 
835  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
836 
837 
838 
843  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
844 
845 
846 
851  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
852 
853 
854 
859  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
860 
861 
862 
867  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindMatcher;
868 
869 
870 
876  OrthancPluginRestOutput* output,
877  const char* url,
878  const OrthancPluginHttpRequest* request);
879 
880 
881 
887  OrthancPluginDicomInstance* instance,
888  const char* instanceId);
889 
890 
891 
897  OrthancPluginChangeType changeType,
898  OrthancPluginResourceType resourceType,
899  const char* resourceId);
900 
901 
902 
908  OrthancPluginImage** target,
909  const void* dicom,
910  const uint32_t size,
911  uint32_t frameIndex);
912 
913 
914 
918  typedef void (*OrthancPluginFree) (void* buffer);
919 
920 
921 
935  const char* uuid,
936  const void* content,
937  int64_t size,
939 
940 
941 
955  void** content,
956  int64_t* size,
957  const char* uuid,
959 
960 
961 
973  const char* uuid,
975 
976 
977 
993  const OrthancPluginWorklistQuery* query,
994  const char* issuerAet,
995  const char* calledAet);
996 
997 
998 
1018  OrthancPluginHttpMethod method,
1019  const char* uri,
1020  const char* ip,
1021  uint32_t headersCount,
1022  const char* const* headersKeys,
1023  const char* const* headersValues);
1024 
1025 
1026 
1042  OrthancPluginFindAnswers* answers,
1043  const OrthancPluginFindQuery* query,
1044  const char* issuerAet,
1045  const char* calledAet);
1046 
1047 
1048 
1084  typedef void* (*OrthancPluginMoveCallback) (
1085  OrthancPluginResourceType resourceType,
1086  const char* patientId,
1087  const char* accessionNumber,
1088  const char* studyInstanceUid,
1089  const char* seriesInstanceUid,
1090  const char* sopInstanceUid,
1091  const char* originatorAet,
1092  const char* sourceAet,
1093  const char* targetAet,
1094  uint16_t originatorId);
1095 
1096 
1108  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1109 
1110 
1122  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1123 
1124 
1135  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1136 
1137 
1138 
1142  typedef struct _OrthancPluginContext_t
1143  {
1144  void* pluginsManager;
1145  const char* orthancVersion;
1146  OrthancPluginFree Free;
1147  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1148  _OrthancPluginService service,
1149  const void* params);
1151 
1152 
1153 
1157  typedef struct
1158  {
1159  uint16_t group;
1160  uint16_t element;
1162  uint32_t minMultiplicity;
1163  uint32_t maxMultiplicity;
1165 
1166 
1167 
1176  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1177  OrthancPluginContext* context,
1178  char* str)
1179  {
1180  if (str != NULL)
1181  {
1182  context->Free(str);
1183  }
1184  }
1185 
1186 
1200  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1201  OrthancPluginContext* context)
1202  {
1203  int major, minor, revision;
1204 
1205  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1206  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1207  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1208  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1209  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1210  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1211  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1212  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1213  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1214  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1215  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1216  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1217  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1218  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1219  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1220  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin))
1221  {
1222  /* Mismatch in the size of the enumerations */
1223  return 0;
1224  }
1225 
1226  /* Assume compatibility with the mainline */
1227  if (!strcmp(context->orthancVersion, "mainline"))
1228  {
1229  return 1;
1230  }
1231 
1232  /* Parse the version of the Orthanc core */
1233  if (
1234 #ifdef _MSC_VER
1235  sscanf_s
1236 #else
1237  sscanf
1238 #endif
1239  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1240  {
1241  return 0;
1242  }
1243 
1244  /* Check the major number of the version */
1245 
1246  if (major > ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
1247  {
1248  return 1;
1249  }
1250 
1251  if (major < ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
1252  {
1253  return 0;
1254  }
1255 
1256  /* Check the minor number of the version */
1257 
1258  if (minor > ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
1259  {
1260  return 1;
1261  }
1262 
1263  if (minor < ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
1264  {
1265  return 0;
1266  }
1267 
1268  /* Check the revision number of the version */
1269 
1270  if (revision >= ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER)
1271  {
1272  return 1;
1273  }
1274  else
1275  {
1276  return 0;
1277  }
1278  }
1279 
1280 
1289  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1290  OrthancPluginContext* context,
1291  OrthancPluginMemoryBuffer* buffer)
1292  {
1293  context->Free(buffer->data);
1294  }
1295 
1296 
1305  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1306  OrthancPluginContext* context,
1307  const char* message)
1308  {
1309  context->InvokeService(context, _OrthancPluginService_LogError, message);
1310  }
1311 
1312 
1321  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
1322  OrthancPluginContext* context,
1323  const char* message)
1324  {
1325  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1326  }
1327 
1328 
1337  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
1338  OrthancPluginContext* context,
1339  const char* message)
1340  {
1341  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
1342  }
1343 
1344 
1345 
1346  typedef struct
1347  {
1348  const char* pathRegularExpression;
1349  OrthancPluginRestCallback callback;
1350  } _OrthancPluginRestCallback;
1351 
1368  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
1369  OrthancPluginContext* context,
1370  const char* pathRegularExpression,
1371  OrthancPluginRestCallback callback)
1372  {
1373  _OrthancPluginRestCallback params;
1374  params.pathRegularExpression = pathRegularExpression;
1375  params.callback = callback;
1376  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
1377  }
1378 
1379 
1380 
1402  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
1403  OrthancPluginContext* context,
1404  const char* pathRegularExpression,
1405  OrthancPluginRestCallback callback)
1406  {
1407  _OrthancPluginRestCallback params;
1408  params.pathRegularExpression = pathRegularExpression;
1409  params.callback = callback;
1410  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
1411  }
1412 
1413 
1414 
1415  typedef struct
1416  {
1418  } _OrthancPluginOnStoredInstanceCallback;
1419 
1431  OrthancPluginContext* context,
1433  {
1434  _OrthancPluginOnStoredInstanceCallback params;
1435  params.callback = callback;
1436 
1437  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
1438  }
1439 
1440 
1441 
1442  typedef struct
1443  {
1444  OrthancPluginRestOutput* output;
1445  const char* answer;
1446  uint32_t answerSize;
1447  const char* mimeType;
1448  } _OrthancPluginAnswerBuffer;
1449 
1462  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
1463  OrthancPluginContext* context,
1464  OrthancPluginRestOutput* output,
1465  const char* answer,
1466  uint32_t answerSize,
1467  const char* mimeType)
1468  {
1469  _OrthancPluginAnswerBuffer params;
1470  params.output = output;
1471  params.answer = answer;
1472  params.answerSize = answerSize;
1473  params.mimeType = mimeType;
1474  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
1475  }
1476 
1477 
1478  typedef struct
1479  {
1480  OrthancPluginRestOutput* output;
1481  OrthancPluginPixelFormat format;
1482  uint32_t width;
1483  uint32_t height;
1484  uint32_t pitch;
1485  const void* buffer;
1486  } _OrthancPluginCompressAndAnswerPngImage;
1487 
1488  typedef struct
1489  {
1490  OrthancPluginRestOutput* output;
1491  OrthancPluginImageFormat imageFormat;
1492  OrthancPluginPixelFormat pixelFormat;
1493  uint32_t width;
1494  uint32_t height;
1495  uint32_t pitch;
1496  const void* buffer;
1497  uint8_t quality;
1498  } _OrthancPluginCompressAndAnswerImage;
1499 
1500 
1519  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
1520  OrthancPluginContext* context,
1521  OrthancPluginRestOutput* output,
1522  OrthancPluginPixelFormat format,
1523  uint32_t width,
1524  uint32_t height,
1525  uint32_t pitch,
1526  const void* buffer)
1527  {
1528  _OrthancPluginCompressAndAnswerImage params;
1529  params.output = output;
1530  params.imageFormat = OrthancPluginImageFormat_Png;
1531  params.pixelFormat = format;
1532  params.width = width;
1533  params.height = height;
1534  params.pitch = pitch;
1535  params.buffer = buffer;
1536  params.quality = 0; /* No quality for PNG */
1537  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
1538  }
1539 
1540 
1541 
1542  typedef struct
1543  {
1544  OrthancPluginMemoryBuffer* target;
1545  const char* instanceId;
1546  } _OrthancPluginGetDicomForInstance;
1547 
1561  OrthancPluginContext* context,
1562  OrthancPluginMemoryBuffer* target,
1563  const char* instanceId)
1564  {
1565  _OrthancPluginGetDicomForInstance params;
1566  params.target = target;
1567  params.instanceId = instanceId;
1568  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
1569  }
1570 
1571 
1572 
1573  typedef struct
1574  {
1575  OrthancPluginMemoryBuffer* target;
1576  const char* uri;
1577  } _OrthancPluginRestApiGet;
1578 
1594  OrthancPluginContext* context,
1595  OrthancPluginMemoryBuffer* target,
1596  const char* uri)
1597  {
1598  _OrthancPluginRestApiGet params;
1599  params.target = target;
1600  params.uri = uri;
1601  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
1602  }
1603 
1604 
1605 
1624  OrthancPluginContext* context,
1625  OrthancPluginMemoryBuffer* target,
1626  const char* uri)
1627  {
1628  _OrthancPluginRestApiGet params;
1629  params.target = target;
1630  params.uri = uri;
1631  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
1632  }
1633 
1634 
1635 
1636  typedef struct
1637  {
1638  OrthancPluginMemoryBuffer* target;
1639  const char* uri;
1640  const char* body;
1641  uint32_t bodySize;
1642  } _OrthancPluginRestApiPostPut;
1643 
1661  OrthancPluginContext* context,
1662  OrthancPluginMemoryBuffer* target,
1663  const char* uri,
1664  const char* body,
1665  uint32_t bodySize)
1666  {
1667  _OrthancPluginRestApiPostPut params;
1668  params.target = target;
1669  params.uri = uri;
1670  params.body = body;
1671  params.bodySize = bodySize;
1672  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
1673  }
1674 
1675 
1696  OrthancPluginContext* context,
1697  OrthancPluginMemoryBuffer* target,
1698  const char* uri,
1699  const char* body,
1700  uint32_t bodySize)
1701  {
1702  _OrthancPluginRestApiPostPut params;
1703  params.target = target;
1704  params.uri = uri;
1705  params.body = body;
1706  params.bodySize = bodySize;
1707  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
1708  }
1709 
1710 
1711 
1725  OrthancPluginContext* context,
1726  const char* uri)
1727  {
1728  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
1729  }
1730 
1731 
1748  OrthancPluginContext* context,
1749  const char* uri)
1750  {
1751  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
1752  }
1753 
1754 
1755 
1773  OrthancPluginContext* context,
1774  OrthancPluginMemoryBuffer* target,
1775  const char* uri,
1776  const char* body,
1777  uint32_t bodySize)
1778  {
1779  _OrthancPluginRestApiPostPut params;
1780  params.target = target;
1781  params.uri = uri;
1782  params.body = body;
1783  params.bodySize = bodySize;
1784  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
1785  }
1786 
1787 
1788 
1809  OrthancPluginContext* context,
1810  OrthancPluginMemoryBuffer* target,
1811  const char* uri,
1812  const char* body,
1813  uint32_t bodySize)
1814  {
1815  _OrthancPluginRestApiPostPut params;
1816  params.target = target;
1817  params.uri = uri;
1818  params.body = body;
1819  params.bodySize = bodySize;
1820  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
1821  }
1822 
1823 
1824 
1825  typedef struct
1826  {
1827  OrthancPluginRestOutput* output;
1828  const char* argument;
1829  } _OrthancPluginOutputPlusArgument;
1830 
1842  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
1843  OrthancPluginContext* context,
1844  OrthancPluginRestOutput* output,
1845  const char* redirection)
1846  {
1847  _OrthancPluginOutputPlusArgument params;
1848  params.output = output;
1849  params.argument = redirection;
1850  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
1851  }
1852 
1853 
1854 
1855  typedef struct
1856  {
1857  char** result;
1858  const char* argument;
1859  } _OrthancPluginRetrieveDynamicString;
1860 
1874  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
1875  OrthancPluginContext* context,
1876  const char* patientID)
1877  {
1878  char* result;
1879 
1880  _OrthancPluginRetrieveDynamicString params;
1881  params.result = &result;
1882  params.argument = patientID;
1883 
1884  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
1885  {
1886  /* Error */
1887  return NULL;
1888  }
1889  else
1890  {
1891  return result;
1892  }
1893  }
1894 
1895 
1909  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
1910  OrthancPluginContext* context,
1911  const char* studyUID)
1912  {
1913  char* result;
1914 
1915  _OrthancPluginRetrieveDynamicString params;
1916  params.result = &result;
1917  params.argument = studyUID;
1918 
1919  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
1920  {
1921  /* Error */
1922  return NULL;
1923  }
1924  else
1925  {
1926  return result;
1927  }
1928  }
1929 
1930 
1944  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
1945  OrthancPluginContext* context,
1946  const char* accessionNumber)
1947  {
1948  char* result;
1949 
1950  _OrthancPluginRetrieveDynamicString params;
1951  params.result = &result;
1952  params.argument = accessionNumber;
1953 
1954  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
1955  {
1956  /* Error */
1957  return NULL;
1958  }
1959  else
1960  {
1961  return result;
1962  }
1963  }
1964 
1965 
1979  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
1980  OrthancPluginContext* context,
1981  const char* seriesUID)
1982  {
1983  char* result;
1984 
1985  _OrthancPluginRetrieveDynamicString params;
1986  params.result = &result;
1987  params.argument = seriesUID;
1988 
1989  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
1990  {
1991  /* Error */
1992  return NULL;
1993  }
1994  else
1995  {
1996  return result;
1997  }
1998  }
1999 
2000 
2014  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2015  OrthancPluginContext* context,
2016  const char* sopInstanceUID)
2017  {
2018  char* result;
2019 
2020  _OrthancPluginRetrieveDynamicString params;
2021  params.result = &result;
2022  params.argument = sopInstanceUID;
2023 
2024  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2025  {
2026  /* Error */
2027  return NULL;
2028  }
2029  else
2030  {
2031  return result;
2032  }
2033  }
2034 
2035 
2036 
2037  typedef struct
2038  {
2039  OrthancPluginRestOutput* output;
2040  uint16_t status;
2041  } _OrthancPluginSendHttpStatusCode;
2042 
2059  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2060  OrthancPluginContext* context,
2061  OrthancPluginRestOutput* output,
2062  uint16_t status)
2063  {
2064  _OrthancPluginSendHttpStatusCode params;
2065  params.output = output;
2066  params.status = status;
2067  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2068  }
2069 
2070 
2082  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2083  OrthancPluginContext* context,
2084  OrthancPluginRestOutput* output,
2085  const char* realm)
2086  {
2087  _OrthancPluginOutputPlusArgument params;
2088  params.output = output;
2089  params.argument = realm;
2090  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2091  }
2092 
2093 
2105  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2106  OrthancPluginContext* context,
2107  OrthancPluginRestOutput* output,
2108  const char* allowedMethods)
2109  {
2110  _OrthancPluginOutputPlusArgument params;
2111  params.output = output;
2112  params.argument = allowedMethods;
2113  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2114  }
2115 
2116 
2117  typedef struct
2118  {
2119  OrthancPluginRestOutput* output;
2120  const char* key;
2121  const char* value;
2122  } _OrthancPluginSetHttpHeader;
2123 
2135  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2136  OrthancPluginContext* context,
2137  OrthancPluginRestOutput* output,
2138  const char* cookie,
2139  const char* value)
2140  {
2141  _OrthancPluginSetHttpHeader params;
2142  params.output = output;
2143  params.key = cookie;
2144  params.value = value;
2145  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2146  }
2147 
2148 
2160  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2161  OrthancPluginContext* context,
2162  OrthancPluginRestOutput* output,
2163  const char* key,
2164  const char* value)
2165  {
2166  _OrthancPluginSetHttpHeader params;
2167  params.output = output;
2168  params.key = key;
2169  params.value = value;
2170  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2171  }
2172 
2173 
2174  typedef struct
2175  {
2176  char** resultStringToFree;
2177  const char** resultString;
2178  int64_t* resultInt64;
2179  const char* key;
2180  OrthancPluginDicomInstance* instance;
2181  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2182  } _OrthancPluginAccessDicomInstance;
2183 
2184 
2196  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2197  OrthancPluginContext* context,
2198  OrthancPluginDicomInstance* instance)
2199  {
2200  const char* result;
2201 
2202  _OrthancPluginAccessDicomInstance params;
2203  memset(&params, 0, sizeof(params));
2204  params.resultString = &result;
2205  params.instance = instance;
2206 
2207  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2208  {
2209  /* Error */
2210  return NULL;
2211  }
2212  else
2213  {
2214  return result;
2215  }
2216  }
2217 
2218 
2229  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2230  OrthancPluginContext* context,
2231  OrthancPluginDicomInstance* instance)
2232  {
2233  int64_t size;
2234 
2235  _OrthancPluginAccessDicomInstance params;
2236  memset(&params, 0, sizeof(params));
2237  params.resultInt64 = &size;
2238  params.instance = instance;
2239 
2240  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2241  {
2242  /* Error */
2243  return -1;
2244  }
2245  else
2246  {
2247  return size;
2248  }
2249  }
2250 
2251 
2262  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceData(
2263  OrthancPluginContext* context,
2264  OrthancPluginDicomInstance* instance)
2265  {
2266  const char* result;
2267 
2268  _OrthancPluginAccessDicomInstance params;
2269  memset(&params, 0, sizeof(params));
2270  params.resultString = &result;
2271  params.instance = instance;
2272 
2273  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2274  {
2275  /* Error */
2276  return NULL;
2277  }
2278  else
2279  {
2280  return result;
2281  }
2282  }
2283 
2284 
2298  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
2299  OrthancPluginContext* context,
2300  OrthancPluginDicomInstance* instance)
2301  {
2302  char* result;
2303 
2304  _OrthancPluginAccessDicomInstance params;
2305  memset(&params, 0, sizeof(params));
2306  params.resultStringToFree = &result;
2307  params.instance = instance;
2308 
2309  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
2310  {
2311  /* Error */
2312  return NULL;
2313  }
2314  else
2315  {
2316  return result;
2317  }
2318  }
2319 
2320 
2336  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
2337  OrthancPluginContext* context,
2338  OrthancPluginDicomInstance* instance)
2339  {
2340  char* result;
2341 
2342  _OrthancPluginAccessDicomInstance params;
2343  memset(&params, 0, sizeof(params));
2344  params.resultStringToFree = &result;
2345  params.instance = instance;
2346 
2347  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
2348  {
2349  /* Error */
2350  return NULL;
2351  }
2352  else
2353  {
2354  return result;
2355  }
2356  }
2357 
2358 
2375  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
2376  OrthancPluginContext* context,
2377  OrthancPluginDicomInstance* instance,
2378  const char* metadata)
2379  {
2380  int64_t result;
2381 
2382  _OrthancPluginAccessDicomInstance params;
2383  memset(&params, 0, sizeof(params));
2384  params.resultInt64 = &result;
2385  params.instance = instance;
2386  params.key = metadata;
2387 
2388  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2389  {
2390  /* Error */
2391  return -1;
2392  }
2393  else
2394  {
2395  return (result != 0);
2396  }
2397  }
2398 
2399 
2413  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
2414  OrthancPluginContext* context,
2415  OrthancPluginDicomInstance* instance,
2416  const char* metadata)
2417  {
2418  const char* result;
2419 
2420  _OrthancPluginAccessDicomInstance params;
2421  memset(&params, 0, sizeof(params));
2422  params.resultString = &result;
2423  params.instance = instance;
2424  params.key = metadata;
2425 
2426  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2427  {
2428  /* Error */
2429  return NULL;
2430  }
2431  else
2432  {
2433  return result;
2434  }
2435  }
2436 
2437 
2438 
2439  typedef struct
2440  {
2444  OrthancPluginFree free;
2445  } _OrthancPluginRegisterStorageArea;
2446 
2461  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
2462  OrthancPluginContext* context,
2466  {
2467  _OrthancPluginRegisterStorageArea params;
2468  params.create = create;
2469  params.read = read;
2470  params.remove = remove;
2471 
2472 #ifdef __cplusplus
2473  params.free = ::free;
2474 #else
2475  params.free = free;
2476 #endif
2477 
2478  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
2479  }
2480 
2481 
2482 
2493  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
2494  {
2495  char* result;
2496 
2497  _OrthancPluginRetrieveDynamicString params;
2498  params.result = &result;
2499  params.argument = NULL;
2500 
2501  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
2502  {
2503  /* Error */
2504  return NULL;
2505  }
2506  else
2507  {
2508  return result;
2509  }
2510  }
2511 
2512 
2523  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
2524  {
2525  char* result;
2526 
2527  _OrthancPluginRetrieveDynamicString params;
2528  params.result = &result;
2529  params.argument = NULL;
2530 
2531  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
2532  {
2533  /* Error */
2534  return NULL;
2535  }
2536  else
2537  {
2538  return result;
2539  }
2540  }
2541 
2542 
2558  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
2559  {
2560  char* result;
2561 
2562  _OrthancPluginRetrieveDynamicString params;
2563  params.result = &result;
2564  params.argument = NULL;
2565 
2566  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
2567  {
2568  /* Error */
2569  return NULL;
2570  }
2571  else
2572  {
2573  return result;
2574  }
2575  }
2576 
2577 
2578 
2579  typedef struct
2580  {
2582  } _OrthancPluginOnChangeCallback;
2583 
2600  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
2601  OrthancPluginContext* context,
2603  {
2604  _OrthancPluginOnChangeCallback params;
2605  params.callback = callback;
2606 
2607  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
2608  }
2609 
2610 
2611 
2612  typedef struct
2613  {
2614  const char* plugin;
2615  _OrthancPluginProperty property;
2616  const char* value;
2617  } _OrthancPluginSetPluginProperty;
2618 
2619 
2631  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
2632  OrthancPluginContext* context,
2633  const char* uri)
2634  {
2635  _OrthancPluginSetPluginProperty params;
2636  params.plugin = OrthancPluginGetName();
2637  params.property = _OrthancPluginProperty_RootUri;
2638  params.value = uri;
2639 
2640  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2641  }
2642 
2643 
2653  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
2654  OrthancPluginContext* context,
2655  const char* description)
2656  {
2657  _OrthancPluginSetPluginProperty params;
2658  params.plugin = OrthancPluginGetName();
2659  params.property = _OrthancPluginProperty_Description;
2660  params.value = description;
2661 
2662  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2663  }
2664 
2665 
2675  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
2676  OrthancPluginContext* context,
2677  const char* javascript)
2678  {
2679  _OrthancPluginSetPluginProperty params;
2680  params.plugin = OrthancPluginGetName();
2681  params.property = _OrthancPluginProperty_OrthancExplorer;
2682  params.value = javascript;
2683 
2684  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2685  }
2686 
2687 
2688  typedef struct
2689  {
2690  char** result;
2691  int32_t property;
2692  const char* value;
2693  } _OrthancPluginGlobalProperty;
2694 
2695 
2709  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
2710  OrthancPluginContext* context,
2711  int32_t property,
2712  const char* defaultValue)
2713  {
2714  char* result;
2715 
2716  _OrthancPluginGlobalProperty params;
2717  params.result = &result;
2718  params.property = property;
2719  params.value = defaultValue;
2720 
2721  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
2722  {
2723  /* Error */
2724  return NULL;
2725  }
2726  else
2727  {
2728  return result;
2729  }
2730  }
2731 
2732 
2749  OrthancPluginContext* context,
2750  int32_t property,
2751  const char* value)
2752  {
2753  _OrthancPluginGlobalProperty params;
2754  params.result = NULL;
2755  params.property = property;
2756  params.value = value;
2757 
2758  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
2759  }
2760 
2761 
2762 
2763  typedef struct
2764  {
2765  int32_t *resultInt32;
2766  uint32_t *resultUint32;
2767  int64_t *resultInt64;
2768  uint64_t *resultUint64;
2769  } _OrthancPluginReturnSingleValue;
2770 
2779  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
2780  OrthancPluginContext* context)
2781  {
2782  uint32_t count = 0;
2783 
2784  _OrthancPluginReturnSingleValue params;
2785  memset(&params, 0, sizeof(params));
2786  params.resultUint32 = &count;
2787 
2788  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
2789  {
2790  /* Error */
2791  return 0;
2792  }
2793  else
2794  {
2795  return count;
2796  }
2797  }
2798 
2799 
2800 
2813  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
2814  OrthancPluginContext* context,
2815  uint32_t argument)
2816  {
2817  char* result;
2818 
2819  _OrthancPluginGlobalProperty params;
2820  params.result = &result;
2821  params.property = (int32_t) argument;
2822  params.value = NULL;
2823 
2824  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
2825  {
2826  /* Error */
2827  return NULL;
2828  }
2829  else
2830  {
2831  return result;
2832  }
2833  }
2834 
2835 
2846  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
2847  OrthancPluginContext* context)
2848  {
2849  uint32_t count = 0;
2850 
2851  _OrthancPluginReturnSingleValue params;
2852  memset(&params, 0, sizeof(params));
2853  params.resultUint32 = &count;
2854 
2855  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
2856  {
2857  /* Error */
2858  return 0;
2859  }
2860  else
2861  {
2862  return count;
2863  }
2864  }
2865 
2866 
2867 
2879  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
2880  {
2881  char* result;
2882 
2883  _OrthancPluginRetrieveDynamicString params;
2884  params.result = &result;
2885  params.argument = NULL;
2886 
2887  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
2888  {
2889  /* Error */
2890  return NULL;
2891  }
2892  else
2893  {
2894  return result;
2895  }
2896  }
2897 
2898 
2899 
2900  typedef struct
2901  {
2902  OrthancPluginRestOutput* output;
2903  const char* subType;
2904  const char* contentType;
2905  } _OrthancPluginStartMultipartAnswer;
2906 
2921  OrthancPluginContext* context,
2922  OrthancPluginRestOutput* output,
2923  const char* subType,
2924  const char* contentType)
2925  {
2926  _OrthancPluginStartMultipartAnswer params;
2927  params.output = output;
2928  params.subType = subType;
2929  params.contentType = contentType;
2930  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
2931  }
2932 
2933 
2950  OrthancPluginContext* context,
2951  OrthancPluginRestOutput* output,
2952  const char* answer,
2953  uint32_t answerSize)
2954  {
2955  _OrthancPluginAnswerBuffer params;
2956  params.output = output;
2957  params.answer = answer;
2958  params.answerSize = answerSize;
2959  params.mimeType = NULL;
2960  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
2961  }
2962 
2963 
2964 
2965  typedef struct
2966  {
2967  OrthancPluginMemoryBuffer* target;
2968  const void* source;
2969  uint32_t size;
2970  OrthancPluginCompressionType compression;
2971  uint8_t uncompress;
2972  } _OrthancPluginBufferCompression;
2973 
2974 
2992  OrthancPluginContext* context,
2993  OrthancPluginMemoryBuffer* target,
2994  const void* source,
2995  uint32_t size,
2996  OrthancPluginCompressionType compression,
2997  uint8_t uncompress)
2998  {
2999  _OrthancPluginBufferCompression params;
3000  params.target = target;
3001  params.source = source;
3002  params.size = size;
3003  params.compression = compression;
3004  params.uncompress = uncompress;
3005 
3006  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3007  }
3008 
3009 
3010 
3011  typedef struct
3012  {
3013  OrthancPluginMemoryBuffer* target;
3014  const char* path;
3015  } _OrthancPluginReadFile;
3016 
3029  OrthancPluginContext* context,
3030  OrthancPluginMemoryBuffer* target,
3031  const char* path)
3032  {
3033  _OrthancPluginReadFile params;
3034  params.target = target;
3035  params.path = path;
3036  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3037  }
3038 
3039 
3040 
3041  typedef struct
3042  {
3043  const char* path;
3044  const void* data;
3045  uint32_t size;
3046  } _OrthancPluginWriteFile;
3047 
3060  OrthancPluginContext* context,
3061  const char* path,
3062  const void* data,
3063  uint32_t size)
3064  {
3065  _OrthancPluginWriteFile params;
3066  params.path = path;
3067  params.data = data;
3068  params.size = size;
3069  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3070  }
3071 
3072 
3073 
3074  typedef struct
3075  {
3076  const char** target;
3077  OrthancPluginErrorCode error;
3078  } _OrthancPluginGetErrorDescription;
3079 
3090  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3091  OrthancPluginContext* context,
3092  OrthancPluginErrorCode error)
3093  {
3094  const char* result = NULL;
3095 
3096  _OrthancPluginGetErrorDescription params;
3097  params.target = &result;
3098  params.error = error;
3099 
3100  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3101  result == NULL)
3102  {
3103  return "Unknown error code";
3104  }
3105  else
3106  {
3107  return result;
3108  }
3109  }
3110 
3111 
3112 
3113  typedef struct
3114  {
3115  OrthancPluginRestOutput* output;
3116  uint16_t status;
3117  const char* body;
3118  uint32_t bodySize;
3119  } _OrthancPluginSendHttpStatus;
3120 
3143  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3144  OrthancPluginContext* context,
3145  OrthancPluginRestOutput* output,
3146  uint16_t status,
3147  const char* body,
3148  uint32_t bodySize)
3149  {
3150  _OrthancPluginSendHttpStatus params;
3151  params.output = output;
3152  params.status = status;
3153  params.body = body;
3154  params.bodySize = bodySize;
3155  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3156  }
3157 
3158 
3159 
3160  typedef struct
3161  {
3162  const OrthancPluginImage* image;
3163  uint32_t* resultUint32;
3164  OrthancPluginPixelFormat* resultPixelFormat;
3165  void** resultBuffer;
3166  } _OrthancPluginGetImageInfo;
3167 
3168 
3180  OrthancPluginContext* context,
3181  const OrthancPluginImage* image)
3182  {
3183  OrthancPluginPixelFormat target;
3184 
3185  _OrthancPluginGetImageInfo params;
3186  memset(&params, 0, sizeof(params));
3187  params.image = image;
3188  params.resultPixelFormat = &target;
3189 
3190  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3191  {
3193  }
3194  else
3195  {
3196  return (OrthancPluginPixelFormat) target;
3197  }
3198  }
3199 
3200 
3201 
3212  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3213  OrthancPluginContext* context,
3214  const OrthancPluginImage* image)
3215  {
3216  uint32_t width;
3217 
3218  _OrthancPluginGetImageInfo params;
3219  memset(&params, 0, sizeof(params));
3220  params.image = image;
3221  params.resultUint32 = &width;
3222 
3223  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3224  {
3225  return 0;
3226  }
3227  else
3228  {
3229  return width;
3230  }
3231  }
3232 
3233 
3234 
3245  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3246  OrthancPluginContext* context,
3247  const OrthancPluginImage* image)
3248  {
3249  uint32_t height;
3250 
3251  _OrthancPluginGetImageInfo params;
3252  memset(&params, 0, sizeof(params));
3253  params.image = image;
3254  params.resultUint32 = &height;
3255 
3256  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3257  {
3258  return 0;
3259  }
3260  else
3261  {
3262  return height;
3263  }
3264  }
3265 
3266 
3267 
3280  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3281  OrthancPluginContext* context,
3282  const OrthancPluginImage* image)
3283  {
3284  uint32_t pitch;
3285 
3286  _OrthancPluginGetImageInfo params;
3287  memset(&params, 0, sizeof(params));
3288  params.image = image;
3289  params.resultUint32 = &pitch;
3290 
3291  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
3292  {
3293  return 0;
3294  }
3295  else
3296  {
3297  return pitch;
3298  }
3299  }
3300 
3301 
3302 
3314  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
3315  OrthancPluginContext* context,
3316  const OrthancPluginImage* image)
3317  {
3318  void* target = NULL;
3319 
3320  _OrthancPluginGetImageInfo params;
3321  memset(&params, 0, sizeof(params));
3322  params.resultBuffer = &target;
3323  params.image = image;
3324 
3325  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
3326  {
3327  return NULL;
3328  }
3329  else
3330  {
3331  return target;
3332  }
3333  }
3334 
3335 
3336  typedef struct
3337  {
3338  OrthancPluginImage** target;
3339  const void* data;
3340  uint32_t size;
3341  OrthancPluginImageFormat format;
3342  } _OrthancPluginUncompressImage;
3343 
3344 
3358  OrthancPluginContext* context,
3359  const void* data,
3360  uint32_t size,
3361  OrthancPluginImageFormat format)
3362  {
3363  OrthancPluginImage* target = NULL;
3364 
3365  _OrthancPluginUncompressImage params;
3366  memset(&params, 0, sizeof(params));
3367  params.target = &target;
3368  params.data = data;
3369  params.size = size;
3370  params.format = format;
3371 
3372  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
3373  {
3374  return NULL;
3375  }
3376  else
3377  {
3378  return target;
3379  }
3380  }
3381 
3382 
3383 
3384 
3385  typedef struct
3386  {
3387  OrthancPluginImage* image;
3388  } _OrthancPluginFreeImage;
3389 
3399  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
3400  OrthancPluginContext* context,
3401  OrthancPluginImage* image)
3402  {
3403  _OrthancPluginFreeImage params;
3404  params.image = image;
3405 
3406  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
3407  }
3408 
3409 
3410 
3411 
3412  typedef struct
3413  {
3414  OrthancPluginMemoryBuffer* target;
3415  OrthancPluginImageFormat imageFormat;
3416  OrthancPluginPixelFormat pixelFormat;
3417  uint32_t width;
3418  uint32_t height;
3419  uint32_t pitch;
3420  const void* buffer;
3421  uint8_t quality;
3422  } _OrthancPluginCompressImage;
3423 
3424 
3445  OrthancPluginContext* context,
3446  OrthancPluginMemoryBuffer* target,
3447  OrthancPluginPixelFormat format,
3448  uint32_t width,
3449  uint32_t height,
3450  uint32_t pitch,
3451  const void* buffer)
3452  {
3453  _OrthancPluginCompressImage params;
3454  memset(&params, 0, sizeof(params));
3455  params.target = target;
3456  params.imageFormat = OrthancPluginImageFormat_Png;
3457  params.pixelFormat = format;
3458  params.width = width;
3459  params.height = height;
3460  params.pitch = pitch;
3461  params.buffer = buffer;
3462  params.quality = 0; /* Unused for PNG */
3463 
3464  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3465  }
3466 
3467 
3490  OrthancPluginContext* context,
3491  OrthancPluginMemoryBuffer* target,
3492  OrthancPluginPixelFormat format,
3493  uint32_t width,
3494  uint32_t height,
3495  uint32_t pitch,
3496  const void* buffer,
3497  uint8_t quality)
3498  {
3499  _OrthancPluginCompressImage params;
3500  memset(&params, 0, sizeof(params));
3501  params.target = target;
3502  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3503  params.pixelFormat = format;
3504  params.width = width;
3505  params.height = height;
3506  params.pitch = pitch;
3507  params.buffer = buffer;
3508  params.quality = quality;
3509 
3510  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3511  }
3512 
3513 
3514 
3536  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
3537  OrthancPluginContext* context,
3538  OrthancPluginRestOutput* output,
3539  OrthancPluginPixelFormat format,
3540  uint32_t width,
3541  uint32_t height,
3542  uint32_t pitch,
3543  const void* buffer,
3544  uint8_t quality)
3545  {
3546  _OrthancPluginCompressAndAnswerImage params;
3547  params.output = output;
3548  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3549  params.pixelFormat = format;
3550  params.width = width;
3551  params.height = height;
3552  params.pitch = pitch;
3553  params.buffer = buffer;
3554  params.quality = quality;
3555  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
3556  }
3557 
3558 
3559 
3560 
3561  typedef struct
3562  {
3563  OrthancPluginMemoryBuffer* target;
3564  OrthancPluginHttpMethod method;
3565  const char* url;
3566  const char* username;
3567  const char* password;
3568  const char* body;
3569  uint32_t bodySize;
3570  } _OrthancPluginCallHttpClient;
3571 
3572 
3589  OrthancPluginContext* context,
3590  OrthancPluginMemoryBuffer* target,
3591  const char* url,
3592  const char* username,
3593  const char* password)
3594  {
3595  _OrthancPluginCallHttpClient params;
3596  memset(&params, 0, sizeof(params));
3597 
3598  params.target = target;
3599  params.method = OrthancPluginHttpMethod_Get;
3600  params.url = url;
3601  params.username = username;
3602  params.password = password;
3603 
3604  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3605  }
3606 
3607 
3626  OrthancPluginContext* context,
3627  OrthancPluginMemoryBuffer* target,
3628  const char* url,
3629  const char* body,
3630  uint32_t bodySize,
3631  const char* username,
3632  const char* password)
3633  {
3634  _OrthancPluginCallHttpClient params;
3635  memset(&params, 0, sizeof(params));
3636 
3637  params.target = target;
3638  params.method = OrthancPluginHttpMethod_Post;
3639  params.url = url;
3640  params.body = body;
3641  params.bodySize = bodySize;
3642  params.username = username;
3643  params.password = password;
3644 
3645  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3646  }
3647 
3648 
3667  OrthancPluginContext* context,
3668  OrthancPluginMemoryBuffer* target,
3669  const char* url,
3670  const char* body,
3671  uint32_t bodySize,
3672  const char* username,
3673  const char* password)
3674  {
3675  _OrthancPluginCallHttpClient params;
3676  memset(&params, 0, sizeof(params));
3677 
3678  params.target = target;
3679  params.method = OrthancPluginHttpMethod_Put;
3680  params.url = url;
3681  params.body = body;
3682  params.bodySize = bodySize;
3683  params.username = username;
3684  params.password = password;
3685 
3686  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3687  }
3688 
3689 
3704  OrthancPluginContext* context,
3705  const char* url,
3706  const char* username,
3707  const char* password)
3708  {
3709  _OrthancPluginCallHttpClient params;
3710  memset(&params, 0, sizeof(params));
3711 
3712  params.method = OrthancPluginHttpMethod_Delete;
3713  params.url = url;
3714  params.username = username;
3715  params.password = password;
3716 
3717  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3718  }
3719 
3720 
3721 
3722  typedef struct
3723  {
3724  OrthancPluginImage** target;
3725  const OrthancPluginImage* source;
3726  OrthancPluginPixelFormat targetFormat;
3727  } _OrthancPluginConvertPixelFormat;
3728 
3729 
3742  OrthancPluginContext* context,
3743  const OrthancPluginImage* source,
3744  OrthancPluginPixelFormat targetFormat)
3745  {
3746  OrthancPluginImage* target = NULL;
3747 
3748  _OrthancPluginConvertPixelFormat params;
3749  params.target = &target;
3750  params.source = source;
3751  params.targetFormat = targetFormat;
3752 
3753  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
3754  {
3755  return NULL;
3756  }
3757  else
3758  {
3759  return target;
3760  }
3761  }
3762 
3763 
3764 
3776  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
3777  OrthancPluginContext* context)
3778  {
3779  uint32_t count = 0;
3780 
3781  _OrthancPluginReturnSingleValue params;
3782  memset(&params, 0, sizeof(params));
3783  params.resultUint32 = &count;
3784 
3785  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
3786  {
3787  /* Error */
3788  return 0;
3789  }
3790  else
3791  {
3792  return count;
3793  }
3794  }
3795 
3796 
3797 
3798 
3799  typedef struct
3800  {
3801  uint32_t fontIndex; /* in */
3802  const char** name; /* out */
3803  uint32_t* size; /* out */
3804  } _OrthancPluginGetFontInfo;
3805 
3816  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
3817  OrthancPluginContext* context,
3818  uint32_t fontIndex)
3819  {
3820  const char* result = NULL;
3821 
3822  _OrthancPluginGetFontInfo params;
3823  memset(&params, 0, sizeof(params));
3824  params.name = &result;
3825  params.fontIndex = fontIndex;
3826 
3827  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
3828  {
3829  return NULL;
3830  }
3831  else
3832  {
3833  return result;
3834  }
3835  }
3836 
3837 
3848  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
3849  OrthancPluginContext* context,
3850  uint32_t fontIndex)
3851  {
3852  uint32_t result;
3853 
3854  _OrthancPluginGetFontInfo params;
3855  memset(&params, 0, sizeof(params));
3856  params.size = &result;
3857  params.fontIndex = fontIndex;
3858 
3859  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
3860  {
3861  return 0;
3862  }
3863  else
3864  {
3865  return result;
3866  }
3867  }
3868 
3869 
3870 
3871  typedef struct
3872  {
3873  OrthancPluginImage* image;
3874  uint32_t fontIndex;
3875  const char* utf8Text;
3876  int32_t x;
3877  int32_t y;
3878  uint8_t r;
3879  uint8_t g;
3880  uint8_t b;
3881  } _OrthancPluginDrawText;
3882 
3883 
3902  OrthancPluginContext* context,
3903  OrthancPluginImage* image,
3904  uint32_t fontIndex,
3905  const char* utf8Text,
3906  int32_t x,
3907  int32_t y,
3908  uint8_t r,
3909  uint8_t g,
3910  uint8_t b)
3911  {
3912  _OrthancPluginDrawText params;
3913  memset(&params, 0, sizeof(params));
3914  params.image = image;
3915  params.fontIndex = fontIndex;
3916  params.utf8Text = utf8Text;
3917  params.x = x;
3918  params.y = y;
3919  params.r = r;
3920  params.g = g;
3921  params.b = b;
3922 
3923  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
3924  }
3925 
3926 
3927 
3928  typedef struct
3929  {
3930  OrthancPluginStorageArea* storageArea;
3931  const char* uuid;
3932  const void* content;
3933  uint64_t size;
3935  } _OrthancPluginStorageAreaCreate;
3936 
3937 
3954  OrthancPluginContext* context,
3955  OrthancPluginStorageArea* storageArea,
3956  const char* uuid,
3957  const void* content,
3958  uint64_t size,
3960  {
3961  _OrthancPluginStorageAreaCreate params;
3962  params.storageArea = storageArea;
3963  params.uuid = uuid;
3964  params.content = content;
3965  params.size = size;
3966  params.type = type;
3967 
3968  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
3969  }
3970 
3971 
3972  typedef struct
3973  {
3974  OrthancPluginMemoryBuffer* target;
3975  OrthancPluginStorageArea* storageArea;
3976  const char* uuid;
3978  } _OrthancPluginStorageAreaRead;
3979 
3980 
3996  OrthancPluginContext* context,
3997  OrthancPluginMemoryBuffer* target,
3998  OrthancPluginStorageArea* storageArea,
3999  const char* uuid,
4001  {
4002  _OrthancPluginStorageAreaRead params;
4003  params.target = target;
4004  params.storageArea = storageArea;
4005  params.uuid = uuid;
4006  params.type = type;
4007 
4008  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4009  }
4010 
4011 
4012  typedef struct
4013  {
4014  OrthancPluginStorageArea* storageArea;
4015  const char* uuid;
4017  } _OrthancPluginStorageAreaRemove;
4018 
4033  OrthancPluginContext* context,
4034  OrthancPluginStorageArea* storageArea,
4035  const char* uuid,
4037  {
4038  _OrthancPluginStorageAreaRemove params;
4039  params.storageArea = storageArea;
4040  params.uuid = uuid;
4041  params.type = type;
4042 
4043  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4044  }
4045 
4046 
4047 
4048  typedef struct
4049  {
4050  OrthancPluginErrorCode* target;
4051  int32_t code;
4052  uint16_t httpStatus;
4053  const char* message;
4054  } _OrthancPluginRegisterErrorCode;
4055 
4072  OrthancPluginContext* context,
4073  int32_t code,
4074  uint16_t httpStatus,
4075  const char* message)
4076  {
4077  OrthancPluginErrorCode target;
4078 
4079  _OrthancPluginRegisterErrorCode params;
4080  params.target = &target;
4081  params.code = code;
4082  params.httpStatus = httpStatus;
4083  params.message = message;
4084 
4085  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4086  {
4087  return target;
4088  }
4089  else
4090  {
4091  /* There was an error while assigned the error. Use a generic code. */
4093  }
4094  }
4095 
4096 
4097 
4098  typedef struct
4099  {
4100  uint16_t group;
4101  uint16_t element;
4103  const char* name;
4104  uint32_t minMultiplicity;
4105  uint32_t maxMultiplicity;
4106  } _OrthancPluginRegisterDictionaryTag;
4107 
4128  OrthancPluginContext* context,
4129  uint16_t group,
4130  uint16_t element,
4132  const char* name,
4133  uint32_t minMultiplicity,
4134  uint32_t maxMultiplicity)
4135  {
4136  _OrthancPluginRegisterDictionaryTag params;
4137  params.group = group;
4138  params.element = element;
4139  params.vr = vr;
4140  params.name = name;
4141  params.minMultiplicity = minMultiplicity;
4142  params.maxMultiplicity = maxMultiplicity;
4143 
4144  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4145  }
4146 
4147 
4148 
4149  typedef struct
4150  {
4151  uint16_t group;
4152  uint16_t element;
4154  const char* name;
4155  uint32_t minMultiplicity;
4156  uint32_t maxMultiplicity;
4157  const char* privateCreator;
4158  } _OrthancPluginRegisterPrivateDictionaryTag;
4159 
4181  OrthancPluginContext* context,
4182  uint16_t group,
4183  uint16_t element,
4185  const char* name,
4186  uint32_t minMultiplicity,
4187  uint32_t maxMultiplicity,
4188  const char* privateCreator)
4189  {
4190  _OrthancPluginRegisterPrivateDictionaryTag params;
4191  params.group = group;
4192  params.element = element;
4193  params.vr = vr;
4194  params.name = name;
4195  params.minMultiplicity = minMultiplicity;
4196  params.maxMultiplicity = maxMultiplicity;
4197  params.privateCreator = privateCreator;
4198 
4199  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4200  }
4201 
4202 
4203 
4204  typedef struct
4205  {
4206  OrthancPluginStorageArea* storageArea;
4208  } _OrthancPluginReconstructMainDicomTags;
4209 
4227  OrthancPluginContext* context,
4228  OrthancPluginStorageArea* storageArea,
4230  {
4231  _OrthancPluginReconstructMainDicomTags params;
4232  params.level = level;
4233  params.storageArea = storageArea;
4234 
4235  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
4236  }
4237 
4238 
4239  typedef struct
4240  {
4241  char** result;
4242  const char* instanceId;
4243  const void* buffer;
4244  uint32_t size;
4247  uint32_t maxStringLength;
4248  } _OrthancPluginDicomToJson;
4249 
4250 
4270  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4271  OrthancPluginContext* context,
4272  const void* buffer,
4273  uint32_t size,
4276  uint32_t maxStringLength)
4277  {
4278  char* result;
4279 
4280  _OrthancPluginDicomToJson params;
4281  memset(&params, 0, sizeof(params));
4282  params.result = &result;
4283  params.buffer = buffer;
4284  params.size = size;
4285  params.format = format;
4286  params.flags = flags;
4287  params.maxStringLength = maxStringLength;
4288 
4289  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
4290  {
4291  /* Error */
4292  return NULL;
4293  }
4294  else
4295  {
4296  return result;
4297  }
4298  }
4299 
4300 
4319  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
4320  OrthancPluginContext* context,
4321  const char* instanceId,
4324  uint32_t maxStringLength)
4325  {
4326  char* result;
4327 
4328  _OrthancPluginDicomToJson params;
4329  memset(&params, 0, sizeof(params));
4330  params.result = &result;
4331  params.instanceId = instanceId;
4332  params.format = format;
4333  params.flags = flags;
4334  params.maxStringLength = maxStringLength;
4335 
4336  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
4337  {
4338  /* Error */
4339  return NULL;
4340  }
4341  else
4342  {
4343  return result;
4344  }
4345  }
4346 
4347 
4348  typedef struct
4349  {
4350  OrthancPluginMemoryBuffer* target;
4351  const char* uri;
4352  uint32_t headersCount;
4353  const char* const* headersKeys;
4354  const char* const* headersValues;
4355  int32_t afterPlugins;
4356  } _OrthancPluginRestApiGet2;
4357 
4378  OrthancPluginContext* context,
4379  OrthancPluginMemoryBuffer* target,
4380  const char* uri,
4381  uint32_t headersCount,
4382  const char* const* headersKeys,
4383  const char* const* headersValues,
4384  int32_t afterPlugins)
4385  {
4386  _OrthancPluginRestApiGet2 params;
4387  params.target = target;
4388  params.uri = uri;
4389  params.headersCount = headersCount;
4390  params.headersKeys = headersKeys;
4391  params.headersValues = headersValues;
4392  params.afterPlugins = afterPlugins;
4393 
4394  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
4395  }
4396 
4397 
4398 
4399  typedef struct
4400  {
4402  } _OrthancPluginWorklistCallback;
4403 
4416  OrthancPluginContext* context,
4418  {
4419  _OrthancPluginWorklistCallback params;
4420  params.callback = callback;
4421 
4422  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
4423  }
4424 
4425 
4426 
4427  typedef struct
4428  {
4430  const OrthancPluginWorklistQuery* query;
4431  const void* dicom;
4432  uint32_t size;
4433  } _OrthancPluginWorklistAnswersOperation;
4434 
4452  OrthancPluginContext* context,
4454  const OrthancPluginWorklistQuery* query,
4455  const void* dicom,
4456  uint32_t size)
4457  {
4458  _OrthancPluginWorklistAnswersOperation params;
4459  params.answers = answers;
4460  params.query = query;
4461  params.dicom = dicom;
4462  params.size = size;
4463 
4464  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
4465  }
4466 
4467 
4482  OrthancPluginContext* context,
4484  {
4485  _OrthancPluginWorklistAnswersOperation params;
4486  params.answers = answers;
4487  params.query = NULL;
4488  params.dicom = NULL;
4489  params.size = 0;
4490 
4491  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
4492  }
4493 
4494 
4495  typedef struct
4496  {
4497  const OrthancPluginWorklistQuery* query;
4498  const void* dicom;
4499  uint32_t size;
4500  int32_t* isMatch;
4501  OrthancPluginMemoryBuffer* target;
4502  } _OrthancPluginWorklistQueryOperation;
4503 
4519  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
4520  OrthancPluginContext* context,
4521  const OrthancPluginWorklistQuery* query,
4522  const void* dicom,
4523  uint32_t size)
4524  {
4525  int32_t isMatch = 0;
4526 
4527  _OrthancPluginWorklistQueryOperation params;
4528  params.query = query;
4529  params.dicom = dicom;
4530  params.size = size;
4531  params.isMatch = &isMatch;
4532  params.target = NULL;
4533 
4534  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
4535  {
4536  return isMatch;
4537  }
4538  else
4539  {
4540  /* Error: Assume non-match */
4541  return 0;
4542  }
4543  }
4544 
4545 
4559  OrthancPluginContext* context,
4560  OrthancPluginMemoryBuffer* target,
4561  const OrthancPluginWorklistQuery* query)
4562  {
4563  _OrthancPluginWorklistQueryOperation params;
4564  params.query = query;
4565  params.dicom = NULL;
4566  params.size = 0;
4567  params.isMatch = NULL;
4568  params.target = target;
4569 
4570  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
4571  }
4572 
4573 
4585  OrthancPluginContext* context,
4586  OrthancPluginDicomInstance* instance)
4587  {
4589 
4590  _OrthancPluginAccessDicomInstance params;
4591  memset(&params, 0, sizeof(params));
4592  params.resultOrigin = &origin;
4593  params.instance = instance;
4594 
4595  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
4596  {
4597  /* Error */
4599  }
4600  else
4601  {
4602  return origin;
4603  }
4604  }
4605 
4606 
4607  typedef struct
4608  {
4609  OrthancPluginMemoryBuffer* target;
4610  const char* json;
4611  const OrthancPluginImage* pixelData;
4613  } _OrthancPluginCreateDicom;
4614 
4634  OrthancPluginContext* context,
4635  OrthancPluginMemoryBuffer* target,
4636  const char* json,
4637  const OrthancPluginImage* pixelData,
4639  {
4640  _OrthancPluginCreateDicom params;
4641  params.target = target;
4642  params.json = json;
4643  params.pixelData = pixelData;
4644  params.flags = flags;
4645 
4646  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
4647  }
4648 
4649 
4650  typedef struct
4651  {
4653  } _OrthancPluginDecodeImageCallback;
4654 
4667  OrthancPluginContext* context,
4669  {
4670  _OrthancPluginDecodeImageCallback params;
4671  params.callback = callback;
4672 
4673  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
4674  }
4675 
4676 
4677 
4678  typedef struct
4679  {
4680  OrthancPluginImage** target;
4681  OrthancPluginPixelFormat format;
4682  uint32_t width;
4683  uint32_t height;
4684  uint32_t pitch;
4685  void* buffer;
4686  const void* constBuffer;
4687  uint32_t bufferSize;
4688  uint32_t frameIndex;
4689  } _OrthancPluginCreateImage;
4690 
4691 
4705  OrthancPluginContext* context,
4706  OrthancPluginPixelFormat format,
4707  uint32_t width,
4708  uint32_t height)
4709  {
4710  OrthancPluginImage* target = NULL;
4711 
4712  _OrthancPluginCreateImage params;
4713  memset(&params, 0, sizeof(params));
4714  params.target = &target;
4715  params.format = format;
4716  params.width = width;
4717  params.height = height;
4718 
4719  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
4720  {
4721  return NULL;
4722  }
4723  else
4724  {
4725  return target;
4726  }
4727  }
4728 
4729 
4748  OrthancPluginContext* context,
4749  OrthancPluginPixelFormat format,
4750  uint32_t width,
4751  uint32_t height,
4752  uint32_t pitch,
4753  void* buffer)
4754  {
4755  OrthancPluginImage* target = NULL;
4756 
4757  _OrthancPluginCreateImage params;
4758  memset(&params, 0, sizeof(params));
4759  params.target = &target;
4760  params.format = format;
4761  params.width = width;
4762  params.height = height;
4763  params.pitch = pitch;
4764  params.buffer = buffer;
4765 
4766  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
4767  {
4768  return NULL;
4769  }
4770  else
4771  {
4772  return target;
4773  }
4774  }
4775 
4776 
4777 
4793  OrthancPluginContext* context,
4794  const void* buffer,
4795  uint32_t bufferSize,
4796  uint32_t frameIndex)
4797  {
4798  OrthancPluginImage* target = NULL;
4799 
4800  _OrthancPluginCreateImage params;
4801  memset(&params, 0, sizeof(params));
4802  params.target = &target;
4803  params.constBuffer = buffer;
4804  params.bufferSize = bufferSize;
4805  params.frameIndex = frameIndex;
4806 
4807  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
4808  {
4809  return NULL;
4810  }
4811  else
4812  {
4813  return target;
4814  }
4815  }
4816 
4817 
4818 
4819  typedef struct
4820  {
4821  char** result;
4822  const void* buffer;
4823  uint32_t size;
4824  } _OrthancPluginComputeHash;
4825 
4838  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
4839  OrthancPluginContext* context,
4840  const void* buffer,
4841  uint32_t size)
4842  {
4843  char* result;
4844 
4845  _OrthancPluginComputeHash params;
4846  params.result = &result;
4847  params.buffer = buffer;
4848  params.size = size;
4849 
4850  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
4851  {
4852  /* Error */
4853  return NULL;
4854  }
4855  else
4856  {
4857  return result;
4858  }
4859  }
4860 
4861 
4874  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
4875  OrthancPluginContext* context,
4876  const void* buffer,
4877  uint32_t size)
4878  {
4879  char* result;
4880 
4881  _OrthancPluginComputeHash params;
4882  params.result = &result;
4883  params.buffer = buffer;
4884  params.size = size;
4885 
4886  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
4887  {
4888  /* Error */
4889  return NULL;
4890  }
4891  else
4892  {
4893  return result;
4894  }
4895  }
4896 
4897 
4898 
4899  typedef struct
4900  {
4902  const char* name;
4903  } _OrthancPluginLookupDictionary;
4904 
4921  OrthancPluginContext* context,
4923  const char* name)
4924  {
4925  _OrthancPluginLookupDictionary params;
4926  params.target = target;
4927  params.name = name;
4928  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
4929  }
4930 
4931 
4932 
4933  typedef struct
4934  {
4935  OrthancPluginRestOutput* output;
4936  const char* answer;
4937  uint32_t answerSize;
4938  uint32_t headersCount;
4939  const char* const* headersKeys;
4940  const char* const* headersValues;
4941  } _OrthancPluginSendMultipartItem2;
4942 
4964  OrthancPluginContext* context,
4965  OrthancPluginRestOutput* output,
4966  const char* answer,
4967  uint32_t answerSize,
4968  uint32_t headersCount,
4969  const char* const* headersKeys,
4970  const char* const* headersValues)
4971  {
4972  _OrthancPluginSendMultipartItem2 params;
4973  params.output = output;
4974  params.answer = answer;
4975  params.answerSize = answerSize;
4976  params.headersCount = headersCount;
4977  params.headersKeys = headersKeys;
4978  params.headersValues = headersValues;
4979 
4980  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
4981  }
4982 
4983 
4984  typedef struct
4985  {
4987  } _OrthancPluginIncomingHttpRequestFilter;
4988 
5001  OrthancPluginContext* context,
5003  {
5004  _OrthancPluginIncomingHttpRequestFilter params;
5005  params.callback = callback;
5006 
5007  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5008  }
5009 
5010 
5011 
5012  typedef struct
5013  {
5014  OrthancPluginMemoryBuffer* answerBody;
5015  OrthancPluginMemoryBuffer* answerHeaders;
5016  uint16_t* httpStatus;
5017  OrthancPluginHttpMethod method;
5018  const char* url;
5019  uint32_t headersCount;
5020  const char* const* headersKeys;
5021  const char* const* headersValues;
5022  const char* body;
5023  uint32_t bodySize;
5024  const char* username;
5025  const char* password;
5026  uint32_t timeout;
5027  const char* certificateFile;
5028  const char* certificateKeyFile;
5029  const char* certificateKeyPassword;
5030  uint8_t pkcs11;
5031  } _OrthancPluginCallHttpClient2;
5032 
5033 
5034 
5073  OrthancPluginContext* context,
5074  OrthancPluginMemoryBuffer* answerBody,
5075  OrthancPluginMemoryBuffer* answerHeaders,
5076  uint16_t* httpStatus,
5077  OrthancPluginHttpMethod method,
5078  const char* url,
5079  uint32_t headersCount,
5080  const char* const* headersKeys,
5081  const char* const* headersValues,
5082  const char* body,
5083  uint32_t bodySize,
5084  const char* username,
5085  const char* password,
5086  uint32_t timeout,
5087  const char* certificateFile,
5088  const char* certificateKeyFile,
5089  const char* certificateKeyPassword,
5090  uint8_t pkcs11)
5091  {
5092  _OrthancPluginCallHttpClient2 params;
5093  memset(&params, 0, sizeof(params));
5094 
5095  params.answerBody = answerBody;
5096  params.answerHeaders = answerHeaders;
5097  params.httpStatus = httpStatus;
5098  params.method = method;
5099  params.url = url;
5100  params.headersCount = headersCount;
5101  params.headersKeys = headersKeys;
5102  params.headersValues = headersValues;
5103  params.body = body;
5104  params.bodySize = bodySize;
5105  params.username = username;
5106  params.password = password;
5107  params.timeout = timeout;
5108  params.certificateFile = certificateFile;
5109  params.certificateKeyFile = certificateKeyFile;
5110  params.certificateKeyPassword = certificateKeyPassword;
5111  params.pkcs11 = pkcs11;
5112 
5113  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5114  }
5115 
5116 
5127  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5128  OrthancPluginContext* context)
5129  {
5130  char* result;
5131 
5132  _OrthancPluginRetrieveDynamicString params;
5133  params.result = &result;
5134  params.argument = NULL;
5135 
5136  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5137  {
5138  /* Error */
5139  return NULL;
5140  }
5141  else
5142  {
5143  return result;
5144  }
5145  }
5146 
5147 
5148 
5149 
5150  typedef struct
5151  {
5152  OrthancPluginFindCallback callback;
5153  } _OrthancPluginFindCallback;
5154 
5167  OrthancPluginContext* context,
5168  OrthancPluginFindCallback callback)
5169  {
5170  _OrthancPluginFindCallback params;
5171  params.callback = callback;
5172 
5173  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5174  }
5175 
5176 
5177  typedef struct
5178  {
5179  OrthancPluginFindAnswers *answers;
5180  const OrthancPluginFindQuery *query;
5181  const void *dicom;
5182  uint32_t size;
5183  uint32_t index;
5184  uint32_t *resultUint32;
5185  uint16_t *resultGroup;
5186  uint16_t *resultElement;
5187  char **resultString;
5188  } _OrthancPluginFindOperation;
5189 
5206  OrthancPluginContext* context,
5207  OrthancPluginFindAnswers* answers,
5208  const void* dicom,
5209  uint32_t size)
5210  {
5211  _OrthancPluginFindOperation params;
5212  memset(&params, 0, sizeof(params));
5213  params.answers = answers;
5214  params.dicom = dicom;
5215  params.size = size;
5216 
5217  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
5218  }
5219 
5220 
5235  OrthancPluginContext* context,
5236  OrthancPluginFindAnswers* answers)
5237  {
5238  _OrthancPluginFindOperation params;
5239  memset(&params, 0, sizeof(params));
5240  params.answers = answers;
5241 
5242  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
5243  }
5244 
5245 
5246 
5258  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
5259  OrthancPluginContext* context,
5260  const OrthancPluginFindQuery* query)
5261  {
5262  uint32_t count = 0;
5263 
5264  _OrthancPluginFindOperation params;
5265  memset(&params, 0, sizeof(params));
5266  params.query = query;
5267  params.resultUint32 = &count;
5268 
5269  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
5270  {
5271  /* Error */
5272  return 0;
5273  }
5274  else
5275  {
5276  return count;
5277  }
5278  }
5279 
5280 
5296  OrthancPluginContext* context,
5297  uint16_t* group,
5298  uint16_t* element,
5299  const OrthancPluginFindQuery* query,
5300  uint32_t index)
5301  {
5302  _OrthancPluginFindOperation params;
5303  memset(&params, 0, sizeof(params));
5304  params.query = query;
5305  params.index = index;
5306  params.resultGroup = group;
5307  params.resultElement = element;
5308 
5309  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
5310  }
5311 
5312 
5326  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
5327  OrthancPluginContext* context,
5328  const OrthancPluginFindQuery* query,
5329  uint32_t index)
5330  {
5331  char* result;
5332 
5333  _OrthancPluginFindOperation params;
5334  memset(&params, 0, sizeof(params));
5335  params.query = query;
5336  params.index = index;
5337  params.resultString = &result;
5338 
5339  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
5340  {
5341  /* Error */
5342  return NULL;
5343  }
5344  else
5345  {
5346  return result;
5347  }
5348  }
5349 
5350 
5364  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
5365  OrthancPluginContext* context,
5366  const OrthancPluginFindQuery* query,
5367  uint32_t index)
5368  {
5369  char* result;
5370 
5371  _OrthancPluginFindOperation params;
5372  memset(&params, 0, sizeof(params));
5373  params.query = query;
5374  params.index = index;
5375  params.resultString = &result;
5376 
5377  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
5378  {
5379  /* Error */
5380  return NULL;
5381  }
5382  else
5383  {
5384  return result;
5385  }
5386  }
5387 
5388 
5389 
5390 
5391  typedef struct
5392  {
5393  OrthancPluginMoveCallback callback;
5394  OrthancPluginGetMoveSize getMoveSize;
5395  OrthancPluginApplyMove applyMove;
5396  OrthancPluginFreeMove freeMove;
5397  } _OrthancPluginMoveCallback;
5398 
5413  OrthancPluginContext* context,
5414  OrthancPluginMoveCallback callback,
5415  OrthancPluginGetMoveSize getMoveSize,
5416  OrthancPluginApplyMove applyMove,
5417  OrthancPluginFreeMove freeMove)
5418  {
5419  _OrthancPluginMoveCallback params;
5420  params.callback = callback;
5421  params.getMoveSize = getMoveSize;
5422  params.applyMove = applyMove;
5423  params.freeMove = freeMove;
5424 
5425  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
5426  }
5427 
5428 
5429 
5430  typedef struct
5431  {
5432  OrthancPluginFindMatcher** target;
5433  const void* query;
5434  uint32_t size;
5435  } _OrthancPluginCreateFindMatcher;
5436 
5437 
5452  OrthancPluginContext* context,
5453  const void* query,
5454  uint32_t size)
5455  {
5456  OrthancPluginFindMatcher* target = NULL;
5457 
5458  _OrthancPluginCreateFindMatcher params;
5459  memset(&params, 0, sizeof(params));
5460  params.target = &target;
5461  params.query = query;
5462  params.size = size;
5463 
5464  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
5465  {
5466  return NULL;
5467  }
5468  else
5469  {
5470  return target;
5471  }
5472  }
5473 
5474 
5475  typedef struct
5476  {
5477  OrthancPluginFindMatcher* matcher;
5478  } _OrthancPluginFreeFindMatcher;
5479 
5489  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
5490  OrthancPluginContext* context,
5491  OrthancPluginFindMatcher* matcher)
5492  {
5493  _OrthancPluginFreeFindMatcher params;
5494  params.matcher = matcher;
5495 
5496  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
5497  }
5498 
5499 
5500  typedef struct
5501  {
5502  const OrthancPluginFindMatcher* matcher;
5503  const void* dicom;
5504  uint32_t size;
5505  int32_t* isMatch;
5506  } _OrthancPluginFindMatcherIsMatch;
5507 
5522  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
5523  OrthancPluginContext* context,
5524  const OrthancPluginFindMatcher* matcher,
5525  const void* dicom,
5526  uint32_t size)
5527  {
5528  int32_t isMatch = 0;
5529 
5530  _OrthancPluginFindMatcherIsMatch params;
5531  params.matcher = matcher;
5532  params.dicom = dicom;
5533  params.size = size;
5534  params.isMatch = &isMatch;
5535 
5536  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
5537  {
5538  return isMatch;
5539  }
5540  else
5541  {
5542  /* Error: Assume non-match */
5543  return 0;
5544  }
5545  }
5546 
5547 
5548 #ifdef __cplusplus
5549 }
5550 #endif
5551 
5552 
Definition: OrthancCPlugin.h:653
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2196
Definition: OrthancCPlugin.h:754
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:2375
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:851
OrthancPluginChangeType
Definition: OrthancCPlugin.h:610
Definition: OrthancCPlugin.h:223
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2059
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:804
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2160
Definition: OrthancCPlugin.h:676
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1135
Definition: OrthancCPlugin.h:256
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:1337
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:4666
Definition: OrthancCPlugin.h:755
The parameters of a REST request.
Definition: OrthancCPlugin.h:315
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:1842
OrthancPluginContentType
Definition: OrthancCPlugin.h:579
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:1747
Definition: OrthancCPlugin.h:596
Definition: OrthancCPlugin.h:675
Definition: OrthancCPlugin.h:770
const char * OrthancPluginGetInstanceData(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2262
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:3444
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:3536
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1200
Definition: OrthancCPlugin.h:248
Definition: OrthancCPlugin.h:193
Definition: OrthancCPlugin.h:246
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:765
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:4451
Definition: OrthancCPlugin.h:673
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:4415
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2229
OrthancPluginErrorCode OrthancPluginRegisterPrivateDictionaryTag(OrthancPluginContext *context, uint16_t group, uint16_t element, OrthancPluginValueRepresentation vr, const char *name, uint32_t minMultiplicity, uint32_t maxMultiplicity, const char *privateCreator)
Register a new private tag into the DICOM dictionary.
Definition: OrthancCPlugin.h:4180
Definition: OrthancCPlugin.h:271
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:543
Definition: OrthancCPlugin.h:625
Definition: OrthancCPlugin.h:215
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:375
Definition: OrthancCPlugin.h:258
Definition: OrthancCPlugin.h:260
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:370
Definition: OrthancCPlugin.h:244
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:737
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:4874
Definition: OrthancCPlugin.h:262
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:527
Definition: OrthancCPlugin.h:771
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:335
Definition: OrthancCPlugin.h:569
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:2461
OrthancPluginErrorCode(* OrthancPluginWorklistCallback)(OrthancPluginWorklistAnswers *answers, const OrthancPluginWorklistQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle the C-Find SCP requests for worklists.
Definition: OrthancCPlugin.h:991
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:1560
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:650
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:4558
Definition: OrthancCPlugin.h:201
Definition: OrthancCPlugin.h:284
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1176
Definition: OrthancCPlugin.h:268
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:3816
Definition: OrthancCPlugin.h:221
Definition: OrthancCPlugin.h:274
Definition: OrthancCPlugin.h:266
Definition: OrthancCPlugin.h:303
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:918
Definition: OrthancCPlugin.h:212
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:4838
Definition: OrthancCPlugin.h:214
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:187
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:3741
Definition: OrthancCPlugin.h:269
Definition: OrthancCPlugin.h:619
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:3995
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:3776
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:2558
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1108
Definition: OrthancCPlugin.h:210
OrthancPluginErrorCode OrthancPluginHttpClient(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, OrthancPluginHttpMethod method, const char *url, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, const char *body, uint32_t bodySize, const char *username, const char *password, uint32_t timeout, const char *certificateFile, const char *certificateKeyFile, const char *certificateKeyPassword, uint8_t pkcs11)
Issue a HTTP call with full flexibility.
Definition: OrthancCPlugin.h:5072
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:2600
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:567
Definition: OrthancCPlugin.h:721
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:718
Definition: OrthancCPlugin.h:203
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2105
Definition: OrthancCPlugin.h:637
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5127
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:1462
Definition: OrthancCPlugin.h:613
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:4792
Definition: OrthancCPlugin.h:245
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:703
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:4920
Definition: OrthancCPlugin.h:705
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4071
Definition: OrthancCPlugin.h:226
uint16_t group
Definition: OrthancCPlugin.h:1159
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:3314
Definition: OrthancCPlugin.h:666
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1162
Definition: OrthancCPlugin.h:707
Definition: OrthancCPlugin.h:678
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:2413
Definition: OrthancCPlugin.h:652
Definition: OrthancCPlugin.h:238
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:827
Definition: OrthancCPlugin.h:230
Definition: OrthancCPlugin.h:581
OrthancPluginErrorCode OrthancPluginGetFindQueryTag(OrthancPluginContext *context, uint16_t *group, uint16_t *element, const OrthancPluginFindQuery *query, uint32_t index)
Get one tag in a C-Find query.
Definition: OrthancCPlugin.h:5295
Definition: OrthancCPlugin.h:617
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:1808
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:2846
Definition: OrthancCPlugin.h:261
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:535
Definition: OrthancCPlugin.h:259
Definition: OrthancCPlugin.h:204
OrthancPluginResourceType
Definition: OrthancCPlugin.h:593
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:300
Definition: OrthancCPlugin.h:220
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:3245
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:664
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:2879
Definition: OrthancCPlugin.h:191
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:3143
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:3357
Definition: OrthancCPlugin.h:264
Definition: OrthancCPlugin.h:668
Definition: OrthancCPlugin.h:207
Definition: OrthancCPlugin.h:598
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:875
Definition: OrthancCPlugin.h:255
Definition: OrthancCPlugin.h:638
Definition: OrthancCPlugin.h:671
Definition: OrthancCPlugin.h:272
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:2523
Definition: OrthancCPlugin.h:225
Definition: OrthancCPlugin.h:640
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5205
Definition: OrthancCPlugin.h:690
Definition: OrthancCPlugin.h:247
Color image in RGB24 format.
Definition: OrthancCPlugin.h:559
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:4481
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:551
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1157
Definition: OrthancCPlugin.h:257
Definition: OrthancCPlugin.h:197
Definition: OrthancCPlugin.h:612
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:635
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:3666
Definition: OrthancCPlugin.h:189
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:4377
Definition: OrthancCPlugin.h:724
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3179
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:3901
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3280
Definition: OrthancCPlugin.h:582
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:1519
Definition: OrthancCPlugin.h:277
Definition: OrthancCPlugin.h:283
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:843
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1163
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5166
Definition: OrthancCPlugin.h:276
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:907
char * OrthancPluginDicomBufferToJson(OrthancPluginContext *context, const void *buffer, uint32_t size, OrthancPluginDicomToJsonFormat format, OrthancPluginDicomToJsonFlags flags, uint32_t maxStringLength)
Format a DICOM memory buffer as a JSON string.
Definition: OrthancCPlugin.h:4270
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:2779
Definition: OrthancCPlugin.h:228
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2082
Definition: OrthancCPlugin.h:199
Definition: OrthancCPlugin.h:253
Definition: OrthancCPlugin.h:241
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:5489
Definition: OrthancCPlugin.h:273
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:1305
Definition: OrthancCPlugin.h:218
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:835
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:5451
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:789
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:3848
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:2675
Definition: OrthancCPlugin.h:769
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1593
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3090
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1041
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:365
int32_t(* OrthancPluginIncomingHttpRequestFilter)(OrthancPluginHttpMethod method, const char *uri, const char *ip, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues)
Callback to filter incoming HTTP requests received by Orthanc.
Definition: OrthancCPlugin.h:1017
Definition: OrthancCPlugin.h:618
Definition: OrthancCPlugin.h:723
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1289
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:934
Definition: OrthancCPlugin.h:684
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1724
Definition: OrthancCPlugin.h:688
Definition: OrthancCPlugin.h:597
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3028
Definition: OrthancCPlugin.h:677
Definition: OrthancCPlugin.h:756
Definition: OrthancCPlugin.h:304
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:4704
char * OrthancPluginGetFindQueryTagName(OrthancPluginContext *context, const OrthancPluginFindQuery *query, uint32_t index)
Get the symbolic name of one tag in a C-Find query.
Definition: OrthancCPlugin.h:5326
Definition: OrthancCPlugin.h:679
Definition: OrthancCPlugin.h:233
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:2493
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:2709
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:4963
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:972
Definition: OrthancCPlugin.h:706
Definition: OrthancCPlugin.h:242
Definition: OrthancCPlugin.h:280
Definition: OrthancCPlugin.h:302
Definition: OrthancCPlugin.h:620
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4226
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:2813
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:3588
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:4747
Definition: OrthancCPlugin.h:250
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5000
Definition: OrthancCPlugin.h:211
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:4319
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:345
Definition: OrthancCPlugin.h:691
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:896
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:2336
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:2991
Definition: OrthancCPlugin.h:243
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:4633
Definition: OrthancCPlugin.h:236
Definition: OrthancCPlugin.h:654
Definition: OrthancCPlugin.h:198
const char * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:350
Definition: OrthancCPlugin.h:249
Definition: OrthancCPlugin.h:205
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:1402
void *(* OrthancPluginMoveCallback)(OrthancPluginResourceType resourceType, const char *patientId, const char *accessionNumber, const char *studyInstanceUid, const char *seriesInstanceUid, const char *sopInstanceUid, const char *originatorAet, const char *sourceAet, const char *targetAet, uint16_t originatorId)
Callback to handle incoming C-Move SCP requests.
Definition: OrthancCPlugin.h:1084
Definition: OrthancCPlugin.h:623
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:819
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:1772
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:2920
Definition: OrthancCPlugin.h:190
Definition: OrthancCPlugin.h:216
Definition: OrthancCPlugin.h:209
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:859
Definition: OrthancCPlugin.h:753
Definition: OrthancCPlugin.h:281
Definition: OrthancCPlugin.h:252
char * OrthancPluginGetFindQueryValue(OrthancPluginContext *context, const OrthancPluginFindQuery *query, uint32_t index)
Get the value associated with one tag in a C-Find query.
Definition: OrthancCPlugin.h:5364
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:2631
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4032
Definition: OrthancCPlugin.h:683
Definition: OrthancCPlugin.h:624
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:340
Definition: OrthancCPlugin.h:686
Definition: OrthancCPlugin.h:615
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:1874
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:4584
Definition: OrthancCPlugin.h:687
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:3399
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1161
uint16_t element
Definition: OrthancCPlugin.h:1160
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2014
Definition: OrthancCPlugin.h:622
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:2748
Definition: OrthancCPlugin.h:222
Definition: OrthancCPlugin.h:583
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:2949
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:330
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3059
Definition: OrthancCPlugin.h:251
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:954
Definition: OrthancCPlugin.h:254
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:1909
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:794
Definition: OrthancCPlugin.h:767
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:5412
Definition: OrthancCPlugin.h:234
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance received by Orthanc.
Definition: OrthancCPlugin.h:811
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:325
Definition: OrthancCPlugin.h:235
Definition: OrthancCPlugin.h:599
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:1321
Definition: OrthancCPlugin.h:672
Definition: OrthancCPlugin.h:240
Definition: OrthancCPlugin.h:692
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:751
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:355
Definition: OrthancCPlugin.h:305
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2135
Definition: OrthancCPlugin.h:614
Definition: OrthancCPlugin.h:682
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2298
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:2653
Definition: OrthancCPlugin.h:282
Definition: OrthancCPlugin.h:224
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:1660
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:1430
Definition: OrthancCPlugin.h:616
Definition: OrthancCPlugin.h:685
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:4127
Definition: OrthancCPlugin.h:237
Definition: OrthancCPlugin.h:202
Definition: OrthancCPlugin.h:689
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:3625
Definition: OrthancCPlugin.h:669
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:5234
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:1368
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:1944
Definition: OrthancCPlugin.h:681
Definition: OrthancCPlugin.h:667
Definition: OrthancCPlugin.h:194
Definition: OrthancCPlugin.h:595
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:1623
Definition: OrthancCPlugin.h:768
Definition: OrthancCPlugin.h:213
OrthancPluginErrorCode(* OrthancPluginOnStoredInstanceCallback)(OrthancPluginDicomInstance *instance, const char *instanceId)
Signature of a callback function that is triggered when Orthanc receives a DICOM instance.
Definition: OrthancCPlugin.h:886
Definition: OrthancCPlugin.h:275
Definition: OrthancCPlugin.h:195
Definition: OrthancCPlugin.h:200
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:1695
Definition: OrthancCPlugin.h:192
Definition: OrthancCPlugin.h:217
Definition: OrthancCPlugin.h:621
Definition: OrthancCPlugin.h:639
Definition: OrthancCPlugin.h:227
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1122
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:320
Definition: OrthancCPlugin.h:270
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:3953
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:3703
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:784
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5258
Definition: OrthancCPlugin.h:674
Definition: OrthancCPlugin.h:722
Definition: OrthancCPlugin.h:206
int32_t OrthancPluginFindMatcherIsMatch(OrthancPluginContext *context, const OrthancPluginFindMatcher *matcher, const void *dicom, uint32_t size)
Test whether a DICOM instance matches a C-Find query.
Definition: OrthancCPlugin.h:5522
Definition: OrthancCPlugin.h:680
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:1979
Definition: OrthancCPlugin.h:196
Definition: OrthancCPlugin.h:670
Definition: OrthancCPlugin.h:263
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:4519
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3212
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:3489
struct _OrthancPluginFindAnswers_t OrthancPluginFindMatcher
Opaque structure to an object that can be used to check whether a DICOM instance matches a C-Find que...
Definition: OrthancCPlugin.h:867
Definition: OrthancCPlugin.h:219