Orthanc Plugin SDK  1.3.2
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1 
107 #pragma once
108 
109 
110 #include <stdio.h>
111 #include <string.h>
112 
113 #ifdef WIN32
114 #define ORTHANC_PLUGINS_API __declspec(dllexport)
115 #else
116 #define ORTHANC_PLUGINS_API
117 #endif
118 
119 #define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
120 #define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 3
121 #define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 2
122 
123 
124 #if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
125 #define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
126  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
127  (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
128  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
129  (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
130  ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
131 #endif
132 
133 
134 
135 /********************************************************************
136  ** Check that function inlining is properly supported. The use of
137  ** inlining is required, to avoid the duplication of object code
138  ** between two compilation modules that would use the Orthanc Plugin
139  ** API.
140  ********************************************************************/
141 
142 /* If the auto-detection of the "inline" keyword below does not work
143  automatically and that your compiler is known to properly support
144  inlining, uncomment the following #define and adapt the definition
145  of "static inline". */
146 
147 /* #define ORTHANC_PLUGIN_INLINE static inline */
148 
149 #ifndef ORTHANC_PLUGIN_INLINE
150 # if __STDC_VERSION__ >= 199901L
151 /* This is C99 or above: http://predef.sourceforge.net/prestd.html */
152 # define ORTHANC_PLUGIN_INLINE static inline
153 # elif defined(__cplusplus)
154 /* This is C++ */
155 # define ORTHANC_PLUGIN_INLINE static inline
156 # elif defined(__GNUC__)
157 /* This is GCC running in C89 mode */
158 # define ORTHANC_PLUGIN_INLINE static __inline
159 # elif defined(_MSC_VER)
160 /* This is Visual Studio running in C89 mode */
161 # define ORTHANC_PLUGIN_INLINE static __inline
162 # else
163 # error Your compiler is not known to support the "inline" keyword
164 # endif
165 #endif
166 
167 
168 
169 /********************************************************************
170  ** Inclusion of standard libraries.
171  ********************************************************************/
172 
178 #include <stdint.h>
179 
180 #include <stdlib.h>
181 
182 
183 
184 /********************************************************************
185  ** Definition of the Orthanc Plugin API.
186  ********************************************************************/
187 
190 #ifdef __cplusplus
191 extern "C"
192 {
193 #endif
194 
198  typedef enum
199  {
297 
298  _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
300 
301 
306  ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
307 
308 
312  typedef enum
313  {
319  _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
321 
322 
327  typedef struct
328  {
333 
337  uint32_t groupsCount;
338 
342  const char* const* groups;
343 
347  uint32_t getCount;
348 
352  const char* const* getKeys;
353 
357  const char* const* getValues;
358 
362  const char* body;
363 
367  uint32_t bodySize;
368 
369 
370  /* --------------------------------------------------
371  New in version 0.8.1
372  -------------------------------------------------- */
373 
377  uint32_t headersCount;
378 
382  const char* const* headersKeys;
383 
387  const char* const* headersValues;
388 
390 
391 
392  typedef enum
393  {
394  /* Generic services */
395  _OrthancPluginService_LogInfo = 1,
396  _OrthancPluginService_LogWarning = 2,
397  _OrthancPluginService_LogError = 3,
398  _OrthancPluginService_GetOrthancPath = 4,
399  _OrthancPluginService_GetOrthancDirectory = 5,
400  _OrthancPluginService_GetConfigurationPath = 6,
401  _OrthancPluginService_SetPluginProperty = 7,
402  _OrthancPluginService_GetGlobalProperty = 8,
403  _OrthancPluginService_SetGlobalProperty = 9,
404  _OrthancPluginService_GetCommandLineArgumentsCount = 10,
405  _OrthancPluginService_GetCommandLineArgument = 11,
406  _OrthancPluginService_GetExpectedDatabaseVersion = 12,
407  _OrthancPluginService_GetConfiguration = 13,
408  _OrthancPluginService_BufferCompression = 14,
409  _OrthancPluginService_ReadFile = 15,
410  _OrthancPluginService_WriteFile = 16,
411  _OrthancPluginService_GetErrorDescription = 17,
412  _OrthancPluginService_CallHttpClient = 18,
413  _OrthancPluginService_RegisterErrorCode = 19,
414  _OrthancPluginService_RegisterDictionaryTag = 20,
415  _OrthancPluginService_DicomBufferToJson = 21,
416  _OrthancPluginService_DicomInstanceToJson = 22,
417  _OrthancPluginService_CreateDicom = 23,
418  _OrthancPluginService_ComputeMd5 = 24,
419  _OrthancPluginService_ComputeSha1 = 25,
420  _OrthancPluginService_LookupDictionary = 26,
421  _OrthancPluginService_CallHttpClient2 = 27,
422  _OrthancPluginService_GenerateUuid = 28,
423  _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
424 
425  /* Registration of callbacks */
426  _OrthancPluginService_RegisterRestCallback = 1000,
427  _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
428  _OrthancPluginService_RegisterStorageArea = 1002,
429  _OrthancPluginService_RegisterOnChangeCallback = 1003,
430  _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
431  _OrthancPluginService_RegisterWorklistCallback = 1005,
432  _OrthancPluginService_RegisterDecodeImageCallback = 1006,
433  _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
434  _OrthancPluginService_RegisterFindCallback = 1008,
435  _OrthancPluginService_RegisterMoveCallback = 1009,
436  _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
437 
438  /* Sending answers to REST calls */
439  _OrthancPluginService_AnswerBuffer = 2000,
440  _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
441  _OrthancPluginService_Redirect = 2002,
442  _OrthancPluginService_SendHttpStatusCode = 2003,
443  _OrthancPluginService_SendUnauthorized = 2004,
444  _OrthancPluginService_SendMethodNotAllowed = 2005,
445  _OrthancPluginService_SetCookie = 2006,
446  _OrthancPluginService_SetHttpHeader = 2007,
447  _OrthancPluginService_StartMultipartAnswer = 2008,
448  _OrthancPluginService_SendMultipartItem = 2009,
449  _OrthancPluginService_SendHttpStatus = 2010,
450  _OrthancPluginService_CompressAndAnswerImage = 2011,
451  _OrthancPluginService_SendMultipartItem2 = 2012,
452 
453  /* Access to the Orthanc database and API */
454  _OrthancPluginService_GetDicomForInstance = 3000,
455  _OrthancPluginService_RestApiGet = 3001,
456  _OrthancPluginService_RestApiPost = 3002,
457  _OrthancPluginService_RestApiDelete = 3003,
458  _OrthancPluginService_RestApiPut = 3004,
459  _OrthancPluginService_LookupPatient = 3005,
460  _OrthancPluginService_LookupStudy = 3006,
461  _OrthancPluginService_LookupSeries = 3007,
462  _OrthancPluginService_LookupInstance = 3008,
463  _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
464  _OrthancPluginService_RestApiGetAfterPlugins = 3010,
465  _OrthancPluginService_RestApiPostAfterPlugins = 3011,
466  _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
467  _OrthancPluginService_RestApiPutAfterPlugins = 3013,
468  _OrthancPluginService_ReconstructMainDicomTags = 3014,
469  _OrthancPluginService_RestApiGet2 = 3015,
470 
471  /* Access to DICOM instances */
472  _OrthancPluginService_GetInstanceRemoteAet = 4000,
473  _OrthancPluginService_GetInstanceSize = 4001,
474  _OrthancPluginService_GetInstanceData = 4002,
475  _OrthancPluginService_GetInstanceJson = 4003,
476  _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
477  _OrthancPluginService_HasInstanceMetadata = 4005,
478  _OrthancPluginService_GetInstanceMetadata = 4006,
479  _OrthancPluginService_GetInstanceOrigin = 4007,
480 
481  /* Services for plugins implementing a database back-end */
482  _OrthancPluginService_RegisterDatabaseBackend = 5000,
483  _OrthancPluginService_DatabaseAnswer = 5001,
484  _OrthancPluginService_RegisterDatabaseBackendV2 = 5002,
485  _OrthancPluginService_StorageAreaCreate = 5003,
486  _OrthancPluginService_StorageAreaRead = 5004,
487  _OrthancPluginService_StorageAreaRemove = 5005,
488 
489  /* Primitives for handling images */
490  _OrthancPluginService_GetImagePixelFormat = 6000,
491  _OrthancPluginService_GetImageWidth = 6001,
492  _OrthancPluginService_GetImageHeight = 6002,
493  _OrthancPluginService_GetImagePitch = 6003,
494  _OrthancPluginService_GetImageBuffer = 6004,
495  _OrthancPluginService_UncompressImage = 6005,
496  _OrthancPluginService_FreeImage = 6006,
497  _OrthancPluginService_CompressImage = 6007,
498  _OrthancPluginService_ConvertPixelFormat = 6008,
499  _OrthancPluginService_GetFontsCount = 6009,
500  _OrthancPluginService_GetFontInfo = 6010,
501  _OrthancPluginService_DrawText = 6011,
502  _OrthancPluginService_CreateImage = 6012,
503  _OrthancPluginService_CreateImageAccessor = 6013,
504  _OrthancPluginService_DecodeDicomImage = 6014,
505 
506  /* Primitives for handling C-Find, C-Move and worklists */
507  _OrthancPluginService_WorklistAddAnswer = 7000,
508  _OrthancPluginService_WorklistMarkIncomplete = 7001,
509  _OrthancPluginService_WorklistIsMatch = 7002,
510  _OrthancPluginService_WorklistGetDicomQuery = 7003,
511  _OrthancPluginService_FindAddAnswer = 7004,
512  _OrthancPluginService_FindMarkIncomplete = 7005,
513  _OrthancPluginService_GetFindQuerySize = 7006,
514  _OrthancPluginService_GetFindQueryTag = 7007,
515  _OrthancPluginService_GetFindQueryTagName = 7008,
516  _OrthancPluginService_GetFindQueryValue = 7009,
517  _OrthancPluginService_CreateFindMatcher = 7010,
518  _OrthancPluginService_FreeFindMatcher = 7011,
519  _OrthancPluginService_FindMatcherIsMatch = 7012,
520 
521  _OrthancPluginService_INTERNAL = 0x7fffffff
522  } _OrthancPluginService;
523 
524 
525  typedef enum
526  {
527  _OrthancPluginProperty_Description = 1,
528  _OrthancPluginProperty_RootUri = 2,
529  _OrthancPluginProperty_OrthancExplorer = 3,
530 
531  _OrthancPluginProperty_INTERNAL = 0x7fffffff
532  } _OrthancPluginProperty;
533 
534 
535 
540  typedef enum
541  {
549 
557 
565 
573 
581 
591 
599 
607 
615 
616  _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
618 
619 
620 
624  typedef enum
625  {
630  _OrthancPluginContentType_INTERNAL = 0x7fffffff
632 
633 
634 
638  typedef enum
639  {
646  _OrthancPluginResourceType_INTERNAL = 0x7fffffff
648 
649 
650 
655  typedef enum
656  {
672  _OrthancPluginChangeType_INTERNAL = 0x7fffffff
674 
675 
680  typedef enum
681  {
687  _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
689 
690 
695  typedef enum
696  {
701  _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
703 
704 
709  typedef enum
710  {
739  _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
741 
742 
748  typedef enum
749  {
754  _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
756 
757 
763  typedef enum
764  {
765  OrthancPluginDicomToJsonFlags_None = 0,
773  _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
775 
776 
782  typedef enum
783  {
784  OrthancPluginCreateDicomFlags_None = 0,
788  _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
790 
791 
796  typedef enum
797  {
803  _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
805 
806 
810  typedef enum
811  {
818  _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
820 
821 
829  typedef struct
830  {
834  void* data;
835 
839  uint32_t size;
841 
842 
843 
844 
849  typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
850 
851 
852 
856  typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
857 
858 
859 
864  typedef struct _OrthancPluginImage_t OrthancPluginImage;
865 
866 
867 
872  typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
873 
874 
875 
880  typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
881 
882 
883 
888  typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
889 
890 
891 
896  typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
897 
898 
899 
904  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
905 
906 
907 
912  typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindMatcher;
913 
914 
915 
921  OrthancPluginRestOutput* output,
922  const char* url,
923  const OrthancPluginHttpRequest* request);
924 
925 
926 
932  OrthancPluginDicomInstance* instance,
933  const char* instanceId);
934 
935 
936 
942  OrthancPluginChangeType changeType,
943  OrthancPluginResourceType resourceType,
944  const char* resourceId);
945 
946 
947 
953  OrthancPluginImage** target,
954  const void* dicom,
955  const uint32_t size,
956  uint32_t frameIndex);
957 
958 
959 
963  typedef void (*OrthancPluginFree) (void* buffer);
964 
965 
966 
980  const char* uuid,
981  const void* content,
982  int64_t size,
984 
985 
986 
1000  void** content,
1001  int64_t* size,
1002  const char* uuid,
1004 
1005 
1006 
1018  const char* uuid,
1020 
1021 
1022 
1038  const OrthancPluginWorklistQuery* query,
1039  const char* issuerAet,
1040  const char* calledAet);
1041 
1042 
1043 
1064  OrthancPluginHttpMethod method,
1065  const char* uri,
1066  const char* ip,
1067  uint32_t headersCount,
1068  const char* const* headersKeys,
1069  const char* const* headersValues);
1070 
1071 
1072 
1095  OrthancPluginHttpMethod method,
1096  const char* uri,
1097  const char* ip,
1098  uint32_t headersCount,
1099  const char* const* headersKeys,
1100  const char* const* headersValues,
1101  uint32_t getArgumentsCount,
1102  const char* const* getArgumentsKeys,
1103  const char* const* getArgumentsValues);
1104 
1105 
1106 
1122  OrthancPluginFindAnswers* answers,
1123  const OrthancPluginFindQuery* query,
1124  const char* issuerAet,
1125  const char* calledAet);
1126 
1127 
1128 
1164  typedef void* (*OrthancPluginMoveCallback) (
1165  OrthancPluginResourceType resourceType,
1166  const char* patientId,
1167  const char* accessionNumber,
1168  const char* studyInstanceUid,
1169  const char* seriesInstanceUid,
1170  const char* sopInstanceUid,
1171  const char* originatorAet,
1172  const char* sourceAet,
1173  const char* targetAet,
1174  uint16_t originatorId);
1175 
1176 
1188  typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1189 
1190 
1202  typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1203 
1204 
1215  typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1216 
1217 
1218 
1222  typedef struct _OrthancPluginContext_t
1223  {
1224  void* pluginsManager;
1225  const char* orthancVersion;
1226  OrthancPluginFree Free;
1227  OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1228  _OrthancPluginService service,
1229  const void* params);
1231 
1232 
1233 
1237  typedef struct
1238  {
1239  uint16_t group;
1240  uint16_t element;
1242  uint32_t minMultiplicity;
1243  uint32_t maxMultiplicity;
1245 
1246 
1247 
1256  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1257  OrthancPluginContext* context,
1258  char* str)
1259  {
1260  if (str != NULL)
1261  {
1262  context->Free(str);
1263  }
1264  }
1265 
1266 
1280  ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1281  OrthancPluginContext* context)
1282  {
1283  int major, minor, revision;
1284 
1285  if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1286  sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1287  sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1288  sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1289  sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1290  sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1291  sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1292  sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1293  sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1294  sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1295  sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1296  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1297  sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1298  sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1299  sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1300  sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin))
1301  {
1302  /* Mismatch in the size of the enumerations */
1303  return 0;
1304  }
1305 
1306  /* Assume compatibility with the mainline */
1307  if (!strcmp(context->orthancVersion, "mainline"))
1308  {
1309  return 1;
1310  }
1311 
1312  /* Parse the version of the Orthanc core */
1313  if (
1314 #ifdef _MSC_VER
1315  sscanf_s
1316 #else
1317  sscanf
1318 #endif
1319  (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1320  {
1321  return 0;
1322  }
1323 
1324  /* Check the major number of the version */
1325 
1326  if (major > ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
1327  {
1328  return 1;
1329  }
1330 
1331  if (major < ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER)
1332  {
1333  return 0;
1334  }
1335 
1336  /* Check the minor number of the version */
1337 
1338  if (minor > ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
1339  {
1340  return 1;
1341  }
1342 
1343  if (minor < ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER)
1344  {
1345  return 0;
1346  }
1347 
1348  /* Check the revision number of the version */
1349 
1350  if (revision >= ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER)
1351  {
1352  return 1;
1353  }
1354  else
1355  {
1356  return 0;
1357  }
1358  }
1359 
1360 
1369  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
1370  OrthancPluginContext* context,
1371  OrthancPluginMemoryBuffer* buffer)
1372  {
1373  context->Free(buffer->data);
1374  }
1375 
1376 
1385  ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
1386  OrthancPluginContext* context,
1387  const char* message)
1388  {
1389  context->InvokeService(context, _OrthancPluginService_LogError, message);
1390  }
1391 
1392 
1401  ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
1402  OrthancPluginContext* context,
1403  const char* message)
1404  {
1405  context->InvokeService(context, _OrthancPluginService_LogWarning, message);
1406  }
1407 
1408 
1417  ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
1418  OrthancPluginContext* context,
1419  const char* message)
1420  {
1421  context->InvokeService(context, _OrthancPluginService_LogInfo, message);
1422  }
1423 
1424 
1425 
1426  typedef struct
1427  {
1428  const char* pathRegularExpression;
1429  OrthancPluginRestCallback callback;
1430  } _OrthancPluginRestCallback;
1431 
1448  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
1449  OrthancPluginContext* context,
1450  const char* pathRegularExpression,
1451  OrthancPluginRestCallback callback)
1452  {
1453  _OrthancPluginRestCallback params;
1454  params.pathRegularExpression = pathRegularExpression;
1455  params.callback = callback;
1456  context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
1457  }
1458 
1459 
1460 
1482  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallbackNoLock(
1483  OrthancPluginContext* context,
1484  const char* pathRegularExpression,
1485  OrthancPluginRestCallback callback)
1486  {
1487  _OrthancPluginRestCallback params;
1488  params.pathRegularExpression = pathRegularExpression;
1489  params.callback = callback;
1490  context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
1491  }
1492 
1493 
1494 
1495  typedef struct
1496  {
1498  } _OrthancPluginOnStoredInstanceCallback;
1499 
1511  OrthancPluginContext* context,
1513  {
1514  _OrthancPluginOnStoredInstanceCallback params;
1515  params.callback = callback;
1516 
1517  context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
1518  }
1519 
1520 
1521 
1522  typedef struct
1523  {
1524  OrthancPluginRestOutput* output;
1525  const char* answer;
1526  uint32_t answerSize;
1527  const char* mimeType;
1528  } _OrthancPluginAnswerBuffer;
1529 
1542  ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
1543  OrthancPluginContext* context,
1544  OrthancPluginRestOutput* output,
1545  const char* answer,
1546  uint32_t answerSize,
1547  const char* mimeType)
1548  {
1549  _OrthancPluginAnswerBuffer params;
1550  params.output = output;
1551  params.answer = answer;
1552  params.answerSize = answerSize;
1553  params.mimeType = mimeType;
1554  context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
1555  }
1556 
1557 
1558  typedef struct
1559  {
1560  OrthancPluginRestOutput* output;
1561  OrthancPluginPixelFormat format;
1562  uint32_t width;
1563  uint32_t height;
1564  uint32_t pitch;
1565  const void* buffer;
1566  } _OrthancPluginCompressAndAnswerPngImage;
1567 
1568  typedef struct
1569  {
1570  OrthancPluginRestOutput* output;
1571  OrthancPluginImageFormat imageFormat;
1572  OrthancPluginPixelFormat pixelFormat;
1573  uint32_t width;
1574  uint32_t height;
1575  uint32_t pitch;
1576  const void* buffer;
1577  uint8_t quality;
1578  } _OrthancPluginCompressAndAnswerImage;
1579 
1580 
1599  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
1600  OrthancPluginContext* context,
1601  OrthancPluginRestOutput* output,
1602  OrthancPluginPixelFormat format,
1603  uint32_t width,
1604  uint32_t height,
1605  uint32_t pitch,
1606  const void* buffer)
1607  {
1608  _OrthancPluginCompressAndAnswerImage params;
1609  params.output = output;
1610  params.imageFormat = OrthancPluginImageFormat_Png;
1611  params.pixelFormat = format;
1612  params.width = width;
1613  params.height = height;
1614  params.pitch = pitch;
1615  params.buffer = buffer;
1616  params.quality = 0; /* No quality for PNG */
1617  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
1618  }
1619 
1620 
1621 
1622  typedef struct
1623  {
1624  OrthancPluginMemoryBuffer* target;
1625  const char* instanceId;
1626  } _OrthancPluginGetDicomForInstance;
1627 
1641  OrthancPluginContext* context,
1642  OrthancPluginMemoryBuffer* target,
1643  const char* instanceId)
1644  {
1645  _OrthancPluginGetDicomForInstance params;
1646  params.target = target;
1647  params.instanceId = instanceId;
1648  return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
1649  }
1650 
1651 
1652 
1653  typedef struct
1654  {
1655  OrthancPluginMemoryBuffer* target;
1656  const char* uri;
1657  } _OrthancPluginRestApiGet;
1658 
1674  OrthancPluginContext* context,
1675  OrthancPluginMemoryBuffer* target,
1676  const char* uri)
1677  {
1678  _OrthancPluginRestApiGet params;
1679  params.target = target;
1680  params.uri = uri;
1681  return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
1682  }
1683 
1684 
1685 
1704  OrthancPluginContext* context,
1705  OrthancPluginMemoryBuffer* target,
1706  const char* uri)
1707  {
1708  _OrthancPluginRestApiGet params;
1709  params.target = target;
1710  params.uri = uri;
1711  return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
1712  }
1713 
1714 
1715 
1716  typedef struct
1717  {
1718  OrthancPluginMemoryBuffer* target;
1719  const char* uri;
1720  const char* body;
1721  uint32_t bodySize;
1722  } _OrthancPluginRestApiPostPut;
1723 
1741  OrthancPluginContext* context,
1742  OrthancPluginMemoryBuffer* target,
1743  const char* uri,
1744  const char* body,
1745  uint32_t bodySize)
1746  {
1747  _OrthancPluginRestApiPostPut params;
1748  params.target = target;
1749  params.uri = uri;
1750  params.body = body;
1751  params.bodySize = bodySize;
1752  return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
1753  }
1754 
1755 
1776  OrthancPluginContext* context,
1777  OrthancPluginMemoryBuffer* target,
1778  const char* uri,
1779  const char* body,
1780  uint32_t bodySize)
1781  {
1782  _OrthancPluginRestApiPostPut params;
1783  params.target = target;
1784  params.uri = uri;
1785  params.body = body;
1786  params.bodySize = bodySize;
1787  return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
1788  }
1789 
1790 
1791 
1805  OrthancPluginContext* context,
1806  const char* uri)
1807  {
1808  return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
1809  }
1810 
1811 
1828  OrthancPluginContext* context,
1829  const char* uri)
1830  {
1831  return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
1832  }
1833 
1834 
1835 
1853  OrthancPluginContext* context,
1854  OrthancPluginMemoryBuffer* target,
1855  const char* uri,
1856  const char* body,
1857  uint32_t bodySize)
1858  {
1859  _OrthancPluginRestApiPostPut params;
1860  params.target = target;
1861  params.uri = uri;
1862  params.body = body;
1863  params.bodySize = bodySize;
1864  return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
1865  }
1866 
1867 
1868 
1889  OrthancPluginContext* context,
1890  OrthancPluginMemoryBuffer* target,
1891  const char* uri,
1892  const char* body,
1893  uint32_t bodySize)
1894  {
1895  _OrthancPluginRestApiPostPut params;
1896  params.target = target;
1897  params.uri = uri;
1898  params.body = body;
1899  params.bodySize = bodySize;
1900  return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
1901  }
1902 
1903 
1904 
1905  typedef struct
1906  {
1907  OrthancPluginRestOutput* output;
1908  const char* argument;
1909  } _OrthancPluginOutputPlusArgument;
1910 
1922  ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
1923  OrthancPluginContext* context,
1924  OrthancPluginRestOutput* output,
1925  const char* redirection)
1926  {
1927  _OrthancPluginOutputPlusArgument params;
1928  params.output = output;
1929  params.argument = redirection;
1930  context->InvokeService(context, _OrthancPluginService_Redirect, &params);
1931  }
1932 
1933 
1934 
1935  typedef struct
1936  {
1937  char** result;
1938  const char* argument;
1939  } _OrthancPluginRetrieveDynamicString;
1940 
1954  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
1955  OrthancPluginContext* context,
1956  const char* patientID)
1957  {
1958  char* result;
1959 
1960  _OrthancPluginRetrieveDynamicString params;
1961  params.result = &result;
1962  params.argument = patientID;
1963 
1964  if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
1965  {
1966  /* Error */
1967  return NULL;
1968  }
1969  else
1970  {
1971  return result;
1972  }
1973  }
1974 
1975 
1989  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
1990  OrthancPluginContext* context,
1991  const char* studyUID)
1992  {
1993  char* result;
1994 
1995  _OrthancPluginRetrieveDynamicString params;
1996  params.result = &result;
1997  params.argument = studyUID;
1998 
1999  if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2000  {
2001  /* Error */
2002  return NULL;
2003  }
2004  else
2005  {
2006  return result;
2007  }
2008  }
2009 
2010 
2024  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudyWithAccessionNumber(
2025  OrthancPluginContext* context,
2026  const char* accessionNumber)
2027  {
2028  char* result;
2029 
2030  _OrthancPluginRetrieveDynamicString params;
2031  params.result = &result;
2032  params.argument = accessionNumber;
2033 
2034  if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2035  {
2036  /* Error */
2037  return NULL;
2038  }
2039  else
2040  {
2041  return result;
2042  }
2043  }
2044 
2045 
2059  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2060  OrthancPluginContext* context,
2061  const char* seriesUID)
2062  {
2063  char* result;
2064 
2065  _OrthancPluginRetrieveDynamicString params;
2066  params.result = &result;
2067  params.argument = seriesUID;
2068 
2069  if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2070  {
2071  /* Error */
2072  return NULL;
2073  }
2074  else
2075  {
2076  return result;
2077  }
2078  }
2079 
2080 
2094  ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2095  OrthancPluginContext* context,
2096  const char* sopInstanceUID)
2097  {
2098  char* result;
2099 
2100  _OrthancPluginRetrieveDynamicString params;
2101  params.result = &result;
2102  params.argument = sopInstanceUID;
2103 
2104  if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2105  {
2106  /* Error */
2107  return NULL;
2108  }
2109  else
2110  {
2111  return result;
2112  }
2113  }
2114 
2115 
2116 
2117  typedef struct
2118  {
2119  OrthancPluginRestOutput* output;
2120  uint16_t status;
2121  } _OrthancPluginSendHttpStatusCode;
2122 
2139  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2140  OrthancPluginContext* context,
2141  OrthancPluginRestOutput* output,
2142  uint16_t status)
2143  {
2144  _OrthancPluginSendHttpStatusCode params;
2145  params.output = output;
2146  params.status = status;
2147  context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2148  }
2149 
2150 
2162  ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2163  OrthancPluginContext* context,
2164  OrthancPluginRestOutput* output,
2165  const char* realm)
2166  {
2167  _OrthancPluginOutputPlusArgument params;
2168  params.output = output;
2169  params.argument = realm;
2170  context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2171  }
2172 
2173 
2185  ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2186  OrthancPluginContext* context,
2187  OrthancPluginRestOutput* output,
2188  const char* allowedMethods)
2189  {
2190  _OrthancPluginOutputPlusArgument params;
2191  params.output = output;
2192  params.argument = allowedMethods;
2193  context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2194  }
2195 
2196 
2197  typedef struct
2198  {
2199  OrthancPluginRestOutput* output;
2200  const char* key;
2201  const char* value;
2202  } _OrthancPluginSetHttpHeader;
2203 
2215  ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2216  OrthancPluginContext* context,
2217  OrthancPluginRestOutput* output,
2218  const char* cookie,
2219  const char* value)
2220  {
2221  _OrthancPluginSetHttpHeader params;
2222  params.output = output;
2223  params.key = cookie;
2224  params.value = value;
2225  context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2226  }
2227 
2228 
2240  ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2241  OrthancPluginContext* context,
2242  OrthancPluginRestOutput* output,
2243  const char* key,
2244  const char* value)
2245  {
2246  _OrthancPluginSetHttpHeader params;
2247  params.output = output;
2248  params.key = key;
2249  params.value = value;
2250  context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2251  }
2252 
2253 
2254  typedef struct
2255  {
2256  char** resultStringToFree;
2257  const char** resultString;
2258  int64_t* resultInt64;
2259  const char* key;
2260  OrthancPluginDicomInstance* instance;
2261  OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2262  } _OrthancPluginAccessDicomInstance;
2263 
2264 
2276  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2277  OrthancPluginContext* context,
2278  OrthancPluginDicomInstance* instance)
2279  {
2280  const char* result;
2281 
2282  _OrthancPluginAccessDicomInstance params;
2283  memset(&params, 0, sizeof(params));
2284  params.resultString = &result;
2285  params.instance = instance;
2286 
2287  if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2288  {
2289  /* Error */
2290  return NULL;
2291  }
2292  else
2293  {
2294  return result;
2295  }
2296  }
2297 
2298 
2309  ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2310  OrthancPluginContext* context,
2311  OrthancPluginDicomInstance* instance)
2312  {
2313  int64_t size;
2314 
2315  _OrthancPluginAccessDicomInstance params;
2316  memset(&params, 0, sizeof(params));
2317  params.resultInt64 = &size;
2318  params.instance = instance;
2319 
2320  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2321  {
2322  /* Error */
2323  return -1;
2324  }
2325  else
2326  {
2327  return size;
2328  }
2329  }
2330 
2331 
2342  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceData(
2343  OrthancPluginContext* context,
2344  OrthancPluginDicomInstance* instance)
2345  {
2346  const char* result;
2347 
2348  _OrthancPluginAccessDicomInstance params;
2349  memset(&params, 0, sizeof(params));
2350  params.resultString = &result;
2351  params.instance = instance;
2352 
2353  if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
2354  {
2355  /* Error */
2356  return NULL;
2357  }
2358  else
2359  {
2360  return result;
2361  }
2362  }
2363 
2364 
2378  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
2379  OrthancPluginContext* context,
2380  OrthancPluginDicomInstance* instance)
2381  {
2382  char* result;
2383 
2384  _OrthancPluginAccessDicomInstance params;
2385  memset(&params, 0, sizeof(params));
2386  params.resultStringToFree = &result;
2387  params.instance = instance;
2388 
2389  if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
2390  {
2391  /* Error */
2392  return NULL;
2393  }
2394  else
2395  {
2396  return result;
2397  }
2398  }
2399 
2400 
2416  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
2417  OrthancPluginContext* context,
2418  OrthancPluginDicomInstance* instance)
2419  {
2420  char* result;
2421 
2422  _OrthancPluginAccessDicomInstance params;
2423  memset(&params, 0, sizeof(params));
2424  params.resultStringToFree = &result;
2425  params.instance = instance;
2426 
2427  if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
2428  {
2429  /* Error */
2430  return NULL;
2431  }
2432  else
2433  {
2434  return result;
2435  }
2436  }
2437 
2438 
2455  ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
2456  OrthancPluginContext* context,
2457  OrthancPluginDicomInstance* instance,
2458  const char* metadata)
2459  {
2460  int64_t result;
2461 
2462  _OrthancPluginAccessDicomInstance params;
2463  memset(&params, 0, sizeof(params));
2464  params.resultInt64 = &result;
2465  params.instance = instance;
2466  params.key = metadata;
2467 
2468  if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2469  {
2470  /* Error */
2471  return -1;
2472  }
2473  else
2474  {
2475  return (result != 0);
2476  }
2477  }
2478 
2479 
2493  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
2494  OrthancPluginContext* context,
2495  OrthancPluginDicomInstance* instance,
2496  const char* metadata)
2497  {
2498  const char* result;
2499 
2500  _OrthancPluginAccessDicomInstance params;
2501  memset(&params, 0, sizeof(params));
2502  params.resultString = &result;
2503  params.instance = instance;
2504  params.key = metadata;
2505 
2506  if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
2507  {
2508  /* Error */
2509  return NULL;
2510  }
2511  else
2512  {
2513  return result;
2514  }
2515  }
2516 
2517 
2518 
2519  typedef struct
2520  {
2524  OrthancPluginFree free;
2525  } _OrthancPluginRegisterStorageArea;
2526 
2541  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
2542  OrthancPluginContext* context,
2546  {
2547  _OrthancPluginRegisterStorageArea params;
2548  params.create = create;
2549  params.read = read;
2550  params.remove = remove;
2551 
2552 #ifdef __cplusplus
2553  params.free = ::free;
2554 #else
2555  params.free = free;
2556 #endif
2557 
2558  context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
2559  }
2560 
2561 
2562 
2573  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
2574  {
2575  char* result;
2576 
2577  _OrthancPluginRetrieveDynamicString params;
2578  params.result = &result;
2579  params.argument = NULL;
2580 
2581  if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
2582  {
2583  /* Error */
2584  return NULL;
2585  }
2586  else
2587  {
2588  return result;
2589  }
2590  }
2591 
2592 
2603  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
2604  {
2605  char* result;
2606 
2607  _OrthancPluginRetrieveDynamicString params;
2608  params.result = &result;
2609  params.argument = NULL;
2610 
2611  if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
2612  {
2613  /* Error */
2614  return NULL;
2615  }
2616  else
2617  {
2618  return result;
2619  }
2620  }
2621 
2622 
2638  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
2639  {
2640  char* result;
2641 
2642  _OrthancPluginRetrieveDynamicString params;
2643  params.result = &result;
2644  params.argument = NULL;
2645 
2646  if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
2647  {
2648  /* Error */
2649  return NULL;
2650  }
2651  else
2652  {
2653  return result;
2654  }
2655  }
2656 
2657 
2658 
2659  typedef struct
2660  {
2662  } _OrthancPluginOnChangeCallback;
2663 
2680  ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
2681  OrthancPluginContext* context,
2683  {
2684  _OrthancPluginOnChangeCallback params;
2685  params.callback = callback;
2686 
2687  context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
2688  }
2689 
2690 
2691 
2692  typedef struct
2693  {
2694  const char* plugin;
2695  _OrthancPluginProperty property;
2696  const char* value;
2697  } _OrthancPluginSetPluginProperty;
2698 
2699 
2711  ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
2712  OrthancPluginContext* context,
2713  const char* uri)
2714  {
2715  _OrthancPluginSetPluginProperty params;
2716  params.plugin = OrthancPluginGetName();
2717  params.property = _OrthancPluginProperty_RootUri;
2718  params.value = uri;
2719 
2720  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2721  }
2722 
2723 
2733  ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
2734  OrthancPluginContext* context,
2735  const char* description)
2736  {
2737  _OrthancPluginSetPluginProperty params;
2738  params.plugin = OrthancPluginGetName();
2739  params.property = _OrthancPluginProperty_Description;
2740  params.value = description;
2741 
2742  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2743  }
2744 
2745 
2755  ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
2756  OrthancPluginContext* context,
2757  const char* javascript)
2758  {
2759  _OrthancPluginSetPluginProperty params;
2760  params.plugin = OrthancPluginGetName();
2761  params.property = _OrthancPluginProperty_OrthancExplorer;
2762  params.value = javascript;
2763 
2764  context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
2765  }
2766 
2767 
2768  typedef struct
2769  {
2770  char** result;
2771  int32_t property;
2772  const char* value;
2773  } _OrthancPluginGlobalProperty;
2774 
2775 
2789  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
2790  OrthancPluginContext* context,
2791  int32_t property,
2792  const char* defaultValue)
2793  {
2794  char* result;
2795 
2796  _OrthancPluginGlobalProperty params;
2797  params.result = &result;
2798  params.property = property;
2799  params.value = defaultValue;
2800 
2801  if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
2802  {
2803  /* Error */
2804  return NULL;
2805  }
2806  else
2807  {
2808  return result;
2809  }
2810  }
2811 
2812 
2829  OrthancPluginContext* context,
2830  int32_t property,
2831  const char* value)
2832  {
2833  _OrthancPluginGlobalProperty params;
2834  params.result = NULL;
2835  params.property = property;
2836  params.value = value;
2837 
2838  return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
2839  }
2840 
2841 
2842 
2843  typedef struct
2844  {
2845  int32_t *resultInt32;
2846  uint32_t *resultUint32;
2847  int64_t *resultInt64;
2848  uint64_t *resultUint64;
2849  } _OrthancPluginReturnSingleValue;
2850 
2859  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
2860  OrthancPluginContext* context)
2861  {
2862  uint32_t count = 0;
2863 
2864  _OrthancPluginReturnSingleValue params;
2865  memset(&params, 0, sizeof(params));
2866  params.resultUint32 = &count;
2867 
2868  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
2869  {
2870  /* Error */
2871  return 0;
2872  }
2873  else
2874  {
2875  return count;
2876  }
2877  }
2878 
2879 
2880 
2893  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
2894  OrthancPluginContext* context,
2895  uint32_t argument)
2896  {
2897  char* result;
2898 
2899  _OrthancPluginGlobalProperty params;
2900  params.result = &result;
2901  params.property = (int32_t) argument;
2902  params.value = NULL;
2903 
2904  if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
2905  {
2906  /* Error */
2907  return NULL;
2908  }
2909  else
2910  {
2911  return result;
2912  }
2913  }
2914 
2915 
2926  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
2927  OrthancPluginContext* context)
2928  {
2929  uint32_t count = 0;
2930 
2931  _OrthancPluginReturnSingleValue params;
2932  memset(&params, 0, sizeof(params));
2933  params.resultUint32 = &count;
2934 
2935  if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
2936  {
2937  /* Error */
2938  return 0;
2939  }
2940  else
2941  {
2942  return count;
2943  }
2944  }
2945 
2946 
2947 
2959  ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
2960  {
2961  char* result;
2962 
2963  _OrthancPluginRetrieveDynamicString params;
2964  params.result = &result;
2965  params.argument = NULL;
2966 
2967  if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
2968  {
2969  /* Error */
2970  return NULL;
2971  }
2972  else
2973  {
2974  return result;
2975  }
2976  }
2977 
2978 
2979 
2980  typedef struct
2981  {
2982  OrthancPluginRestOutput* output;
2983  const char* subType;
2984  const char* contentType;
2985  } _OrthancPluginStartMultipartAnswer;
2986 
3001  OrthancPluginContext* context,
3002  OrthancPluginRestOutput* output,
3003  const char* subType,
3004  const char* contentType)
3005  {
3006  _OrthancPluginStartMultipartAnswer params;
3007  params.output = output;
3008  params.subType = subType;
3009  params.contentType = contentType;
3010  return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3011  }
3012 
3013 
3030  OrthancPluginContext* context,
3031  OrthancPluginRestOutput* output,
3032  const char* answer,
3033  uint32_t answerSize)
3034  {
3035  _OrthancPluginAnswerBuffer params;
3036  params.output = output;
3037  params.answer = answer;
3038  params.answerSize = answerSize;
3039  params.mimeType = NULL;
3040  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3041  }
3042 
3043 
3044 
3045  typedef struct
3046  {
3047  OrthancPluginMemoryBuffer* target;
3048  const void* source;
3049  uint32_t size;
3050  OrthancPluginCompressionType compression;
3051  uint8_t uncompress;
3052  } _OrthancPluginBufferCompression;
3053 
3054 
3072  OrthancPluginContext* context,
3073  OrthancPluginMemoryBuffer* target,
3074  const void* source,
3075  uint32_t size,
3076  OrthancPluginCompressionType compression,
3077  uint8_t uncompress)
3078  {
3079  _OrthancPluginBufferCompression params;
3080  params.target = target;
3081  params.source = source;
3082  params.size = size;
3083  params.compression = compression;
3084  params.uncompress = uncompress;
3085 
3086  return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3087  }
3088 
3089 
3090 
3091  typedef struct
3092  {
3093  OrthancPluginMemoryBuffer* target;
3094  const char* path;
3095  } _OrthancPluginReadFile;
3096 
3109  OrthancPluginContext* context,
3110  OrthancPluginMemoryBuffer* target,
3111  const char* path)
3112  {
3113  _OrthancPluginReadFile params;
3114  params.target = target;
3115  params.path = path;
3116  return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3117  }
3118 
3119 
3120 
3121  typedef struct
3122  {
3123  const char* path;
3124  const void* data;
3125  uint32_t size;
3126  } _OrthancPluginWriteFile;
3127 
3140  OrthancPluginContext* context,
3141  const char* path,
3142  const void* data,
3143  uint32_t size)
3144  {
3145  _OrthancPluginWriteFile params;
3146  params.path = path;
3147  params.data = data;
3148  params.size = size;
3149  return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3150  }
3151 
3152 
3153 
3154  typedef struct
3155  {
3156  const char** target;
3157  OrthancPluginErrorCode error;
3158  } _OrthancPluginGetErrorDescription;
3159 
3170  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3171  OrthancPluginContext* context,
3172  OrthancPluginErrorCode error)
3173  {
3174  const char* result = NULL;
3175 
3176  _OrthancPluginGetErrorDescription params;
3177  params.target = &result;
3178  params.error = error;
3179 
3180  if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3181  result == NULL)
3182  {
3183  return "Unknown error code";
3184  }
3185  else
3186  {
3187  return result;
3188  }
3189  }
3190 
3191 
3192 
3193  typedef struct
3194  {
3195  OrthancPluginRestOutput* output;
3196  uint16_t status;
3197  const char* body;
3198  uint32_t bodySize;
3199  } _OrthancPluginSendHttpStatus;
3200 
3223  ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3224  OrthancPluginContext* context,
3225  OrthancPluginRestOutput* output,
3226  uint16_t status,
3227  const char* body,
3228  uint32_t bodySize)
3229  {
3230  _OrthancPluginSendHttpStatus params;
3231  params.output = output;
3232  params.status = status;
3233  params.body = body;
3234  params.bodySize = bodySize;
3235  context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3236  }
3237 
3238 
3239 
3240  typedef struct
3241  {
3242  const OrthancPluginImage* image;
3243  uint32_t* resultUint32;
3244  OrthancPluginPixelFormat* resultPixelFormat;
3245  void** resultBuffer;
3246  } _OrthancPluginGetImageInfo;
3247 
3248 
3260  OrthancPluginContext* context,
3261  const OrthancPluginImage* image)
3262  {
3263  OrthancPluginPixelFormat target;
3264 
3265  _OrthancPluginGetImageInfo params;
3266  memset(&params, 0, sizeof(params));
3267  params.image = image;
3268  params.resultPixelFormat = &target;
3269 
3270  if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3271  {
3273  }
3274  else
3275  {
3276  return (OrthancPluginPixelFormat) target;
3277  }
3278  }
3279 
3280 
3281 
3292  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3293  OrthancPluginContext* context,
3294  const OrthancPluginImage* image)
3295  {
3296  uint32_t width;
3297 
3298  _OrthancPluginGetImageInfo params;
3299  memset(&params, 0, sizeof(params));
3300  params.image = image;
3301  params.resultUint32 = &width;
3302 
3303  if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3304  {
3305  return 0;
3306  }
3307  else
3308  {
3309  return width;
3310  }
3311  }
3312 
3313 
3314 
3325  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
3326  OrthancPluginContext* context,
3327  const OrthancPluginImage* image)
3328  {
3329  uint32_t height;
3330 
3331  _OrthancPluginGetImageInfo params;
3332  memset(&params, 0, sizeof(params));
3333  params.image = image;
3334  params.resultUint32 = &height;
3335 
3336  if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
3337  {
3338  return 0;
3339  }
3340  else
3341  {
3342  return height;
3343  }
3344  }
3345 
3346 
3347 
3360  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
3361  OrthancPluginContext* context,
3362  const OrthancPluginImage* image)
3363  {
3364  uint32_t pitch;
3365 
3366  _OrthancPluginGetImageInfo params;
3367  memset(&params, 0, sizeof(params));
3368  params.image = image;
3369  params.resultUint32 = &pitch;
3370 
3371  if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
3372  {
3373  return 0;
3374  }
3375  else
3376  {
3377  return pitch;
3378  }
3379  }
3380 
3381 
3382 
3394  ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
3395  OrthancPluginContext* context,
3396  const OrthancPluginImage* image)
3397  {
3398  void* target = NULL;
3399 
3400  _OrthancPluginGetImageInfo params;
3401  memset(&params, 0, sizeof(params));
3402  params.resultBuffer = &target;
3403  params.image = image;
3404 
3405  if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
3406  {
3407  return NULL;
3408  }
3409  else
3410  {
3411  return target;
3412  }
3413  }
3414 
3415 
3416  typedef struct
3417  {
3418  OrthancPluginImage** target;
3419  const void* data;
3420  uint32_t size;
3421  OrthancPluginImageFormat format;
3422  } _OrthancPluginUncompressImage;
3423 
3424 
3438  OrthancPluginContext* context,
3439  const void* data,
3440  uint32_t size,
3441  OrthancPluginImageFormat format)
3442  {
3443  OrthancPluginImage* target = NULL;
3444 
3445  _OrthancPluginUncompressImage params;
3446  memset(&params, 0, sizeof(params));
3447  params.target = &target;
3448  params.data = data;
3449  params.size = size;
3450  params.format = format;
3451 
3452  if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
3453  {
3454  return NULL;
3455  }
3456  else
3457  {
3458  return target;
3459  }
3460  }
3461 
3462 
3463 
3464 
3465  typedef struct
3466  {
3467  OrthancPluginImage* image;
3468  } _OrthancPluginFreeImage;
3469 
3479  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
3480  OrthancPluginContext* context,
3481  OrthancPluginImage* image)
3482  {
3483  _OrthancPluginFreeImage params;
3484  params.image = image;
3485 
3486  context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
3487  }
3488 
3489 
3490 
3491 
3492  typedef struct
3493  {
3494  OrthancPluginMemoryBuffer* target;
3495  OrthancPluginImageFormat imageFormat;
3496  OrthancPluginPixelFormat pixelFormat;
3497  uint32_t width;
3498  uint32_t height;
3499  uint32_t pitch;
3500  const void* buffer;
3501  uint8_t quality;
3502  } _OrthancPluginCompressImage;
3503 
3504 
3525  OrthancPluginContext* context,
3526  OrthancPluginMemoryBuffer* target,
3527  OrthancPluginPixelFormat format,
3528  uint32_t width,
3529  uint32_t height,
3530  uint32_t pitch,
3531  const void* buffer)
3532  {
3533  _OrthancPluginCompressImage params;
3534  memset(&params, 0, sizeof(params));
3535  params.target = target;
3536  params.imageFormat = OrthancPluginImageFormat_Png;
3537  params.pixelFormat = format;
3538  params.width = width;
3539  params.height = height;
3540  params.pitch = pitch;
3541  params.buffer = buffer;
3542  params.quality = 0; /* Unused for PNG */
3543 
3544  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3545  }
3546 
3547 
3570  OrthancPluginContext* context,
3571  OrthancPluginMemoryBuffer* target,
3572  OrthancPluginPixelFormat format,
3573  uint32_t width,
3574  uint32_t height,
3575  uint32_t pitch,
3576  const void* buffer,
3577  uint8_t quality)
3578  {
3579  _OrthancPluginCompressImage params;
3580  memset(&params, 0, sizeof(params));
3581  params.target = target;
3582  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3583  params.pixelFormat = format;
3584  params.width = width;
3585  params.height = height;
3586  params.pitch = pitch;
3587  params.buffer = buffer;
3588  params.quality = quality;
3589 
3590  return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
3591  }
3592 
3593 
3594 
3616  ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerJpegImage(
3617  OrthancPluginContext* context,
3618  OrthancPluginRestOutput* output,
3619  OrthancPluginPixelFormat format,
3620  uint32_t width,
3621  uint32_t height,
3622  uint32_t pitch,
3623  const void* buffer,
3624  uint8_t quality)
3625  {
3626  _OrthancPluginCompressAndAnswerImage params;
3627  params.output = output;
3628  params.imageFormat = OrthancPluginImageFormat_Jpeg;
3629  params.pixelFormat = format;
3630  params.width = width;
3631  params.height = height;
3632  params.pitch = pitch;
3633  params.buffer = buffer;
3634  params.quality = quality;
3635  context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
3636  }
3637 
3638 
3639 
3640 
3641  typedef struct
3642  {
3643  OrthancPluginMemoryBuffer* target;
3644  OrthancPluginHttpMethod method;
3645  const char* url;
3646  const char* username;
3647  const char* password;
3648  const char* body;
3649  uint32_t bodySize;
3650  } _OrthancPluginCallHttpClient;
3651 
3652 
3669  OrthancPluginContext* context,
3670  OrthancPluginMemoryBuffer* target,
3671  const char* url,
3672  const char* username,
3673  const char* password)
3674  {
3675  _OrthancPluginCallHttpClient params;
3676  memset(&params, 0, sizeof(params));
3677 
3678  params.target = target;
3679  params.method = OrthancPluginHttpMethod_Get;
3680  params.url = url;
3681  params.username = username;
3682  params.password = password;
3683 
3684  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3685  }
3686 
3687 
3706  OrthancPluginContext* context,
3707  OrthancPluginMemoryBuffer* target,
3708  const char* url,
3709  const char* body,
3710  uint32_t bodySize,
3711  const char* username,
3712  const char* password)
3713  {
3714  _OrthancPluginCallHttpClient params;
3715  memset(&params, 0, sizeof(params));
3716 
3717  params.target = target;
3718  params.method = OrthancPluginHttpMethod_Post;
3719  params.url = url;
3720  params.body = body;
3721  params.bodySize = bodySize;
3722  params.username = username;
3723  params.password = password;
3724 
3725  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3726  }
3727 
3728 
3747  OrthancPluginContext* context,
3748  OrthancPluginMemoryBuffer* target,
3749  const char* url,
3750  const char* body,
3751  uint32_t bodySize,
3752  const char* username,
3753  const char* password)
3754  {
3755  _OrthancPluginCallHttpClient params;
3756  memset(&params, 0, sizeof(params));
3757 
3758  params.target = target;
3759  params.method = OrthancPluginHttpMethod_Put;
3760  params.url = url;
3761  params.body = body;
3762  params.bodySize = bodySize;
3763  params.username = username;
3764  params.password = password;
3765 
3766  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3767  }
3768 
3769 
3784  OrthancPluginContext* context,
3785  const char* url,
3786  const char* username,
3787  const char* password)
3788  {
3789  _OrthancPluginCallHttpClient params;
3790  memset(&params, 0, sizeof(params));
3791 
3792  params.method = OrthancPluginHttpMethod_Delete;
3793  params.url = url;
3794  params.username = username;
3795  params.password = password;
3796 
3797  return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
3798  }
3799 
3800 
3801 
3802  typedef struct
3803  {
3804  OrthancPluginImage** target;
3805  const OrthancPluginImage* source;
3806  OrthancPluginPixelFormat targetFormat;
3807  } _OrthancPluginConvertPixelFormat;
3808 
3809 
3822  OrthancPluginContext* context,
3823  const OrthancPluginImage* source,
3824  OrthancPluginPixelFormat targetFormat)
3825  {
3826  OrthancPluginImage* target = NULL;
3827 
3828  _OrthancPluginConvertPixelFormat params;
3829  params.target = &target;
3830  params.source = source;
3831  params.targetFormat = targetFormat;
3832 
3833  if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
3834  {
3835  return NULL;
3836  }
3837  else
3838  {
3839  return target;
3840  }
3841  }
3842 
3843 
3844 
3856  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
3857  OrthancPluginContext* context)
3858  {
3859  uint32_t count = 0;
3860 
3861  _OrthancPluginReturnSingleValue params;
3862  memset(&params, 0, sizeof(params));
3863  params.resultUint32 = &count;
3864 
3865  if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
3866  {
3867  /* Error */
3868  return 0;
3869  }
3870  else
3871  {
3872  return count;
3873  }
3874  }
3875 
3876 
3877 
3878 
3879  typedef struct
3880  {
3881  uint32_t fontIndex; /* in */
3882  const char** name; /* out */
3883  uint32_t* size; /* out */
3884  } _OrthancPluginGetFontInfo;
3885 
3896  ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
3897  OrthancPluginContext* context,
3898  uint32_t fontIndex)
3899  {
3900  const char* result = NULL;
3901 
3902  _OrthancPluginGetFontInfo params;
3903  memset(&params, 0, sizeof(params));
3904  params.name = &result;
3905  params.fontIndex = fontIndex;
3906 
3907  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
3908  {
3909  return NULL;
3910  }
3911  else
3912  {
3913  return result;
3914  }
3915  }
3916 
3917 
3928  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
3929  OrthancPluginContext* context,
3930  uint32_t fontIndex)
3931  {
3932  uint32_t result;
3933 
3934  _OrthancPluginGetFontInfo params;
3935  memset(&params, 0, sizeof(params));
3936  params.size = &result;
3937  params.fontIndex = fontIndex;
3938 
3939  if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
3940  {
3941  return 0;
3942  }
3943  else
3944  {
3945  return result;
3946  }
3947  }
3948 
3949 
3950 
3951  typedef struct
3952  {
3953  OrthancPluginImage* image;
3954  uint32_t fontIndex;
3955  const char* utf8Text;
3956  int32_t x;
3957  int32_t y;
3958  uint8_t r;
3959  uint8_t g;
3960  uint8_t b;
3961  } _OrthancPluginDrawText;
3962 
3963 
3982  OrthancPluginContext* context,
3983  OrthancPluginImage* image,
3984  uint32_t fontIndex,
3985  const char* utf8Text,
3986  int32_t x,
3987  int32_t y,
3988  uint8_t r,
3989  uint8_t g,
3990  uint8_t b)
3991  {
3992  _OrthancPluginDrawText params;
3993  memset(&params, 0, sizeof(params));
3994  params.image = image;
3995  params.fontIndex = fontIndex;
3996  params.utf8Text = utf8Text;
3997  params.x = x;
3998  params.y = y;
3999  params.r = r;
4000  params.g = g;
4001  params.b = b;
4002 
4003  return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4004  }
4005 
4006 
4007 
4008  typedef struct
4009  {
4010  OrthancPluginStorageArea* storageArea;
4011  const char* uuid;
4012  const void* content;
4013  uint64_t size;
4015  } _OrthancPluginStorageAreaCreate;
4016 
4017 
4034  OrthancPluginContext* context,
4035  OrthancPluginStorageArea* storageArea,
4036  const char* uuid,
4037  const void* content,
4038  uint64_t size,
4040  {
4041  _OrthancPluginStorageAreaCreate params;
4042  params.storageArea = storageArea;
4043  params.uuid = uuid;
4044  params.content = content;
4045  params.size = size;
4046  params.type = type;
4047 
4048  return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4049  }
4050 
4051 
4052  typedef struct
4053  {
4054  OrthancPluginMemoryBuffer* target;
4055  OrthancPluginStorageArea* storageArea;
4056  const char* uuid;
4058  } _OrthancPluginStorageAreaRead;
4059 
4060 
4076  OrthancPluginContext* context,
4077  OrthancPluginMemoryBuffer* target,
4078  OrthancPluginStorageArea* storageArea,
4079  const char* uuid,
4081  {
4082  _OrthancPluginStorageAreaRead params;
4083  params.target = target;
4084  params.storageArea = storageArea;
4085  params.uuid = uuid;
4086  params.type = type;
4087 
4088  return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4089  }
4090 
4091 
4092  typedef struct
4093  {
4094  OrthancPluginStorageArea* storageArea;
4095  const char* uuid;
4097  } _OrthancPluginStorageAreaRemove;
4098 
4113  OrthancPluginContext* context,
4114  OrthancPluginStorageArea* storageArea,
4115  const char* uuid,
4117  {
4118  _OrthancPluginStorageAreaRemove params;
4119  params.storageArea = storageArea;
4120  params.uuid = uuid;
4121  params.type = type;
4122 
4123  return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4124  }
4125 
4126 
4127 
4128  typedef struct
4129  {
4130  OrthancPluginErrorCode* target;
4131  int32_t code;
4132  uint16_t httpStatus;
4133  const char* message;
4134  } _OrthancPluginRegisterErrorCode;
4135 
4152  OrthancPluginContext* context,
4153  int32_t code,
4154  uint16_t httpStatus,
4155  const char* message)
4156  {
4157  OrthancPluginErrorCode target;
4158 
4159  _OrthancPluginRegisterErrorCode params;
4160  params.target = &target;
4161  params.code = code;
4162  params.httpStatus = httpStatus;
4163  params.message = message;
4164 
4165  if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4166  {
4167  return target;
4168  }
4169  else
4170  {
4171  /* There was an error while assigned the error. Use a generic code. */
4173  }
4174  }
4175 
4176 
4177 
4178  typedef struct
4179  {
4180  uint16_t group;
4181  uint16_t element;
4183  const char* name;
4184  uint32_t minMultiplicity;
4185  uint32_t maxMultiplicity;
4186  } _OrthancPluginRegisterDictionaryTag;
4187 
4208  OrthancPluginContext* context,
4209  uint16_t group,
4210  uint16_t element,
4212  const char* name,
4213  uint32_t minMultiplicity,
4214  uint32_t maxMultiplicity)
4215  {
4216  _OrthancPluginRegisterDictionaryTag params;
4217  params.group = group;
4218  params.element = element;
4219  params.vr = vr;
4220  params.name = name;
4221  params.minMultiplicity = minMultiplicity;
4222  params.maxMultiplicity = maxMultiplicity;
4223 
4224  return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4225  }
4226 
4227 
4228 
4229  typedef struct
4230  {
4231  uint16_t group;
4232  uint16_t element;
4234  const char* name;
4235  uint32_t minMultiplicity;
4236  uint32_t maxMultiplicity;
4237  const char* privateCreator;
4238  } _OrthancPluginRegisterPrivateDictionaryTag;
4239 
4261  OrthancPluginContext* context,
4262  uint16_t group,
4263  uint16_t element,
4265  const char* name,
4266  uint32_t minMultiplicity,
4267  uint32_t maxMultiplicity,
4268  const char* privateCreator)
4269  {
4270  _OrthancPluginRegisterPrivateDictionaryTag params;
4271  params.group = group;
4272  params.element = element;
4273  params.vr = vr;
4274  params.name = name;
4275  params.minMultiplicity = minMultiplicity;
4276  params.maxMultiplicity = maxMultiplicity;
4277  params.privateCreator = privateCreator;
4278 
4279  return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4280  }
4281 
4282 
4283 
4284  typedef struct
4285  {
4286  OrthancPluginStorageArea* storageArea;
4288  } _OrthancPluginReconstructMainDicomTags;
4289 
4307  OrthancPluginContext* context,
4308  OrthancPluginStorageArea* storageArea,
4310  {
4311  _OrthancPluginReconstructMainDicomTags params;
4312  params.level = level;
4313  params.storageArea = storageArea;
4314 
4315  return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
4316  }
4317 
4318 
4319  typedef struct
4320  {
4321  char** result;
4322  const char* instanceId;
4323  const void* buffer;
4324  uint32_t size;
4327  uint32_t maxStringLength;
4328  } _OrthancPluginDicomToJson;
4329 
4330 
4350  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
4351  OrthancPluginContext* context,
4352  const void* buffer,
4353  uint32_t size,
4356  uint32_t maxStringLength)
4357  {
4358  char* result;
4359 
4360  _OrthancPluginDicomToJson params;
4361  memset(&params, 0, sizeof(params));
4362  params.result = &result;
4363  params.buffer = buffer;
4364  params.size = size;
4365  params.format = format;
4366  params.flags = flags;
4367  params.maxStringLength = maxStringLength;
4368 
4369  if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
4370  {
4371  /* Error */
4372  return NULL;
4373  }
4374  else
4375  {
4376  return result;
4377  }
4378  }
4379 
4380 
4399  ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
4400  OrthancPluginContext* context,
4401  const char* instanceId,
4404  uint32_t maxStringLength)
4405  {
4406  char* result;
4407 
4408  _OrthancPluginDicomToJson params;
4409  memset(&params, 0, sizeof(params));
4410  params.result = &result;
4411  params.instanceId = instanceId;
4412  params.format = format;
4413  params.flags = flags;
4414  params.maxStringLength = maxStringLength;
4415 
4416  if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
4417  {
4418  /* Error */
4419  return NULL;
4420  }
4421  else
4422  {
4423  return result;
4424  }
4425  }
4426 
4427 
4428  typedef struct
4429  {
4430  OrthancPluginMemoryBuffer* target;
4431  const char* uri;
4432  uint32_t headersCount;
4433  const char* const* headersKeys;
4434  const char* const* headersValues;
4435  int32_t afterPlugins;
4436  } _OrthancPluginRestApiGet2;
4437 
4458  OrthancPluginContext* context,
4459  OrthancPluginMemoryBuffer* target,
4460  const char* uri,
4461  uint32_t headersCount,
4462  const char* const* headersKeys,
4463  const char* const* headersValues,
4464  int32_t afterPlugins)
4465  {
4466  _OrthancPluginRestApiGet2 params;
4467  params.target = target;
4468  params.uri = uri;
4469  params.headersCount = headersCount;
4470  params.headersKeys = headersKeys;
4471  params.headersValues = headersValues;
4472  params.afterPlugins = afterPlugins;
4473 
4474  return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
4475  }
4476 
4477 
4478 
4479  typedef struct
4480  {
4482  } _OrthancPluginWorklistCallback;
4483 
4496  OrthancPluginContext* context,
4498  {
4499  _OrthancPluginWorklistCallback params;
4500  params.callback = callback;
4501 
4502  return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
4503  }
4504 
4505 
4506 
4507  typedef struct
4508  {
4510  const OrthancPluginWorklistQuery* query;
4511  const void* dicom;
4512  uint32_t size;
4513  } _OrthancPluginWorklistAnswersOperation;
4514 
4532  OrthancPluginContext* context,
4534  const OrthancPluginWorklistQuery* query,
4535  const void* dicom,
4536  uint32_t size)
4537  {
4538  _OrthancPluginWorklistAnswersOperation params;
4539  params.answers = answers;
4540  params.query = query;
4541  params.dicom = dicom;
4542  params.size = size;
4543 
4544  return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
4545  }
4546 
4547 
4562  OrthancPluginContext* context,
4564  {
4565  _OrthancPluginWorklistAnswersOperation params;
4566  params.answers = answers;
4567  params.query = NULL;
4568  params.dicom = NULL;
4569  params.size = 0;
4570 
4571  return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
4572  }
4573 
4574 
4575  typedef struct
4576  {
4577  const OrthancPluginWorklistQuery* query;
4578  const void* dicom;
4579  uint32_t size;
4580  int32_t* isMatch;
4581  OrthancPluginMemoryBuffer* target;
4582  } _OrthancPluginWorklistQueryOperation;
4583 
4599  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
4600  OrthancPluginContext* context,
4601  const OrthancPluginWorklistQuery* query,
4602  const void* dicom,
4603  uint32_t size)
4604  {
4605  int32_t isMatch = 0;
4606 
4607  _OrthancPluginWorklistQueryOperation params;
4608  params.query = query;
4609  params.dicom = dicom;
4610  params.size = size;
4611  params.isMatch = &isMatch;
4612  params.target = NULL;
4613 
4614  if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
4615  {
4616  return isMatch;
4617  }
4618  else
4619  {
4620  /* Error: Assume non-match */
4621  return 0;
4622  }
4623  }
4624 
4625 
4639  OrthancPluginContext* context,
4640  OrthancPluginMemoryBuffer* target,
4641  const OrthancPluginWorklistQuery* query)
4642  {
4643  _OrthancPluginWorklistQueryOperation params;
4644  params.query = query;
4645  params.dicom = NULL;
4646  params.size = 0;
4647  params.isMatch = NULL;
4648  params.target = target;
4649 
4650  return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
4651  }
4652 
4653 
4665  OrthancPluginContext* context,
4666  OrthancPluginDicomInstance* instance)
4667  {
4669 
4670  _OrthancPluginAccessDicomInstance params;
4671  memset(&params, 0, sizeof(params));
4672  params.resultOrigin = &origin;
4673  params.instance = instance;
4674 
4675  if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
4676  {
4677  /* Error */
4679  }
4680  else
4681  {
4682  return origin;
4683  }
4684  }
4685 
4686 
4687  typedef struct
4688  {
4689  OrthancPluginMemoryBuffer* target;
4690  const char* json;
4691  const OrthancPluginImage* pixelData;
4693  } _OrthancPluginCreateDicom;
4694 
4714  OrthancPluginContext* context,
4715  OrthancPluginMemoryBuffer* target,
4716  const char* json,
4717  const OrthancPluginImage* pixelData,
4719  {
4720  _OrthancPluginCreateDicom params;
4721  params.target = target;
4722  params.json = json;
4723  params.pixelData = pixelData;
4724  params.flags = flags;
4725 
4726  return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
4727  }
4728 
4729 
4730  typedef struct
4731  {
4733  } _OrthancPluginDecodeImageCallback;
4734 
4747  OrthancPluginContext* context,
4749  {
4750  _OrthancPluginDecodeImageCallback params;
4751  params.callback = callback;
4752 
4753  return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
4754  }
4755 
4756 
4757 
4758  typedef struct
4759  {
4760  OrthancPluginImage** target;
4761  OrthancPluginPixelFormat format;
4762  uint32_t width;
4763  uint32_t height;
4764  uint32_t pitch;
4765  void* buffer;
4766  const void* constBuffer;
4767  uint32_t bufferSize;
4768  uint32_t frameIndex;
4769  } _OrthancPluginCreateImage;
4770 
4771 
4785  OrthancPluginContext* context,
4786  OrthancPluginPixelFormat format,
4787  uint32_t width,
4788  uint32_t height)
4789  {
4790  OrthancPluginImage* target = NULL;
4791 
4792  _OrthancPluginCreateImage params;
4793  memset(&params, 0, sizeof(params));
4794  params.target = &target;
4795  params.format = format;
4796  params.width = width;
4797  params.height = height;
4798 
4799  if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
4800  {
4801  return NULL;
4802  }
4803  else
4804  {
4805  return target;
4806  }
4807  }
4808 
4809 
4828  OrthancPluginContext* context,
4829  OrthancPluginPixelFormat format,
4830  uint32_t width,
4831  uint32_t height,
4832  uint32_t pitch,
4833  void* buffer)
4834  {
4835  OrthancPluginImage* target = NULL;
4836 
4837  _OrthancPluginCreateImage params;
4838  memset(&params, 0, sizeof(params));
4839  params.target = &target;
4840  params.format = format;
4841  params.width = width;
4842  params.height = height;
4843  params.pitch = pitch;
4844  params.buffer = buffer;
4845 
4846  if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
4847  {
4848  return NULL;
4849  }
4850  else
4851  {
4852  return target;
4853  }
4854  }
4855 
4856 
4857 
4873  OrthancPluginContext* context,
4874  const void* buffer,
4875  uint32_t bufferSize,
4876  uint32_t frameIndex)
4877  {
4878  OrthancPluginImage* target = NULL;
4879 
4880  _OrthancPluginCreateImage params;
4881  memset(&params, 0, sizeof(params));
4882  params.target = &target;
4883  params.constBuffer = buffer;
4884  params.bufferSize = bufferSize;
4885  params.frameIndex = frameIndex;
4886 
4887  if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
4888  {
4889  return NULL;
4890  }
4891  else
4892  {
4893  return target;
4894  }
4895  }
4896 
4897 
4898 
4899  typedef struct
4900  {
4901  char** result;
4902  const void* buffer;
4903  uint32_t size;
4904  } _OrthancPluginComputeHash;
4905 
4918  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
4919  OrthancPluginContext* context,
4920  const void* buffer,
4921  uint32_t size)
4922  {
4923  char* result;
4924 
4925  _OrthancPluginComputeHash params;
4926  params.result = &result;
4927  params.buffer = buffer;
4928  params.size = size;
4929 
4930  if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
4931  {
4932  /* Error */
4933  return NULL;
4934  }
4935  else
4936  {
4937  return result;
4938  }
4939  }
4940 
4941 
4954  ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
4955  OrthancPluginContext* context,
4956  const void* buffer,
4957  uint32_t size)
4958  {
4959  char* result;
4960 
4961  _OrthancPluginComputeHash params;
4962  params.result = &result;
4963  params.buffer = buffer;
4964  params.size = size;
4965 
4966  if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
4967  {
4968  /* Error */
4969  return NULL;
4970  }
4971  else
4972  {
4973  return result;
4974  }
4975  }
4976 
4977 
4978 
4979  typedef struct
4980  {
4982  const char* name;
4983  } _OrthancPluginLookupDictionary;
4984 
5001  OrthancPluginContext* context,
5003  const char* name)
5004  {
5005  _OrthancPluginLookupDictionary params;
5006  params.target = target;
5007  params.name = name;
5008  return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5009  }
5010 
5011 
5012 
5013  typedef struct
5014  {
5015  OrthancPluginRestOutput* output;
5016  const char* answer;
5017  uint32_t answerSize;
5018  uint32_t headersCount;
5019  const char* const* headersKeys;
5020  const char* const* headersValues;
5021  } _OrthancPluginSendMultipartItem2;
5022 
5044  OrthancPluginContext* context,
5045  OrthancPluginRestOutput* output,
5046  const char* answer,
5047  uint32_t answerSize,
5048  uint32_t headersCount,
5049  const char* const* headersKeys,
5050  const char* const* headersValues)
5051  {
5052  _OrthancPluginSendMultipartItem2 params;
5053  params.output = output;
5054  params.answer = answer;
5055  params.answerSize = answerSize;
5056  params.headersCount = headersCount;
5057  params.headersKeys = headersKeys;
5058  params.headersValues = headersValues;
5059 
5060  return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5061  }
5062 
5063 
5064  typedef struct
5065  {
5067  } _OrthancPluginIncomingHttpRequestFilter;
5068 
5082  OrthancPluginContext* context,
5084  {
5085  _OrthancPluginIncomingHttpRequestFilter params;
5086  params.callback = callback;
5087 
5088  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5089  }
5090 
5091 
5092 
5093  typedef struct
5094  {
5095  OrthancPluginMemoryBuffer* answerBody;
5096  OrthancPluginMemoryBuffer* answerHeaders;
5097  uint16_t* httpStatus;
5098  OrthancPluginHttpMethod method;
5099  const char* url;
5100  uint32_t headersCount;
5101  const char* const* headersKeys;
5102  const char* const* headersValues;
5103  const char* body;
5104  uint32_t bodySize;
5105  const char* username;
5106  const char* password;
5107  uint32_t timeout;
5108  const char* certificateFile;
5109  const char* certificateKeyFile;
5110  const char* certificateKeyPassword;
5111  uint8_t pkcs11;
5112  } _OrthancPluginCallHttpClient2;
5113 
5114 
5115 
5154  OrthancPluginContext* context,
5155  OrthancPluginMemoryBuffer* answerBody,
5156  OrthancPluginMemoryBuffer* answerHeaders,
5157  uint16_t* httpStatus,
5158  OrthancPluginHttpMethod method,
5159  const char* url,
5160  uint32_t headersCount,
5161  const char* const* headersKeys,
5162  const char* const* headersValues,
5163  const char* body,
5164  uint32_t bodySize,
5165  const char* username,
5166  const char* password,
5167  uint32_t timeout,
5168  const char* certificateFile,
5169  const char* certificateKeyFile,
5170  const char* certificateKeyPassword,
5171  uint8_t pkcs11)
5172  {
5173  _OrthancPluginCallHttpClient2 params;
5174  memset(&params, 0, sizeof(params));
5175 
5176  params.answerBody = answerBody;
5177  params.answerHeaders = answerHeaders;
5178  params.httpStatus = httpStatus;
5179  params.method = method;
5180  params.url = url;
5181  params.headersCount = headersCount;
5182  params.headersKeys = headersKeys;
5183  params.headersValues = headersValues;
5184  params.body = body;
5185  params.bodySize = bodySize;
5186  params.username = username;
5187  params.password = password;
5188  params.timeout = timeout;
5189  params.certificateFile = certificateFile;
5190  params.certificateKeyFile = certificateKeyFile;
5191  params.certificateKeyPassword = certificateKeyPassword;
5192  params.pkcs11 = pkcs11;
5193 
5194  return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5195  }
5196 
5197 
5208  ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5209  OrthancPluginContext* context)
5210  {
5211  char* result;
5212 
5213  _OrthancPluginRetrieveDynamicString params;
5214  params.result = &result;
5215  params.argument = NULL;
5216 
5217  if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5218  {
5219  /* Error */
5220  return NULL;
5221  }
5222  else
5223  {
5224  return result;
5225  }
5226  }
5227 
5228 
5229 
5230 
5231  typedef struct
5232  {
5233  OrthancPluginFindCallback callback;
5234  } _OrthancPluginFindCallback;
5235 
5248  OrthancPluginContext* context,
5249  OrthancPluginFindCallback callback)
5250  {
5251  _OrthancPluginFindCallback params;
5252  params.callback = callback;
5253 
5254  return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5255  }
5256 
5257 
5258  typedef struct
5259  {
5260  OrthancPluginFindAnswers *answers;
5261  const OrthancPluginFindQuery *query;
5262  const void *dicom;
5263  uint32_t size;
5264  uint32_t index;
5265  uint32_t *resultUint32;
5266  uint16_t *resultGroup;
5267  uint16_t *resultElement;
5268  char **resultString;
5269  } _OrthancPluginFindOperation;
5270 
5287  OrthancPluginContext* context,
5288  OrthancPluginFindAnswers* answers,
5289  const void* dicom,
5290  uint32_t size)
5291  {
5292  _OrthancPluginFindOperation params;
5293  memset(&params, 0, sizeof(params));
5294  params.answers = answers;
5295  params.dicom = dicom;
5296  params.size = size;
5297 
5298  return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
5299  }
5300 
5301 
5316  OrthancPluginContext* context,
5317  OrthancPluginFindAnswers* answers)
5318  {
5319  _OrthancPluginFindOperation params;
5320  memset(&params, 0, sizeof(params));
5321  params.answers = answers;
5322 
5323  return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
5324  }
5325 
5326 
5327 
5339  ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
5340  OrthancPluginContext* context,
5341  const OrthancPluginFindQuery* query)
5342  {
5343  uint32_t count = 0;
5344 
5345  _OrthancPluginFindOperation params;
5346  memset(&params, 0, sizeof(params));
5347  params.query = query;
5348  params.resultUint32 = &count;
5349 
5350  if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
5351  {
5352  /* Error */
5353  return 0;
5354  }
5355  else
5356  {
5357  return count;
5358  }
5359  }
5360 
5361 
5377  OrthancPluginContext* context,
5378  uint16_t* group,
5379  uint16_t* element,
5380  const OrthancPluginFindQuery* query,
5381  uint32_t index)
5382  {
5383  _OrthancPluginFindOperation params;
5384  memset(&params, 0, sizeof(params));
5385  params.query = query;
5386  params.index = index;
5387  params.resultGroup = group;
5388  params.resultElement = element;
5389 
5390  return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
5391  }
5392 
5393 
5407  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
5408  OrthancPluginContext* context,
5409  const OrthancPluginFindQuery* query,
5410  uint32_t index)
5411  {
5412  char* result;
5413 
5414  _OrthancPluginFindOperation params;
5415  memset(&params, 0, sizeof(params));
5416  params.query = query;
5417  params.index = index;
5418  params.resultString = &result;
5419 
5420  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
5421  {
5422  /* Error */
5423  return NULL;
5424  }
5425  else
5426  {
5427  return result;
5428  }
5429  }
5430 
5431 
5445  ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
5446  OrthancPluginContext* context,
5447  const OrthancPluginFindQuery* query,
5448  uint32_t index)
5449  {
5450  char* result;
5451 
5452  _OrthancPluginFindOperation params;
5453  memset(&params, 0, sizeof(params));
5454  params.query = query;
5455  params.index = index;
5456  params.resultString = &result;
5457 
5458  if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
5459  {
5460  /* Error */
5461  return NULL;
5462  }
5463  else
5464  {
5465  return result;
5466  }
5467  }
5468 
5469 
5470 
5471 
5472  typedef struct
5473  {
5474  OrthancPluginMoveCallback callback;
5475  OrthancPluginGetMoveSize getMoveSize;
5476  OrthancPluginApplyMove applyMove;
5477  OrthancPluginFreeMove freeMove;
5478  } _OrthancPluginMoveCallback;
5479 
5494  OrthancPluginContext* context,
5495  OrthancPluginMoveCallback callback,
5496  OrthancPluginGetMoveSize getMoveSize,
5497  OrthancPluginApplyMove applyMove,
5498  OrthancPluginFreeMove freeMove)
5499  {
5500  _OrthancPluginMoveCallback params;
5501  params.callback = callback;
5502  params.getMoveSize = getMoveSize;
5503  params.applyMove = applyMove;
5504  params.freeMove = freeMove;
5505 
5506  return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
5507  }
5508 
5509 
5510 
5511  typedef struct
5512  {
5513  OrthancPluginFindMatcher** target;
5514  const void* query;
5515  uint32_t size;
5516  } _OrthancPluginCreateFindMatcher;
5517 
5518 
5533  OrthancPluginContext* context,
5534  const void* query,
5535  uint32_t size)
5536  {
5537  OrthancPluginFindMatcher* target = NULL;
5538 
5539  _OrthancPluginCreateFindMatcher params;
5540  memset(&params, 0, sizeof(params));
5541  params.target = &target;
5542  params.query = query;
5543  params.size = size;
5544 
5545  if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
5546  {
5547  return NULL;
5548  }
5549  else
5550  {
5551  return target;
5552  }
5553  }
5554 
5555 
5556  typedef struct
5557  {
5558  OrthancPluginFindMatcher* matcher;
5559  } _OrthancPluginFreeFindMatcher;
5560 
5570  ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
5571  OrthancPluginContext* context,
5572  OrthancPluginFindMatcher* matcher)
5573  {
5574  _OrthancPluginFreeFindMatcher params;
5575  params.matcher = matcher;
5576 
5577  context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
5578  }
5579 
5580 
5581  typedef struct
5582  {
5583  const OrthancPluginFindMatcher* matcher;
5584  const void* dicom;
5585  uint32_t size;
5586  int32_t* isMatch;
5587  } _OrthancPluginFindMatcherIsMatch;
5588 
5603  ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
5604  OrthancPluginContext* context,
5605  const OrthancPluginFindMatcher* matcher,
5606  const void* dicom,
5607  uint32_t size)
5608  {
5609  int32_t isMatch = 0;
5610 
5611  _OrthancPluginFindMatcherIsMatch params;
5612  params.matcher = matcher;
5613  params.dicom = dicom;
5614  params.size = size;
5615  params.isMatch = &isMatch;
5616 
5617  if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
5618  {
5619  return isMatch;
5620  }
5621  else
5622  {
5623  /* Error: Assume non-match */
5624  return 0;
5625  }
5626  }
5627 
5628 
5629  typedef struct
5630  {
5632  } _OrthancPluginIncomingHttpRequestFilter2;
5633 
5646  OrthancPluginContext* context,
5648  {
5649  _OrthancPluginIncomingHttpRequestFilter2 params;
5650  params.callback = callback;
5651 
5652  return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
5653  }
5654 
5655 #ifdef __cplusplus
5656 }
5657 #endif
5658 
5659 
Definition: OrthancCPlugin.h:698
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2276
Definition: OrthancCPlugin.h:799
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:2455
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:896
OrthancPluginChangeType
Definition: OrthancCPlugin.h:655
Definition: OrthancCPlugin.h:234
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2139
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:849
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2240
Definition: OrthancCPlugin.h:721
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1215
Definition: OrthancCPlugin.h:268
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:1417
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:4746
Definition: OrthancCPlugin.h:800
The parameters of a REST request.
Definition: OrthancCPlugin.h:327
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:1922
OrthancPluginContentType
Definition: OrthancCPlugin.h:624
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:1827
Definition: OrthancCPlugin.h:641
Definition: OrthancCPlugin.h:720
Definition: OrthancCPlugin.h:815
const char * OrthancPluginGetInstanceData(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:2342
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:3524
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:3616
int32_t(* OrthancPluginIncomingHttpRequestFilter2)(OrthancPluginHttpMethod method, const char *uri, const char *ip, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, uint32_t getArgumentsCount, const char *const *getArgumentsKeys, const char *const *getArgumentsValues)
Callback to filter incoming HTTP requests received by Orthanc.
Definition: OrthancCPlugin.h:1094
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1280
Definition: OrthancCPlugin.h:260
Definition: OrthancCPlugin.h:204
Definition: OrthancCPlugin.h:258
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:810
OrthancPluginErrorCode OrthancPluginWorklistAddAnswer(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Add one answer to some modality worklist request.
Definition: OrthancCPlugin.h:4531
Definition: OrthancCPlugin.h:718
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:4495
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2309
OrthancPluginErrorCode OrthancPluginRegisterPrivateDictionaryTag(OrthancPluginContext *context, uint16_t group, uint16_t element, OrthancPluginValueRepresentation vr, const char *name, uint32_t minMultiplicity, uint32_t maxMultiplicity, const char *privateCreator)
Register a new private tag into the DICOM dictionary.
Definition: OrthancCPlugin.h:4260
Definition: OrthancCPlugin.h:283
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:556
Definition: OrthancCPlugin.h:670
Definition: OrthancCPlugin.h:226
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:387
Definition: OrthancCPlugin.h:270
Definition: OrthancCPlugin.h:272
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:382
Definition: OrthancCPlugin.h:256
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:782
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:4954
Definition: OrthancCPlugin.h:274
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:540
Definition: OrthancCPlugin.h:816
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:347
Definition: OrthancCPlugin.h:582
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:2541
OrthancPluginErrorCode(* OrthancPluginWorklistCallback)(OrthancPluginWorklistAnswers *answers, const OrthancPluginWorklistQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle the C-Find SCP requests for worklists.
Definition: OrthancCPlugin.h:1036
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:1640
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:695
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:4638
Definition: OrthancCPlugin.h:212
Definition: OrthancCPlugin.h:296
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1256
Definition: OrthancCPlugin.h:280
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:3896
Definition: OrthancCPlugin.h:232
Definition: OrthancCPlugin.h:286
Definition: OrthancCPlugin.h:278
Definition: OrthancCPlugin.h:315
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:963
Definition: OrthancCPlugin.h:223
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:4918
Definition: OrthancCPlugin.h:225
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:198
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:3821
Definition: OrthancCPlugin.h:281
Definition: OrthancCPlugin.h:664
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4075
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:3856
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:2638
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1188
Definition: OrthancCPlugin.h:221
OrthancPluginErrorCode OrthancPluginHttpClient(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, OrthancPluginHttpMethod method, const char *url, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, const char *body, uint32_t bodySize, const char *username, const char *password, uint32_t timeout, const char *certificateFile, const char *certificateKeyFile, const char *certificateKeyPassword, uint8_t pkcs11)
Issue a HTTP call with full flexibility.
Definition: OrthancCPlugin.h:5153
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:2680
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:580
Definition: OrthancCPlugin.h:766
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:763
Definition: OrthancCPlugin.h:214
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2185
Definition: OrthancCPlugin.h:682
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5208
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:1542
Definition: OrthancCPlugin.h:658
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:4872
Definition: OrthancCPlugin.h:257
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:748
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5000
Definition: OrthancCPlugin.h:750
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4151
Definition: OrthancCPlugin.h:238
uint16_t group
Definition: OrthancCPlugin.h:1239
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:3394
Definition: OrthancCPlugin.h:711
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1242
Definition: OrthancCPlugin.h:752
Definition: OrthancCPlugin.h:723
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:2493
Definition: OrthancCPlugin.h:697
Definition: OrthancCPlugin.h:250
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:872
Definition: OrthancCPlugin.h:242
Definition: OrthancCPlugin.h:626
OrthancPluginErrorCode OrthancPluginGetFindQueryTag(OrthancPluginContext *context, uint16_t *group, uint16_t *element, const OrthancPluginFindQuery *query, uint32_t index)
Get one tag in a C-Find query.
Definition: OrthancCPlugin.h:5376
Definition: OrthancCPlugin.h:662
Color image in RGB48 format.
Definition: OrthancCPlugin.h:590
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:1888
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:2926
Definition: OrthancCPlugin.h:273
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:548
Definition: OrthancCPlugin.h:271
Definition: OrthancCPlugin.h:215
OrthancPluginResourceType
Definition: OrthancCPlugin.h:638
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:312
Definition: OrthancCPlugin.h:231
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:3325
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:709
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:2959
Definition: OrthancCPlugin.h:202
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:3223
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:3437
Definition: OrthancCPlugin.h:276
Definition: OrthancCPlugin.h:713
Definition: OrthancCPlugin.h:218
Definition: OrthancCPlugin.h:643
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:920
Definition: OrthancCPlugin.h:267
Definition: OrthancCPlugin.h:683
Definition: OrthancCPlugin.h:716
Definition: OrthancCPlugin.h:284
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:2603
Definition: OrthancCPlugin.h:236
Definition: OrthancCPlugin.h:685
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5286
Definition: OrthancCPlugin.h:735
Definition: OrthancCPlugin.h:259
Color image in RGB24 format.
Definition: OrthancCPlugin.h:572
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5645
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:4561
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:564
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1237
Definition: OrthancCPlugin.h:269
Definition: OrthancCPlugin.h:208
Definition: OrthancCPlugin.h:657
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:680
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:3746
Definition: OrthancCPlugin.h:200
OrthancPluginErrorCode OrthancPluginRestApiGet2(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, int32_t afterPlugins)
Make a GET call to the Orthanc REST API, with custom HTTP headers.
Definition: OrthancCPlugin.h:4457
Definition: OrthancCPlugin.h:769
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3259
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:3981
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:3360
Definition: OrthancCPlugin.h:627
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:1599
Definition: OrthancCPlugin.h:289
Definition: OrthancCPlugin.h:295
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:888
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1243
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5247
Definition: OrthancCPlugin.h:288
OrthancPluginErrorCode(* OrthancPluginDecodeImageCallback)(OrthancPluginImage **target, const void *dicom, const uint32_t size, uint32_t frameIndex)
Signature of a callback function to decode a DICOM instance as an image.
Definition: OrthancCPlugin.h:952
char * OrthancPluginDicomBufferToJson(OrthancPluginContext *context, const void *buffer, uint32_t size, OrthancPluginDicomToJsonFormat format, OrthancPluginDicomToJsonFlags flags, uint32_t maxStringLength)
Format a DICOM memory buffer as a JSON string.
Definition: OrthancCPlugin.h:4350
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:2859
Definition: OrthancCPlugin.h:240
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2162
Definition: OrthancCPlugin.h:210
Definition: OrthancCPlugin.h:265
Definition: OrthancCPlugin.h:253
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:5570
Definition: OrthancCPlugin.h:285
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:1385
Definition: OrthancCPlugin.h:229
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:880
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:5532
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:834
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:3928
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:2755
Definition: OrthancCPlugin.h:814
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1673
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3170
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1121
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:377
int32_t(* OrthancPluginIncomingHttpRequestFilter)(OrthancPluginHttpMethod method, const char *uri, const char *ip, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues)
Callback to filter incoming HTTP requests received by Orthanc.
Definition: OrthancCPlugin.h:1063
Definition: OrthancCPlugin.h:663
Definition: OrthancCPlugin.h:768
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:1369
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:979
Definition: OrthancCPlugin.h:729
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:1804
Definition: OrthancCPlugin.h:733
Definition: OrthancCPlugin.h:642
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3108
Definition: OrthancCPlugin.h:722
Definition: OrthancCPlugin.h:801
Definition: OrthancCPlugin.h:316
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:4784
char * OrthancPluginGetFindQueryTagName(OrthancPluginContext *context, const OrthancPluginFindQuery *query, uint32_t index)
Get the symbolic name of one tag in a C-Find query.
Definition: OrthancCPlugin.h:5407
Definition: OrthancCPlugin.h:724
Definition: OrthancCPlugin.h:245
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:2573
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:2789
OrthancPluginErrorCode OrthancPluginSendMultipartItem2(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *answer, uint32_t answerSize, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues)
Send an item as a part of some HTTP multipart answer, with custom headers.
Definition: OrthancCPlugin.h:5043
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1017
Definition: OrthancCPlugin.h:751
Definition: OrthancCPlugin.h:254
Definition: OrthancCPlugin.h:292
Definition: OrthancCPlugin.h:314
Definition: OrthancCPlugin.h:665
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4306
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:2893
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:3668
OrthancPluginImage * OrthancPluginCreateImageAccessor(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height, uint32_t pitch, void *buffer)
Create an image pointing to a memory buffer.
Definition: OrthancCPlugin.h:4827
Definition: OrthancCPlugin.h:262
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5081
Definition: OrthancCPlugin.h:222
char * OrthancPluginDicomInstanceToJson(OrthancPluginContext *context, const char *instanceId, OrthancPluginDicomToJsonFormat format, OrthancPluginDicomToJsonFlags flags, uint32_t maxStringLength)
Format a DICOM instance as a JSON string.
Definition: OrthancCPlugin.h:4399
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:357
Definition: OrthancCPlugin.h:736
OrthancPluginErrorCode(* OrthancPluginOnChangeCallback)(OrthancPluginChangeType changeType, OrthancPluginResourceType resourceType, const char *resourceId)
Signature of a callback function that is triggered when a change happens to some DICOM resource...
Definition: OrthancCPlugin.h:941
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:2416
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:3071
Definition: OrthancCPlugin.h:255
OrthancPluginErrorCode OrthancPluginCreateDicom(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *json, const OrthancPluginImage *pixelData, OrthancPluginCreateDicomFlags flags)
Create a DICOM instance from a JSON string and an image.
Definition: OrthancCPlugin.h:4713
Definition: OrthancCPlugin.h:248
Definition: OrthancCPlugin.h:699
Definition: OrthancCPlugin.h:209
const char * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:362
Definition: OrthancCPlugin.h:261
Definition: OrthancCPlugin.h:216
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:1482
void *(* OrthancPluginMoveCallback)(OrthancPluginResourceType resourceType, const char *patientId, const char *accessionNumber, const char *studyInstanceUid, const char *seriesInstanceUid, const char *sopInstanceUid, const char *originatorAet, const char *sourceAet, const char *targetAet, uint16_t originatorId)
Callback to handle incoming C-Move SCP requests.
Definition: OrthancCPlugin.h:1164
Definition: OrthancCPlugin.h:668
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:864
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:1852
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3000
Definition: OrthancCPlugin.h:201
Definition: OrthancCPlugin.h:227
Definition: OrthancCPlugin.h:220
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:904
Definition: OrthancCPlugin.h:798
Definition: OrthancCPlugin.h:293
Definition: OrthancCPlugin.h:264
char * OrthancPluginGetFindQueryValue(OrthancPluginContext *context, const OrthancPluginFindQuery *query, uint32_t index)
Get the value associated with one tag in a C-Find query.
Definition: OrthancCPlugin.h:5445
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:2711
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4112
Definition: OrthancCPlugin.h:728
Definition: OrthancCPlugin.h:669
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:352
Definition: OrthancCPlugin.h:731
Definition: OrthancCPlugin.h:660
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:1954
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:4664
Definition: OrthancCPlugin.h:732
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:3479
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1241
uint16_t element
Definition: OrthancCPlugin.h:1240
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2094
Definition: OrthancCPlugin.h:667
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:2828
Definition: OrthancCPlugin.h:233
Definition: OrthancCPlugin.h:628
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:3029
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:342
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3139
Definition: OrthancCPlugin.h:263
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:999
Definition: OrthancCPlugin.h:266
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:1989
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:839
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:606
Definition: OrthancCPlugin.h:812
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:5493
Definition: OrthancCPlugin.h:246
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance received by Orthanc.
Definition: OrthancCPlugin.h:856
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:337
Definition: OrthancCPlugin.h:247
Definition: OrthancCPlugin.h:644
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:1401
Definition: OrthancCPlugin.h:717
Definition: OrthancCPlugin.h:252
Definition: OrthancCPlugin.h:737
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:796
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:367
Definition: OrthancCPlugin.h:317
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2215
Definition: OrthancCPlugin.h:659
Definition: OrthancCPlugin.h:727
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:2378
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:2733
Definition: OrthancCPlugin.h:294
Definition: OrthancCPlugin.h:235
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:1740
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:1510
Definition: OrthancCPlugin.h:661
Definition: OrthancCPlugin.h:730
OrthancPluginErrorCode OrthancPluginRegisterDictionaryTag(OrthancPluginContext *context, uint16_t group, uint16_t element, OrthancPluginValueRepresentation vr, const char *name, uint32_t minMultiplicity, uint32_t maxMultiplicity)
Register a new tag into the DICOM dictionary.
Definition: OrthancCPlugin.h:4207
Definition: OrthancCPlugin.h:249
Definition: OrthancCPlugin.h:213
Definition: OrthancCPlugin.h:734
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:3705
Definition: OrthancCPlugin.h:714
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:5315
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:598
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:1448
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2024
Definition: OrthancCPlugin.h:726
Definition: OrthancCPlugin.h:712
Definition: OrthancCPlugin.h:205
Definition: OrthancCPlugin.h:640
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:1703
Definition: OrthancCPlugin.h:813
Definition: OrthancCPlugin.h:224
OrthancPluginErrorCode(* OrthancPluginOnStoredInstanceCallback)(OrthancPluginDicomInstance *instance, const char *instanceId)
Signature of a callback function that is triggered when Orthanc receives a DICOM instance.
Definition: OrthancCPlugin.h:931
Definition: OrthancCPlugin.h:287
Definition: OrthancCPlugin.h:206
Definition: OrthancCPlugin.h:211
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:1775
Definition: OrthancCPlugin.h:203
Definition: OrthancCPlugin.h:228
Definition: OrthancCPlugin.h:666
Definition: OrthancCPlugin.h:684
Definition: OrthancCPlugin.h:239
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1202
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:332
Definition: OrthancCPlugin.h:282
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:4033
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:3783
A memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:829
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:5339
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:614
Definition: OrthancCPlugin.h:719
Definition: OrthancCPlugin.h:767
Definition: OrthancCPlugin.h:217
int32_t OrthancPluginFindMatcherIsMatch(OrthancPluginContext *context, const OrthancPluginFindMatcher *matcher, const void *dicom, uint32_t size)
Test whether a DICOM instance matches a C-Find query.
Definition: OrthancCPlugin.h:5603
Definition: OrthancCPlugin.h:725
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2059
Definition: OrthancCPlugin.h:207
Definition: OrthancCPlugin.h:715
Definition: OrthancCPlugin.h:275
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:4599
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3292
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:3569
struct _OrthancPluginFindAnswers_t OrthancPluginFindMatcher
Opaque structure to an object that can be used to check whether a DICOM instance matches a C-Find que...
Definition: OrthancCPlugin.h:912
Definition: OrthancCPlugin.h:237
Definition: OrthancCPlugin.h:230