Orthanc Plugin SDK
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1 
79 #pragma once
80 
81 
82 #include <stdio.h>
83 #include <string.h>
84 
85 #ifdef WIN32
86 #define ORTHANC_PLUGINS_API __declspec(dllexport)
87 #else
88 #define ORTHANC_PLUGINS_API
89 #endif
90 
91 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 0
92 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 8
93 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 6
94 
95 
96 
97 /********************************************************************
98  ** Check that function inlining is properly supported. The use of
99  ** inlining is required, to avoid the duplication of object code
100  ** between two compilation modules that would use the Orthanc Plugin
101  ** API.
102  ********************************************************************/
103 
104 /* If the auto-detection of the "inline" keyword below does not work
105  automatically and that your compiler is known to properly support
106  inlining, uncomment the following #define and adapt the definition
107  of "static inline". */
108 
109 /* #define ORTHANC_PLUGIN_INLINE static inline */
110 
111 #ifndef ORTHANC_PLUGIN_INLINE
112 # if __STDC_VERSION__ >= 199901L
113 /* This is C99 or above: http://predef.sourceforge.net/prestd.html */
114 # define ORTHANC_PLUGIN_INLINE static inline
115 # elif defined(__cplusplus)
116 /* This is C++ */
117 # define ORTHANC_PLUGIN_INLINE static inline
118 # elif defined(__GNUC__)
119 /* This is GCC running in C89 mode */
120 # define ORTHANC_PLUGIN_INLINE static __inline
121 # elif defined(_MSC_VER)
122 /* This is Visual Studio running in C89 mode */
123 # define ORTHANC_PLUGIN_INLINE static __inline
124 # else
125 # error Your compiler is not known to support the "inline" keyword
126 # endif
127 #endif
128 
129 
130 
131 /********************************************************************
132  ** Inclusion of standard libraries.
133  ********************************************************************/
134 
135 // For Microsoft Visual Studio, a compatibility "stdint.h" can be
136 // downloaded at the following URL:
137 // https://orthanc.googlecode.com/hg/Resources/ThirdParty/VisualStudio/stdint.h
138 #include <stdint.h>
139 
140 #include <stdlib.h>
141 
142 
143 
144 /********************************************************************
145  ** Definition of the Orthanc Plugin API.
146  ********************************************************************/
147 
150 #ifdef __cplusplus
151 extern "C"
152 {
153 #endif
154 
159  ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
160 
161 
165  typedef enum
166  {
172 
173 
177  typedef struct
178  {
183 
187  uint32_t groupsCount;
188 
192  const char* const* groups;
193 
197  uint32_t getCount;
198 
202  const char* const* getKeys;
203 
207  const char* const* getValues;
208 
212  const char* body;
213 
217  uint32_t bodySize;
218 
219 
220  /* --------------------------------------------------
221  New in version 0.8.1
222  -------------------------------------------------- */
223 
227  uint32_t headersCount;
228 
232  const char* const* headersKeys;
233 
237  const char* const* headersValues;
238 
240 
241 
242  typedef enum
243  {
244  /* Generic services */
245  _OrthancPluginService_LogInfo = 1,
246  _OrthancPluginService_LogWarning = 2,
247  _OrthancPluginService_LogError = 3,
248  _OrthancPluginService_GetOrthancPath = 4,
249  _OrthancPluginService_GetOrthancDirectory = 5,
250  _OrthancPluginService_GetConfigurationPath = 6,
251  _OrthancPluginService_SetPluginProperty = 7,
252  _OrthancPluginService_GetGlobalProperty = 8,
253  _OrthancPluginService_SetGlobalProperty = 9,
254  _OrthancPluginService_GetCommandLineArgumentsCount = 10,
255  _OrthancPluginService_GetCommandLineArgument = 11,
256 
257  /* Registration of callbacks */
258  _OrthancPluginService_RegisterRestCallback = 1000,
259  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
260  _OrthancPluginService_RegisterStorageArea = 1002,
261  _OrthancPluginService_RegisterOnChangeCallback = 1003,
262 
263  /* Sending answers to REST calls */
264  _OrthancPluginService_AnswerBuffer = 2000,
265  _OrthancPluginService_CompressAndAnswerPngImage = 2001,
266  _OrthancPluginService_Redirect = 2002,
267  _OrthancPluginService_SendHttpStatusCode = 2003,
268  _OrthancPluginService_SendUnauthorized = 2004,
269  _OrthancPluginService_SendMethodNotAllowed = 2005,
270  _OrthancPluginService_SetCookie = 2006,
271  _OrthancPluginService_SetHttpHeader = 2007,
272 
273  /* Access to the Orthanc database and API */
274  _OrthancPluginService_GetDicomForInstance = 3000,
275  _OrthancPluginService_RestApiGet = 3001,
276  _OrthancPluginService_RestApiPost = 3002,
277  _OrthancPluginService_RestApiDelete = 3003,
278  _OrthancPluginService_RestApiPut = 3004,
279  _OrthancPluginService_LookupPatient = 3005,
280  _OrthancPluginService_LookupStudy = 3006,
281  _OrthancPluginService_LookupSeries = 3007,
282  _OrthancPluginService_LookupInstance = 3008,
283  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
284  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
285  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
286  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
287  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
288 
289  /* Access to DICOM instances */
290  _OrthancPluginService_GetInstanceRemoteAet = 4000,
291  _OrthancPluginService_GetInstanceSize = 4001,
292  _OrthancPluginService_GetInstanceData = 4002,
293  _OrthancPluginService_GetInstanceJson = 4003,
294  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
295  _OrthancPluginService_HasInstanceMetadata = 4005,
296  _OrthancPluginService_GetInstanceMetadata = 4006,
297 
298  /* Services for plugins implementing a database back-end */
299  _OrthancPluginService_RegisterDatabaseBackend = 5000,
300  _OrthancPluginService_DatabaseAnswer = 5001
301 
302  } _OrthancPluginService;
303 
304 
305  typedef enum
306  {
307  _OrthancPluginProperty_Description = 1,
308  _OrthancPluginProperty_RootUri = 2,
309  _OrthancPluginProperty_OrthancExplorer = 3
310  } _OrthancPluginProperty;
311 
312 
313 
317  typedef enum
318  {
326 
334 
342 
350 
359 
360 
361 
365  typedef enum
366  {
371 
372 
373 
377  typedef enum
378  {
384 
385 
386 
390  typedef enum
391  {
403 
404 
405 
413  typedef struct
414  {
418  void* data;
419 
423  uint32_t size;
425 
426 
427 
428 
432  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
433 
434 
435 
439  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
440 
441 
442 
446  typedef int32_t (*OrthancPluginRestCallback) (
447  OrthancPluginRestOutput* output,
448  const char* url,
449  const OrthancPluginHttpRequest* request);
450 
451 
452 
457  OrthancPluginDicomInstance* instance,
458  const char* instanceId);
459 
460 
461 
465  typedef int32_t (*OrthancPluginOnChangeCallback) (
466  OrthancPluginChangeType changeType,
467  OrthancPluginResourceType resourceType,
468  const char* resourceId);
469 
470 
471 
475  typedef void (*OrthancPluginFree) (void* buffer);
476 
477 
478 
490  typedef int32_t (*OrthancPluginStorageCreate) (
491  const char* uuid,
492  const void* content,
493  int64_t size,
495 
496 
497 
509  typedef int32_t (*OrthancPluginStorageRead) (
510  void** content,
511  int64_t* size,
512  const char* uuid,
514 
515 
516 
526  typedef int32_t (*OrthancPluginStorageRemove) (
527  const char* uuid,
529 
530 
531 
535  typedef struct _OrthancPluginContext_t
536  {
537  void* pluginsManager;
538  const char* orthancVersion;
539  OrthancPluginFree Free;
540  int32_t (*InvokeService) (struct _OrthancPluginContext_t* context,
541  _OrthancPluginService service,
542  const void* params);
544 
545 
546 
555  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
556  OrthancPluginContext* context,
557  char* str)
558  {
559  if (str != NULL)
560  {
561  context->Free(str);
562  }
563  }
564 
565 
578  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
579  OrthancPluginContext* context)
580  {
581  int major, minor, revision;
582 
583  /* Assume compatibility with the mainline */
584  if (!strcmp(context->orthancVersion, "mainline"))
585  {
586  return 1;
587  }
588 
589  /* Parse the version of the Orthanc core */
590  if (
591 #ifdef _MSC_VER
592  sscanf_s
593 #else
594  sscanf
595 #endif
596  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
597  {
598  return 0;
599  }
600 
601  /* Check the major number of the version */
602 
603  if (major > ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
604  {
605  return 1;
606  }
607 
608  if (major < ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
609  {
610  return 0;
611  }
612 
613  /* Check the minor number of the version */
614 
615  if (minor > ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
616  {
617  return 1;
618  }
619 
620  if (minor < ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
621  {
622  return 0;
623  }
624 
625  /* Check the revision number of the version */
626 
627  if (revision >= ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER)
628  {
629  return 1;
630  }
631  else
632  {
633  return 0;
634  }
635  }
636 
637 
646  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
647  OrthancPluginContext* context,
649  {
650  context->Free(buffer->data);
651  }
652 
653 
662  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
663  OrthancPluginContext* context,
664  const char* message)
665  {
666  context->InvokeService(context, _OrthancPluginService_LogError, message);
667  }
668 
669 
678  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
679  OrthancPluginContext* context,
680  const char* message)
681  {
682  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
683  }
684 
685 
694  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
695  OrthancPluginContext* context,
696  const char* message)
697  {
698  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
699  }
700 
701 
702 
703  typedef struct
704  {
705  const char* pathRegularExpression;
706  OrthancPluginRestCallback callback;
707  } _OrthancPluginRestCallback;
708 
721  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
722  OrthancPluginContext* context,
723  const char* pathRegularExpression,
724  OrthancPluginRestCallback callback)
725  {
726  _OrthancPluginRestCallback params;
727  params.pathRegularExpression = pathRegularExpression;
728  params.callback = callback;
729  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
730  }
731 
732 
733 
734  typedef struct
735  {
737  } _OrthancPluginOnStoredInstanceCallback;
738 
749  OrthancPluginContext* context,
751  {
752  _OrthancPluginOnStoredInstanceCallback params;
753  params.callback = callback;
754 
755  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
756  }
757 
758 
759 
760  typedef struct
761  {
762  OrthancPluginRestOutput* output;
763  const char* answer;
764  uint32_t answerSize;
765  const char* mimeType;
766  } _OrthancPluginAnswerBuffer;
767 
779  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
780  OrthancPluginContext* context,
781  OrthancPluginRestOutput* output,
782  const char* answer,
783  uint32_t answerSize,
784  const char* mimeType)
785  {
786  _OrthancPluginAnswerBuffer params;
787  params.output = output;
788  params.answer = answer;
789  params.answerSize = answerSize;
790  params.mimeType = mimeType;
791  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
792  }
793 
794 
795  typedef struct
796  {
797  OrthancPluginRestOutput* output;
799  uint32_t width;
800  uint32_t height;
801  uint32_t pitch;
802  const void* buffer;
803  } _OrthancPluginCompressAndAnswerPngImage;
804 
822  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
823  OrthancPluginContext* context,
824  OrthancPluginRestOutput* output,
826  uint32_t width,
827  uint32_t height,
828  uint32_t pitch,
829  const void* buffer)
830  {
831  _OrthancPluginCompressAndAnswerPngImage params;
832  params.output = output;
833  params.format = format;
834  params.width = width;
835  params.height = height;
836  params.pitch = pitch;
837  params.buffer = buffer;
838  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerPngImage, &params);
839  }
840 
841 
842 
843  typedef struct
844  {
846  const char* instanceId;
847  } _OrthancPluginGetDicomForInstance;
848 
860  ORTHANC_PLUGIN_INLINE int OrthancPluginGetDicomForInstance(
861  OrthancPluginContext* context,
863  const char* instanceId)
864  {
865  _OrthancPluginGetDicomForInstance params;
866  params.target = target;
867  params.instanceId = instanceId;
868  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
869  }
870 
871 
872 
873  typedef struct
874  {
876  const char* uri;
877  } _OrthancPluginRestApiGet;
878 
890  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiGet(
891  OrthancPluginContext* context,
893  const char* uri)
894  {
895  _OrthancPluginRestApiGet params;
896  params.target = target;
897  params.uri = uri;
898  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
899  }
900 
901 
902 
917  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiGetAfterPlugins(
918  OrthancPluginContext* context,
920  const char* uri)
921  {
922  _OrthancPluginRestApiGet params;
923  params.target = target;
924  params.uri = uri;
925  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
926  }
927 
928 
929 
930  typedef struct
931  {
933  const char* uri;
934  const char* body;
935  uint32_t bodySize;
936  } _OrthancPluginRestApiPostPut;
937 
951  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiPost(
952  OrthancPluginContext* context,
954  const char* uri,
955  const char* body,
956  uint32_t bodySize)
957  {
958  _OrthancPluginRestApiPostPut params;
959  params.target = target;
960  params.uri = uri;
961  params.body = body;
962  params.bodySize = bodySize;
963  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
964  }
965 
966 
983  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiPostAfterPlugins(
984  OrthancPluginContext* context,
986  const char* uri,
987  const char* body,
988  uint32_t bodySize)
989  {
990  _OrthancPluginRestApiPostPut params;
991  params.target = target;
992  params.uri = uri;
993  params.body = body;
994  params.bodySize = bodySize;
995  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
996  }
997 
998 
999 
1009  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiDelete(
1010  OrthancPluginContext* context,
1011  const char* uri)
1012  {
1013  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
1014  }
1015 
1016 
1029  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiDeleteAfterPlugins(
1030  OrthancPluginContext* context,
1031  const char* uri)
1032  {
1033  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
1034  }
1035 
1036 
1037 
1051  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiPut(
1052  OrthancPluginContext* context,
1053  OrthancPluginMemoryBuffer* target,
1054  const char* uri,
1055  const char* body,
1056  uint32_t bodySize)
1057  {
1058  _OrthancPluginRestApiPostPut params;
1059  params.target = target;
1060  params.uri = uri;
1061  params.body = body;
1062  params.bodySize = bodySize;
1063  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
1064  }
1065 
1066 
1067 
1084  ORTHANC_PLUGIN_INLINE int OrthancPluginRestApiPutAfterPlugins(
1085  OrthancPluginContext* context,
1086  OrthancPluginMemoryBuffer* target,
1087  const char* uri,
1088  const char* body,
1089  uint32_t bodySize)
1090  {
1091  _OrthancPluginRestApiPostPut params;
1092  params.target = target;
1093  params.uri = uri;
1094  params.body = body;
1095  params.bodySize = bodySize;
1096  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
1097  }
1098 
1099 
1100 
1101  typedef struct
1102  {
1103  OrthancPluginRestOutput* output;
1104  const char* argument;
1105  } _OrthancPluginOutputPlusArgument;
1106 
1117  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
1118  OrthancPluginContext* context,
1119  OrthancPluginRestOutput* output,
1120  const char* redirection)
1121  {
1122  _OrthancPluginOutputPlusArgument params;
1123  params.output = output;
1124  params.argument = redirection;
1125  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
1126  }
1127 
1128 
1129 
1130  typedef struct
1131  {
1132  char** result;
1133  const char* argument;
1134  } _OrthancPluginRetrieveDynamicString;
1135 
1148  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
1149  OrthancPluginContext* context,
1150  const char* patientID)
1151  {
1152  char* result;
1153 
1154  _OrthancPluginRetrieveDynamicString params;
1155  params.result = &result;
1156  params.argument = patientID;
1157 
1158  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params))
1159  {
1160  /* Error */
1161  return NULL;
1162  }
1163  else
1164  {
1165  return result;
1166  }
1167  }
1168 
1169 
1182  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
1183  OrthancPluginContext* context,
1184  const char* studyUID)
1185  {
1186  char* result;
1187 
1188  _OrthancPluginRetrieveDynamicString params;
1189  params.result = &result;
1190  params.argument = studyUID;
1191 
1192  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params))
1193  {
1194  /* Error */
1195  return NULL;
1196  }
1197  else
1198  {
1199  return result;
1200  }
1201  }
1202 
1203 
1216  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
1217  OrthancPluginContext* context,
1218  const char* accessionNumber)
1219  {
1220  char* result;
1221 
1222  _OrthancPluginRetrieveDynamicString params;
1223  params.result = &result;
1224  params.argument = accessionNumber;
1225 
1226  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params))
1227  {
1228  /* Error */
1229  return NULL;
1230  }
1231  else
1232  {
1233  return result;
1234  }
1235  }
1236 
1237 
1250  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
1251  OrthancPluginContext* context,
1252  const char* seriesUID)
1253  {
1254  char* result;
1255 
1256  _OrthancPluginRetrieveDynamicString params;
1257  params.result = &result;
1258  params.argument = seriesUID;
1259 
1260  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params))
1261  {
1262  /* Error */
1263  return NULL;
1264  }
1265  else
1266  {
1267  return result;
1268  }
1269  }
1270 
1271 
1284  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
1285  OrthancPluginContext* context,
1286  const char* sopInstanceUID)
1287  {
1288  char* result;
1289 
1290  _OrthancPluginRetrieveDynamicString params;
1291  params.result = &result;
1292  params.argument = sopInstanceUID;
1293 
1294  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params))
1295  {
1296  /* Error */
1297  return NULL;
1298  }
1299  else
1300  {
1301  return result;
1302  }
1303  }
1304 
1305 
1306 
1307  typedef struct
1308  {
1309  OrthancPluginRestOutput* output;
1310  uint16_t status;
1311  } _OrthancPluginSendHttpStatusCode;
1312 
1327  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
1328  OrthancPluginContext* context,
1329  OrthancPluginRestOutput* output,
1330  uint16_t status)
1331  {
1332  _OrthancPluginSendHttpStatusCode params;
1333  params.output = output;
1334  params.status = status;
1335  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
1336  }
1337 
1338 
1349  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
1350  OrthancPluginContext* context,
1351  OrthancPluginRestOutput* output,
1352  const char* realm)
1353  {
1354  _OrthancPluginOutputPlusArgument params;
1355  params.output = output;
1356  params.argument = realm;
1357  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
1358  }
1359 
1360 
1371  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
1372  OrthancPluginContext* context,
1373  OrthancPluginRestOutput* output,
1374  const char* allowedMethods)
1375  {
1376  _OrthancPluginOutputPlusArgument params;
1377  params.output = output;
1378  params.argument = allowedMethods;
1379  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
1380  }
1381 
1382 
1383  typedef struct
1384  {
1385  OrthancPluginRestOutput* output;
1386  const char* key;
1387  const char* value;
1388  } _OrthancPluginSetHttpHeader;
1389 
1400  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
1401  OrthancPluginContext* context,
1402  OrthancPluginRestOutput* output,
1403  const char* cookie,
1404  const char* value)
1405  {
1406  _OrthancPluginSetHttpHeader params;
1407  params.output = output;
1408  params.key = cookie;
1409  params.value = value;
1410  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
1411  }
1412 
1413 
1424  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
1425  OrthancPluginContext* context,
1426  OrthancPluginRestOutput* output,
1427  const char* key,
1428  const char* value)
1429  {
1430  _OrthancPluginSetHttpHeader params;
1431  params.output = output;
1432  params.key = key;
1433  params.value = value;
1434  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
1435  }
1436 
1437 
1438  typedef struct
1439  {
1440  char** resultStringToFree;
1441  const char** resultString;
1442  int64_t* resultInt64;
1443  const char* key;
1444  OrthancPluginDicomInstance* instance;
1445  } _OrthancPluginAccessDicomInstance;
1446 
1447 
1458  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
1459  OrthancPluginContext* context,
1460  OrthancPluginDicomInstance* instance)
1461  {
1462  const char* result;
1463 
1464  _OrthancPluginAccessDicomInstance params;
1465  memset(&params, 0, sizeof(params));
1466  params.resultString = &result;
1467  params.instance = instance;
1468 
1469  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params))
1470  {
1471  /* Error */
1472  return NULL;
1473  }
1474  else
1475  {
1476  return result;
1477  }
1478  }
1479 
1480 
1490  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
1491  OrthancPluginContext* context,
1492  OrthancPluginDicomInstance* instance)
1493  {
1494  int64_t size;
1495 
1496  _OrthancPluginAccessDicomInstance params;
1497  memset(&params, 0, sizeof(params));
1498  params.resultInt64 = &size;
1499  params.instance = instance;
1500 
1501  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params))
1502  {
1503  /* Error */
1504  return -1;
1505  }
1506  else
1507  {
1508  return size;
1509  }
1510  }
1511 
1512 
1522  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceData(
1523  OrthancPluginContext* context,
1524  OrthancPluginDicomInstance* instance)
1525  {
1526  const char* result;
1527 
1528  _OrthancPluginAccessDicomInstance params;
1529  memset(&params, 0, sizeof(params));
1530  params.resultString = &result;
1531  params.instance = instance;
1532 
1533  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params))
1534  {
1535  /* Error */
1536  return NULL;
1537  }
1538  else
1539  {
1540  return result;
1541  }
1542  }
1543 
1544 
1557  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
1558  OrthancPluginContext* context,
1559  OrthancPluginDicomInstance* instance)
1560  {
1561  char* result;
1562 
1563  _OrthancPluginAccessDicomInstance params;
1564  memset(&params, 0, sizeof(params));
1565  params.resultStringToFree = &result;
1566  params.instance = instance;
1567 
1568  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params))
1569  {
1570  /* Error */
1571  return NULL;
1572  }
1573  else
1574  {
1575  return result;
1576  }
1577  }
1578 
1579 
1594  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
1595  OrthancPluginContext* context,
1596  OrthancPluginDicomInstance* instance)
1597  {
1598  char* result;
1599 
1600  _OrthancPluginAccessDicomInstance params;
1601  memset(&params, 0, sizeof(params));
1602  params.resultStringToFree = &result;
1603  params.instance = instance;
1604 
1605  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params))
1606  {
1607  /* Error */
1608  return NULL;
1609  }
1610  else
1611  {
1612  return result;
1613  }
1614  }
1615 
1616 
1632  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
1633  OrthancPluginContext* context,
1634  OrthancPluginDicomInstance* instance,
1635  const char* metadata)
1636  {
1637  int64_t result;
1638 
1639  _OrthancPluginAccessDicomInstance params;
1640  memset(&params, 0, sizeof(params));
1641  params.resultInt64 = &result;
1642  params.instance = instance;
1643  params.key = metadata;
1644 
1645  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params))
1646  {
1647  /* Error */
1648  return -1;
1649  }
1650  else
1651  {
1652  return (result != 0);
1653  }
1654  }
1655 
1656 
1669  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
1670  OrthancPluginContext* context,
1671  OrthancPluginDicomInstance* instance,
1672  const char* metadata)
1673  {
1674  const char* result;
1675 
1676  _OrthancPluginAccessDicomInstance params;
1677  memset(&params, 0, sizeof(params));
1678  params.resultString = &result;
1679  params.instance = instance;
1680  params.key = metadata;
1681 
1682  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params))
1683  {
1684  /* Error */
1685  return NULL;
1686  }
1687  else
1688  {
1689  return result;
1690  }
1691  }
1692 
1693 
1694 
1695  typedef struct
1696  {
1700  OrthancPluginFree free;
1701  } _OrthancPluginRegisterStorageArea;
1702 
1716  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
1717  OrthancPluginContext* context,
1721  {
1722  _OrthancPluginRegisterStorageArea params;
1723  params.create = create;
1724  params.read = read;
1725  params.remove = remove;
1726 
1727 #ifdef __cplusplus
1728  params.free = ::free;
1729 #else
1730  params.free = free;
1731 #endif
1732 
1733  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
1734  }
1735 
1736 
1737 
1748  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
1749  {
1750  char* result;
1751 
1752  _OrthancPluginRetrieveDynamicString params;
1753  params.result = &result;
1754  params.argument = NULL;
1755 
1756  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params))
1757  {
1758  /* Error */
1759  return NULL;
1760  }
1761  else
1762  {
1763  return result;
1764  }
1765  }
1766 
1767 
1778  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
1779  {
1780  char* result;
1781 
1782  _OrthancPluginRetrieveDynamicString params;
1783  params.result = &result;
1784  params.argument = NULL;
1785 
1786  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params))
1787  {
1788  /* Error */
1789  return NULL;
1790  }
1791  else
1792  {
1793  return result;
1794  }
1795  }
1796 
1797 
1809  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
1810  {
1811  char* result;
1812 
1813  _OrthancPluginRetrieveDynamicString params;
1814  params.result = &result;
1815  params.argument = NULL;
1816 
1817  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params))
1818  {
1819  /* Error */
1820  return NULL;
1821  }
1822  else
1823  {
1824  return result;
1825  }
1826  }
1827 
1828 
1829 
1830  typedef struct
1831  {
1833  } _OrthancPluginOnChangeCallback;
1834 
1844  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
1845  OrthancPluginContext* context,
1847  {
1848  _OrthancPluginOnChangeCallback params;
1849  params.callback = callback;
1850 
1851  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
1852  }
1853 
1854 
1855 
1856  typedef struct
1857  {
1858  const char* plugin;
1859  _OrthancPluginProperty property;
1860  const char* value;
1861  } _OrthancPluginSetPluginProperty;
1862 
1863 
1875  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
1876  OrthancPluginContext* context,
1877  const char* uri)
1878  {
1879  _OrthancPluginSetPluginProperty params;
1880  params.plugin = OrthancPluginGetName();
1881  params.property = _OrthancPluginProperty_RootUri;
1882  params.value = uri;
1883 
1884  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
1885  }
1886 
1887 
1897  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
1898  OrthancPluginContext* context,
1899  const char* description)
1900  {
1901  _OrthancPluginSetPluginProperty params;
1902  params.plugin = OrthancPluginGetName();
1903  params.property = _OrthancPluginProperty_Description;
1904  params.value = description;
1905 
1906  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
1907  }
1908 
1909 
1919  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
1920  OrthancPluginContext* context,
1921  const char* javascript)
1922  {
1923  _OrthancPluginSetPluginProperty params;
1924  params.plugin = OrthancPluginGetName();
1925  params.property = _OrthancPluginProperty_OrthancExplorer;
1926  params.value = javascript;
1927 
1928  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
1929  }
1930 
1931 
1932  typedef struct
1933  {
1934  char** result;
1935  int32_t property;
1936  const char* value;
1937  } _OrthancPluginGlobalProperty;
1938 
1939 
1952  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
1953  OrthancPluginContext* context,
1954  int32_t property,
1955  const char* defaultValue)
1956  {
1957  char* result;
1958 
1959  _OrthancPluginGlobalProperty params;
1960  params.result = &result;
1961  params.property = property;
1962  params.value = defaultValue;
1963 
1964  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params))
1965  {
1966  /* Error */
1967  return NULL;
1968  }
1969  else
1970  {
1971  return result;
1972  }
1973  }
1974 
1975 
1990  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginSetGlobalProperty(
1991  OrthancPluginContext* context,
1992  int32_t property,
1993  const char* value)
1994  {
1995  _OrthancPluginGlobalProperty params;
1996  params.result = NULL;
1997  params.property = property;
1998  params.value = value;
1999 
2000  if (context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params))
2001  {
2002  /* Error */
2003  return -1;
2004  }
2005  else
2006  {
2007  return 0;
2008  }
2009  }
2010 
2011 
2012 
2013  typedef struct
2014  {
2015  int32_t *resultInt32;
2016  uint32_t *resultUint32;
2017  int64_t *resultInt64;
2018  uint64_t *resultUint64;
2019  } _OrthancPluginReturnSingleValue;
2020 
2029  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
2030  OrthancPluginContext* context)
2031  {
2032  uint32_t count = 0;
2033 
2034  _OrthancPluginReturnSingleValue params;
2035  memset(&params, 0, sizeof(params));
2036  params.resultUint32 = &count;
2037 
2038  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params))
2039  {
2040  /* Error */
2041  return 0;
2042  }
2043  else
2044  {
2045  return count;
2046  }
2047  }
2048 
2049 
2050 
2063  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
2064  OrthancPluginContext* context,
2065  uint32_t argument)
2066  {
2067  char* result;
2068 
2069  _OrthancPluginGlobalProperty params;
2070  params.result = &result;
2071  params.property = (int32_t) argument;
2072  params.value = NULL;
2073 
2074  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params))
2075  {
2076  /* Error */
2077  return NULL;
2078  }
2079  else
2080  {
2081  return result;
2082  }
2083  }
2084 
2085 
2086 #ifdef __cplusplus
2087 }
2088 #endif
2089 
2090 
int32_t(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:526
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:1371
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:1952
The parameters of a REST request.
Definition: OrthancCPlugin.h:177
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:1844
Definition: OrthancCPlugin.h:368
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:748
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:237
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:232
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:197
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:1117
int32_t(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:490
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:951
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:1327
Definition: OrthancCPlugin.h:394
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:1458
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:822
OrthancPluginContentType
Definition: OrthancCPlugin.h:365
Definition: OrthancCPlugin.h:397
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:694
int32_t(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:509
Definition: OrthancCPlugin.h:167
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:662
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:646
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:1748
OrthancPluginResourceType
Definition: OrthancCPlugin.h:377
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:446
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:1349
OrthancPluginChangeType
Definition: OrthancCPlugin.h:390
int OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1009
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:1424
int OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:860
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:1778
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:333
int OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:1029
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:1216
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:1875
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:418
Definition: OrthancCPlugin.h:395
Color image in RGB24 format.
Definition: OrthancCPlugin.h:349
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:1632
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:227
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:1594
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:1919
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:165
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance received by Orthanc.
Definition: OrthancCPlugin.h:439
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:2063
Definition: OrthancCPlugin.h:401
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
Definition: OrthancCPlugin.h:393
Definition: OrthancCPlugin.h:379
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:432
int32_t OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:1990
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:1051
int 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:1084
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:207
int 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:983
Definition: OrthancCPlugin.h:169
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file.
Definition: OrthancCPlugin.h:1809
const char * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:212
Definition: OrthancCPlugin.h:170
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:1148
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:357
Definition: OrthancCPlugin.h:380
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:1400
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:202
Definition: OrthancCPlugin.h:392
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:192
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:2029
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:423
int OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:890
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:187
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:456
Definition: OrthancCPlugin.h:400
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:317
Definition: OrthancCPlugin.h:381
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:721
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:325
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:217
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:779
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:1669
Definition: OrthancCPlugin.h:399
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:1716
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:555
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:475
Definition: OrthancCPlugin.h:396
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:1490
Definition: OrthancCPlugin.h:382
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:1557
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:341
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:182
const char * OrthancPluginGetInstanceData(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:1522
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:413
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:1897
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:578
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:678
Definition: OrthancCPlugin.h:369
Definition: OrthancCPlugin.h:168
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:1182
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:1250
Definition: OrthancCPlugin.h:367
Definition: OrthancCPlugin.h:398
int OrthancPluginRestApiGetAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:917
int32_t(* 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:465
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:1284