Orthanc Plugin SDK
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1 
98 #pragma once
99 
100 
101 #include <stdio.h>
102 #include <string.h>
103 
104 #ifdef WIN32
105 #define ORTHANC_PLUGINS_API __declspec(dllexport)
106 #else
107 #define ORTHANC_PLUGINS_API
108 #endif
109 
110 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 0
111 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 9
112 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 4
113 
114 
115 
116 /********************************************************************
117  ** Check that function inlining is properly supported. The use of
118  ** inlining is required, to avoid the duplication of object code
119  ** between two compilation modules that would use the Orthanc Plugin
120  ** API.
121  ********************************************************************/
122 
123 /* If the auto-detection of the "inline" keyword below does not work
124  automatically and that your compiler is known to properly support
125  inlining, uncomment the following #define and adapt the definition
126  of "static inline". */
127 
128 /* #define ORTHANC_PLUGIN_INLINE static inline */
129 
130 #ifndef ORTHANC_PLUGIN_INLINE
131 # if __STDC_VERSION__ >= 199901L
132 /* This is C99 or above: http://predef.sourceforge.net/prestd.html */
133 # define ORTHANC_PLUGIN_INLINE static inline
134 # elif defined(__cplusplus)
135 /* This is C++ */
136 # define ORTHANC_PLUGIN_INLINE static inline
137 # elif defined(__GNUC__)
138 /* This is GCC running in C89 mode */
139 # define ORTHANC_PLUGIN_INLINE static __inline
140 # elif defined(_MSC_VER)
141 /* This is Visual Studio running in C89 mode */
142 # define ORTHANC_PLUGIN_INLINE static __inline
143 # else
144 # error Your compiler is not known to support the "inline" keyword
145 # endif
146 #endif
147 
148 
149 
150 /********************************************************************
151  ** Inclusion of standard libraries.
152  ********************************************************************/
153 
159 #include <stdint.h>
160 
161 #include <stdlib.h>
162 
163 
164 
165 /********************************************************************
166  ** Definition of the Orthanc Plugin API.
167  ********************************************************************/
168 
171 #ifdef __cplusplus
172 extern "C"
173 {
174 #endif
175 
179  typedef enum
180  {
265 
266  _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
268 
269 
274  ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
275 
276 
280  typedef enum
281  {
287  _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
289 
290 
295  typedef struct
296  {
301 
305  uint32_t groupsCount;
306 
310  const char* const* groups;
311 
315  uint32_t getCount;
316 
320  const char* const* getKeys;
321 
325  const char* const* getValues;
326 
330  const char* body;
331 
335  uint32_t bodySize;
336 
337 
338  /* --------------------------------------------------
339  New in version 0.8.1
340  -------------------------------------------------- */
341 
345  uint32_t headersCount;
346 
350  const char* const* headersKeys;
351 
355  const char* const* headersValues;
356 
358 
359 
360  typedef enum
361  {
362  /* Generic services */
363  _OrthancPluginService_LogInfo = 1,
364  _OrthancPluginService_LogWarning = 2,
365  _OrthancPluginService_LogError = 3,
366  _OrthancPluginService_GetOrthancPath = 4,
367  _OrthancPluginService_GetOrthancDirectory = 5,
368  _OrthancPluginService_GetConfigurationPath = 6,
369  _OrthancPluginService_SetPluginProperty = 7,
370  _OrthancPluginService_GetGlobalProperty = 8,
371  _OrthancPluginService_SetGlobalProperty = 9,
372  _OrthancPluginService_GetCommandLineArgumentsCount = 10,
373  _OrthancPluginService_GetCommandLineArgument = 11,
374  _OrthancPluginService_GetExpectedDatabaseVersion = 12,
375  _OrthancPluginService_GetConfiguration = 13,
376  _OrthancPluginService_BufferCompression = 14,
377  _OrthancPluginService_ReadFile = 15,
378  _OrthancPluginService_WriteFile = 16,
379  _OrthancPluginService_GetErrorDescription = 17,
380  _OrthancPluginService_CallHttpClient = 18,
381 
382  /* Registration of callbacks */
383  _OrthancPluginService_RegisterRestCallback = 1000,
384  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
385  _OrthancPluginService_RegisterStorageArea = 1002,
386  _OrthancPluginService_RegisterOnChangeCallback = 1003,
387  _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
388 
389  /* Sending answers to REST calls */
390  _OrthancPluginService_AnswerBuffer = 2000,
391  _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
392  _OrthancPluginService_Redirect = 2002,
393  _OrthancPluginService_SendHttpStatusCode = 2003,
394  _OrthancPluginService_SendUnauthorized = 2004,
395  _OrthancPluginService_SendMethodNotAllowed = 2005,
396  _OrthancPluginService_SetCookie = 2006,
397  _OrthancPluginService_SetHttpHeader = 2007,
398  _OrthancPluginService_StartMultipartAnswer = 2008,
399  _OrthancPluginService_SendMultipartItem = 2009,
400  _OrthancPluginService_SendHttpStatus = 2010,
401  _OrthancPluginService_CompressAndAnswerImage = 2011,
402 
403  /* Access to the Orthanc database and API */
404  _OrthancPluginService_GetDicomForInstance = 3000,
405  _OrthancPluginService_RestApiGet = 3001,
406  _OrthancPluginService_RestApiPost = 3002,
407  _OrthancPluginService_RestApiDelete = 3003,
408  _OrthancPluginService_RestApiPut = 3004,
409  _OrthancPluginService_LookupPatient = 3005,
410  _OrthancPluginService_LookupStudy = 3006,
411  _OrthancPluginService_LookupSeries = 3007,
412  _OrthancPluginService_LookupInstance = 3008,
413  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
414  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
415  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
416  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
417  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
418 
419  /* Access to DICOM instances */
420  _OrthancPluginService_GetInstanceRemoteAet = 4000,
421  _OrthancPluginService_GetInstanceSize = 4001,
422  _OrthancPluginService_GetInstanceData = 4002,
423  _OrthancPluginService_GetInstanceJson = 4003,
424  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
425  _OrthancPluginService_HasInstanceMetadata = 4005,
426  _OrthancPluginService_GetInstanceMetadata = 4006,
427 
428  /* Services for plugins implementing a database back-end */
429  _OrthancPluginService_RegisterDatabaseBackend = 5000,
430  _OrthancPluginService_DatabaseAnswer = 5001,
431  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
432  _OrthancPluginService_StorageAreaCreate = 5003,
433  _OrthancPluginService_StorageAreaRead = 5004,
434  _OrthancPluginService_StorageAreaRemove = 5005,
435 
436  /* Primitives for handling images */
437  _OrthancPluginService_GetImagePixelFormat = 6000,
438  _OrthancPluginService_GetImageWidth = 6001,
439  _OrthancPluginService_GetImageHeight = 6002,
440  _OrthancPluginService_GetImagePitch = 6003,
441  _OrthancPluginService_GetImageBuffer = 6004,
442  _OrthancPluginService_UncompressImage = 6005,
443  _OrthancPluginService_FreeImage = 6006,
444  _OrthancPluginService_CompressImage = 6007,
445  _OrthancPluginService_ConvertPixelFormat = 6008,
446  _OrthancPluginService_GetFontsCount = 6009,
447  _OrthancPluginService_GetFontInfo = 6010,
448  _OrthancPluginService_DrawText = 6011,
449 
450  _OrthancPluginService_INTERNAL = 0x7fffffff
451  } _OrthancPluginService;
452 
453 
454  typedef enum
455  {
456  _OrthancPluginProperty_Description = 1,
457  _OrthancPluginProperty_RootUri = 2,
458  _OrthancPluginProperty_OrthancExplorer = 3,
459 
460  _OrthancPluginProperty_INTERNAL = 0x7fffffff
461  } _OrthancPluginProperty;
462 
463 
464 
469  typedef enum
470  {
478 
486 
494 
502 
510 
513  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
515 
516 
517 
521  typedef enum
522  {
527  _OrthancPluginContentType_INTERNAL = 0x7fffffff
529 
530 
531 
535  typedef enum
536  {
542  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
544 
545 
546 
551  typedef enum
552  {
564  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
566 
567 
572  typedef enum
573  {
579  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
581 
582 
587  typedef enum
588  {
592  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
594 
595 
596 
604  typedef struct
605  {
609  void* data;
610 
614  uint32_t size;
616 
617 
618 
619 
624  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
625 
626 
627 
631  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
632 
633 
634 
639  typedef struct _OrthancPluginImage_t OrthancPluginImage;
640 
641 
642 
647  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
648 
649 
650 
655  typedef int32_t (*OrthancPluginRestCallback) (
656  OrthancPluginRestOutput* output,
657  const char* url,
658  const OrthancPluginHttpRequest* request);
659 
660 
661 
667  OrthancPluginDicomInstance* instance,
668  const char* instanceId);
669 
670 
671 
676  typedef int32_t (*OrthancPluginOnChangeCallback) (
677  OrthancPluginChangeType changeType,
678  OrthancPluginResourceType resourceType,
679  const char* resourceId);
680 
681 
682 
686  typedef void (*OrthancPluginFree) (void* buffer);
687 
688 
689 
702  typedef int32_t (*OrthancPluginStorageCreate) (
703  const char* uuid,
704  const void* content,
705  int64_t size,
707 
708 
709 
722  typedef int32_t (*OrthancPluginStorageRead) (
723  void** content,
724  int64_t* size,
725  const char* uuid,
727 
728 
729 
740  typedef int32_t (*OrthancPluginStorageRemove) (
741  const char* uuid,
743 
744 
745 
749  typedef struct _OrthancPluginContext_t
750  {
751  void* pluginsManager;
752  const char* orthancVersion;
753  OrthancPluginFree Free;
754  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
755  _OrthancPluginService service,
756  const void* params);
758 
759 
760 
769  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
770  OrthancPluginContext* context,
771  char* str)
772  {
773  if (str != NULL)
774  {
775  context->Free(str);
776  }
777  }
778 
779 
793  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
794  OrthancPluginContext* context)
795  {
796  int major, minor, revision;
797 
798  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
799  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
800  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
801  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
802  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
803  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
804  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
805  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
806  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
807  sizeof(int32_t) != sizeof(OrthancPluginImageFormat))
808  {
809  /* Mismatch in the size of the enumerations */
810  return 0;
811  }
812 
813  /* Assume compatibility with the mainline */
814  if (!strcmp(context->orthancVersion, "mainline"))
815  {
816  return 1;
817  }
818 
819  /* Parse the version of the Orthanc core */
820  if (
821 #ifdef _MSC_VER
822  sscanf_s
823 #else
824  sscanf
825 #endif
826  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
827  {
828  return 0;
829  }
830 
831  /* Check the major number of the version */
832 
833  if (major > ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
834  {
835  return 1;
836  }
837 
838  if (major < ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
839  {
840  return 0;
841  }
842 
843  /* Check the minor number of the version */
844 
845  if (minor > ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
846  {
847  return 1;
848  }
849 
850  if (minor < ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
851  {
852  return 0;
853  }
854 
855  /* Check the revision number of the version */
856 
857  if (revision >= ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER)
858  {
859  return 1;
860  }
861  else
862  {
863  return 0;
864  }
865  }
866 
867 
876  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
877  OrthancPluginContext* context,
879  {
880  context->Free(buffer->data);
881  }
882 
883 
892  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
893  OrthancPluginContext* context,
894  const char* message)
895  {
896  context->InvokeService(context, _OrthancPluginService_LogError, message);
897  }
898 
899 
908  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
909  OrthancPluginContext* context,
910  const char* message)
911  {
912  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
913  }
914 
915 
924  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
925  OrthancPluginContext* context,
926  const char* message)
927  {
928  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
929  }
930 
931 
932 
933  typedef struct
934  {
935  const char* pathRegularExpression;
936  OrthancPluginRestCallback callback;
937  } _OrthancPluginRestCallback;
938 
955  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
956  OrthancPluginContext* context,
957  const char* pathRegularExpression,
958  OrthancPluginRestCallback callback)
959  {
960  _OrthancPluginRestCallback params;
961  params.pathRegularExpression = pathRegularExpression;
962  params.callback = callback;
963  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
964  }
965 
966 
967 
989  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
990  OrthancPluginContext* context,
991  const char* pathRegularExpression,
992  OrthancPluginRestCallback callback)
993  {
994  _OrthancPluginRestCallback params;
995  params.pathRegularExpression = pathRegularExpression;
996  params.callback = callback;
997  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
998  }
999 
1000 
1001 
1002  typedef struct
1003  {
1005  } _OrthancPluginOnStoredInstanceCallback;
1006 
1018  OrthancPluginContext* context,
1020  {
1021  _OrthancPluginOnStoredInstanceCallback params;
1022  params.callback = callback;
1023 
1024  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
1025  }
1026 
1027 
1028 
1029  typedef struct
1030  {
1031  OrthancPluginRestOutput* output;
1032  const char* answer;
1033  uint32_t answerSize;
1034  const char* mimeType;
1035  } _OrthancPluginAnswerBuffer;
1036 
1049  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
1050  OrthancPluginContext* context,
1051  OrthancPluginRestOutput* output,
1052  const char* answer,
1053  uint32_t answerSize,
1054  const char* mimeType)
1055  {
1056  _OrthancPluginAnswerBuffer params;
1057  params.output = output;
1058  params.answer = answer;
1059  params.answerSize = answerSize;
1060  params.mimeType = mimeType;
1061  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
1062  }
1063 
1064 
1065  typedef struct
1066  {
1067  OrthancPluginRestOutput* output;
1068  OrthancPluginPixelFormat format;
1069  uint32_t width;
1070  uint32_t height;
1071  uint32_t pitch;
1072  const void* buffer;
1073  } _OrthancPluginCompressAndAnswerPngImage;
1074 
1075  typedef struct
1076  {
1077  OrthancPluginRestOutput* output;
1078  OrthancPluginImageFormat imageFormat;
1079  OrthancPluginPixelFormat pixelFormat;
1080  uint32_t width;
1081  uint32_t height;
1082  uint32_t pitch;
1083  const void* buffer;
1084  uint8_t quality;
1085  } _OrthancPluginCompressAndAnswerImage;
1086 
1087 
1106  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
1107  OrthancPluginContext* context,
1108  OrthancPluginRestOutput* output,
1109  OrthancPluginPixelFormat format,
1110  uint32_t width,
1111  uint32_t height,
1112  uint32_t pitch,
1113  const void* buffer)
1114  {
1115  _OrthancPluginCompressAndAnswerImage params;
1116  params.output = output;
1117  params.imageFormat = OrthancPluginImageFormat_Png;
1118  params.pixelFormat = format;
1119  params.width = width;
1120  params.height = height;
1121  params.pitch = pitch;
1122  params.buffer = buffer;
1123  params.quality = 0; /* No quality for PNG */
1124  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
1125  }
1126 
1127 
1128 
1129  typedef struct
1130  {
1131  OrthancPluginMemoryBuffer* target;
1132  const char* instanceId;
1133  } _OrthancPluginGetDicomForInstance;
1134 
1148  OrthancPluginContext* context,
1149  OrthancPluginMemoryBuffer* target,
1150  const char* instanceId)
1151  {
1152  _OrthancPluginGetDicomForInstance params;
1153  params.target = target;
1154  params.instanceId = instanceId;
1155  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
1156  }
1157 
1158 
1159 
1160  typedef struct
1161  {
1162  OrthancPluginMemoryBuffer* target;
1163  const char* uri;
1164  } _OrthancPluginRestApiGet;
1165 
1180  OrthancPluginContext* context,
1181  OrthancPluginMemoryBuffer* target,
1182  const char* uri)
1183  {
1184  _OrthancPluginRestApiGet params;
1185  params.target = target;
1186  params.uri = uri;
1187  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
1188  }
1189 
1190 
1191 
1209  OrthancPluginContext* context,
1210  OrthancPluginMemoryBuffer* target,
1211  const char* uri)
1212  {
1213  _OrthancPluginRestApiGet params;
1214  params.target = target;
1215  params.uri = uri;
1216  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
1217  }
1218 
1219 
1220 
1221  typedef struct
1222  {
1223  OrthancPluginMemoryBuffer* target;
1224  const char* uri;
1225  const char* body;
1226  uint32_t bodySize;
1227  } _OrthancPluginRestApiPostPut;
1228 
1245  OrthancPluginContext* context,
1246  OrthancPluginMemoryBuffer* target,
1247  const char* uri,
1248  const char* body,
1249  uint32_t bodySize)
1250  {
1251  _OrthancPluginRestApiPostPut params;
1252  params.target = target;
1253  params.uri = uri;
1254  params.body = body;
1255  params.bodySize = bodySize;
1256  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
1257  }
1258 
1259 
1279  OrthancPluginContext* context,
1280  OrthancPluginMemoryBuffer* target,
1281  const char* uri,
1282  const char* body,
1283  uint32_t bodySize)
1284  {
1285  _OrthancPluginRestApiPostPut params;
1286  params.target = target;
1287  params.uri = uri;
1288  params.body = body;
1289  params.bodySize = bodySize;
1290  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
1291  }
1292 
1293 
1294 
1307  OrthancPluginContext* context,
1308  const char* uri)
1309  {
1310  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
1311  }
1312 
1313 
1329  OrthancPluginContext* context,
1330  const char* uri)
1331  {
1332  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
1333  }
1334 
1335 
1336 
1353  OrthancPluginContext* context,
1354  OrthancPluginMemoryBuffer* target,
1355  const char* uri,
1356  const char* body,
1357  uint32_t bodySize)
1358  {
1359  _OrthancPluginRestApiPostPut params;
1360  params.target = target;
1361  params.uri = uri;
1362  params.body = body;
1363  params.bodySize = bodySize;
1364  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
1365  }
1366 
1367 
1368 
1388  OrthancPluginContext* context,
1389  OrthancPluginMemoryBuffer* target,
1390  const char* uri,
1391  const char* body,
1392  uint32_t bodySize)
1393  {
1394  _OrthancPluginRestApiPostPut params;
1395  params.target = target;
1396  params.uri = uri;
1397  params.body = body;
1398  params.bodySize = bodySize;
1399  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
1400  }
1401 
1402 
1403 
1404  typedef struct
1405  {
1406  OrthancPluginRestOutput* output;
1407  const char* argument;
1408  } _OrthancPluginOutputPlusArgument;
1409 
1421  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
1422  OrthancPluginContext* context,
1423  OrthancPluginRestOutput* output,
1424  const char* redirection)
1425  {
1426  _OrthancPluginOutputPlusArgument params;
1427  params.output = output;
1428  params.argument = redirection;
1429  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
1430  }
1431 
1432 
1433 
1434  typedef struct
1435  {
1436  char** result;
1437  const char* argument;
1438  } _OrthancPluginRetrieveDynamicString;
1439 
1453  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
1454  OrthancPluginContext* context,
1455  const char* patientID)
1456  {
1457  char* result;
1458 
1459  _OrthancPluginRetrieveDynamicString params;
1460  params.result = &result;
1461  params.argument = patientID;
1462 
1463  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
1464  {
1465  /* Error */
1466  return NULL;
1467  }
1468  else
1469  {
1470  return result;
1471  }
1472  }
1473 
1474 
1488  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
1489  OrthancPluginContext* context,
1490  const char* studyUID)
1491  {
1492  char* result;
1493 
1494  _OrthancPluginRetrieveDynamicString params;
1495  params.result = &result;
1496  params.argument = studyUID;
1497 
1498  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
1499  {
1500  /* Error */
1501  return NULL;
1502  }
1503  else
1504  {
1505  return result;
1506  }
1507  }
1508 
1509 
1523  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
1524  OrthancPluginContext* context,
1525  const char* accessionNumber)
1526  {
1527  char* result;
1528 
1529  _OrthancPluginRetrieveDynamicString params;
1530  params.result = &result;
1531  params.argument = accessionNumber;
1532 
1533  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
1534  {
1535  /* Error */
1536  return NULL;
1537  }
1538  else
1539  {
1540  return result;
1541  }
1542  }
1543 
1544 
1558  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
1559  OrthancPluginContext* context,
1560  const char* seriesUID)
1561  {
1562  char* result;
1563 
1564  _OrthancPluginRetrieveDynamicString params;
1565  params.result = &result;
1566  params.argument = seriesUID;
1567 
1568  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
1569  {
1570  /* Error */
1571  return NULL;
1572  }
1573  else
1574  {
1575  return result;
1576  }
1577  }
1578 
1579 
1593  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
1594  OrthancPluginContext* context,
1595  const char* sopInstanceUID)
1596  {
1597  char* result;
1598 
1599  _OrthancPluginRetrieveDynamicString params;
1600  params.result = &result;
1601  params.argument = sopInstanceUID;
1602 
1603  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
1604  {
1605  /* Error */
1606  return NULL;
1607  }
1608  else
1609  {
1610  return result;
1611  }
1612  }
1613 
1614 
1615 
1616  typedef struct
1617  {
1618  OrthancPluginRestOutput* output;
1619  uint16_t status;
1620  } _OrthancPluginSendHttpStatusCode;
1621 
1638  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
1639  OrthancPluginContext* context,
1640  OrthancPluginRestOutput* output,
1641  uint16_t status)
1642  {
1643  _OrthancPluginSendHttpStatusCode params;
1644  params.output = output;
1645  params.status = status;
1646  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
1647  }
1648 
1649 
1661  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
1662  OrthancPluginContext* context,
1663  OrthancPluginRestOutput* output,
1664  const char* realm)
1665  {
1666  _OrthancPluginOutputPlusArgument params;
1667  params.output = output;
1668  params.argument = realm;
1669  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
1670  }
1671 
1672 
1684  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
1685  OrthancPluginContext* context,
1686  OrthancPluginRestOutput* output,
1687  const char* allowedMethods)
1688  {
1689  _OrthancPluginOutputPlusArgument params;
1690  params.output = output;
1691  params.argument = allowedMethods;
1692  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
1693  }
1694 
1695 
1696  typedef struct
1697  {
1698  OrthancPluginRestOutput* output;
1699  const char* key;
1700  const char* value;
1701  } _OrthancPluginSetHttpHeader;
1702 
1714  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
1715  OrthancPluginContext* context,
1716  OrthancPluginRestOutput* output,
1717  const char* cookie,
1718  const char* value)
1719  {
1720  _OrthancPluginSetHttpHeader params;
1721  params.output = output;
1722  params.key = cookie;
1723  params.value = value;
1724  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
1725  }
1726 
1727 
1739  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
1740  OrthancPluginContext* context,
1741  OrthancPluginRestOutput* output,
1742  const char* key,
1743  const char* value)
1744  {
1745  _OrthancPluginSetHttpHeader params;
1746  params.output = output;
1747  params.key = key;
1748  params.value = value;
1749  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
1750  }
1751 
1752 
1753  typedef struct
1754  {
1755  char** resultStringToFree;
1756  const char** resultString;
1757  int64_t* resultInt64;
1758  const char* key;
1759  OrthancPluginDicomInstance* instance;
1760  } _OrthancPluginAccessDicomInstance;
1761 
1762 
1774  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
1775  OrthancPluginContext* context,
1776  OrthancPluginDicomInstance* instance)
1777  {
1778  const char* result;
1779 
1780  _OrthancPluginAccessDicomInstance params;
1781  memset(&params, 0, sizeof(params));
1782  params.resultString = &result;
1783  params.instance = instance;
1784 
1785  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
1786  {
1787  /* Error */
1788  return NULL;
1789  }
1790  else
1791  {
1792  return result;
1793  }
1794  }
1795 
1796 
1807  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
1808  OrthancPluginContext* context,
1809  OrthancPluginDicomInstance* instance)
1810  {
1811  int64_t size;
1812 
1813  _OrthancPluginAccessDicomInstance params;
1814  memset(&params, 0, sizeof(params));
1815  params.resultInt64 = &size;
1816  params.instance = instance;
1817 
1818  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
1819  {
1820  /* Error */
1821  return -1;
1822  }
1823  else
1824  {
1825  return size;
1826  }
1827  }
1828 
1829 
1840  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceData(
1841  OrthancPluginContext* context,
1842  OrthancPluginDicomInstance* instance)
1843  {
1844  const char* result;
1845 
1846  _OrthancPluginAccessDicomInstance params;
1847  memset(&params, 0, sizeof(params));
1848  params.resultString = &result;
1849  params.instance = instance;
1850 
1851  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
1852  {
1853  /* Error */
1854  return NULL;
1855  }
1856  else
1857  {
1858  return result;
1859  }
1860  }
1861 
1862 
1876  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
1877  OrthancPluginContext* context,
1878  OrthancPluginDicomInstance* instance)
1879  {
1880  char* result;
1881 
1882  _OrthancPluginAccessDicomInstance params;
1883  memset(&params, 0, sizeof(params));
1884  params.resultStringToFree = &result;
1885  params.instance = instance;
1886 
1887  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
1888  {
1889  /* Error */
1890  return NULL;
1891  }
1892  else
1893  {
1894  return result;
1895  }
1896  }
1897 
1898 
1914  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
1915  OrthancPluginContext* context,
1916  OrthancPluginDicomInstance* instance)
1917  {
1918  char* result;
1919 
1920  _OrthancPluginAccessDicomInstance params;
1921  memset(&params, 0, sizeof(params));
1922  params.resultStringToFree = &result;
1923  params.instance = instance;
1924 
1925  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
1926  {
1927  /* Error */
1928  return NULL;
1929  }
1930  else
1931  {
1932  return result;
1933  }
1934  }
1935 
1936 
1953  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
1954  OrthancPluginContext* context,
1955  OrthancPluginDicomInstance* instance,
1956  const char* metadata)
1957  {
1958  int64_t result;
1959 
1960  _OrthancPluginAccessDicomInstance params;
1961  memset(&params, 0, sizeof(params));
1962  params.resultInt64 = &result;
1963  params.instance = instance;
1964  params.key = metadata;
1965 
1966  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
1967  {
1968  /* Error */
1969  return -1;
1970  }
1971  else
1972  {
1973  return (result != 0);
1974  }
1975  }
1976 
1977 
1991  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
1992  OrthancPluginContext* context,
1993  OrthancPluginDicomInstance* instance,
1994  const char* metadata)
1995  {
1996  const char* result;
1997 
1998  _OrthancPluginAccessDicomInstance params;
1999  memset(&params, 0, sizeof(params));
2000  params.resultString = &result;
2001  params.instance = instance;
2002  params.key = metadata;
2003 
2004  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2005  {
2006  /* Error */
2007  return NULL;
2008  }
2009  else
2010  {
2011  return result;
2012  }
2013  }
2014 
2015 
2016 
2017  typedef struct
2018  {
2022  OrthancPluginFree free;
2023  } _OrthancPluginRegisterStorageArea;
2024 
2039  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
2040  OrthancPluginContext* context,
2044  {
2045  _OrthancPluginRegisterStorageArea params;
2046  params.create = create;
2047  params.read = read;
2048  params.remove = remove;
2049 
2050 #ifdef __cplusplus
2051  params.free = ::free;
2052 #else
2053  params.free = free;
2054 #endif
2055 
2056  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
2057  }
2058 
2059 
2060 
2071  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
2072  {
2073  char* result;
2074 
2075  _OrthancPluginRetrieveDynamicString params;
2076  params.result = &result;
2077  params.argument = NULL;
2078 
2079  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
2080  {
2081  /* Error */
2082  return NULL;
2083  }
2084  else
2085  {
2086  return result;
2087  }
2088  }
2089 
2090 
2101  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
2102  {
2103  char* result;
2104 
2105  _OrthancPluginRetrieveDynamicString params;
2106  params.result = &result;
2107  params.argument = NULL;
2108 
2109  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
2110  {
2111  /* Error */
2112  return NULL;
2113  }
2114  else
2115  {
2116  return result;
2117  }
2118  }
2119 
2120 
2136  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
2137  {
2138  char* result;
2139 
2140  _OrthancPluginRetrieveDynamicString params;
2141  params.result = &result;
2142  params.argument = NULL;
2143 
2144  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
2145  {
2146  /* Error */
2147  return NULL;
2148  }
2149  else
2150  {
2151  return result;
2152  }
2153  }
2154 
2155 
2156 
2157  typedef struct
2158  {
2160  } _OrthancPluginOnChangeCallback;
2161 
2172  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
2173  OrthancPluginContext* context,
2175  {
2176  _OrthancPluginOnChangeCallback params;
2177  params.callback = callback;
2178 
2179  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
2180  }
2181 
2182 
2183 
2184  typedef struct
2185  {
2186  const char* plugin;
2187  _OrthancPluginProperty property;
2188  const char* value;
2189  } _OrthancPluginSetPluginProperty;
2190 
2191 
2203  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
2204  OrthancPluginContext* context,
2205  const char* uri)
2206  {
2207  _OrthancPluginSetPluginProperty params;
2208  params.plugin = OrthancPluginGetName();
2209  params.property = _OrthancPluginProperty_RootUri;
2210  params.value = uri;
2211 
2212  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2213  }
2214 
2215 
2225  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
2226  OrthancPluginContext* context,
2227  const char* description)
2228  {
2229  _OrthancPluginSetPluginProperty params;
2230  params.plugin = OrthancPluginGetName();
2231  params.property = _OrthancPluginProperty_Description;
2232  params.value = description;
2233 
2234  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2235  }
2236 
2237 
2247  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
2248  OrthancPluginContext* context,
2249  const char* javascript)
2250  {
2251  _OrthancPluginSetPluginProperty params;
2252  params.plugin = OrthancPluginGetName();
2253  params.property = _OrthancPluginProperty_OrthancExplorer;
2254  params.value = javascript;
2255 
2256  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2257  }
2258 
2259 
2260  typedef struct
2261  {
2262  char** result;
2263  int32_t property;
2264  const char* value;
2265  } _OrthancPluginGlobalProperty;
2266 
2267 
2281  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
2282  OrthancPluginContext* context,
2283  int32_t property,
2284  const char* defaultValue)
2285  {
2286  char* result;
2287 
2288  _OrthancPluginGlobalProperty params;
2289  params.result = &result;
2290  params.property = property;
2291  params.value = defaultValue;
2292 
2293  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
2294  {
2295  /* Error */
2296  return NULL;
2297  }
2298  else
2299  {
2300  return result;
2301  }
2302  }
2303 
2304 
2321  OrthancPluginContext* context,
2322  int32_t property,
2323  const char* value)
2324  {
2325  _OrthancPluginGlobalProperty params;
2326  params.result = NULL;
2327  params.property = property;
2328  params.value = value;
2329 
2330  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
2331  }
2332 
2333 
2334 
2335  typedef struct
2336  {
2337  int32_t *resultInt32;
2338  uint32_t *resultUint32;
2339  int64_t *resultInt64;
2340  uint64_t *resultUint64;
2341  } _OrthancPluginReturnSingleValue;
2342 
2351  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
2352  OrthancPluginContext* context)
2353  {
2354  uint32_t count = 0;
2355 
2356  _OrthancPluginReturnSingleValue params;
2357  memset(&params, 0, sizeof(params));
2358  params.resultUint32 = &count;
2359 
2360  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
2361  {
2362  /* Error */
2363  return 0;
2364  }
2365  else
2366  {
2367  return count;
2368  }
2369  }
2370 
2371 
2372 
2385  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
2386  OrthancPluginContext* context,
2387  uint32_t argument)
2388  {
2389  char* result;
2390 
2391  _OrthancPluginGlobalProperty params;
2392  params.result = &result;
2393  params.property = (int32_t) argument;
2394  params.value = NULL;
2395 
2396  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
2397  {
2398  /* Error */
2399  return NULL;
2400  }
2401  else
2402  {
2403  return result;
2404  }
2405  }
2406 
2407 
2418  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
2419  OrthancPluginContext* context)
2420  {
2421  uint32_t count = 0;
2422 
2423  _OrthancPluginReturnSingleValue params;
2424  memset(&params, 0, sizeof(params));
2425  params.resultUint32 = &count;
2426 
2427  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
2428  {
2429  /* Error */
2430  return 0;
2431  }
2432  else
2433  {
2434  return count;
2435  }
2436  }
2437 
2438 
2439 
2451  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
2452  {
2453  char* result;
2454 
2455  _OrthancPluginRetrieveDynamicString params;
2456  params.result = &result;
2457  params.argument = NULL;
2458 
2459  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
2460  {
2461  /* Error */
2462  return NULL;
2463  }
2464  else
2465  {
2466  return result;
2467  }
2468  }
2469 
2470 
2471 
2472  typedef struct
2473  {
2474  OrthancPluginRestOutput* output;
2475  const char* subType;
2476  const char* contentType;
2477  } _OrthancPluginStartMultipartAnswer;
2478 
2493  OrthancPluginContext* context,
2494  OrthancPluginRestOutput* output,
2495  const char* subType,
2496  const char* contentType)
2497  {
2498  _OrthancPluginStartMultipartAnswer params;
2499  params.output = output;
2500  params.subType = subType;
2501  params.contentType = contentType;
2502  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
2503  }
2504 
2505 
2521  OrthancPluginContext* context,
2522  OrthancPluginRestOutput* output,
2523  const char* answer,
2524  uint32_t answerSize)
2525  {
2526  _OrthancPluginAnswerBuffer params;
2527  params.output = output;
2528  params.answer = answer;
2529  params.answerSize = answerSize;
2530  params.mimeType = NULL;
2531  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
2532  }
2533 
2534 
2535 
2536  typedef struct
2537  {
2538  OrthancPluginMemoryBuffer* target;
2539  const void* source;
2540  uint32_t size;
2541  OrthancPluginCompressionType compression;
2542  uint8_t uncompress;
2543  } _OrthancPluginBufferCompression;
2544 
2545 
2563  OrthancPluginContext* context,
2564  OrthancPluginMemoryBuffer* target,
2565  const void* source,
2566  uint32_t size,
2567  OrthancPluginCompressionType compression,
2568  uint8_t uncompress)
2569  {
2570  _OrthancPluginBufferCompression params;
2571  params.target = target;
2572  params.source = source;
2573  params.size = size;
2574  params.compression = compression;
2575  params.uncompress = uncompress;
2576 
2577  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
2578  }
2579 
2580 
2581 
2582  typedef struct
2583  {
2584  OrthancPluginMemoryBuffer* target;
2585  const char* path;
2586  } _OrthancPluginReadFile;
2587 
2600  OrthancPluginContext* context,
2601  OrthancPluginMemoryBuffer* target,
2602  const char* path)
2603  {
2604  _OrthancPluginReadFile params;
2605  params.target = target;
2606  params.path = path;
2607  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
2608  }
2609 
2610 
2611 
2612  typedef struct
2613  {
2614  const char* path;
2615  const void* data;
2616  uint32_t size;
2617  } _OrthancPluginWriteFile;
2618 
2631  OrthancPluginContext* context,
2632  const char* path,
2633  const void* data,
2634  uint32_t size)
2635  {
2636  _OrthancPluginWriteFile params;
2637  params.path = path;
2638  params.data = data;
2639  params.size = size;
2640  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
2641  }
2642 
2643 
2644 
2645  typedef struct
2646  {
2647  const char** target;
2648  OrthancPluginErrorCode error;
2649  } _OrthancPluginGetErrorDescription;
2650 
2661  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
2662  OrthancPluginContext* context,
2663  OrthancPluginErrorCode error)
2664  {
2665  const char* result = NULL;
2666 
2667  _OrthancPluginGetErrorDescription params;
2668  params.target = &result;
2669  params.error = error;
2670 
2671  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
2672  result == NULL)
2673  {
2674  return "Unknown error code";
2675  }
2676  else
2677  {
2678  return result;
2679  }
2680  }
2681 
2682 
2683 
2684  typedef struct
2685  {
2686  OrthancPluginRestOutput* output;
2687  uint16_t status;
2688  const char* body;
2689  uint32_t bodySize;
2690  } _OrthancPluginSendHttpStatus;
2691 
2714  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
2715  OrthancPluginContext* context,
2716  OrthancPluginRestOutput* output,
2717  uint16_t status,
2718  const char* body,
2719  uint32_t bodySize)
2720  {
2721  _OrthancPluginSendHttpStatus params;
2722  params.output = output;
2723  params.status = status;
2724  params.body = body;
2725  params.bodySize = bodySize;
2726  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
2727  }
2728 
2729 
2730 
2731  typedef struct
2732  {
2733  const OrthancPluginImage* image;
2734  uint32_t* resultUint32;
2735  OrthancPluginPixelFormat* resultPixelFormat;
2736  const void** resultBuffer;
2737  } _OrthancPluginGetImageInfo;
2738 
2739 
2751  OrthancPluginContext* context,
2752  const OrthancPluginImage* image)
2753  {
2754  OrthancPluginPixelFormat target;
2755 
2756  _OrthancPluginGetImageInfo params;
2757  memset(&params, 0, sizeof(params));
2758  params.image = image;
2759  params.resultPixelFormat = &target;
2760 
2761  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
2762  {
2764  }
2765  else
2766  {
2767  return (OrthancPluginPixelFormat) target;
2768  }
2769  }
2770 
2771 
2772 
2783  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
2784  OrthancPluginContext* context,
2785  const OrthancPluginImage* image)
2786  {
2787  uint32_t width;
2788 
2789  _OrthancPluginGetImageInfo params;
2790  memset(&params, 0, sizeof(params));
2791  params.image = image;
2792  params.resultUint32 = &width;
2793 
2794  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
2795  {
2796  return 0;
2797  }
2798  else
2799  {
2800  return width;
2801  }
2802  }
2803 
2804 
2805 
2816  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
2817  OrthancPluginContext* context,
2818  const OrthancPluginImage* image)
2819  {
2820  uint32_t height;
2821 
2822  _OrthancPluginGetImageInfo params;
2823  memset(&params, 0, sizeof(params));
2824  params.image = image;
2825  params.resultUint32 = &height;
2826 
2827  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
2828  {
2829  return 0;
2830  }
2831  else
2832  {
2833  return height;
2834  }
2835  }
2836 
2837 
2838 
2851  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
2852  OrthancPluginContext* context,
2853  const OrthancPluginImage* image)
2854  {
2855  uint32_t pitch;
2856 
2857  _OrthancPluginGetImageInfo params;
2858  memset(&params, 0, sizeof(params));
2859  params.image = image;
2860  params.resultUint32 = &pitch;
2861 
2862  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
2863  {
2864  return 0;
2865  }
2866  else
2867  {
2868  return pitch;
2869  }
2870  }
2871 
2872 
2873 
2885  ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetImageBuffer(
2886  OrthancPluginContext* context,
2887  const OrthancPluginImage* image)
2888  {
2889  const void* target = NULL;
2890 
2891  _OrthancPluginGetImageInfo params;
2892  memset(&params, 0, sizeof(params));
2893  params.resultBuffer = &target;
2894  params.image = image;
2895 
2896  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
2897  {
2898  return NULL;
2899  }
2900  else
2901  {
2902  return target;
2903  }
2904  }
2905 
2906 
2907  typedef struct
2908  {
2909  OrthancPluginImage** target;
2910  const void* data;
2911  uint32_t size;
2912  OrthancPluginImageFormat format;
2913  } _OrthancPluginUncompressImage;
2914 
2915 
2929  OrthancPluginContext* context,
2930  const void* data,
2931  uint32_t size,
2932  OrthancPluginImageFormat format)
2933  {
2934  OrthancPluginImage* target = NULL;
2935 
2936  _OrthancPluginUncompressImage params;
2937  memset(&params, 0, sizeof(params));
2938  params.target = &target;
2939  params.data = data;
2940  params.size = size;
2941  params.format = format;
2942 
2943  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
2944  {
2945  return NULL;
2946  }
2947  else
2948  {
2949  return target;
2950  }
2951  }
2952 
2953 
2954 
2955 
2956  typedef struct
2957  {
2958  OrthancPluginImage* image;
2959  } _OrthancPluginFreeImage;
2960 
2970  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
2971  OrthancPluginContext* context,
2972  OrthancPluginImage* image)
2973  {
2974  _OrthancPluginFreeImage params;
2975  params.image = image;
2976 
2977  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
2978  }
2979 
2980 
2981 
2982 
2983  typedef struct
2984  {
2985  OrthancPluginMemoryBuffer* target;
2986  OrthancPluginImageFormat imageFormat;
2987  OrthancPluginPixelFormat pixelFormat;
2988  uint32_t width;
2989  uint32_t height;
2990  uint32_t pitch;
2991  const void* buffer;
2992  uint8_t quality;
2993  } _OrthancPluginCompressImage;
2994 
2995 
3016  OrthancPluginContext* context,
3017  OrthancPluginMemoryBuffer* target,
3018  OrthancPluginPixelFormat format,
3019  uint32_t width,
3020  uint32_t height,
3021  uint32_t pitch,
3022  const void* buffer)
3023  {
3024  _OrthancPluginCompressImage params;
3025  memset(&params, 0, sizeof(params));
3026  params.target = target;
3027  params.imageFormat = OrthancPluginImageFormat_Png;
3028  params.pixelFormat = format;
3029  params.width = width;
3030  params.height = height;
3031  params.pitch = pitch;
3032  params.buffer = buffer;
3033  params.quality = 0; /* Unused for PNG */
3034 
3035  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3036  }
3037 
3038 
3061  OrthancPluginContext* context,
3062  OrthancPluginMemoryBuffer* target,
3063  OrthancPluginPixelFormat format,
3064  uint32_t width,
3065  uint32_t height,
3066  uint32_t pitch,
3067  const void* buffer,
3068  uint8_t quality)
3069  {
3070  _OrthancPluginCompressImage params;
3071  memset(&params, 0, sizeof(params));
3072  params.target = target;
3073  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3074  params.pixelFormat = format;
3075  params.width = width;
3076  params.height = height;
3077  params.pitch = pitch;
3078  params.buffer = buffer;
3079  params.quality = quality;
3080 
3081  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3082  }
3083 
3084 
3085 
3107  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
3108  OrthancPluginContext* context,
3109  OrthancPluginRestOutput* output,
3110  OrthancPluginPixelFormat format,
3111  uint32_t width,
3112  uint32_t height,
3113  uint32_t pitch,
3114  const void* buffer,
3115  uint8_t quality)
3116  {
3117  _OrthancPluginCompressAndAnswerImage params;
3118  params.output = output;
3119  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3120  params.pixelFormat = format;
3121  params.width = width;
3122  params.height = height;
3123  params.pitch = pitch;
3124  params.buffer = buffer;
3125  params.quality = quality;
3126  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
3127  }
3128 
3129 
3130 
3131 
3132  typedef struct
3133  {
3134  OrthancPluginMemoryBuffer* target;
3135  OrthancPluginHttpMethod method;
3136  const char* url;
3137  const char* username;
3138  const char* password;
3139  const char* body;
3140  uint32_t bodySize;
3141  } _OrthancPluginCallHttpClient;
3142 
3143 
3160  OrthancPluginContext* context,
3161  OrthancPluginMemoryBuffer* target,
3162  const char* url,
3163  const char* username,
3164  const char* password)
3165  {
3166  _OrthancPluginCallHttpClient params;
3167  memset(&params, 0, sizeof(params));
3168 
3169  params.target = target;
3170  params.method = OrthancPluginHttpMethod_Get;
3171  params.url = url;
3172  params.username = username;
3173  params.password = password;
3174 
3175  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3176  }
3177 
3178 
3197  OrthancPluginContext* context,
3198  OrthancPluginMemoryBuffer* target,
3199  const char* url,
3200  const char* body,
3201  uint32_t bodySize,
3202  const char* username,
3203  const char* password)
3204  {
3205  _OrthancPluginCallHttpClient params;
3206  memset(&params, 0, sizeof(params));
3207 
3208  params.target = target;
3209  params.method = OrthancPluginHttpMethod_Post;
3210  params.url = url;
3211  params.body = body;
3212  params.bodySize = bodySize;
3213  params.username = username;
3214  params.password = password;
3215 
3216  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3217  }
3218 
3219 
3238  OrthancPluginContext* context,
3239  OrthancPluginMemoryBuffer* target,
3240  const char* url,
3241  const char* body,
3242  uint32_t bodySize,
3243  const char* username,
3244  const char* password)
3245  {
3246  _OrthancPluginCallHttpClient params;
3247  memset(&params, 0, sizeof(params));
3248 
3249  params.target = target;
3250  params.method = OrthancPluginHttpMethod_Put;
3251  params.url = url;
3252  params.body = body;
3253  params.bodySize = bodySize;
3254  params.username = username;
3255  params.password = password;
3256 
3257  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3258  }
3259 
3260 
3275  OrthancPluginContext* context,
3276  const char* url,
3277  const char* username,
3278  const char* password)
3279  {
3280  _OrthancPluginCallHttpClient params;
3281  memset(&params, 0, sizeof(params));
3282 
3283  params.method = OrthancPluginHttpMethod_Delete;
3284  params.url = url;
3285  params.username = username;
3286  params.password = password;
3287 
3288  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3289  }
3290 
3291 
3292 
3293  typedef struct
3294  {
3295  OrthancPluginImage** target;
3296  const OrthancPluginImage* source;
3297  OrthancPluginPixelFormat targetFormat;
3298  } _OrthancPluginConvertPixelFormat;
3299 
3300 
3313  OrthancPluginContext* context,
3314  const OrthancPluginImage* source,
3315  OrthancPluginPixelFormat targetFormat)
3316  {
3317  OrthancPluginImage* target = NULL;
3318 
3319  _OrthancPluginConvertPixelFormat params;
3320  params.target = &target;
3321  params.source = source;
3322  params.targetFormat = targetFormat;
3323 
3324  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
3325  {
3326  return NULL;
3327  }
3328  else
3329  {
3330  return target;
3331  }
3332  }
3333 
3334 
3335 
3347  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
3348  OrthancPluginContext* context)
3349  {
3350  uint32_t count = 0;
3351 
3352  _OrthancPluginReturnSingleValue params;
3353  memset(&params, 0, sizeof(params));
3354  params.resultUint32 = &count;
3355 
3356  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
3357  {
3358  /* Error */
3359  return 0;
3360  }
3361  else
3362  {
3363  return count;
3364  }
3365  }
3366 
3367 
3368 
3369 
3370  typedef struct
3371  {
3372  uint32_t fontIndex; /* in */
3373  const char** name; /* out */
3374  uint32_t* size; /* out */
3375  } _OrthancPluginGetFontInfo;
3376 
3387  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
3388  OrthancPluginContext* context,
3389  uint32_t fontIndex)
3390  {
3391  const char* result = NULL;
3392 
3393  _OrthancPluginGetFontInfo params;
3394  memset(&params, 0, sizeof(params));
3395  params.name = &result;
3396  params.fontIndex = fontIndex;
3397 
3398  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
3399  {
3400  return NULL;
3401  }
3402  else
3403  {
3404  return result;
3405  }
3406  }
3407 
3408 
3419  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
3420  OrthancPluginContext* context,
3421  uint32_t fontIndex)
3422  {
3423  uint32_t result;
3424 
3425  _OrthancPluginGetFontInfo params;
3426  memset(&params, 0, sizeof(params));
3427  params.size = &result;
3428  params.fontIndex = fontIndex;
3429 
3430  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
3431  {
3432  return 0;
3433  }
3434  else
3435  {
3436  return result;
3437  }
3438  }
3439 
3440 
3441 
3442  typedef struct
3443  {
3444  OrthancPluginImage* image;
3445  uint32_t fontIndex;
3446  const char* utf8Text;
3447  int32_t x;
3448  int32_t y;
3449  uint8_t r;
3450  uint8_t g;
3451  uint8_t b;
3452  } _OrthancPluginDrawText;
3453 
3454 
3473  OrthancPluginContext* context,
3474  OrthancPluginImage* image,
3475  uint32_t fontIndex,
3476  const char* utf8Text,
3477  int32_t x,
3478  int32_t y,
3479  uint8_t r,
3480  uint8_t g,
3481  uint8_t b)
3482  {
3483  _OrthancPluginDrawText params;
3484  memset(&params, 0, sizeof(params));
3485  params.image = image;
3486  params.fontIndex = fontIndex;
3487  params.utf8Text = utf8Text;
3488  params.x = x;
3489  params.y = y;
3490  params.r = r;
3491  params.g = g;
3492  params.b = b;
3493 
3494  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
3495  }
3496 
3497 
3498 
3499  typedef struct
3500  {
3501  OrthancPluginStorageArea* storageArea;
3502  const char* uuid;
3503  const void* content;
3504  uint64_t size;
3506  } _OrthancPluginStorageAreaCreate;
3507 
3508 
3525  OrthancPluginContext* context,
3526  OrthancPluginStorageArea* storageArea,
3527  const char* uuid,
3528  const void* content,
3529  uint64_t size,
3531  {
3532  _OrthancPluginStorageAreaCreate params;
3533  params.storageArea = storageArea;
3534  params.uuid = uuid;
3535  params.content = content;
3536  params.size = size;
3537  params.type = type;
3538 
3539  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
3540  }
3541 
3542 
3543  typedef struct
3544  {
3545  OrthancPluginMemoryBuffer* target;
3546  OrthancPluginStorageArea* storageArea;
3547  const char* uuid;
3549  } _OrthancPluginStorageAreaRead;
3550 
3551 
3567  OrthancPluginContext* context,
3568  OrthancPluginMemoryBuffer* target,
3569  OrthancPluginStorageArea* storageArea,
3570  const char* uuid,
3572  {
3573  _OrthancPluginStorageAreaRead params;
3574  params.target = target;
3575  params.storageArea = storageArea;
3576  params.uuid = uuid;
3577  params.type = type;
3578 
3579  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
3580  }
3581 
3582 
3583  typedef struct
3584  {
3585  OrthancPluginStorageArea* storageArea;
3586  const char* uuid;
3588  } _OrthancPluginStorageAreaRemove;
3589 
3590 
3605  OrthancPluginContext* context,
3606  OrthancPluginStorageArea* storageArea,
3607  const char* uuid,
3609  {
3610  _OrthancPluginStorageAreaRemove params;
3611  params.storageArea = storageArea;
3612  params.uuid = uuid;
3613  params.type = type;
3614 
3615  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
3616  }
3617 
3618 
3619 
3620 #ifdef __cplusplus
3621 }
3622 #endif
3623 
3624 
Definition: OrthancCPlugin.h:590
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:1774
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:1953
OrthancPluginChangeType
Definition: OrthancCPlugin.h:551
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:1638
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:624
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:1739
Definition: OrthancCPlugin.h:243
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:924
The parameters of a REST request.
Definition: OrthancCPlugin.h:295
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:1421
OrthancPluginContentType
Definition: OrthancCPlugin.h:521
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:1328
Definition: OrthancCPlugin.h:538
const char * OrthancPluginGetInstanceData(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:1840
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:3015
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:3107
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:793
Definition: OrthancCPlugin.h:235
Definition: OrthancCPlugin.h:185
Definition: OrthancCPlugin.h:233
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:1807
Definition: OrthancCPlugin.h:258
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:485
Definition: OrthancCPlugin.h:207
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:355
Definition: OrthancCPlugin.h:245
Definition: OrthancCPlugin.h:247
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:350
Definition: OrthancCPlugin.h:231
Definition: OrthancCPlugin.h:249
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:469
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:315
Definition: OrthancCPlugin.h:511
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:2039
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:1147
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:666
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:587
Definition: OrthancCPlugin.h:193
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:769
Definition: OrthancCPlugin.h:255
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:3387
Definition: OrthancCPlugin.h:261
Definition: OrthancCPlugin.h:253
Definition: OrthancCPlugin.h:283
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:686
Definition: OrthancCPlugin.h:204
Definition: OrthancCPlugin.h:206
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:179
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:3312
Definition: OrthancCPlugin.h:256
Definition: OrthancCPlugin.h:560
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:3566
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:3347
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:2136
Definition: OrthancCPlugin.h:202
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:2172
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:509
Definition: OrthancCPlugin.h:195
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:1684
Definition: OrthancCPlugin.h:574
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:1049
Definition: OrthancCPlugin.h:554
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
Definition: OrthancCPlugin.h:232
Definition: OrthancCPlugin.h:213
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:655
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:1991
Definition: OrthancCPlugin.h:589
Definition: OrthancCPlugin.h:225
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:647
Definition: OrthancCPlugin.h:217
Definition: OrthancCPlugin.h:523
Definition: OrthancCPlugin.h:558
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:1387
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:2418
Definition: OrthancCPlugin.h:248
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:477
Definition: OrthancCPlugin.h:246
Definition: OrthancCPlugin.h:196
OrthancPluginResourceType
Definition: OrthancCPlugin.h:535
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:280
Definition: OrthancCPlugin.h:212
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:2816
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:2451
Definition: OrthancCPlugin.h:183
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:2714
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:2928
Definition: OrthancCPlugin.h:251
Definition: OrthancCPlugin.h:199
Definition: OrthancCPlugin.h:540
Definition: OrthancCPlugin.h:242
Definition: OrthancCPlugin.h:575
Definition: OrthancCPlugin.h:259
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:2101
Definition: OrthancCPlugin.h:577
Definition: OrthancCPlugin.h:234
Color image in RGB24 format.
Definition: OrthancCPlugin.h:501
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:493
Definition: OrthancCPlugin.h:244
Definition: OrthancCPlugin.h:189
Definition: OrthancCPlugin.h:553
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:572
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:3237
Definition: OrthancCPlugin.h:181
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:2750
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:3472
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:2851
Definition: OrthancCPlugin.h:524
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:1106
Definition: OrthancCPlugin.h:264
Definition: OrthancCPlugin.h:263
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:2351
Definition: OrthancCPlugin.h:215
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:1661
Definition: OrthancCPlugin.h:191
Definition: OrthancCPlugin.h:240
Definition: OrthancCPlugin.h:228
Definition: OrthancCPlugin.h:260
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:892
Definition: OrthancCPlugin.h:210
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:609
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:3419
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:2247
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1179
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:2661
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:345
Definition: OrthancCPlugin.h:559
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:876
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1306
Definition: OrthancCPlugin.h:539
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:2599
int32_t(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:702
Definition: OrthancCPlugin.h:284
Definition: OrthancCPlugin.h:220
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:2071
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:2281
Definition: OrthancCPlugin.h:229
Definition: OrthancCPlugin.h:282
int32_t(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:722
Definition: OrthancCPlugin.h:561
int32_t(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:740
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:2385
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:3159
Definition: OrthancCPlugin.h:237
Definition: OrthancCPlugin.h:203
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:325
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:1914
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:2562
Definition: OrthancCPlugin.h:230
Definition: OrthancCPlugin.h:223
Definition: OrthancCPlugin.h:190
const char * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:330
Definition: OrthancCPlugin.h:236
Definition: OrthancCPlugin.h:197
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:989
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:639
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:1352
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:2492
Definition: OrthancCPlugin.h:182
Definition: OrthancCPlugin.h:208
Definition: OrthancCPlugin.h:201
Definition: OrthancCPlugin.h:239
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:2203
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:3604
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:320
Definition: OrthancCPlugin.h:556
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:1453
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:2970
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:1593
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:2320
Definition: OrthancCPlugin.h:525
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:2520
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:310
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:2630
Definition: OrthancCPlugin.h:238
Definition: OrthancCPlugin.h:241
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:1488
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:614
Definition: OrthancCPlugin.h:221
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance received by Orthanc.
Definition: OrthancCPlugin.h:631
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:305
Definition: OrthancCPlugin.h:222
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:908
Definition: OrthancCPlugin.h:227
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:335
Definition: OrthancCPlugin.h:285
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:676
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:1714
Definition: OrthancCPlugin.h:555
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:1876
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:2225
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:1244
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:1017
Definition: OrthancCPlugin.h:557
Definition: OrthancCPlugin.h:224
Definition: OrthancCPlugin.h:194
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:3196
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:955
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:1523
Definition: OrthancCPlugin.h:186
Definition: OrthancCPlugin.h:537
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:1208
Definition: OrthancCPlugin.h:205
Definition: OrthancCPlugin.h:262
Definition: OrthancCPlugin.h:187
Definition: OrthancCPlugin.h:192
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:1278
Definition: OrthancCPlugin.h:184
Definition: OrthancCPlugin.h:209
Definition: OrthancCPlugin.h:562
Definition: OrthancCPlugin.h:576
Definition: OrthancCPlugin.h:214
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:300
Definition: OrthancCPlugin.h:257
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:3524
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:3274
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:604
Definition: OrthancCPlugin.h:198
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:1558
Definition: OrthancCPlugin.h:188
Definition: OrthancCPlugin.h:250
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:2783
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:3060
const void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:2885
Definition: OrthancCPlugin.h:211