Orthanc Plugin SDK
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1 
77 #pragma once
78 
79 
80 #include <stdio.h>
81 #include <string.h>
82 
83 #ifdef WIN32
84 #define ORTHANC_PLUGINS_API __declspec(dllexport)
85 #else
86 #define ORTHANC_PLUGINS_API
87 #endif
88 
89 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 0
90 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 8
91 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 3
92 
93 
94 
95 /********************************************************************
96  ** Check that function inlining is properly supported. The use of
97  ** inlining is required, to avoid the duplication of object code
98  ** between two compilation modules that would use the Orthanc Plugin
99  ** API.
100  ********************************************************************/
101 
102 /* If the auto-detection of the "inline" keyword below does not work
103  automatically and that your compiler is known to properly support
104  inlining, uncomment the following #define and adapt the definition
105  of "static inline". */
106 
107 /* #define ORTHANC_PLUGIN_INLINE static inline */
108 
109 #ifndef ORTHANC_PLUGIN_INLINE
110 # if __STDC_VERSION__ >= 199901L
111 /* This is C99 or above: http://predef.sourceforge.net/prestd.html */
112 # define ORTHANC_PLUGIN_INLINE static inline
113 # elif defined(__cplusplus)
114 /* This is C++ */
115 # define ORTHANC_PLUGIN_INLINE static inline
116 # elif defined(__GNUC__)
117 /* This is GCC running in C89 mode */
118 # define ORTHANC_PLUGIN_INLINE static __inline
119 # elif defined(_MSC_VER)
120 /* This is Visual Studio running in C89 mode */
121 # define ORTHANC_PLUGIN_INLINE static __inline
122 # else
123 # error Your compiler is not known to support the "inline" keyword
124 # endif
125 #endif
126 
127 
128 
129 /********************************************************************
130  ** Inclusion of standard libraries.
131  ********************************************************************/
132 
133 #ifdef _MSC_VER
134 #include "../../Resources/ThirdParty/VisualStudio/stdint.h"
135 #else
136 #include <stdint.h>
137 #endif
138 
139 #include <stdlib.h>
140 
141 
142 
143 /********************************************************************
144  ** Definition of the Orthanc Plugin API.
145  ********************************************************************/
146 
149 #ifdef __cplusplus
150 extern "C"
151 {
152 #endif
153 
157  typedef enum
158  {
164 
165 
169  typedef struct
170  {
175 
179  uint32_t groupsCount;
180 
184  const char* const* groups;
185 
189  uint32_t getCount;
190 
194  const char* const* getKeys;
195 
199  const char* const* getValues;
200 
204  const char* body;
205 
209  uint32_t bodySize;
210 
211 
212  /* --------------------------------------------------
213  New in version 0.8.1
214  -------------------------------------------------- */
215 
219  uint32_t headersCount;
220 
224  const char* const* headersKeys;
225 
229  const char* const* headersValues;
230 
232 
233 
234  typedef enum
235  {
236  /* Generic services */
237  _OrthancPluginService_LogInfo = 1,
238  _OrthancPluginService_LogWarning = 2,
239  _OrthancPluginService_LogError = 3,
240  _OrthancPluginService_GetOrthancPath = 4,
241  _OrthancPluginService_GetOrthancDirectory = 5,
242  _OrthancPluginService_GetConfigurationPath = 6,
243 
244  /* Registration of callbacks */
245  _OrthancPluginService_RegisterRestCallback = 1000,
246  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
247  _OrthancPluginService_RegisterStorageArea = 1002,
248 
249  /* Sending answers to REST calls */
250  _OrthancPluginService_AnswerBuffer = 2000,
251  _OrthancPluginService_CompressAndAnswerPngImage = 2001,
252  _OrthancPluginService_Redirect = 2002,
253  _OrthancPluginService_SendHttpStatusCode = 2003,
254  _OrthancPluginService_SendUnauthorized = 2004,
255  _OrthancPluginService_SendMethodNotAllowed = 2005,
256  _OrthancPluginService_SetCookie = 2006,
257  _OrthancPluginService_SetHttpHeader = 2007,
258 
259  /* Access to the Orthanc database and API */
260  _OrthancPluginService_GetDicomForInstance = 3000,
261  _OrthancPluginService_RestApiGet = 3001,
262  _OrthancPluginService_RestApiPost = 3002,
263  _OrthancPluginService_RestApiDelete = 3003,
264  _OrthancPluginService_RestApiPut = 3004,
265  _OrthancPluginService_LookupPatient = 3005,
266  _OrthancPluginService_LookupStudy = 3006,
267  _OrthancPluginService_LookupSeries = 3007,
268  _OrthancPluginService_LookupInstance = 3008,
269  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
270 
271  /* Access to DICOM instances */
272  _OrthancPluginService_GetInstanceRemoteAet = 4000,
273  _OrthancPluginService_GetInstanceSize = 4001,
274  _OrthancPluginService_GetInstanceData = 4002,
275  _OrthancPluginService_GetInstanceJson = 4003,
276  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
277  _OrthancPluginService_HasInstanceMetadata = 4005,
278  _OrthancPluginService_GetInstanceMetadata = 4006
279  } _OrthancPluginService;
280 
281 
282 
286  typedef enum
287  {
295 
303 
311 
319 
328 
329 
330 
334  typedef enum
335  {
340 
341 
342 
350  typedef struct
351  {
355  void* data;
356 
360  uint32_t size;
362 
363 
364 
365 
369  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
370 
371 
372 
376  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
377 
378 
379 
383  typedef int32_t (*OrthancPluginRestCallback) (
384  OrthancPluginRestOutput* output,
385  const char* url,
386  const OrthancPluginHttpRequest* request);
387 
388 
389 
394  OrthancPluginDicomInstance* instance,
395  const char* instanceId);
396 
397 
398 
402  typedef void (*OrthancPluginFree) (void* buffer);
403 
404 
405 
417  typedef int32_t (*OrthancPluginStorageCreate) (
418  const char* uuid,
419  const void* content,
420  int64_t size,
422 
423 
424 
436  typedef int32_t (*OrthancPluginStorageRead) (
437  void** content,
438  int64_t* size,
439  const char* uuid,
441 
442 
443 
453  typedef int32_t (*OrthancPluginStorageRemove) (
454  const char* uuid,
456 
457 
458 
462  typedef struct _OrthancPluginContext_t
463  {
464  void* pluginsManager;
465  const char* orthancVersion;
466  OrthancPluginFree Free;
467  int32_t (*InvokeService) (struct _OrthancPluginContext_t* context,
468  _OrthancPluginService service,
469  const void* params);
471 
472 
473 
482  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
483  OrthancPluginContext* context,
484  char* str)
485  {
486  if (str != NULL)
487  {
488  context->Free(str);
489  }
490  }
491 
492 
505  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
506  OrthancPluginContext* context)
507  {
508  int major, minor, revision;
509 
510  /* Assume compatibility with the mainline */
511  if (!strcmp(context->orthancVersion, "mainline"))
512  {
513  return 1;
514  }
515 
516  /* Parse the version of the Orthanc core */
517  if (
518 #ifdef _MSC_VER
519  sscanf_s
520 #else
521  sscanf
522 #endif
523  (context->orthancVersion, "%d.%d.%d", &major, &minor, &revision) != 3)
524  {
525  return 0;
526  }
527 
528  /* Check the major number of the version */
529 
530  if (major > ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
531  {
532  return 1;
533  }
534 
535  if (major < ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
536  {
537  return 0;
538  }
539 
540  /* Check the minor number of the version */
541 
542  if (minor > ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
543  {
544  return 1;
545  }
546 
547  if (minor < ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
548  {
549  return 0;
550  }
551 
552  /* Check the revision number of the version */
553 
554  if (revision >= ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER)
555  {
556  return 1;
557  }
558  else
559  {
560  return 0;
561  }
562  }
563 
564 
573  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
574  OrthancPluginContext* context,
576  {
577  context->Free(buffer->data);
578  }
579 
580 
589  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
590  OrthancPluginContext* context,
591  const char* message)
592  {
593  context->InvokeService(context, _OrthancPluginService_LogError, message);
594  }
595 
596 
605  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
606  OrthancPluginContext* context,
607  const char* message)
608  {
609  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
610  }
611 
612 
621  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
622  OrthancPluginContext* context,
623  const char* message)
624  {
625  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
626  }
627 
628 
629 
630  typedef struct
631  {
632  const char* pathRegularExpression;
633  OrthancPluginRestCallback callback;
634  } _OrthancPluginRestCallback;
635 
648  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
649  OrthancPluginContext* context,
650  const char* pathRegularExpression,
651  OrthancPluginRestCallback callback)
652  {
653  _OrthancPluginRestCallback params;
654  params.pathRegularExpression = pathRegularExpression;
655  params.callback = callback;
656  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
657  }
658 
659 
660 
661  typedef struct
662  {
664  } _OrthancPluginOnStoredInstanceCallback;
665 
676  OrthancPluginContext* context,
678  {
679  _OrthancPluginOnStoredInstanceCallback params;
680  params.callback = callback;
681 
682  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
683  }
684 
685 
686 
687  typedef struct
688  {
689  OrthancPluginRestOutput* output;
690  const char* answer;
691  uint32_t answerSize;
692  const char* mimeType;
693  } _OrthancPluginAnswerBuffer;
694 
706  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
707  OrthancPluginContext* context,
708  OrthancPluginRestOutput* output,
709  const char* answer,
710  uint32_t answerSize,
711  const char* mimeType)
712  {
713  _OrthancPluginAnswerBuffer params;
714  params.output = output;
715  params.answer = answer;
716  params.answerSize = answerSize;
717  params.mimeType = mimeType;
718  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
719  }
720 
721 
722  typedef struct
723  {
724  OrthancPluginRestOutput* output;
726  uint32_t width;
727  uint32_t height;
728  uint32_t pitch;
729  const void* buffer;
730  } _OrthancPluginCompressAndAnswerPngImage;
731 
749  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
750  OrthancPluginContext* context,
751  OrthancPluginRestOutput* output,
753  uint32_t width,
754  uint32_t height,
755  uint32_t pitch,
756  const void* buffer)
757  {
758  _OrthancPluginCompressAndAnswerPngImage params;
759  params.output = output;
760  params.format = format;
761  params.width = width;
762  params.height = height;
763  params.pitch = pitch;
764  params.buffer = buffer;
765  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerPngImage, &params);
766  }
767 
768 
769 
770  typedef struct
771  {
773  const char* instanceId;
774  } _OrthancPluginGetDicomForInstance;
775 
787  ORTHANC_PLUGIN_INLINE int OrthancPluginGetDicomForInstance(
788  OrthancPluginContext* context,
790  const char* instanceId)
791  {
792  _OrthancPluginGetDicomForInstance params;
793  params.target = target;
794  params.instanceId = instanceId;
795  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
796  }
797 
798 
799 
800  typedef struct
801  {
803  const char* uri;
804  } _OrthancPluginRestApiGet;
805 
817  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiGet(
818  OrthancPluginContext* context,
820  const char* uri)
821  {
822  _OrthancPluginRestApiGet params;
823  params.target = target;
824  params.uri = uri;
825  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
826  }
827 
828 
829 
830  typedef struct
831  {
833  const char* uri;
834  const char* body;
835  uint32_t bodySize;
836  } _OrthancPluginRestApiPostPut;
837 
851  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiPost(
852  OrthancPluginContext* context,
854  const char* uri,
855  const char* body,
856  uint32_t bodySize)
857  {
858  _OrthancPluginRestApiPostPut params;
859  params.target = target;
860  params.uri = uri;
861  params.body = body;
862  params.bodySize = bodySize;
863  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
864  }
865 
866 
867 
877  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiDelete(
878  OrthancPluginContext* context,
879  const char* uri)
880  {
881  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
882  }
883 
884 
885 
899  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiPut(
900  OrthancPluginContext* context,
902  const char* uri,
903  const char* body,
904  uint32_t bodySize)
905  {
906  _OrthancPluginRestApiPostPut params;
907  params.target = target;
908  params.uri = uri;
909  params.body = body;
910  params.bodySize = bodySize;
911  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
912  }
913 
914 
915 
916  typedef struct
917  {
918  OrthancPluginRestOutput* output;
919  const char* argument;
920  } _OrthancPluginOutputPlusArgument;
921 
932  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
933  OrthancPluginContext* context,
934  OrthancPluginRestOutput* output,
935  const char* redirection)
936  {
937  _OrthancPluginOutputPlusArgument params;
938  params.output = output;
939  params.argument = redirection;
940  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
941  }
942 
943 
944 
945  typedef struct
946  {
947  char** result;
948  const char* argument;
949  } _OrthancPluginRetrieveDynamicString;
950 
963  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
964  OrthancPluginContext* context,
965  const char* patientID)
966  {
967  char* result;
968 
969  _OrthancPluginRetrieveDynamicString params;
970  params.result = &result;
971  params.argument = patientID;
972 
973  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params))
974  {
975  /* Error */
976  return NULL;
977  }
978  else
979  {
980  return result;
981  }
982  }
983 
984 
997  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
998  OrthancPluginContext* context,
999  const char* studyUID)
1000  {
1001  char* result;
1002 
1003  _OrthancPluginRetrieveDynamicString params;
1004  params.result = &result;
1005  params.argument = studyUID;
1006 
1007  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params))
1008  {
1009  /* Error */
1010  return NULL;
1011  }
1012  else
1013  {
1014  return result;
1015  }
1016  }
1017 
1018 
1031  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
1032  OrthancPluginContext* context,
1033  const char* accessionNumber)
1034  {
1035  char* result;
1036 
1037  _OrthancPluginRetrieveDynamicString params;
1038  params.result = &result;
1039  params.argument = accessionNumber;
1040 
1041  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params))
1042  {
1043  /* Error */
1044  return NULL;
1045  }
1046  else
1047  {
1048  return result;
1049  }
1050  }
1051 
1052 
1065  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
1066  OrthancPluginContext* context,
1067  const char* seriesUID)
1068  {
1069  char* result;
1070 
1071  _OrthancPluginRetrieveDynamicString params;
1072  params.result = &result;
1073  params.argument = seriesUID;
1074 
1075  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params))
1076  {
1077  /* Error */
1078  return NULL;
1079  }
1080  else
1081  {
1082  return result;
1083  }
1084  }
1085 
1086 
1099  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
1100  OrthancPluginContext* context,
1101  const char* sopInstanceUID)
1102  {
1103  char* result;
1104 
1105  _OrthancPluginRetrieveDynamicString params;
1106  params.result = &result;
1107  params.argument = sopInstanceUID;
1108 
1109  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params))
1110  {
1111  /* Error */
1112  return NULL;
1113  }
1114  else
1115  {
1116  return result;
1117  }
1118  }
1119 
1120 
1121 
1122  typedef struct
1123  {
1124  OrthancPluginRestOutput* output;
1125  uint16_t status;
1126  } _OrthancPluginSendHttpStatusCode;
1127 
1142  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
1143  OrthancPluginContext* context,
1144  OrthancPluginRestOutput* output,
1145  uint16_t status)
1146  {
1147  _OrthancPluginSendHttpStatusCode params;
1148  params.output = output;
1149  params.status = status;
1150  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
1151  }
1152 
1153 
1164  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
1165  OrthancPluginContext* context,
1166  OrthancPluginRestOutput* output,
1167  const char* realm)
1168  {
1169  _OrthancPluginOutputPlusArgument params;
1170  params.output = output;
1171  params.argument = realm;
1172  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
1173  }
1174 
1175 
1186  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
1187  OrthancPluginContext* context,
1188  OrthancPluginRestOutput* output,
1189  const char* allowedMethods)
1190  {
1191  _OrthancPluginOutputPlusArgument params;
1192  params.output = output;
1193  params.argument = allowedMethods;
1194  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
1195  }
1196 
1197 
1198  typedef struct
1199  {
1200  OrthancPluginRestOutput* output;
1201  const char* key;
1202  const char* value;
1203  } _OrthancPluginSetHttpHeader;
1204 
1215  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
1216  OrthancPluginContext* context,
1217  OrthancPluginRestOutput* output,
1218  const char* cookie,
1219  const char* value)
1220  {
1221  _OrthancPluginSetHttpHeader params;
1222  params.output = output;
1223  params.key = cookie;
1224  params.value = value;
1225  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
1226  }
1227 
1228 
1239  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
1240  OrthancPluginContext* context,
1241  OrthancPluginRestOutput* output,
1242  const char* key,
1243  const char* value)
1244  {
1245  _OrthancPluginSetHttpHeader params;
1246  params.output = output;
1247  params.key = key;
1248  params.value = value;
1249  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
1250  }
1251 
1252 
1253  typedef struct
1254  {
1255  char** resultStringToFree;
1256  const char** resultString;
1257  int64_t* resultInt64;
1258  const char* key;
1259  OrthancPluginDicomInstance* instance;
1260  } _OrthancPluginAccessDicomInstance;
1261 
1262 
1273  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
1274  OrthancPluginContext* context,
1275  OrthancPluginDicomInstance* instance)
1276  {
1277  const char* result;
1278 
1279  _OrthancPluginAccessDicomInstance params;
1280  memset(&params, 0, sizeof(params));
1281  params.resultString = &result;
1282  params.instance = instance;
1283 
1284  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params))
1285  {
1286  /* Error */
1287  return NULL;
1288  }
1289  else
1290  {
1291  return result;
1292  }
1293  }
1294 
1295 
1305  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
1306  OrthancPluginContext* context,
1307  OrthancPluginDicomInstance* instance)
1308  {
1309  int64_t size;
1310 
1311  _OrthancPluginAccessDicomInstance params;
1312  memset(&params, 0, sizeof(params));
1313  params.resultInt64 = &size;
1314  params.instance = instance;
1315 
1316  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params))
1317  {
1318  /* Error */
1319  return -1;
1320  }
1321  else
1322  {
1323  return size;
1324  }
1325  }
1326 
1327 
1337  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceData(
1338  OrthancPluginContext* context,
1339  OrthancPluginDicomInstance* instance)
1340  {
1341  const char* result;
1342 
1343  _OrthancPluginAccessDicomInstance params;
1344  memset(&params, 0, sizeof(params));
1345  params.resultString = &result;
1346  params.instance = instance;
1347 
1348  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params))
1349  {
1350  /* Error */
1351  return NULL;
1352  }
1353  else
1354  {
1355  return result;
1356  }
1357  }
1358 
1359 
1372  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
1373  OrthancPluginContext* context,
1374  OrthancPluginDicomInstance* instance)
1375  {
1376  char* result;
1377 
1378  _OrthancPluginAccessDicomInstance params;
1379  memset(&params, 0, sizeof(params));
1380  params.resultStringToFree = &result;
1381  params.instance = instance;
1382 
1383  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params))
1384  {
1385  /* Error */
1386  return NULL;
1387  }
1388  else
1389  {
1390  return result;
1391  }
1392  }
1393 
1394 
1409  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
1410  OrthancPluginContext* context,
1411  OrthancPluginDicomInstance* instance)
1412  {
1413  char* result;
1414 
1415  _OrthancPluginAccessDicomInstance params;
1416  memset(&params, 0, sizeof(params));
1417  params.resultStringToFree = &result;
1418  params.instance = instance;
1419 
1420  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params))
1421  {
1422  /* Error */
1423  return NULL;
1424  }
1425  else
1426  {
1427  return result;
1428  }
1429  }
1430 
1431 
1447  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
1448  OrthancPluginContext* context,
1449  OrthancPluginDicomInstance* instance,
1450  const char* metadata)
1451  {
1452  int64_t result;
1453 
1454  _OrthancPluginAccessDicomInstance params;
1455  memset(&params, 0, sizeof(params));
1456  params.resultInt64 = &result;
1457  params.instance = instance;
1458  params.key = metadata;
1459 
1460  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params))
1461  {
1462  /* Error */
1463  return -1;
1464  }
1465  else
1466  {
1467  return (result != 0);
1468  }
1469  }
1470 
1471 
1484  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
1485  OrthancPluginContext* context,
1486  OrthancPluginDicomInstance* instance,
1487  const char* metadata)
1488  {
1489  const char* result;
1490 
1491  _OrthancPluginAccessDicomInstance params;
1492  memset(&params, 0, sizeof(params));
1493  params.resultString = &result;
1494  params.instance = instance;
1495  params.key = metadata;
1496 
1497  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params))
1498  {
1499  /* Error */
1500  return NULL;
1501  }
1502  else
1503  {
1504  return result;
1505  }
1506  }
1507 
1508 
1509 
1510  typedef struct
1511  {
1515  OrthancPluginFree free_;
1516  } _OrthancPluginRegisterStorageArea;
1517 
1531  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
1532  OrthancPluginContext* context,
1536  {
1537  _OrthancPluginRegisterStorageArea params;
1538  params.create_ = create;
1539  params.read_ = read;
1540  params.remove_ = remove;
1541 
1542 #ifdef __cplusplus
1543  params.free_ = ::free;
1544 #else
1545  params.free_ = free;
1546 #endif
1547 
1548  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
1549  }
1550 
1551 
1552 
1563  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
1564  {
1565  char* result;
1566 
1567  _OrthancPluginRetrieveDynamicString params;
1568  params.result = &result;
1569  params.argument = NULL;
1570 
1571  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params))
1572  {
1573  /* Error */
1574  return NULL;
1575  }
1576  else
1577  {
1578  return result;
1579  }
1580  }
1581 
1582 
1593  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
1594  {
1595  char* result;
1596 
1597  _OrthancPluginRetrieveDynamicString params;
1598  params.result = &result;
1599  params.argument = NULL;
1600 
1601  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params))
1602  {
1603  /* Error */
1604  return NULL;
1605  }
1606  else
1607  {
1608  return result;
1609  }
1610  }
1611 
1612 
1624  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
1625  {
1626  char* result;
1627 
1628  _OrthancPluginRetrieveDynamicString params;
1629  params.result = &result;
1630  params.argument = NULL;
1631 
1632  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params))
1633  {
1634  /* Error */
1635  return NULL;
1636  }
1637  else
1638  {
1639  return result;
1640  }
1641  }
1642 
1643 
1644 
1645 #ifdef __cplusplus
1646 }
1647 #endif
1648 
1649 
int32_t(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:417
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:1186
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:402
int32_t(* OrthancPluginOnStoredInstanceCallback)(OrthancPluginDicomInstance *instance, const char *instanceId)
Signature of a callback function that is triggered when Orthanc receives a DICOM instance.
Definition: OrthancCPlugin.h:393
The parameters of a REST request.
Definition: OrthancCPlugin.h:169
int32_t(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:436
Definition: OrthancCPlugin.h:337
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:675
int32_t(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:383
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:229
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:224
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:189
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:932
int 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:851
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:1142
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:1273
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:749
OrthancPluginContentType
Definition: OrthancCPlugin.h:334
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:621
Definition: OrthancCPlugin.h:159
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:589
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:573
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:1563
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:1164
int OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:877
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:1239
int OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:787
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:1593
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:302
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:1031
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:355
Color image in RGB24 format.
Definition: OrthancCPlugin.h:318
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:1447
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:219
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:1409
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:157
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance received by Orthanc.
Definition: OrthancCPlugin.h:376
struct _OrthancPluginContext_t OrthancPluginContext
Opaque structure that contains information about the Orthanc core.
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:369
int 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:899
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:199
Definition: OrthancCPlugin.h:161
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file.
Definition: OrthancCPlugin.h:1624
const char * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:204
Definition: OrthancCPlugin.h:162
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:963
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:326
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:1215
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:194
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:184
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:360
int OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:817
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:179
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:286
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:648
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:294
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:209
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:706
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:1484
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:1531
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:482
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:1305
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:1372
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:310
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:174
const char * OrthancPluginGetInstanceData(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:1337
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:350
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:505
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:605
int32_t(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:453
Definition: OrthancCPlugin.h:338
Definition: OrthancCPlugin.h:160
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:997
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:1065
Definition: OrthancCPlugin.h:336
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:1099