Orthanc Plugin SDK
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 1
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  {
284 
285  _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
287 
288 
293  ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
294 
295 
299  typedef enum
300  {
306  _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
308 
309 
314  typedef struct
315  {
320 
324  uint32_t groupsCount;
325 
329  const char* const* groups;
330 
334  uint32_t getCount;
335 
339  const char* const* getKeys;
340 
344  const char* const* getValues;
345 
349  const char* body;
350 
354  uint32_t bodySize;
355 
356 
357  /* --------------------------------------------------
358  New in version 0.8.1
359  -------------------------------------------------- */
360 
364  uint32_t headersCount;
365 
369  const char* const* headersKeys;
370 
374  const char* const* headersValues;
375 
377 
378 
379  typedef enum
380  {
381  /* Generic services */
382  _OrthancPluginService_LogInfo = 1,
383  _OrthancPluginService_LogWarning = 2,
384  _OrthancPluginService_LogError = 3,
385  _OrthancPluginService_GetOrthancPath = 4,
386  _OrthancPluginService_GetOrthancDirectory = 5,
387  _OrthancPluginService_GetConfigurationPath = 6,
388  _OrthancPluginService_SetPluginProperty = 7,
389  _OrthancPluginService_GetGlobalProperty = 8,
390  _OrthancPluginService_SetGlobalProperty = 9,
391  _OrthancPluginService_GetCommandLineArgumentsCount = 10,
392  _OrthancPluginService_GetCommandLineArgument = 11,
393  _OrthancPluginService_GetExpectedDatabaseVersion = 12,
394  _OrthancPluginService_GetConfiguration = 13,
395  _OrthancPluginService_BufferCompression = 14,
396  _OrthancPluginService_ReadFile = 15,
397  _OrthancPluginService_WriteFile = 16,
398  _OrthancPluginService_GetErrorDescription = 17,
399  _OrthancPluginService_CallHttpClient = 18,
400  _OrthancPluginService_RegisterErrorCode = 19,
401  _OrthancPluginService_RegisterDictionaryTag = 20,
402  _OrthancPluginService_DicomBufferToJson = 21,
403  _OrthancPluginService_DicomInstanceToJson = 22,
404  _OrthancPluginService_CreateDicom = 23,
405  _OrthancPluginService_ComputeMd5 = 24,
406  _OrthancPluginService_ComputeSha1 = 25,
407  _OrthancPluginService_LookupDictionary = 26,
408  _OrthancPluginService_CallHttpClient2 = 27,
409  _OrthancPluginService_GenerateUuid = 28,
410 
411  /* Registration of callbacks */
412  _OrthancPluginService_RegisterRestCallback = 1000,
413  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
414  _OrthancPluginService_RegisterStorageArea = 1002,
415  _OrthancPluginService_RegisterOnChangeCallback = 1003,
416  _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
417  _OrthancPluginService_RegisterWorklistCallback = 1005,
418  _OrthancPluginService_RegisterDecodeImageCallback = 1006,
419  _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
420  _OrthancPluginService_RegisterFindCallback = 1008,
421  _OrthancPluginService_RegisterMoveCallback = 1009,
422 
423  /* Sending answers to REST calls */
424  _OrthancPluginService_AnswerBuffer = 2000,
425  _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
426  _OrthancPluginService_Redirect = 2002,
427  _OrthancPluginService_SendHttpStatusCode = 2003,
428  _OrthancPluginService_SendUnauthorized = 2004,
429  _OrthancPluginService_SendMethodNotAllowed = 2005,
430  _OrthancPluginService_SetCookie = 2006,
431  _OrthancPluginService_SetHttpHeader = 2007,
432  _OrthancPluginService_StartMultipartAnswer = 2008,
433  _OrthancPluginService_SendMultipartItem = 2009,
434  _OrthancPluginService_SendHttpStatus = 2010,
435  _OrthancPluginService_CompressAndAnswerImage = 2011,
436  _OrthancPluginService_SendMultipartItem2 = 2012,
437 
438  /* Access to the Orthanc database and API */
439  _OrthancPluginService_GetDicomForInstance = 3000,
440  _OrthancPluginService_RestApiGet = 3001,
441  _OrthancPluginService_RestApiPost = 3002,
442  _OrthancPluginService_RestApiDelete = 3003,
443  _OrthancPluginService_RestApiPut = 3004,
444  _OrthancPluginService_LookupPatient = 3005,
445  _OrthancPluginService_LookupStudy = 3006,
446  _OrthancPluginService_LookupSeries = 3007,
447  _OrthancPluginService_LookupInstance = 3008,
448  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
449  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
450  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
451  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
452  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
453  _OrthancPluginService_ReconstructMainDicomTags = 3014,
454  _OrthancPluginService_RestApiGet2 = 3015,
455 
456  /* Access to DICOM instances */
457  _OrthancPluginService_GetInstanceRemoteAet = 4000,
458  _OrthancPluginService_GetInstanceSize = 4001,
459  _OrthancPluginService_GetInstanceData = 4002,
460  _OrthancPluginService_GetInstanceJson = 4003,
461  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
462  _OrthancPluginService_HasInstanceMetadata = 4005,
463  _OrthancPluginService_GetInstanceMetadata = 4006,
464  _OrthancPluginService_GetInstanceOrigin = 4007,
465 
466  /* Services for plugins implementing a database back-end */
467  _OrthancPluginService_RegisterDatabaseBackend = 5000,
468  _OrthancPluginService_DatabaseAnswer = 5001,
469  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
470  _OrthancPluginService_StorageAreaCreate = 5003,
471  _OrthancPluginService_StorageAreaRead = 5004,
472  _OrthancPluginService_StorageAreaRemove = 5005,
473 
474  /* Primitives for handling images */
475  _OrthancPluginService_GetImagePixelFormat = 6000,
476  _OrthancPluginService_GetImageWidth = 6001,
477  _OrthancPluginService_GetImageHeight = 6002,
478  _OrthancPluginService_GetImagePitch = 6003,
479  _OrthancPluginService_GetImageBuffer = 6004,
480  _OrthancPluginService_UncompressImage = 6005,
481  _OrthancPluginService_FreeImage = 6006,
482  _OrthancPluginService_CompressImage = 6007,
483  _OrthancPluginService_ConvertPixelFormat = 6008,
484  _OrthancPluginService_GetFontsCount = 6009,
485  _OrthancPluginService_GetFontInfo = 6010,
486  _OrthancPluginService_DrawText = 6011,
487  _OrthancPluginService_CreateImage = 6012,
488  _OrthancPluginService_CreateImageAccessor = 6013,
489  _OrthancPluginService_DecodeDicomImage = 6014,
490 
491  /* Primitives for handling C-Find, C-Move and worklists */
492  _OrthancPluginService_WorklistAddAnswer = 7000,
493  _OrthancPluginService_WorklistMarkIncomplete = 7001,
494  _OrthancPluginService_WorklistIsMatch = 7002,
495  _OrthancPluginService_WorklistGetDicomQuery = 7003,
496  _OrthancPluginService_FindAddAnswer = 7004,
497  _OrthancPluginService_FindMarkIncomplete = 7005,
498  _OrthancPluginService_GetFindQuerySize = 7006,
499  _OrthancPluginService_GetFindQueryTag = 7007,
500  _OrthancPluginService_GetFindQueryTagName = 7008,
501  _OrthancPluginService_GetFindQueryValue = 7009,
502 
503  _OrthancPluginService_INTERNAL = 0x7fffffff
504  } _OrthancPluginService;
505 
506 
507  typedef enum
508  {
509  _OrthancPluginProperty_Description = 1,
510  _OrthancPluginProperty_RootUri = 2,
511  _OrthancPluginProperty_OrthancExplorer = 3,
512 
513  _OrthancPluginProperty_INTERNAL = 0x7fffffff
514  } _OrthancPluginProperty;
515 
516 
517 
522  typedef enum
523  {
531 
539 
547 
555 
563 
566  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
568 
569 
570 
574  typedef enum
575  {
580  _OrthancPluginContentType_INTERNAL = 0x7fffffff
582 
583 
584 
588  typedef enum
589  {
596  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
598 
599 
600 
605  typedef enum
606  {
622  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
624 
625 
630  typedef enum
631  {
637  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
639 
640 
645  typedef enum
646  {
651  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
653 
654 
659  typedef enum
660  {
689  _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
691 
692 
698  typedef enum
699  {
704  _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
706 
707 
713  typedef enum
714  {
722  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
724 
725 
731  typedef enum
732  {
736  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
738 
739 
744  typedef enum
745  {
751  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
753 
754 
758  typedef enum
759  {
766  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
768 
769 
777  typedef struct
778  {
782  void* data;
783 
787  uint32_t size;
789 
790 
791 
792 
797  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
798 
799 
800 
804  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
805 
806 
807 
812  typedef struct _OrthancPluginImage_t OrthancPluginImage;
813 
814 
815 
820  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
821 
822 
823 
828  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
829 
830 
831 
836  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
837 
838 
839 
844  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
845 
846 
847 
852  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
853 
854 
855 
861  OrthancPluginRestOutput* output,
862  const char* url,
863  const OrthancPluginHttpRequest* request);
864 
865 
866 
872  OrthancPluginDicomInstance* instance,
873  const char* instanceId);
874 
875 
876 
882  OrthancPluginChangeType changeType,
883  OrthancPluginResourceType resourceType,
884  const char* resourceId);
885 
886 
887 
893  OrthancPluginImage** target,
894  const void* dicom,
895  const uint32_t size,
896  uint32_t frameIndex);
897 
898 
899 
903  typedef void (*OrthancPluginFree) (void* buffer);
904 
905 
906 
920  const char* uuid,
921  const void* content,
922  int64_t size,
924 
925 
926 
940  void** content,
941  int64_t* size,
942  const char* uuid,
944 
945 
946 
958  const char* uuid,
960 
961 
962 
978  const OrthancPluginWorklistQuery* query,
979  const char* issuerAet,
980  const char* calledAet);
981 
982 
983 
1003  OrthancPluginHttpMethod method,
1004  const char* uri,
1005  const char* ip,
1006  uint32_t headersCount,
1007  const char* const* headersKeys,
1008  const char* const* headersValues);
1009 
1010 
1011 
1027  OrthancPluginFindAnswers* answers,
1028  const OrthancPluginFindQuery* query,
1029  const char* issuerAet,
1030  const char* calledAet);
1031 
1032 
1033 
1067  typedef void* (*OrthancPluginMoveCallback) (
1068  OrthancPluginResourceType resourceType,
1069  const char* patientId,
1070  const char* accessionNumber,
1071  const char* studyInstanceUid,
1072  const char* seriesInstanceUid,
1073  const char* sopInstanceUid,
1074  const char* issuerAet,
1075  const char* sourceAet,
1076  const char* targetAet,
1077  uint16_t moveOriginatorId);
1078 
1079 
1091  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1092 
1093 
1105  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1106 
1107 
1118  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1119 
1120 
1121 
1125  typedef struct _OrthancPluginContext_t
1126  {
1127  void* pluginsManager;
1128  const char* orthancVersion;
1129  OrthancPluginFree Free;
1130  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1131  _OrthancPluginService service,
1132  const void* params);
1134 
1135 
1136 
1140  typedef struct
1141  {
1142  uint16_t group;
1143  uint16_t element;
1145  uint32_t minMultiplicity;
1146  uint32_t maxMultiplicity;
1148 
1149 
1150 
1159  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1160  OrthancPluginContext* context,
1161  char* str)
1162  {
1163  if (str != NULL)
1164  {
1165  context->Free(str);
1166  }
1167  }
1168 
1169 
1183  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1184  OrthancPluginContext* context)
1185  {
1186  int major, minor, revision;
1187 
1188  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1189  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1190  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1191  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1192  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1193  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1194  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1195  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1196  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1197  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1198  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1199  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1200  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1201  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1202  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1203  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin))
1204  {
1205  /* Mismatch in the size of the enumerations */
1206  return 0;
1207  }
1208 
1209  /* Assume compatibility with the mainline */
1210  if (!strcmp(context->orthancVersion, "mainline"))
1211  {
1212  return 1;
1213  }
1214 
1215  /* Parse the version of the Orthanc core */
1216  if (
1217 #ifdef _MSC_VER
1218  sscanf_s
1219 #else
1220  sscanf
1221 #endif
1222  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1223  {
1224  return 0;
1225  }
1226 
1227  /* Check the major number of the version */
1228 
1229  if (major > ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
1230  {
1231  return 1;
1232  }
1233 
1234  if (major < ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
1235  {
1236  return 0;
1237  }
1238 
1239  /* Check the minor number of the version */
1240 
1241  if (minor > ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
1242  {
1243  return 1;
1244  }
1245 
1246  if (minor < ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
1247  {
1248  return 0;
1249  }
1250 
1251  /* Check the revision number of the version */
1252 
1253  if (revision >= ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER)
1254  {
1255  return 1;
1256  }
1257  else
1258  {
1259  return 0;
1260  }
1261  }
1262 
1263 
1272  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1273  OrthancPluginContext* context,
1274  OrthancPluginMemoryBuffer* buffer)
1275  {
1276  context->Free(buffer->data);
1277  }
1278 
1279 
1288  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1289  OrthancPluginContext* context,
1290  const char* message)
1291  {
1292  context->InvokeService(context, _OrthancPluginService_LogError, message);
1293  }
1294 
1295 
1304  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
1305  OrthancPluginContext* context,
1306  const char* message)
1307  {
1308  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1309  }
1310 
1311 
1320  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
1321  OrthancPluginContext* context,
1322  const char* message)
1323  {
1324  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
1325  }
1326 
1327 
1328 
1329  typedef struct
1330  {
1331  const char* pathRegularExpression;
1332  OrthancPluginRestCallback callback;
1333  } _OrthancPluginRestCallback;
1334 
1351  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
1352  OrthancPluginContext* context,
1353  const char* pathRegularExpression,
1354  OrthancPluginRestCallback callback)
1355  {
1356  _OrthancPluginRestCallback params;
1357  params.pathRegularExpression = pathRegularExpression;
1358  params.callback = callback;
1359  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
1360  }
1361 
1362 
1363 
1385  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
1386  OrthancPluginContext* context,
1387  const char* pathRegularExpression,
1388  OrthancPluginRestCallback callback)
1389  {
1390  _OrthancPluginRestCallback params;
1391  params.pathRegularExpression = pathRegularExpression;
1392  params.callback = callback;
1393  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
1394  }
1395 
1396 
1397 
1398  typedef struct
1399  {
1401  } _OrthancPluginOnStoredInstanceCallback;
1402 
1414  OrthancPluginContext* context,
1416  {
1417  _OrthancPluginOnStoredInstanceCallback params;
1418  params.callback = callback;
1419 
1420  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
1421  }
1422 
1423 
1424 
1425  typedef struct
1426  {
1427  OrthancPluginRestOutput* output;
1428  const char* answer;
1429  uint32_t answerSize;
1430  const char* mimeType;
1431  } _OrthancPluginAnswerBuffer;
1432 
1445  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
1446  OrthancPluginContext* context,
1447  OrthancPluginRestOutput* output,
1448  const char* answer,
1449  uint32_t answerSize,
1450  const char* mimeType)
1451  {
1452  _OrthancPluginAnswerBuffer params;
1453  params.output = output;
1454  params.answer = answer;
1455  params.answerSize = answerSize;
1456  params.mimeType = mimeType;
1457  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
1458  }
1459 
1460 
1461  typedef struct
1462  {
1463  OrthancPluginRestOutput* output;
1464  OrthancPluginPixelFormat format;
1465  uint32_t width;
1466  uint32_t height;
1467  uint32_t pitch;
1468  const void* buffer;
1469  } _OrthancPluginCompressAndAnswerPngImage;
1470 
1471  typedef struct
1472  {
1473  OrthancPluginRestOutput* output;
1474  OrthancPluginImageFormat imageFormat;
1475  OrthancPluginPixelFormat pixelFormat;
1476  uint32_t width;
1477  uint32_t height;
1478  uint32_t pitch;
1479  const void* buffer;
1480  uint8_t quality;
1481  } _OrthancPluginCompressAndAnswerImage;
1482 
1483 
1502  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
1503  OrthancPluginContext* context,
1504  OrthancPluginRestOutput* output,
1505  OrthancPluginPixelFormat format,
1506  uint32_t width,
1507  uint32_t height,
1508  uint32_t pitch,
1509  const void* buffer)
1510  {
1511  _OrthancPluginCompressAndAnswerImage params;
1512  params.output = output;
1513  params.imageFormat = OrthancPluginImageFormat_Png;
1514  params.pixelFormat = format;
1515  params.width = width;
1516  params.height = height;
1517  params.pitch = pitch;
1518  params.buffer = buffer;
1519  params.quality = 0; /* No quality for PNG */
1520  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
1521  }
1522 
1523 
1524 
1525  typedef struct
1526  {
1527  OrthancPluginMemoryBuffer* target;
1528  const char* instanceId;
1529  } _OrthancPluginGetDicomForInstance;
1530 
1544  OrthancPluginContext* context,
1545  OrthancPluginMemoryBuffer* target,
1546  const char* instanceId)
1547  {
1548  _OrthancPluginGetDicomForInstance params;
1549  params.target = target;
1550  params.instanceId = instanceId;
1551  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
1552  }
1553 
1554 
1555 
1556  typedef struct
1557  {
1558  OrthancPluginMemoryBuffer* target;
1559  const char* uri;
1560  } _OrthancPluginRestApiGet;
1561 
1577  OrthancPluginContext* context,
1578  OrthancPluginMemoryBuffer* target,
1579  const char* uri)
1580  {
1581  _OrthancPluginRestApiGet params;
1582  params.target = target;
1583  params.uri = uri;
1584  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
1585  }
1586 
1587 
1588 
1607  OrthancPluginContext* context,
1608  OrthancPluginMemoryBuffer* target,
1609  const char* uri)
1610  {
1611  _OrthancPluginRestApiGet params;
1612  params.target = target;
1613  params.uri = uri;
1614  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
1615  }
1616 
1617 
1618 
1619  typedef struct
1620  {
1621  OrthancPluginMemoryBuffer* target;
1622  const char* uri;
1623  const char* body;
1624  uint32_t bodySize;
1625  } _OrthancPluginRestApiPostPut;
1626 
1644  OrthancPluginContext* context,
1645  OrthancPluginMemoryBuffer* target,
1646  const char* uri,
1647  const char* body,
1648  uint32_t bodySize)
1649  {
1650  _OrthancPluginRestApiPostPut params;
1651  params.target = target;
1652  params.uri = uri;
1653  params.body = body;
1654  params.bodySize = bodySize;
1655  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
1656  }
1657 
1658 
1679  OrthancPluginContext* context,
1680  OrthancPluginMemoryBuffer* target,
1681  const char* uri,
1682  const char* body,
1683  uint32_t bodySize)
1684  {
1685  _OrthancPluginRestApiPostPut params;
1686  params.target = target;
1687  params.uri = uri;
1688  params.body = body;
1689  params.bodySize = bodySize;
1690  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
1691  }
1692 
1693 
1694 
1708  OrthancPluginContext* context,
1709  const char* uri)
1710  {
1711  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
1712  }
1713 
1714 
1731  OrthancPluginContext* context,
1732  const char* uri)
1733  {
1734  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
1735  }
1736 
1737 
1738 
1756  OrthancPluginContext* context,
1757  OrthancPluginMemoryBuffer* target,
1758  const char* uri,
1759  const char* body,
1760  uint32_t bodySize)
1761  {
1762  _OrthancPluginRestApiPostPut params;
1763  params.target = target;
1764  params.uri = uri;
1765  params.body = body;
1766  params.bodySize = bodySize;
1767  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
1768  }
1769 
1770 
1771 
1792  OrthancPluginContext* context,
1793  OrthancPluginMemoryBuffer* target,
1794  const char* uri,
1795  const char* body,
1796  uint32_t bodySize)
1797  {
1798  _OrthancPluginRestApiPostPut params;
1799  params.target = target;
1800  params.uri = uri;
1801  params.body = body;
1802  params.bodySize = bodySize;
1803  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
1804  }
1805 
1806 
1807 
1808  typedef struct
1809  {
1810  OrthancPluginRestOutput* output;
1811  const char* argument;
1812  } _OrthancPluginOutputPlusArgument;
1813 
1825  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
1826  OrthancPluginContext* context,
1827  OrthancPluginRestOutput* output,
1828  const char* redirection)
1829  {
1830  _OrthancPluginOutputPlusArgument params;
1831  params.output = output;
1832  params.argument = redirection;
1833  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
1834  }
1835 
1836 
1837 
1838  typedef struct
1839  {
1840  char** result;
1841  const char* argument;
1842  } _OrthancPluginRetrieveDynamicString;
1843 
1857  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
1858  OrthancPluginContext* context,
1859  const char* patientID)
1860  {
1861  char* result;
1862 
1863  _OrthancPluginRetrieveDynamicString params;
1864  params.result = &result;
1865  params.argument = patientID;
1866 
1867  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
1868  {
1869  /* Error */
1870  return NULL;
1871  }
1872  else
1873  {
1874  return result;
1875  }
1876  }
1877 
1878 
1892  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
1893  OrthancPluginContext* context,
1894  const char* studyUID)
1895  {
1896  char* result;
1897 
1898  _OrthancPluginRetrieveDynamicString params;
1899  params.result = &result;
1900  params.argument = studyUID;
1901 
1902  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
1903  {
1904  /* Error */
1905  return NULL;
1906  }
1907  else
1908  {
1909  return result;
1910  }
1911  }
1912 
1913 
1927  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
1928  OrthancPluginContext* context,
1929  const char* accessionNumber)
1930  {
1931  char* result;
1932 
1933  _OrthancPluginRetrieveDynamicString params;
1934  params.result = &result;
1935  params.argument = accessionNumber;
1936 
1937  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
1938  {
1939  /* Error */
1940  return NULL;
1941  }
1942  else
1943  {
1944  return result;
1945  }
1946  }
1947 
1948 
1962  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
1963  OrthancPluginContext* context,
1964  const char* seriesUID)
1965  {
1966  char* result;
1967 
1968  _OrthancPluginRetrieveDynamicString params;
1969  params.result = &result;
1970  params.argument = seriesUID;
1971 
1972  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
1973  {
1974  /* Error */
1975  return NULL;
1976  }
1977  else
1978  {
1979  return result;
1980  }
1981  }
1982 
1983 
1997  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
1998  OrthancPluginContext* context,
1999  const char* sopInstanceUID)
2000  {
2001  char* result;
2002 
2003  _OrthancPluginRetrieveDynamicString params;
2004  params.result = &result;
2005  params.argument = sopInstanceUID;
2006 
2007  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2008  {
2009  /* Error */
2010  return NULL;
2011  }
2012  else
2013  {
2014  return result;
2015  }
2016  }
2017 
2018 
2019 
2020  typedef struct
2021  {
2022  OrthancPluginRestOutput* output;
2023  uint16_t status;
2024  } _OrthancPluginSendHttpStatusCode;
2025 
2042  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2043  OrthancPluginContext* context,
2044  OrthancPluginRestOutput* output,
2045  uint16_t status)
2046  {
2047  _OrthancPluginSendHttpStatusCode params;
2048  params.output = output;
2049  params.status = status;
2050  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2051  }
2052 
2053 
2065  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2066  OrthancPluginContext* context,
2067  OrthancPluginRestOutput* output,
2068  const char* realm)
2069  {
2070  _OrthancPluginOutputPlusArgument params;
2071  params.output = output;
2072  params.argument = realm;
2073  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2074  }
2075 
2076 
2088  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2089  OrthancPluginContext* context,
2090  OrthancPluginRestOutput* output,
2091  const char* allowedMethods)
2092  {
2093  _OrthancPluginOutputPlusArgument params;
2094  params.output = output;
2095  params.argument = allowedMethods;
2096  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2097  }
2098 
2099 
2100  typedef struct
2101  {
2102  OrthancPluginRestOutput* output;
2103  const char* key;
2104  const char* value;
2105  } _OrthancPluginSetHttpHeader;
2106 
2118  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2119  OrthancPluginContext* context,
2120  OrthancPluginRestOutput* output,
2121  const char* cookie,
2122  const char* value)
2123  {
2124  _OrthancPluginSetHttpHeader params;
2125  params.output = output;
2126  params.key = cookie;
2127  params.value = value;
2128  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2129  }
2130 
2131 
2143  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2144  OrthancPluginContext* context,
2145  OrthancPluginRestOutput* output,
2146  const char* key,
2147  const char* value)
2148  {
2149  _OrthancPluginSetHttpHeader params;
2150  params.output = output;
2151  params.key = key;
2152  params.value = value;
2153  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2154  }
2155 
2156 
2157  typedef struct
2158  {
2159  char** resultStringToFree;
2160  const char** resultString;
2161  int64_t* resultInt64;
2162  const char* key;
2163  OrthancPluginDicomInstance* instance;
2164  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2165  } _OrthancPluginAccessDicomInstance;
2166 
2167 
2179  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2180  OrthancPluginContext* context,
2181  OrthancPluginDicomInstance* instance)
2182  {
2183  const char* result;
2184 
2185  _OrthancPluginAccessDicomInstance params;
2186  memset(&params, 0, sizeof(params));
2187  params.resultString = &result;
2188  params.instance = instance;
2189 
2190  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2191  {
2192  /* Error */
2193  return NULL;
2194  }
2195  else
2196  {
2197  return result;
2198  }
2199  }
2200 
2201 
2212  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2213  OrthancPluginContext* context,
2214  OrthancPluginDicomInstance* instance)
2215  {
2216  int64_t size;
2217 
2218  _OrthancPluginAccessDicomInstance params;
2219  memset(&params, 0, sizeof(params));
2220  params.resultInt64 = &size;
2221  params.instance = instance;
2222 
2223  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2224  {
2225  /* Error */
2226  return -1;
2227  }
2228  else
2229  {
2230  return size;
2231  }
2232  }
2233 
2234 
2245  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceData(
2246  OrthancPluginContext* context,
2247  OrthancPluginDicomInstance* instance)
2248  {
2249  const char* result;
2250 
2251  _OrthancPluginAccessDicomInstance params;
2252  memset(&params, 0, sizeof(params));
2253  params.resultString = &result;
2254  params.instance = instance;
2255 
2256  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2257  {
2258  /* Error */
2259  return NULL;
2260  }
2261  else
2262  {
2263  return result;
2264  }
2265  }
2266 
2267 
2281  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
2282  OrthancPluginContext* context,
2283  OrthancPluginDicomInstance* instance)
2284  {
2285  char* result;
2286 
2287  _OrthancPluginAccessDicomInstance params;
2288  memset(&params, 0, sizeof(params));
2289  params.resultStringToFree = &result;
2290  params.instance = instance;
2291 
2292  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
2293  {
2294  /* Error */
2295  return NULL;
2296  }
2297  else
2298  {
2299  return result;
2300  }
2301  }
2302 
2303 
2319  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
2320  OrthancPluginContext* context,
2321  OrthancPluginDicomInstance* instance)
2322  {
2323  char* result;
2324 
2325  _OrthancPluginAccessDicomInstance params;
2326  memset(&params, 0, sizeof(params));
2327  params.resultStringToFree = &result;
2328  params.instance = instance;
2329 
2330  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
2331  {
2332  /* Error */
2333  return NULL;
2334  }
2335  else
2336  {
2337  return result;
2338  }
2339  }
2340 
2341 
2358  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
2359  OrthancPluginContext* context,
2360  OrthancPluginDicomInstance* instance,
2361  const char* metadata)
2362  {
2363  int64_t result;
2364 
2365  _OrthancPluginAccessDicomInstance params;
2366  memset(&params, 0, sizeof(params));
2367  params.resultInt64 = &result;
2368  params.instance = instance;
2369  params.key = metadata;
2370 
2371  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2372  {
2373  /* Error */
2374  return -1;
2375  }
2376  else
2377  {
2378  return (result != 0);
2379  }
2380  }
2381 
2382 
2396  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
2397  OrthancPluginContext* context,
2398  OrthancPluginDicomInstance* instance,
2399  const char* metadata)
2400  {
2401  const char* result;
2402 
2403  _OrthancPluginAccessDicomInstance params;
2404  memset(&params, 0, sizeof(params));
2405  params.resultString = &result;
2406  params.instance = instance;
2407  params.key = metadata;
2408 
2409  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2410  {
2411  /* Error */
2412  return NULL;
2413  }
2414  else
2415  {
2416  return result;
2417  }
2418  }
2419 
2420 
2421 
2422  typedef struct
2423  {
2427  OrthancPluginFree free;
2428  } _OrthancPluginRegisterStorageArea;
2429 
2444  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
2445  OrthancPluginContext* context,
2449  {
2450  _OrthancPluginRegisterStorageArea params;
2451  params.create = create;
2452  params.read = read;
2453  params.remove = remove;
2454 
2455 #ifdef __cplusplus
2456  params.free = ::free;
2457 #else
2458  params.free = free;
2459 #endif
2460 
2461  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
2462  }
2463 
2464 
2465 
2476  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
2477  {
2478  char* result;
2479 
2480  _OrthancPluginRetrieveDynamicString params;
2481  params.result = &result;
2482  params.argument = NULL;
2483 
2484  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
2485  {
2486  /* Error */
2487  return NULL;
2488  }
2489  else
2490  {
2491  return result;
2492  }
2493  }
2494 
2495 
2506  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
2507  {
2508  char* result;
2509 
2510  _OrthancPluginRetrieveDynamicString params;
2511  params.result = &result;
2512  params.argument = NULL;
2513 
2514  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
2515  {
2516  /* Error */
2517  return NULL;
2518  }
2519  else
2520  {
2521  return result;
2522  }
2523  }
2524 
2525 
2541  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
2542  {
2543  char* result;
2544 
2545  _OrthancPluginRetrieveDynamicString params;
2546  params.result = &result;
2547  params.argument = NULL;
2548 
2549  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
2550  {
2551  /* Error */
2552  return NULL;
2553  }
2554  else
2555  {
2556  return result;
2557  }
2558  }
2559 
2560 
2561 
2562  typedef struct
2563  {
2565  } _OrthancPluginOnChangeCallback;
2566 
2583  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
2584  OrthancPluginContext* context,
2586  {
2587  _OrthancPluginOnChangeCallback params;
2588  params.callback = callback;
2589 
2590  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
2591  }
2592 
2593 
2594 
2595  typedef struct
2596  {
2597  const char* plugin;
2598  _OrthancPluginProperty property;
2599  const char* value;
2600  } _OrthancPluginSetPluginProperty;
2601 
2602 
2614  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
2615  OrthancPluginContext* context,
2616  const char* uri)
2617  {
2618  _OrthancPluginSetPluginProperty params;
2619  params.plugin = OrthancPluginGetName();
2620  params.property = _OrthancPluginProperty_RootUri;
2621  params.value = uri;
2622 
2623  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2624  }
2625 
2626 
2636  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
2637  OrthancPluginContext* context,
2638  const char* description)
2639  {
2640  _OrthancPluginSetPluginProperty params;
2641  params.plugin = OrthancPluginGetName();
2642  params.property = _OrthancPluginProperty_Description;
2643  params.value = description;
2644 
2645  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2646  }
2647 
2648 
2658  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
2659  OrthancPluginContext* context,
2660  const char* javascript)
2661  {
2662  _OrthancPluginSetPluginProperty params;
2663  params.plugin = OrthancPluginGetName();
2664  params.property = _OrthancPluginProperty_OrthancExplorer;
2665  params.value = javascript;
2666 
2667  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2668  }
2669 
2670 
2671  typedef struct
2672  {
2673  char** result;
2674  int32_t property;
2675  const char* value;
2676  } _OrthancPluginGlobalProperty;
2677 
2678 
2692  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
2693  OrthancPluginContext* context,
2694  int32_t property,
2695  const char* defaultValue)
2696  {
2697  char* result;
2698 
2699  _OrthancPluginGlobalProperty params;
2700  params.result = &result;
2701  params.property = property;
2702  params.value = defaultValue;
2703 
2704  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
2705  {
2706  /* Error */
2707  return NULL;
2708  }
2709  else
2710  {
2711  return result;
2712  }
2713  }
2714 
2715 
2732  OrthancPluginContext* context,
2733  int32_t property,
2734  const char* value)
2735  {
2736  _OrthancPluginGlobalProperty params;
2737  params.result = NULL;
2738  params.property = property;
2739  params.value = value;
2740 
2741  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
2742  }
2743 
2744 
2745 
2746  typedef struct
2747  {
2748  int32_t *resultInt32;
2749  uint32_t *resultUint32;
2750  int64_t *resultInt64;
2751  uint64_t *resultUint64;
2752  } _OrthancPluginReturnSingleValue;
2753 
2762  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
2763  OrthancPluginContext* context)
2764  {
2765  uint32_t count = 0;
2766 
2767  _OrthancPluginReturnSingleValue params;
2768  memset(&params, 0, sizeof(params));
2769  params.resultUint32 = &count;
2770 
2771  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
2772  {
2773  /* Error */
2774  return 0;
2775  }
2776  else
2777  {
2778  return count;
2779  }
2780  }
2781 
2782 
2783 
2796  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
2797  OrthancPluginContext* context,
2798  uint32_t argument)
2799  {
2800  char* result;
2801 
2802  _OrthancPluginGlobalProperty params;
2803  params.result = &result;
2804  params.property = (int32_t) argument;
2805  params.value = NULL;
2806 
2807  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
2808  {
2809  /* Error */
2810  return NULL;
2811  }
2812  else
2813  {
2814  return result;
2815  }
2816  }
2817 
2818 
2829  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
2830  OrthancPluginContext* context)
2831  {
2832  uint32_t count = 0;
2833 
2834  _OrthancPluginReturnSingleValue params;
2835  memset(&params, 0, sizeof(params));
2836  params.resultUint32 = &count;
2837 
2838  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
2839  {
2840  /* Error */
2841  return 0;
2842  }
2843  else
2844  {
2845  return count;
2846  }
2847  }
2848 
2849 
2850 
2862  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
2863  {
2864  char* result;
2865 
2866  _OrthancPluginRetrieveDynamicString params;
2867  params.result = &result;
2868  params.argument = NULL;
2869 
2870  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
2871  {
2872  /* Error */
2873  return NULL;
2874  }
2875  else
2876  {
2877  return result;
2878  }
2879  }
2880 
2881 
2882 
2883  typedef struct
2884  {
2885  OrthancPluginRestOutput* output;
2886  const char* subType;
2887  const char* contentType;
2888  } _OrthancPluginStartMultipartAnswer;
2889 
2904  OrthancPluginContext* context,
2905  OrthancPluginRestOutput* output,
2906  const char* subType,
2907  const char* contentType)
2908  {
2909  _OrthancPluginStartMultipartAnswer params;
2910  params.output = output;
2911  params.subType = subType;
2912  params.contentType = contentType;
2913  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
2914  }
2915 
2916 
2933  OrthancPluginContext* context,
2934  OrthancPluginRestOutput* output,
2935  const char* answer,
2936  uint32_t answerSize)
2937  {
2938  _OrthancPluginAnswerBuffer params;
2939  params.output = output;
2940  params.answer = answer;
2941  params.answerSize = answerSize;
2942  params.mimeType = NULL;
2943  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
2944  }
2945 
2946 
2947 
2948  typedef struct
2949  {
2950  OrthancPluginMemoryBuffer* target;
2951  const void* source;
2952  uint32_t size;
2953  OrthancPluginCompressionType compression;
2954  uint8_t uncompress;
2955  } _OrthancPluginBufferCompression;
2956 
2957 
2975  OrthancPluginContext* context,
2976  OrthancPluginMemoryBuffer* target,
2977  const void* source,
2978  uint32_t size,
2979  OrthancPluginCompressionType compression,
2980  uint8_t uncompress)
2981  {
2982  _OrthancPluginBufferCompression params;
2983  params.target = target;
2984  params.source = source;
2985  params.size = size;
2986  params.compression = compression;
2987  params.uncompress = uncompress;
2988 
2989  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
2990  }
2991 
2992 
2993 
2994  typedef struct
2995  {
2996  OrthancPluginMemoryBuffer* target;
2997  const char* path;
2998  } _OrthancPluginReadFile;
2999 
3012  OrthancPluginContext* context,
3013  OrthancPluginMemoryBuffer* target,
3014  const char* path)
3015  {
3016  _OrthancPluginReadFile params;
3017  params.target = target;
3018  params.path = path;
3019  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3020  }
3021 
3022 
3023 
3024  typedef struct
3025  {
3026  const char* path;
3027  const void* data;
3028  uint32_t size;
3029  } _OrthancPluginWriteFile;
3030 
3043  OrthancPluginContext* context,
3044  const char* path,
3045  const void* data,
3046  uint32_t size)
3047  {
3048  _OrthancPluginWriteFile params;
3049  params.path = path;
3050  params.data = data;
3051  params.size = size;
3052  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3053  }
3054 
3055 
3056 
3057  typedef struct
3058  {
3059  const char** target;
3060  OrthancPluginErrorCode error;
3061  } _OrthancPluginGetErrorDescription;
3062 
3073  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3074  OrthancPluginContext* context,
3075  OrthancPluginErrorCode error)
3076  {
3077  const char* result = NULL;
3078 
3079  _OrthancPluginGetErrorDescription params;
3080  params.target = &result;
3081  params.error = error;
3082 
3083  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3084  result == NULL)
3085  {
3086  return "Unknown error code";
3087  }
3088  else
3089  {
3090  return result;
3091  }
3092  }
3093 
3094 
3095 
3096  typedef struct
3097  {
3098  OrthancPluginRestOutput* output;
3099  uint16_t status;
3100  const char* body;
3101  uint32_t bodySize;
3102  } _OrthancPluginSendHttpStatus;
3103 
3126  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3127  OrthancPluginContext* context,
3128  OrthancPluginRestOutput* output,
3129  uint16_t status,
3130  const char* body,
3131  uint32_t bodySize)
3132  {
3133  _OrthancPluginSendHttpStatus params;
3134  params.output = output;
3135  params.status = status;
3136  params.body = body;
3137  params.bodySize = bodySize;
3138  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3139  }
3140 
3141 
3142 
3143  typedef struct
3144  {
3145  const OrthancPluginImage* image;
3146  uint32_t* resultUint32;
3147  OrthancPluginPixelFormat* resultPixelFormat;
3148  void** resultBuffer;
3149  } _OrthancPluginGetImageInfo;
3150 
3151 
3163  OrthancPluginContext* context,
3164  const OrthancPluginImage* image)
3165  {
3166  OrthancPluginPixelFormat target;
3167 
3168  _OrthancPluginGetImageInfo params;
3169  memset(&params, 0, sizeof(params));
3170  params.image = image;
3171  params.resultPixelFormat = &target;
3172 
3173  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3174  {
3176  }
3177  else
3178  {
3179  return (OrthancPluginPixelFormat) target;
3180  }
3181  }
3182 
3183 
3184 
3195  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3196  OrthancPluginContext* context,
3197  const OrthancPluginImage* image)
3198  {
3199  uint32_t width;
3200 
3201  _OrthancPluginGetImageInfo params;
3202  memset(&params, 0, sizeof(params));
3203  params.image = image;
3204  params.resultUint32 = &width;
3205 
3206  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3207  {
3208  return 0;
3209  }
3210  else
3211  {
3212  return width;
3213  }
3214  }
3215 
3216 
3217 
3228  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3229  OrthancPluginContext* context,
3230  const OrthancPluginImage* image)
3231  {
3232  uint32_t height;
3233 
3234  _OrthancPluginGetImageInfo params;
3235  memset(&params, 0, sizeof(params));
3236  params.image = image;
3237  params.resultUint32 = &height;
3238 
3239  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3240  {
3241  return 0;
3242  }
3243  else
3244  {
3245  return height;
3246  }
3247  }
3248 
3249 
3250 
3263  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3264  OrthancPluginContext* context,
3265  const OrthancPluginImage* image)
3266  {
3267  uint32_t pitch;
3268 
3269  _OrthancPluginGetImageInfo params;
3270  memset(&params, 0, sizeof(params));
3271  params.image = image;
3272  params.resultUint32 = &pitch;
3273 
3274  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
3275  {
3276  return 0;
3277  }
3278  else
3279  {
3280  return pitch;
3281  }
3282  }
3283 
3284 
3285 
3297  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
3298  OrthancPluginContext* context,
3299  const OrthancPluginImage* image)
3300  {
3301  void* target = NULL;
3302 
3303  _OrthancPluginGetImageInfo params;
3304  memset(&params, 0, sizeof(params));
3305  params.resultBuffer = &target;
3306  params.image = image;
3307 
3308  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
3309  {
3310  return NULL;
3311  }
3312  else
3313  {
3314  return target;
3315  }
3316  }
3317 
3318 
3319  typedef struct
3320  {
3321  OrthancPluginImage** target;
3322  const void* data;
3323  uint32_t size;
3324  OrthancPluginImageFormat format;
3325  } _OrthancPluginUncompressImage;
3326 
3327 
3341  OrthancPluginContext* context,
3342  const void* data,
3343  uint32_t size,
3344  OrthancPluginImageFormat format)
3345  {
3346  OrthancPluginImage* target = NULL;
3347 
3348  _OrthancPluginUncompressImage params;
3349  memset(&params, 0, sizeof(params));
3350  params.target = &target;
3351  params.data = data;
3352  params.size = size;
3353  params.format = format;
3354 
3355  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
3356  {
3357  return NULL;
3358  }
3359  else
3360  {
3361  return target;
3362  }
3363  }
3364 
3365 
3366 
3367 
3368  typedef struct
3369  {
3370  OrthancPluginImage* image;
3371  } _OrthancPluginFreeImage;
3372 
3382  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
3383  OrthancPluginContext* context,
3384  OrthancPluginImage* image)
3385  {
3386  _OrthancPluginFreeImage params;
3387  params.image = image;
3388 
3389  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
3390  }
3391 
3392 
3393 
3394 
3395  typedef struct
3396  {
3397  OrthancPluginMemoryBuffer* target;
3398  OrthancPluginImageFormat imageFormat;
3399  OrthancPluginPixelFormat pixelFormat;
3400  uint32_t width;
3401  uint32_t height;
3402  uint32_t pitch;
3403  const void* buffer;
3404  uint8_t quality;
3405  } _OrthancPluginCompressImage;
3406 
3407 
3428  OrthancPluginContext* context,
3429  OrthancPluginMemoryBuffer* target,
3430  OrthancPluginPixelFormat format,
3431  uint32_t width,
3432  uint32_t height,
3433  uint32_t pitch,
3434  const void* buffer)
3435  {
3436  _OrthancPluginCompressImage params;
3437  memset(&params, 0, sizeof(params));
3438  params.target = target;
3439  params.imageFormat = OrthancPluginImageFormat_Png;
3440  params.pixelFormat = format;
3441  params.width = width;
3442  params.height = height;
3443  params.pitch = pitch;
3444  params.buffer = buffer;
3445  params.quality = 0; /* Unused for PNG */
3446 
3447  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3448  }
3449 
3450 
3473  OrthancPluginContext* context,
3474  OrthancPluginMemoryBuffer* target,
3475  OrthancPluginPixelFormat format,
3476  uint32_t width,
3477  uint32_t height,
3478  uint32_t pitch,
3479  const void* buffer,
3480  uint8_t quality)
3481  {
3482  _OrthancPluginCompressImage params;
3483  memset(&params, 0, sizeof(params));
3484  params.target = target;
3485  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3486  params.pixelFormat = format;
3487  params.width = width;
3488  params.height = height;
3489  params.pitch = pitch;
3490  params.buffer = buffer;
3491  params.quality = quality;
3492 
3493  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3494  }
3495 
3496 
3497 
3519  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
3520  OrthancPluginContext* context,
3521  OrthancPluginRestOutput* output,
3522  OrthancPluginPixelFormat format,
3523  uint32_t width,
3524  uint32_t height,
3525  uint32_t pitch,
3526  const void* buffer,
3527  uint8_t quality)
3528  {
3529  _OrthancPluginCompressAndAnswerImage params;
3530  params.output = output;
3531  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3532  params.pixelFormat = format;
3533  params.width = width;
3534  params.height = height;
3535  params.pitch = pitch;
3536  params.buffer = buffer;
3537  params.quality = quality;
3538  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
3539  }
3540 
3541 
3542 
3543 
3544  typedef struct
3545  {
3546  OrthancPluginMemoryBuffer* target;
3547  OrthancPluginHttpMethod method;
3548  const char* url;
3549  const char* username;
3550  const char* password;
3551  const char* body;
3552  uint32_t bodySize;
3553  } _OrthancPluginCallHttpClient;
3554 
3555 
3572  OrthancPluginContext* context,
3573  OrthancPluginMemoryBuffer* target,
3574  const char* url,
3575  const char* username,
3576  const char* password)
3577  {
3578  _OrthancPluginCallHttpClient params;
3579  memset(&params, 0, sizeof(params));
3580 
3581  params.target = target;
3582  params.method = OrthancPluginHttpMethod_Get;
3583  params.url = url;
3584  params.username = username;
3585  params.password = password;
3586 
3587  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3588  }
3589 
3590 
3609  OrthancPluginContext* context,
3610  OrthancPluginMemoryBuffer* target,
3611  const char* url,
3612  const char* body,
3613  uint32_t bodySize,
3614  const char* username,
3615  const char* password)
3616  {
3617  _OrthancPluginCallHttpClient params;
3618  memset(&params, 0, sizeof(params));
3619 
3620  params.target = target;
3621  params.method = OrthancPluginHttpMethod_Post;
3622  params.url = url;
3623  params.body = body;
3624  params.bodySize = bodySize;
3625  params.username = username;
3626  params.password = password;
3627 
3628  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3629  }
3630 
3631 
3650  OrthancPluginContext* context,
3651  OrthancPluginMemoryBuffer* target,
3652  const char* url,
3653  const char* body,
3654  uint32_t bodySize,
3655  const char* username,
3656  const char* password)
3657  {
3658  _OrthancPluginCallHttpClient params;
3659  memset(&params, 0, sizeof(params));
3660 
3661  params.target = target;
3662  params.method = OrthancPluginHttpMethod_Put;
3663  params.url = url;
3664  params.body = body;
3665  params.bodySize = bodySize;
3666  params.username = username;
3667  params.password = password;
3668 
3669  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3670  }
3671 
3672 
3687  OrthancPluginContext* context,
3688  const char* url,
3689  const char* username,
3690  const char* password)
3691  {
3692  _OrthancPluginCallHttpClient params;
3693  memset(&params, 0, sizeof(params));
3694 
3695  params.method = OrthancPluginHttpMethod_Delete;
3696  params.url = url;
3697  params.username = username;
3698  params.password = password;
3699 
3700  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3701  }
3702 
3703 
3704 
3705  typedef struct
3706  {
3707  OrthancPluginImage** target;
3708  const OrthancPluginImage* source;
3709  OrthancPluginPixelFormat targetFormat;
3710  } _OrthancPluginConvertPixelFormat;
3711 
3712 
3725  OrthancPluginContext* context,
3726  const OrthancPluginImage* source,
3727  OrthancPluginPixelFormat targetFormat)
3728  {
3729  OrthancPluginImage* target = NULL;
3730 
3731  _OrthancPluginConvertPixelFormat params;
3732  params.target = &target;
3733  params.source = source;
3734  params.targetFormat = targetFormat;
3735 
3736  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
3737  {
3738  return NULL;
3739  }
3740  else
3741  {
3742  return target;
3743  }
3744  }
3745 
3746 
3747 
3759  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
3760  OrthancPluginContext* context)
3761  {
3762  uint32_t count = 0;
3763 
3764  _OrthancPluginReturnSingleValue params;
3765  memset(&params, 0, sizeof(params));
3766  params.resultUint32 = &count;
3767 
3768  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
3769  {
3770  /* Error */
3771  return 0;
3772  }
3773  else
3774  {
3775  return count;
3776  }
3777  }
3778 
3779 
3780 
3781 
3782  typedef struct
3783  {
3784  uint32_t fontIndex; /* in */
3785  const char** name; /* out */
3786  uint32_t* size; /* out */
3787  } _OrthancPluginGetFontInfo;
3788 
3799  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
3800  OrthancPluginContext* context,
3801  uint32_t fontIndex)
3802  {
3803  const char* result = NULL;
3804 
3805  _OrthancPluginGetFontInfo params;
3806  memset(&params, 0, sizeof(params));
3807  params.name = &result;
3808  params.fontIndex = fontIndex;
3809 
3810  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
3811  {
3812  return NULL;
3813  }
3814  else
3815  {
3816  return result;
3817  }
3818  }
3819 
3820 
3831  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
3832  OrthancPluginContext* context,
3833  uint32_t fontIndex)
3834  {
3835  uint32_t result;
3836 
3837  _OrthancPluginGetFontInfo params;
3838  memset(&params, 0, sizeof(params));
3839  params.size = &result;
3840  params.fontIndex = fontIndex;
3841 
3842  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
3843  {
3844  return 0;
3845  }
3846  else
3847  {
3848  return result;
3849  }
3850  }
3851 
3852 
3853 
3854  typedef struct
3855  {
3856  OrthancPluginImage* image;
3857  uint32_t fontIndex;
3858  const char* utf8Text;
3859  int32_t x;
3860  int32_t y;
3861  uint8_t r;
3862  uint8_t g;
3863  uint8_t b;
3864  } _OrthancPluginDrawText;
3865 
3866 
3885  OrthancPluginContext* context,
3886  OrthancPluginImage* image,
3887  uint32_t fontIndex,
3888  const char* utf8Text,
3889  int32_t x,
3890  int32_t y,
3891  uint8_t r,
3892  uint8_t g,
3893  uint8_t b)
3894  {
3895  _OrthancPluginDrawText params;
3896  memset(&params, 0, sizeof(params));
3897  params.image = image;
3898  params.fontIndex = fontIndex;
3899  params.utf8Text = utf8Text;
3900  params.x = x;
3901  params.y = y;
3902  params.r = r;
3903  params.g = g;
3904  params.b = b;
3905 
3906  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
3907  }
3908 
3909 
3910 
3911  typedef struct
3912  {
3913  OrthancPluginStorageArea* storageArea;
3914  const char* uuid;
3915  const void* content;
3916  uint64_t size;
3918  } _OrthancPluginStorageAreaCreate;
3919 
3920 
3937  OrthancPluginContext* context,
3938  OrthancPluginStorageArea* storageArea,
3939  const char* uuid,
3940  const void* content,
3941  uint64_t size,
3943  {
3944  _OrthancPluginStorageAreaCreate params;
3945  params.storageArea = storageArea;
3946  params.uuid = uuid;
3947  params.content = content;
3948  params.size = size;
3949  params.type = type;
3950 
3951  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
3952  }
3953 
3954 
3955  typedef struct
3956  {
3957  OrthancPluginMemoryBuffer* target;
3958  OrthancPluginStorageArea* storageArea;
3959  const char* uuid;
3961  } _OrthancPluginStorageAreaRead;
3962 
3963 
3979  OrthancPluginContext* context,
3980  OrthancPluginMemoryBuffer* target,
3981  OrthancPluginStorageArea* storageArea,
3982  const char* uuid,
3984  {
3985  _OrthancPluginStorageAreaRead params;
3986  params.target = target;
3987  params.storageArea = storageArea;
3988  params.uuid = uuid;
3989  params.type = type;
3990 
3991  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
3992  }
3993 
3994 
3995  typedef struct
3996  {
3997  OrthancPluginStorageArea* storageArea;
3998  const char* uuid;
4000  } _OrthancPluginStorageAreaRemove;
4001 
4016  OrthancPluginContext* context,
4017  OrthancPluginStorageArea* storageArea,
4018  const char* uuid,
4020  {
4021  _OrthancPluginStorageAreaRemove params;
4022  params.storageArea = storageArea;
4023  params.uuid = uuid;
4024  params.type = type;
4025 
4026  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4027  }
4028 
4029 
4030 
4031  typedef struct
4032  {
4033  OrthancPluginErrorCode* target;
4034  int32_t code;
4035  uint16_t httpStatus;
4036  const char* message;
4037  } _OrthancPluginRegisterErrorCode;
4038 
4055  OrthancPluginContext* context,
4056  int32_t code,
4057  uint16_t httpStatus,
4058  const char* message)
4059  {
4060  OrthancPluginErrorCode target;
4061 
4062  _OrthancPluginRegisterErrorCode params;
4063  params.target = &target;
4064  params.code = code;
4065  params.httpStatus = httpStatus;
4066  params.message = message;
4067 
4068  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4069  {
4070  return target;
4071  }
4072  else
4073  {
4074  /* There was an error while assigned the error. Use a generic code. */
4076  }
4077  }
4078 
4079 
4080 
4081  typedef struct
4082  {
4083  uint16_t group;
4084  uint16_t element;
4086  const char* name;
4087  uint32_t minMultiplicity;
4088  uint32_t maxMultiplicity;
4089  } _OrthancPluginRegisterDictionaryTag;
4090 
4110  OrthancPluginContext* context,
4111  uint16_t group,
4112  uint16_t element,
4114  const char* name,
4115  uint32_t minMultiplicity,
4116  uint32_t maxMultiplicity)
4117  {
4118  _OrthancPluginRegisterDictionaryTag params;
4119  params.group = group;
4120  params.element = element;
4121  params.vr = vr;
4122  params.name = name;
4123  params.minMultiplicity = minMultiplicity;
4124  params.maxMultiplicity = maxMultiplicity;
4125 
4126  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4127  }
4128 
4129 
4130 
4131 
4132  typedef struct
4133  {
4134  OrthancPluginStorageArea* storageArea;
4136  } _OrthancPluginReconstructMainDicomTags;
4137 
4155  OrthancPluginContext* context,
4156  OrthancPluginStorageArea* storageArea,
4158  {
4159  _OrthancPluginReconstructMainDicomTags params;
4160  params.level = level;
4161  params.storageArea = storageArea;
4162 
4163  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
4164  }
4165 
4166 
4167  typedef struct
4168  {
4169  char** result;
4170  const char* instanceId;
4171  const void* buffer;
4172  uint32_t size;
4175  uint32_t maxStringLength;
4176  } _OrthancPluginDicomToJson;
4177 
4178 
4198  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4199  OrthancPluginContext* context,
4200  const void* buffer,
4201  uint32_t size,
4204  uint32_t maxStringLength)
4205  {
4206  char* result;
4207 
4208  _OrthancPluginDicomToJson params;
4209  memset(&params, 0, sizeof(params));
4210  params.result = &result;
4211  params.buffer = buffer;
4212  params.size = size;
4213  params.format = format;
4214  params.flags = flags;
4215  params.maxStringLength = maxStringLength;
4216 
4217  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
4218  {
4219  /* Error */
4220  return NULL;
4221  }
4222  else
4223  {
4224  return result;
4225  }
4226  }
4227 
4228 
4247  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
4248  OrthancPluginContext* context,
4249  const char* instanceId,
4252  uint32_t maxStringLength)
4253  {
4254  char* result;
4255 
4256  _OrthancPluginDicomToJson params;
4257  memset(&params, 0, sizeof(params));
4258  params.result = &result;
4259  params.instanceId = instanceId;
4260  params.format = format;
4261  params.flags = flags;
4262  params.maxStringLength = maxStringLength;
4263 
4264  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
4265  {
4266  /* Error */
4267  return NULL;
4268  }
4269  else
4270  {
4271  return result;
4272  }
4273  }
4274 
4275 
4276  typedef struct
4277  {
4278  OrthancPluginMemoryBuffer* target;
4279  const char* uri;
4280  uint32_t headersCount;
4281  const char* const* headersKeys;
4282  const char* const* headersValues;
4283  int32_t afterPlugins;
4284  } _OrthancPluginRestApiGet2;
4285 
4306  OrthancPluginContext* context,
4307  OrthancPluginMemoryBuffer* target,
4308  const char* uri,
4309  uint32_t headersCount,
4310  const char* const* headersKeys,
4311  const char* const* headersValues,
4312  int32_t afterPlugins)
4313  {
4314  _OrthancPluginRestApiGet2 params;
4315  params.target = target;
4316  params.uri = uri;
4317  params.headersCount = headersCount;
4318  params.headersKeys = headersKeys;
4319  params.headersValues = headersValues;
4320  params.afterPlugins = afterPlugins;
4321 
4322  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
4323  }
4324 
4325 
4326 
4327  typedef struct
4328  {
4330  } _OrthancPluginWorklistCallback;
4331 
4344  OrthancPluginContext* context,
4346  {
4347  _OrthancPluginWorklistCallback params;
4348  params.callback = callback;
4349 
4350  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
4351  }
4352 
4353 
4354 
4355  typedef struct
4356  {
4358  const OrthancPluginWorklistQuery* query;
4359  const void* dicom;
4360  uint32_t size;
4361  } _OrthancPluginWorklistAnswersOperation;
4362 
4380  OrthancPluginContext* context,
4382  const OrthancPluginWorklistQuery* query,
4383  const void* dicom,
4384  uint32_t size)
4385  {
4386  _OrthancPluginWorklistAnswersOperation params;
4387  params.answers = answers;
4388  params.query = query;
4389  params.dicom = dicom;
4390  params.size = size;
4391 
4392  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
4393  }
4394 
4395 
4410  OrthancPluginContext* context,
4412  {
4413  _OrthancPluginWorklistAnswersOperation params;
4414  params.answers = answers;
4415  params.query = NULL;
4416  params.dicom = NULL;
4417  params.size = 0;
4418 
4419  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
4420  }
4421 
4422 
4423  typedef struct
4424  {
4425  const OrthancPluginWorklistQuery* query;
4426  const void* dicom;
4427  uint32_t size;
4428  int32_t* isMatch;
4429  OrthancPluginMemoryBuffer* target;
4430  } _OrthancPluginWorklistQueryOperation;
4431 
4447  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
4448  OrthancPluginContext* context,
4449  const OrthancPluginWorklistQuery* query,
4450  const void* dicom,
4451  uint32_t size)
4452  {
4453  int32_t isMatch = 0;
4454 
4455  _OrthancPluginWorklistQueryOperation params;
4456  params.query = query;
4457  params.dicom = dicom;
4458  params.size = size;
4459  params.isMatch = &isMatch;
4460  params.target = NULL;
4461 
4462  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
4463  {
4464  return isMatch;
4465  }
4466  else
4467  {
4468  /* Error: Assume non-match */
4469  return 0;
4470  }
4471  }
4472 
4473 
4487  OrthancPluginContext* context,
4488  OrthancPluginMemoryBuffer* target,
4489  const OrthancPluginWorklistQuery* query)
4490  {
4491  _OrthancPluginWorklistQueryOperation params;
4492  params.query = query;
4493  params.dicom = NULL;
4494  params.size = 0;
4495  params.isMatch = NULL;
4496  params.target = target;
4497 
4498  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
4499  }
4500 
4501 
4513  OrthancPluginContext* context,
4514  OrthancPluginDicomInstance* instance)
4515  {
4517 
4518  _OrthancPluginAccessDicomInstance params;
4519  memset(&params, 0, sizeof(params));
4520  params.resultOrigin = &origin;
4521  params.instance = instance;
4522 
4523  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
4524  {
4525  /* Error */
4527  }
4528  else
4529  {
4530  return origin;
4531  }
4532  }
4533 
4534 
4535  typedef struct
4536  {
4537  OrthancPluginMemoryBuffer* target;
4538  const char* json;
4539  const OrthancPluginImage* pixelData;
4541  } _OrthancPluginCreateDicom;
4542 
4562  OrthancPluginContext* context,
4563  OrthancPluginMemoryBuffer* target,
4564  const char* json,
4565  const OrthancPluginImage* pixelData,
4567  {
4568  _OrthancPluginCreateDicom params;
4569  params.target = target;
4570  params.json = json;
4571  params.pixelData = pixelData;
4572  params.flags = flags;
4573 
4574  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
4575  }
4576 
4577 
4578  typedef struct
4579  {
4581  } _OrthancPluginDecodeImageCallback;
4582 
4595  OrthancPluginContext* context,
4597  {
4598  _OrthancPluginDecodeImageCallback params;
4599  params.callback = callback;
4600 
4601  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
4602  }
4603 
4604 
4605 
4606  typedef struct
4607  {
4608  OrthancPluginImage** target;
4609  OrthancPluginPixelFormat format;
4610  uint32_t width;
4611  uint32_t height;
4612  uint32_t pitch;
4613  void* buffer;
4614  const void* constBuffer;
4615  uint32_t bufferSize;
4616  uint32_t frameIndex;
4617  } _OrthancPluginCreateImage;
4618 
4619 
4633  OrthancPluginContext* context,
4634  OrthancPluginPixelFormat format,
4635  uint32_t width,
4636  uint32_t height)
4637  {
4638  OrthancPluginImage* target = NULL;
4639 
4640  _OrthancPluginCreateImage params;
4641  memset(&params, 0, sizeof(params));
4642  params.target = &target;
4643  params.format = format;
4644  params.width = width;
4645  params.height = height;
4646 
4647  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
4648  {
4649  return NULL;
4650  }
4651  else
4652  {
4653  return target;
4654  }
4655  }
4656 
4657 
4676  OrthancPluginContext* context,
4677  OrthancPluginPixelFormat format,
4678  uint32_t width,
4679  uint32_t height,
4680  uint32_t pitch,
4681  void* buffer)
4682  {
4683  OrthancPluginImage* target = NULL;
4684 
4685  _OrthancPluginCreateImage params;
4686  memset(&params, 0, sizeof(params));
4687  params.target = &target;
4688  params.format = format;
4689  params.width = width;
4690  params.height = height;
4691  params.pitch = pitch;
4692  params.buffer = buffer;
4693 
4694  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
4695  {
4696  return NULL;
4697  }
4698  else
4699  {
4700  return target;
4701  }
4702  }
4703 
4704 
4705 
4721  OrthancPluginContext* context,
4722  const void* buffer,
4723  uint32_t bufferSize,
4724  uint32_t frameIndex)
4725  {
4726  OrthancPluginImage* target = NULL;
4727 
4728  _OrthancPluginCreateImage params;
4729  memset(&params, 0, sizeof(params));
4730  params.target = &target;
4731  params.constBuffer = buffer;
4732  params.bufferSize = bufferSize;
4733  params.frameIndex = frameIndex;
4734 
4735  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
4736  {
4737  return NULL;
4738  }
4739  else
4740  {
4741  return target;
4742  }
4743  }
4744 
4745 
4746 
4747  typedef struct
4748  {
4749  char** result;
4750  const void* buffer;
4751  uint32_t size;
4752  } _OrthancPluginComputeHash;
4753 
4766  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
4767  OrthancPluginContext* context,
4768  const void* buffer,
4769  uint32_t size)
4770  {
4771  char* result;
4772 
4773  _OrthancPluginComputeHash params;
4774  params.result = &result;
4775  params.buffer = buffer;
4776  params.size = size;
4777 
4778  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
4779  {
4780  /* Error */
4781  return NULL;
4782  }
4783  else
4784  {
4785  return result;
4786  }
4787  }
4788 
4789 
4802  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
4803  OrthancPluginContext* context,
4804  const void* buffer,
4805  uint32_t size)
4806  {
4807  char* result;
4808 
4809  _OrthancPluginComputeHash params;
4810  params.result = &result;
4811  params.buffer = buffer;
4812  params.size = size;
4813 
4814  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
4815  {
4816  /* Error */
4817  return NULL;
4818  }
4819  else
4820  {
4821  return result;
4822  }
4823  }
4824 
4825 
4826 
4827  typedef struct
4828  {
4830  const char* name;
4831  } _OrthancPluginLookupDictionary;
4832 
4849  OrthancPluginContext* context,
4851  const char* name)
4852  {
4853  _OrthancPluginLookupDictionary params;
4854  params.target = target;
4855  params.name = name;
4856  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
4857  }
4858 
4859 
4860 
4861  typedef struct
4862  {
4863  OrthancPluginRestOutput* output;
4864  const char* answer;
4865  uint32_t answerSize;
4866  uint32_t headersCount;
4867  const char* const* headersKeys;
4868  const char* const* headersValues;
4869  } _OrthancPluginSendMultipartItem2;
4870 
4892  OrthancPluginContext* context,
4893  OrthancPluginRestOutput* output,
4894  const char* answer,
4895  uint32_t answerSize,
4896  uint32_t headersCount,
4897  const char* const* headersKeys,
4898  const char* const* headersValues)
4899  {
4900  _OrthancPluginSendMultipartItem2 params;
4901  params.output = output;
4902  params.answer = answer;
4903  params.answerSize = answerSize;
4904  params.headersCount = headersCount;
4905  params.headersKeys = headersKeys;
4906  params.headersValues = headersValues;
4907 
4908  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
4909  }
4910 
4911 
4912  typedef struct
4913  {
4915  } _OrthancPluginIncomingHttpRequestFilter;
4916 
4929  OrthancPluginContext* context,
4931  {
4932  _OrthancPluginIncomingHttpRequestFilter params;
4933  params.callback = callback;
4934 
4935  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
4936  }
4937 
4938 
4939 
4940  typedef struct
4941  {
4942  OrthancPluginMemoryBuffer* answerBody;
4943  OrthancPluginMemoryBuffer* answerHeaders;
4944  uint16_t* httpStatus;
4945  OrthancPluginHttpMethod method;
4946  const char* url;
4947  uint32_t headersCount;
4948  const char* const* headersKeys;
4949  const char* const* headersValues;
4950  const char* body;
4951  uint32_t bodySize;
4952  const char* username;
4953  const char* password;
4954  uint32_t timeout;
4955  const char* certificateFile;
4956  const char* certificateKeyFile;
4957  const char* certificateKeyPassword;
4958  uint8_t pkcs11;
4959  } _OrthancPluginCallHttpClient2;
4960 
4961 
4962 
5001  OrthancPluginContext* context,
5002  OrthancPluginMemoryBuffer* answerBody,
5003  OrthancPluginMemoryBuffer* answerHeaders,
5004  uint16_t* httpStatus,
5005  OrthancPluginHttpMethod method,
5006  const char* url,
5007  uint32_t headersCount,
5008  const char* const* headersKeys,
5009  const char* const* headersValues,
5010  const char* body,
5011  uint32_t bodySize,
5012  const char* username,
5013  const char* password,
5014  uint32_t timeout,
5015  const char* certificateFile,
5016  const char* certificateKeyFile,
5017  const char* certificateKeyPassword,
5018  uint8_t pkcs11)
5019  {
5020  _OrthancPluginCallHttpClient2 params;
5021  memset(&params, 0, sizeof(params));
5022 
5023  params.answerBody = answerBody;
5024  params.answerHeaders = answerHeaders;
5025  params.httpStatus = httpStatus;
5026  params.method = method;
5027  params.url = url;
5028  params.headersCount = headersCount;
5029  params.headersKeys = headersKeys;
5030  params.headersValues = headersValues;
5031  params.body = body;
5032  params.bodySize = bodySize;
5033  params.username = username;
5034  params.password = password;
5035  params.timeout = timeout;
5036  params.certificateFile = certificateFile;
5037  params.certificateKeyFile = certificateKeyFile;
5038  params.certificateKeyPassword = certificateKeyPassword;
5039  params.pkcs11 = pkcs11;
5040 
5041  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5042  }
5043 
5044 
5055  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5056  OrthancPluginContext* context)
5057  {
5058  char* result;
5059 
5060  _OrthancPluginRetrieveDynamicString params;
5061  params.result = &result;
5062  params.argument = NULL;
5063 
5064  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5065  {
5066  /* Error */
5067  return NULL;
5068  }
5069  else
5070  {
5071  return result;
5072  }
5073  }
5074 
5075 
5076 
5077 
5078  typedef struct
5079  {
5080  OrthancPluginFindCallback callback;
5081  } _OrthancPluginFindCallback;
5082 
5095  OrthancPluginContext* context,
5096  OrthancPluginFindCallback callback)
5097  {
5098  _OrthancPluginFindCallback params;
5099  params.callback = callback;
5100 
5101  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5102  }
5103 
5104 
5105  typedef struct
5106  {
5107  OrthancPluginFindAnswers *answers;
5108  const OrthancPluginFindQuery *query;
5109  const void *dicom;
5110  uint32_t size;
5111  uint32_t index;
5112  uint32_t *resultUint32;
5113  uint16_t *resultGroup;
5114  uint16_t *resultElement;
5115  char **resultString;
5116  } _OrthancPluginFindOperation;
5117 
5134  OrthancPluginContext* context,
5135  OrthancPluginFindAnswers* answers,
5136  const void* dicom,
5137  uint32_t size)
5138  {
5139  _OrthancPluginFindOperation params;
5140  memset(&params, 0, sizeof(params));
5141  params.answers = answers;
5142  params.dicom = dicom;
5143  params.size = size;
5144 
5145  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
5146  }
5147 
5148 
5163  OrthancPluginContext* context,
5164  OrthancPluginFindAnswers* answers)
5165  {
5166  _OrthancPluginFindOperation params;
5167  memset(&params, 0, sizeof(params));
5168  params.answers = answers;
5169 
5170  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
5171  }
5172 
5173 
5174 
5186  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
5187  OrthancPluginContext* context,
5188  const OrthancPluginFindQuery* query)
5189  {
5190  uint32_t count = 0;
5191 
5192  _OrthancPluginFindOperation params;
5193  memset(&params, 0, sizeof(params));
5194  params.query = query;
5195  params.resultUint32 = &count;
5196 
5197  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
5198  {
5199  /* Error */
5200  return 0;
5201  }
5202  else
5203  {
5204  return count;
5205  }
5206  }
5207 
5208 
5224  OrthancPluginContext* context,
5225  uint16_t* group,
5226  uint16_t* element,
5227  const OrthancPluginFindQuery* query,
5228  uint32_t index)
5229  {
5230  _OrthancPluginFindOperation params;
5231  memset(&params, 0, sizeof(params));
5232  params.query = query;
5233  params.index = index;
5234  params.resultGroup = group;
5235  params.resultElement = element;
5236 
5237  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
5238  }
5239 
5240 
5254  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
5255  OrthancPluginContext* context,
5256  const OrthancPluginFindQuery* query,
5257  uint32_t index)
5258  {
5259  char* result;
5260 
5261  _OrthancPluginFindOperation params;
5262  memset(&params, 0, sizeof(params));
5263  params.query = query;
5264  params.index = index;
5265  params.resultString = &result;
5266 
5267  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
5268  {
5269  /* Error */
5270  return NULL;
5271  }
5272  else
5273  {
5274  return result;
5275  }
5276  }
5277 
5278 
5292  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
5293  OrthancPluginContext* context,
5294  const OrthancPluginFindQuery* query,
5295  uint32_t index)
5296  {
5297  char* result;
5298 
5299  _OrthancPluginFindOperation params;
5300  memset(&params, 0, sizeof(params));
5301  params.query = query;
5302  params.index = index;
5303  params.resultString = &result;
5304 
5305  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
5306  {
5307  /* Error */
5308  return NULL;
5309  }
5310  else
5311  {
5312  return result;
5313  }
5314  }
5315 
5316 
5317 
5318 
5319  typedef struct
5320  {
5321  OrthancPluginMoveCallback callback;
5322  OrthancPluginGetMoveSize getMoveSize;
5323  OrthancPluginApplyMove applyMove;
5324  OrthancPluginFreeMove freeMove;
5325  } _OrthancPluginMoveCallback;
5326 
5341  OrthancPluginContext* context,
5342  OrthancPluginMoveCallback callback,
5343  OrthancPluginGetMoveSize getMoveSize,
5344  OrthancPluginApplyMove applyMove,
5345  OrthancPluginFreeMove freeMove)
5346  {
5347  _OrthancPluginMoveCallback params;
5348  params.callback = callback;
5349  params.getMoveSize = getMoveSize;
5350  params.applyMove = applyMove;
5351  params.freeMove = freeMove;
5352 
5353  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
5354  }
5355 
5356 
5357 
5358 
5359 #ifdef __cplusplus
5360 }
5361 #endif
5362 
5363 
Definition: OrthancCPlugin.h:648
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2179
Definition: OrthancCPlugin.h:747
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:2358
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:844
OrthancPluginChangeType
Definition: OrthancCPlugin.h:605
Definition: OrthancCPlugin.h:223
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2042
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:797
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2143
Definition: OrthancCPlugin.h:671
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1118
Definition: OrthancCPlugin.h:255
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:1320
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:4594
Definition: OrthancCPlugin.h:748
The parameters of a REST request.
Definition: OrthancCPlugin.h:314
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:1825
OrthancPluginContentType
Definition: OrthancCPlugin.h:574
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:1730
Definition: OrthancCPlugin.h:591
Definition: OrthancCPlugin.h:670
Definition: OrthancCPlugin.h:763
const char * OrthancPluginGetInstanceData(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2245
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:3427
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:3519
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1183
Definition: OrthancCPlugin.h:247
Definition: OrthancCPlugin.h:193
Definition: OrthancCPlugin.h:245
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:758
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:4379
Definition: OrthancCPlugin.h:668
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:4343
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2212
Definition: OrthancCPlugin.h:270
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:538
Definition: OrthancCPlugin.h:620
Definition: OrthancCPlugin.h:215
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:374
Definition: OrthancCPlugin.h:257
Definition: OrthancCPlugin.h:259
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:369
Definition: OrthancCPlugin.h:243
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:731
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:4802
Definition: OrthancCPlugin.h:261
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:522
Definition: OrthancCPlugin.h:764
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:334
Definition: OrthancCPlugin.h:564
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:2444
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:976
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:1543
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:645
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:4486
Definition: OrthancCPlugin.h:201
Definition: OrthancCPlugin.h:283
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1159
Definition: OrthancCPlugin.h:267
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:3799
Definition: OrthancCPlugin.h:221
Definition: OrthancCPlugin.h:273
Definition: OrthancCPlugin.h:265
Definition: OrthancCPlugin.h:302
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:903
Definition: OrthancCPlugin.h:212
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:4766
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:3724
Definition: OrthancCPlugin.h:268
Definition: OrthancCPlugin.h:614
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:3978
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:3759
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:2541
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1091
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:5000
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:2583
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:562
Definition: OrthancCPlugin.h:715
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:713
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:2088
Definition: OrthancCPlugin.h:632
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5055
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:1445
Definition: OrthancCPlugin.h:608
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:4720
Definition: OrthancCPlugin.h:244
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:698
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:4848
Definition: OrthancCPlugin.h:700
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4054
Definition: OrthancCPlugin.h:225
uint16_t group
Definition: OrthancCPlugin.h:1142
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:3297
Definition: OrthancCPlugin.h:661
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1145
Definition: OrthancCPlugin.h:702
Definition: OrthancCPlugin.h:673
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:2396
Definition: OrthancCPlugin.h:647
Definition: OrthancCPlugin.h:237
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:820
Definition: OrthancCPlugin.h:229
Definition: OrthancCPlugin.h:576
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:5223
Definition: OrthancCPlugin.h:612
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:1791
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:2829
Definition: OrthancCPlugin.h:260
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:530
Definition: OrthancCPlugin.h:258
Definition: OrthancCPlugin.h:204
OrthancPluginResourceType
Definition: OrthancCPlugin.h:588
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:299
Definition: OrthancCPlugin.h:220
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:3228
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:659
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:2862
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:3126
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:3340
Definition: OrthancCPlugin.h:263
Definition: OrthancCPlugin.h:663
Definition: OrthancCPlugin.h:207
Definition: OrthancCPlugin.h:593
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:860
Definition: OrthancCPlugin.h:254
Definition: OrthancCPlugin.h:633
Definition: OrthancCPlugin.h:666
Definition: OrthancCPlugin.h:271
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:2506
Definition: OrthancCPlugin.h:635
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5133
Definition: OrthancCPlugin.h:685
Definition: OrthancCPlugin.h:246
Color image in RGB24 format.
Definition: OrthancCPlugin.h:554
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:4409
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:546
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1140
Definition: OrthancCPlugin.h:256
Definition: OrthancCPlugin.h:197
Definition: OrthancCPlugin.h:607
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:630
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:3649
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:4305
Definition: OrthancCPlugin.h:718
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3162
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:3884
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3263
Definition: OrthancCPlugin.h:577
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:1502
void *(* OrthancPluginMoveCallback)(OrthancPluginResourceType resourceType, const char *patientId, const char *accessionNumber, const char *studyInstanceUid, const char *seriesInstanceUid, const char *sopInstanceUid, const char *issuerAet, const char *sourceAet, const char *targetAet, uint16_t moveOriginatorId)
Callback to handle incoming C-Move SCP requests.
Definition: OrthancCPlugin.h:1067
Definition: OrthancCPlugin.h:276
Definition: OrthancCPlugin.h:282
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:836
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1146
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5094
Definition: OrthancCPlugin.h:275
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:892
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:4198
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:2762
Definition: OrthancCPlugin.h:227
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2065
Definition: OrthancCPlugin.h:199
Definition: OrthancCPlugin.h:252
Definition: OrthancCPlugin.h:240
Definition: OrthancCPlugin.h:272
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:1288
Definition: OrthancCPlugin.h:218
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:828
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:782
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:3831
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:2658
Definition: OrthancCPlugin.h:762
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1576
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3073
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1026
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:364
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:1002
Definition: OrthancCPlugin.h:613
Definition: OrthancCPlugin.h:717
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1272
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:919
Definition: OrthancCPlugin.h:679
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1707
Definition: OrthancCPlugin.h:683
Definition: OrthancCPlugin.h:592
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3011
Definition: OrthancCPlugin.h:672
Definition: OrthancCPlugin.h:749
Definition: OrthancCPlugin.h:303
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:4632
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:5254
Definition: OrthancCPlugin.h:674
Definition: OrthancCPlugin.h:232
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:2476
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:2692
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:4891
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:957
Definition: OrthancCPlugin.h:701
Definition: OrthancCPlugin.h:241
Definition: OrthancCPlugin.h:279
Definition: OrthancCPlugin.h:301
Definition: OrthancCPlugin.h:615
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4154
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:2796
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:3571
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:4675
Definition: OrthancCPlugin.h:249
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:4928
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:4247
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:344
Definition: OrthancCPlugin.h:686
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:881
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:2319
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:2974
Definition: OrthancCPlugin.h:242
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:4561
Definition: OrthancCPlugin.h:235
Definition: OrthancCPlugin.h:649
Definition: OrthancCPlugin.h:198
const char * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:349
Definition: OrthancCPlugin.h:248
Definition: OrthancCPlugin.h:205
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:1385
Definition: OrthancCPlugin.h:618
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:812
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:1755
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:2903
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:852
Definition: OrthancCPlugin.h:746
Definition: OrthancCPlugin.h:280
Definition: OrthancCPlugin.h:251
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:5292
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:2614
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4015
Definition: OrthancCPlugin.h:678
Definition: OrthancCPlugin.h:619
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:339
Definition: OrthancCPlugin.h:681
Definition: OrthancCPlugin.h:610
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:1857
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:4512
Definition: OrthancCPlugin.h:682
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:3382
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1144
uint16_t element
Definition: OrthancCPlugin.h:1143
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:1997
Definition: OrthancCPlugin.h:617
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:2731
Definition: OrthancCPlugin.h:222
Definition: OrthancCPlugin.h:578
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:2932
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:329
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3042
Definition: OrthancCPlugin.h:250
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:939
Definition: OrthancCPlugin.h:253
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:1892
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:787
Definition: OrthancCPlugin.h:760
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:5340
Definition: OrthancCPlugin.h:233
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance received by Orthanc.
Definition: OrthancCPlugin.h:804
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:324
Definition: OrthancCPlugin.h:234
Definition: OrthancCPlugin.h:594
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:1304
Definition: OrthancCPlugin.h:667
Definition: OrthancCPlugin.h:239
Definition: OrthancCPlugin.h:687
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:744
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:354
Definition: OrthancCPlugin.h:304
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2118
Definition: OrthancCPlugin.h:609
Definition: OrthancCPlugin.h:677
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2281
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:2636
Definition: OrthancCPlugin.h:281
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:1643
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:1413
Definition: OrthancCPlugin.h:611
Definition: OrthancCPlugin.h:680
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:4109
Definition: OrthancCPlugin.h:236
Definition: OrthancCPlugin.h:202
Definition: OrthancCPlugin.h:684
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:3608
Definition: OrthancCPlugin.h:664
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:5162
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:1351
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:1927
Definition: OrthancCPlugin.h:676
Definition: OrthancCPlugin.h:662
Definition: OrthancCPlugin.h:194
Definition: OrthancCPlugin.h:590
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:1606
Definition: OrthancCPlugin.h:761
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:871
Definition: OrthancCPlugin.h:274
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:1678
Definition: OrthancCPlugin.h:192
Definition: OrthancCPlugin.h:217
Definition: OrthancCPlugin.h:616
Definition: OrthancCPlugin.h:634
Definition: OrthancCPlugin.h:226
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1105
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:319
Definition: OrthancCPlugin.h:269
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:3936
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:3686
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:777
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5186
Definition: OrthancCPlugin.h:669
Definition: OrthancCPlugin.h:716
Definition: OrthancCPlugin.h:206
Definition: OrthancCPlugin.h:675
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:1962
Definition: OrthancCPlugin.h:196
Definition: OrthancCPlugin.h:665
Definition: OrthancCPlugin.h:262
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:4447
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3195
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:3472
Definition: OrthancCPlugin.h:219