Orthanc Plugin SDK 1.12.0
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#elif __GNUC__ >= 4
116# define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default")))
117#else
118# define ORTHANC_PLUGINS_API
119#endif
120
121#define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
122#define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 12
123#define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 0
124
125
126#if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
127#define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
128 (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
129 (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
130 (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
131 (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
132 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
133#endif
134
135
136
137/********************************************************************
138 ** Check that function inlining is properly supported. The use of
139 ** inlining is required, to avoid the duplication of object code
140 ** between two compilation modules that would use the Orthanc Plugin
141 ** API.
142 ********************************************************************/
143
144/* If the auto-detection of the "inline" keyword below does not work
145 automatically and that your compiler is known to properly support
146 inlining, uncomment the following #define and adapt the definition
147 of "static inline". */
148
149/* #define ORTHANC_PLUGIN_INLINE static inline */
150
151#ifndef ORTHANC_PLUGIN_INLINE
152# if __STDC_VERSION__ >= 199901L
153/* This is C99 or above: http://predef.sourceforge.net/prestd.html */
154# define ORTHANC_PLUGIN_INLINE static inline
155# elif defined(__cplusplus)
156/* This is C++ */
157# define ORTHANC_PLUGIN_INLINE static inline
158# elif defined(__GNUC__)
159/* This is GCC running in C89 mode */
160# define ORTHANC_PLUGIN_INLINE static __inline
161# elif defined(_MSC_VER)
162/* This is Visual Studio running in C89 mode */
163# define ORTHANC_PLUGIN_INLINE static __inline
164# else
165# error Your compiler is not known to support the "inline" keyword
166# endif
167#endif
168
169
170
171/********************************************************************
172 ** Inclusion of standard libraries.
173 ********************************************************************/
174
180#include <stdint.h>
181
182#include <stdlib.h>
183
184
185
186/********************************************************************
187 ** Definition of the Orthanc Plugin API.
188 ********************************************************************/
189
192#ifdef __cplusplus
193extern "C"
194{
195#endif
196
200 typedef enum
201 {
310
311 _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
313
314
319 ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
320
321
325 typedef enum
326 {
332 _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
334
335
340 typedef struct
341 {
346
350 uint32_t groupsCount;
351
355 const char* const* groups;
356
360 uint32_t getCount;
361
365 const char* const* getKeys;
366
370 const char* const* getValues;
371
375 const void* body;
376
380 uint32_t bodySize;
381
382
383 /* --------------------------------------------------
384 New in version 0.8.1
385 -------------------------------------------------- */
386
390 uint32_t headersCount;
391
395 const char* const* headersKeys;
396
400 const char* const* headersValues;
401
403
404
405 typedef enum
406 {
407 /* Generic services */
408 _OrthancPluginService_LogInfo = 1,
409 _OrthancPluginService_LogWarning = 2,
410 _OrthancPluginService_LogError = 3,
411 _OrthancPluginService_GetOrthancPath = 4,
412 _OrthancPluginService_GetOrthancDirectory = 5,
413 _OrthancPluginService_GetConfigurationPath = 6,
414 _OrthancPluginService_SetPluginProperty = 7,
415 _OrthancPluginService_GetGlobalProperty = 8,
416 _OrthancPluginService_SetGlobalProperty = 9,
417 _OrthancPluginService_GetCommandLineArgumentsCount = 10,
418 _OrthancPluginService_GetCommandLineArgument = 11,
419 _OrthancPluginService_GetExpectedDatabaseVersion = 12,
420 _OrthancPluginService_GetConfiguration = 13,
421 _OrthancPluginService_BufferCompression = 14,
422 _OrthancPluginService_ReadFile = 15,
423 _OrthancPluginService_WriteFile = 16,
424 _OrthancPluginService_GetErrorDescription = 17,
425 _OrthancPluginService_CallHttpClient = 18,
426 _OrthancPluginService_RegisterErrorCode = 19,
427 _OrthancPluginService_RegisterDictionaryTag = 20,
428 _OrthancPluginService_DicomBufferToJson = 21,
429 _OrthancPluginService_DicomInstanceToJson = 22,
430 _OrthancPluginService_CreateDicom = 23,
431 _OrthancPluginService_ComputeMd5 = 24,
432 _OrthancPluginService_ComputeSha1 = 25,
433 _OrthancPluginService_LookupDictionary = 26,
434 _OrthancPluginService_CallHttpClient2 = 27,
435 _OrthancPluginService_GenerateUuid = 28,
436 _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
437 _OrthancPluginService_AutodetectMimeType = 30,
438 _OrthancPluginService_SetMetricsValue = 31,
439 _OrthancPluginService_EncodeDicomWebJson = 32,
440 _OrthancPluginService_EncodeDicomWebXml = 33,
441 _OrthancPluginService_ChunkedHttpClient = 34, /* New in Orthanc 1.5.7 */
442 _OrthancPluginService_GetTagName = 35, /* New in Orthanc 1.5.7 */
443 _OrthancPluginService_EncodeDicomWebJson2 = 36, /* New in Orthanc 1.7.0 */
444 _OrthancPluginService_EncodeDicomWebXml2 = 37, /* New in Orthanc 1.7.0 */
445 _OrthancPluginService_CreateMemoryBuffer = 38, /* New in Orthanc 1.7.0 */
446 _OrthancPluginService_GenerateRestApiAuthorizationToken = 39, /* New in Orthanc 1.8.1 */
447 _OrthancPluginService_CreateMemoryBuffer64 = 40, /* New in Orthanc 1.9.0 */
448 _OrthancPluginService_CreateDicom2 = 41, /* New in Orthanc 1.9.0 */
449 _OrthancPluginService_GetDatabaseServerIdentifier = 42, /* New in Orthanc 1.11.1 */
450
451 /* Registration of callbacks */
452 _OrthancPluginService_RegisterRestCallback = 1000,
453 _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
454 _OrthancPluginService_RegisterStorageArea = 1002,
455 _OrthancPluginService_RegisterOnChangeCallback = 1003,
456 _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
457 _OrthancPluginService_RegisterWorklistCallback = 1005,
458 _OrthancPluginService_RegisterDecodeImageCallback = 1006,
459 _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
460 _OrthancPluginService_RegisterFindCallback = 1008,
461 _OrthancPluginService_RegisterMoveCallback = 1009,
462 _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
463 _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
464 _OrthancPluginService_RegisterChunkedRestCallback = 1012, /* New in Orthanc 1.5.7 */
465 _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
466 _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
467 _OrthancPluginService_RegisterTranscoderCallback = 1015, /* New in Orthanc 1.7.0 */
468 _OrthancPluginService_RegisterStorageArea2 = 1016, /* New in Orthanc 1.9.0 */
469 _OrthancPluginService_RegisterIncomingCStoreInstanceFilter = 1017, /* New in Orthanc 1.10.0 */
470 _OrthancPluginService_RegisterReceivedInstanceCallback = 1018, /* New in Orthanc 1.10.0 */
471 _OrthancPluginService_RegisterWebDavCollection = 1019, /* New in Orthanc 1.10.1 */
472
473 /* Sending answers to REST calls */
474 _OrthancPluginService_AnswerBuffer = 2000,
475 _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
476 _OrthancPluginService_Redirect = 2002,
477 _OrthancPluginService_SendHttpStatusCode = 2003,
478 _OrthancPluginService_SendUnauthorized = 2004,
479 _OrthancPluginService_SendMethodNotAllowed = 2005,
480 _OrthancPluginService_SetCookie = 2006,
481 _OrthancPluginService_SetHttpHeader = 2007,
482 _OrthancPluginService_StartMultipartAnswer = 2008,
483 _OrthancPluginService_SendMultipartItem = 2009,
484 _OrthancPluginService_SendHttpStatus = 2010,
485 _OrthancPluginService_CompressAndAnswerImage = 2011,
486 _OrthancPluginService_SendMultipartItem2 = 2012,
487 _OrthancPluginService_SetHttpErrorDetails = 2013,
488
489 /* Access to the Orthanc database and API */
490 _OrthancPluginService_GetDicomForInstance = 3000,
491 _OrthancPluginService_RestApiGet = 3001,
492 _OrthancPluginService_RestApiPost = 3002,
493 _OrthancPluginService_RestApiDelete = 3003,
494 _OrthancPluginService_RestApiPut = 3004,
495 _OrthancPluginService_LookupPatient = 3005,
496 _OrthancPluginService_LookupStudy = 3006,
497 _OrthancPluginService_LookupSeries = 3007,
498 _OrthancPluginService_LookupInstance = 3008,
499 _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
500 _OrthancPluginService_RestApiGetAfterPlugins = 3010,
501 _OrthancPluginService_RestApiPostAfterPlugins = 3011,
502 _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
503 _OrthancPluginService_RestApiPutAfterPlugins = 3013,
504 _OrthancPluginService_ReconstructMainDicomTags = 3014,
505 _OrthancPluginService_RestApiGet2 = 3015,
506 _OrthancPluginService_CallRestApi = 3016, /* New in Orthanc 1.9.2 */
507
508 /* Access to DICOM instances */
509 _OrthancPluginService_GetInstanceRemoteAet = 4000,
510 _OrthancPluginService_GetInstanceSize = 4001,
511 _OrthancPluginService_GetInstanceData = 4002,
512 _OrthancPluginService_GetInstanceJson = 4003,
513 _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
514 _OrthancPluginService_HasInstanceMetadata = 4005,
515 _OrthancPluginService_GetInstanceMetadata = 4006,
516 _OrthancPluginService_GetInstanceOrigin = 4007,
517 _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
518 _OrthancPluginService_HasInstancePixelData = 4009,
519 _OrthancPluginService_CreateDicomInstance = 4010, /* New in Orthanc 1.7.0 */
520 _OrthancPluginService_FreeDicomInstance = 4011, /* New in Orthanc 1.7.0 */
521 _OrthancPluginService_GetInstanceFramesCount = 4012, /* New in Orthanc 1.7.0 */
522 _OrthancPluginService_GetInstanceRawFrame = 4013, /* New in Orthanc 1.7.0 */
523 _OrthancPluginService_GetInstanceDecodedFrame = 4014, /* New in Orthanc 1.7.0 */
524 _OrthancPluginService_TranscodeDicomInstance = 4015, /* New in Orthanc 1.7.0 */
525 _OrthancPluginService_SerializeDicomInstance = 4016, /* New in Orthanc 1.7.0 */
526 _OrthancPluginService_GetInstanceAdvancedJson = 4017, /* New in Orthanc 1.7.0 */
527 _OrthancPluginService_GetInstanceDicomWebJson = 4018, /* New in Orthanc 1.7.0 */
528 _OrthancPluginService_GetInstanceDicomWebXml = 4019, /* New in Orthanc 1.7.0 */
529
530 /* Services for plugins implementing a database back-end */
531 _OrthancPluginService_RegisterDatabaseBackend = 5000, /* New in Orthanc 0.8.6 */
532 _OrthancPluginService_DatabaseAnswer = 5001,
533 _OrthancPluginService_RegisterDatabaseBackendV2 = 5002, /* New in Orthanc 0.9.4 */
534 _OrthancPluginService_StorageAreaCreate = 5003,
535 _OrthancPluginService_StorageAreaRead = 5004,
536 _OrthancPluginService_StorageAreaRemove = 5005,
537 _OrthancPluginService_RegisterDatabaseBackendV3 = 5006, /* New in Orthanc 1.9.2 */
538 _OrthancPluginService_RegisterDatabaseBackendV4 = 5007, /* New in Orthanc 1.12.0 */
539
540 /* Primitives for handling images */
541 _OrthancPluginService_GetImagePixelFormat = 6000,
542 _OrthancPluginService_GetImageWidth = 6001,
543 _OrthancPluginService_GetImageHeight = 6002,
544 _OrthancPluginService_GetImagePitch = 6003,
545 _OrthancPluginService_GetImageBuffer = 6004,
546 _OrthancPluginService_UncompressImage = 6005,
547 _OrthancPluginService_FreeImage = 6006,
548 _OrthancPluginService_CompressImage = 6007,
549 _OrthancPluginService_ConvertPixelFormat = 6008,
550 _OrthancPluginService_GetFontsCount = 6009,
551 _OrthancPluginService_GetFontInfo = 6010,
552 _OrthancPluginService_DrawText = 6011,
553 _OrthancPluginService_CreateImage = 6012,
554 _OrthancPluginService_CreateImageAccessor = 6013,
555 _OrthancPluginService_DecodeDicomImage = 6014,
556
557 /* Primitives for handling C-Find, C-Move and worklists */
558 _OrthancPluginService_WorklistAddAnswer = 7000,
559 _OrthancPluginService_WorklistMarkIncomplete = 7001,
560 _OrthancPluginService_WorklistIsMatch = 7002,
561 _OrthancPluginService_WorklistGetDicomQuery = 7003,
562 _OrthancPluginService_FindAddAnswer = 7004,
563 _OrthancPluginService_FindMarkIncomplete = 7005,
564 _OrthancPluginService_GetFindQuerySize = 7006,
565 _OrthancPluginService_GetFindQueryTag = 7007,
566 _OrthancPluginService_GetFindQueryTagName = 7008,
567 _OrthancPluginService_GetFindQueryValue = 7009,
568 _OrthancPluginService_CreateFindMatcher = 7010,
569 _OrthancPluginService_FreeFindMatcher = 7011,
570 _OrthancPluginService_FindMatcherIsMatch = 7012,
571
572 /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
573 _OrthancPluginService_GetPeers = 8000,
574 _OrthancPluginService_FreePeers = 8001,
575 _OrthancPluginService_GetPeersCount = 8003,
576 _OrthancPluginService_GetPeerName = 8004,
577 _OrthancPluginService_GetPeerUrl = 8005,
578 _OrthancPluginService_CallPeerApi = 8006,
579 _OrthancPluginService_GetPeerUserProperty = 8007,
580
581 /* Primitives for handling jobs (new in 1.4.2) */
582 _OrthancPluginService_CreateJob = 9000, /* Deprecated since SDK 1.11.3 */
583 _OrthancPluginService_FreeJob = 9001,
584 _OrthancPluginService_SubmitJob = 9002,
585 _OrthancPluginService_RegisterJobsUnserializer = 9003,
586 _OrthancPluginService_CreateJob2 = 9004, /* New in SDK 1.11.3 */
587
588 _OrthancPluginService_INTERNAL = 0x7fffffff
589 } _OrthancPluginService;
590
591
592 typedef enum
593 {
594 _OrthancPluginProperty_Description = 1,
595 _OrthancPluginProperty_RootUri = 2,
596 _OrthancPluginProperty_OrthancExplorer = 3,
597
598 _OrthancPluginProperty_INTERNAL = 0x7fffffff
599 } _OrthancPluginProperty;
600
601
602
607 typedef enum
608 {
616
624
632
640
648
658
666
674
682
690
691 _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
693
694
695
699 typedef enum
700 {
706 _OrthancPluginContentType_INTERNAL = 0x7fffffff
708
709
710
714 typedef enum
715 {
722 _OrthancPluginResourceType_INTERNAL = 0x7fffffff
724
725
726
731 typedef enum
732 {
753 _OrthancPluginChangeType_INTERNAL = 0x7fffffff
755
756
761 typedef enum
762 {
768 _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
770
771
776 typedef enum
777 {
782 _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
784
785
790 typedef enum
791 {
820 _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
822
823
829 typedef enum
830 {
835 _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
837
838
844 typedef enum
845 {
846 OrthancPluginDicomToJsonFlags_None = 0,
856 _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
858
859
865 typedef enum
866 {
867 OrthancPluginCreateDicomFlags_None = 0,
871 _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
873
874
880 typedef enum
881 {
887 _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
889
890
895 typedef enum
896 {
903 _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
905
906
910 typedef enum
911 {
919 _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
921
922
926 typedef enum
927 {
932
933
940 typedef enum
941 {
947
948
952 typedef enum
953 {
963
964
969 typedef enum
970 {
975
976
982 typedef enum
983 {
1011
1012
1016 typedef enum
1017 {
1022 _OrthancPluginReceivedInstanceAction_INTERNAL = 0x7fffffff
1024
1025
1033 typedef struct
1034 {
1038 void* data;
1039
1043 uint32_t size;
1045
1046
1047
1055 typedef struct
1056 {
1060 void* data;
1061
1065 uint64_t size;
1067
1068
1069
1070
1075 typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
1076
1077
1078
1083 typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
1084
1085
1086
1091 typedef struct _OrthancPluginImage_t OrthancPluginImage;
1092
1093
1094
1099 typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
1100
1101
1102
1107 typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
1108
1109
1110
1115 typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
1116
1117
1118
1123 typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1124
1125
1126
1131 typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1132
1133
1134
1139 typedef struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher;
1140
1141
1142
1147 typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1148
1149
1150
1155 typedef struct _OrthancPluginJob_t OrthancPluginJob;
1156
1157
1158
1164 typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1165
1166
1167
1174 const char* url,
1175 const OrthancPluginHttpRequest* request);
1176
1177
1178
1184 const OrthancPluginDicomInstance* instance,
1185 const char* instanceId);
1186
1187
1188
1194 OrthancPluginChangeType changeType,
1195 OrthancPluginResourceType resourceType,
1196 const char* resourceId);
1197
1198
1199
1205 OrthancPluginImage** target,
1206 const void* dicom,
1207 const uint32_t size,
1208 uint32_t frameIndex);
1209
1210
1211
1216 typedef void (*OrthancPluginFree) (void* buffer);
1217
1218
1219
1229 const char* bulkDataUri);
1230
1231
1232
1246 const char* uuid,
1247 const void* content,
1248 int64_t size,
1250
1251
1252
1273 void** content,
1274 int64_t* size,
1275 const char* uuid,
1277
1278
1279
1294 const char* uuid,
1296
1297
1298
1317 const char* uuid,
1319 uint64_t rangeStart);
1320
1321
1322
1334 const char* uuid,
1336
1337
1338
1354 const OrthancPluginWorklistQuery* query,
1355 const char* issuerAet,
1356 const char* calledAet);
1357
1358
1359
1385 const char* uri,
1386 const char* ip,
1387 uint32_t headersCount,
1388 const char* const* headersKeys,
1389 const char* const* headersValues);
1390
1391
1392
1420 const char* uri,
1421 const char* ip,
1422 uint32_t headersCount,
1423 const char* const* headersKeys,
1424 const char* const* headersValues,
1425 uint32_t getArgumentsCount,
1426 const char* const* getArgumentsKeys,
1427 const char* const* getArgumentsValues);
1428
1429
1430
1446 OrthancPluginFindAnswers* answers,
1447 const OrthancPluginFindQuery* query,
1448 const char* issuerAet,
1449 const char* calledAet);
1450
1451
1452
1488 typedef void* (*OrthancPluginMoveCallback) (
1489 OrthancPluginResourceType resourceType,
1490 const char* patientId,
1491 const char* accessionNumber,
1492 const char* studyInstanceUid,
1493 const char* seriesInstanceUid,
1494 const char* sopInstanceUid,
1495 const char* originatorAet,
1496 const char* sourceAet,
1497 const char* targetAet,
1498 uint16_t originatorId);
1499
1500
1513 typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1514
1515
1528 typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1529
1530
1542 typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1543
1544
1555 typedef void (*OrthancPluginJobFinalize) (void* job);
1556
1557
1568 typedef float (*OrthancPluginJobGetProgress) (void* job);
1569
1570
1584 typedef const char* (*OrthancPluginJobGetContent) (void* job);
1585
1586
1603 void* job);
1604
1605
1622 typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1623
1624
1643 void* job);
1644
1645
1659
1660
1684
1685
1700
1701
1715 typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1716 const char* serialized);
1717
1718
1719
1734
1735
1736
1764 uint32_t levelDepth,
1765 const uint16_t* levelTagGroup,
1766 const uint16_t* levelTagElement,
1767 const uint32_t* levelIndex,
1768 uint16_t tagGroup,
1769 uint16_t tagElement,
1771
1772
1773
1802 uint32_t levelDepth,
1803 const uint16_t* levelTagGroup,
1804 const uint16_t* levelTagElement,
1805 const uint32_t* levelIndex,
1806 uint16_t tagGroup,
1807 uint16_t tagElement,
1809 void* payload);
1810
1811
1812
1816 typedef struct _OrthancPluginContext_t
1817 {
1818 void* pluginsManager;
1819 const char* orthancVersion;
1820 OrthancPluginFree Free;
1821 OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1822 _OrthancPluginService service,
1823 const void* params);
1825
1826
1827
1831 typedef struct
1832 {
1833 uint16_t group;
1834 uint16_t element;
1839
1840
1841
1850 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1851 OrthancPluginContext* context,
1852 char* str)
1853 {
1854 if (str != NULL)
1855 {
1856 context->Free(str);
1857 }
1858 }
1859
1860
1880 ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1881 OrthancPluginContext* context,
1882 int expectedMajor,
1883 int expectedMinor,
1884 int expectedRevision)
1885 {
1886 int major, minor, revision;
1887
1888 if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1889 sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1890 sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1891 sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1892 sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1893 sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1894 sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1895 sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1896 sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1897 sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1898 sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1899 sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1900 sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1901 sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1902 sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1903 sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1904 sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1905 sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
1906 sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
1907 sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
1908 sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason) ||
1909 sizeof(int32_t) != sizeof(OrthancPluginReceivedInstanceAction))
1910 {
1911 /* Mismatch in the size of the enumerations */
1912 return 0;
1913 }
1914
1915 /* Assume compatibility with the mainline */
1916 if (!strcmp(context->orthancVersion, "mainline"))
1917 {
1918 return 1;
1919 }
1920
1921 /* Parse the version of the Orthanc core */
1922 if (
1923#ifdef _MSC_VER
1924 sscanf_s
1925#else
1926 sscanf
1927#endif
1928 (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1929 {
1930 return 0;
1931 }
1932
1933 /* Check the major number of the version */
1934
1935 if (major > expectedMajor)
1936 {
1937 return 1;
1938 }
1939
1940 if (major < expectedMajor)
1941 {
1942 return 0;
1943 }
1944
1945 /* Check the minor number of the version */
1946
1947 if (minor > expectedMinor)
1948 {
1949 return 1;
1950 }
1951
1952 if (minor < expectedMinor)
1953 {
1954 return 0;
1955 }
1956
1957 /* Check the revision number of the version */
1958
1959 if (revision >= expectedRevision)
1960 {
1961 return 1;
1962 }
1963 else
1964 {
1965 return 0;
1966 }
1967 }
1968
1969
1986 ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
1987 OrthancPluginContext* context)
1988 {
1990 context,
1991 ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
1992 ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
1993 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
1994 }
1995
1996
2005 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
2006 OrthancPluginContext* context,
2008 {
2009 context->Free(buffer->data);
2010 }
2011
2012
2021 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer64(
2022 OrthancPluginContext* context,
2024 {
2025 context->Free(buffer->data);
2026 }
2027
2028
2037 ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
2038 OrthancPluginContext* context,
2039 const char* message)
2040 {
2041 context->InvokeService(context, _OrthancPluginService_LogError, message);
2042 }
2043
2044
2053 ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
2054 OrthancPluginContext* context,
2055 const char* message)
2056 {
2057 context->InvokeService(context, _OrthancPluginService_LogWarning, message);
2058 }
2059
2060
2069 ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
2070 OrthancPluginContext* context,
2071 const char* message)
2072 {
2073 context->InvokeService(context, _OrthancPluginService_LogInfo, message);
2074 }
2075
2076
2077
2078 typedef struct
2079 {
2080 const char* pathRegularExpression;
2082 } _OrthancPluginRestCallback;
2083
2105 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
2106 OrthancPluginContext* context,
2107 const char* pathRegularExpression,
2109 {
2110 _OrthancPluginRestCallback params;
2111 params.pathRegularExpression = pathRegularExpression;
2112 params.callback = callback;
2113 context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
2114 }
2115
2116
2117
2146 OrthancPluginContext* context,
2147 const char* pathRegularExpression,
2149 {
2150 _OrthancPluginRestCallback params;
2151 params.pathRegularExpression = pathRegularExpression;
2152 params.callback = callback;
2153 context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
2154 }
2155
2156
2157
2158 typedef struct
2159 {
2161 } _OrthancPluginOnStoredInstanceCallback;
2162
2184 OrthancPluginContext* context,
2186 {
2187 _OrthancPluginOnStoredInstanceCallback params;
2188 params.callback = callback;
2189
2190 context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
2191 }
2192
2193
2194
2195 typedef struct
2196 {
2198 const void* answer;
2199 uint32_t answerSize;
2200 const char* mimeType;
2201 } _OrthancPluginAnswerBuffer;
2202
2215 ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
2216 OrthancPluginContext* context,
2218 const void* answer,
2219 uint32_t answerSize,
2220 const char* mimeType)
2221 {
2222 _OrthancPluginAnswerBuffer params;
2223 params.output = output;
2224 params.answer = answer;
2225 params.answerSize = answerSize;
2226 params.mimeType = mimeType;
2227 context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
2228 }
2229
2230
2231 typedef struct
2232 {
2235 uint32_t width;
2236 uint32_t height;
2237 uint32_t pitch;
2238 const void* buffer;
2239 } _OrthancPluginCompressAndAnswerPngImage;
2240
2241 typedef struct
2242 {
2244 OrthancPluginImageFormat imageFormat;
2245 OrthancPluginPixelFormat pixelFormat;
2246 uint32_t width;
2247 uint32_t height;
2248 uint32_t pitch;
2249 const void* buffer;
2250 uint8_t quality;
2251 } _OrthancPluginCompressAndAnswerImage;
2252
2253
2272 ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2273 OrthancPluginContext* context,
2276 uint32_t width,
2277 uint32_t height,
2278 uint32_t pitch,
2279 const void* buffer)
2280 {
2281 _OrthancPluginCompressAndAnswerImage params;
2282 params.output = output;
2283 params.imageFormat = OrthancPluginImageFormat_Png;
2284 params.pixelFormat = format;
2285 params.width = width;
2286 params.height = height;
2287 params.pitch = pitch;
2288 params.buffer = buffer;
2289 params.quality = 0; /* No quality for PNG */
2290 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2291 }
2292
2293
2294
2295 typedef struct
2296 {
2298 const char* instanceId;
2299 } _OrthancPluginGetDicomForInstance;
2300
2314 OrthancPluginContext* context,
2316 const char* instanceId)
2317 {
2318 _OrthancPluginGetDicomForInstance params;
2319 params.target = target;
2320 params.instanceId = instanceId;
2321 return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2322 }
2323
2324
2325
2326 typedef struct
2327 {
2329 const char* uri;
2330 } _OrthancPluginRestApiGet;
2331
2347 OrthancPluginContext* context,
2349 const char* uri)
2350 {
2351 _OrthancPluginRestApiGet params;
2352 params.target = target;
2353 params.uri = uri;
2354 return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2355 }
2356
2357
2358
2377 OrthancPluginContext* context,
2379 const char* uri)
2380 {
2381 _OrthancPluginRestApiGet params;
2382 params.target = target;
2383 params.uri = uri;
2384 return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2385 }
2386
2387
2388
2389 typedef struct
2390 {
2392 const char* uri;
2393 const void* body;
2394 uint32_t bodySize;
2395 } _OrthancPluginRestApiPostPut;
2396
2414 OrthancPluginContext* context,
2416 const char* uri,
2417 const void* body,
2418 uint32_t bodySize)
2419 {
2420 _OrthancPluginRestApiPostPut params;
2421 params.target = target;
2422 params.uri = uri;
2423 params.body = body;
2424 params.bodySize = bodySize;
2425 return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2426 }
2427
2428
2449 OrthancPluginContext* context,
2451 const char* uri,
2452 const void* body,
2453 uint32_t bodySize)
2454 {
2455 _OrthancPluginRestApiPostPut params;
2456 params.target = target;
2457 params.uri = uri;
2458 params.body = body;
2459 params.bodySize = bodySize;
2460 return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2461 }
2462
2463
2464
2478 OrthancPluginContext* context,
2479 const char* uri)
2480 {
2481 return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2482 }
2483
2484
2501 OrthancPluginContext* context,
2502 const char* uri)
2503 {
2504 return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2505 }
2506
2507
2508
2526 OrthancPluginContext* context,
2528 const char* uri,
2529 const void* body,
2530 uint32_t bodySize)
2531 {
2532 _OrthancPluginRestApiPostPut params;
2533 params.target = target;
2534 params.uri = uri;
2535 params.body = body;
2536 params.bodySize = bodySize;
2537 return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2538 }
2539
2540
2541
2562 OrthancPluginContext* context,
2564 const char* uri,
2565 const void* body,
2566 uint32_t bodySize)
2567 {
2568 _OrthancPluginRestApiPostPut params;
2569 params.target = target;
2570 params.uri = uri;
2571 params.body = body;
2572 params.bodySize = bodySize;
2573 return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2574 }
2575
2576
2577
2578 typedef struct
2579 {
2581 const char* argument;
2582 } _OrthancPluginOutputPlusArgument;
2583
2595 ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2596 OrthancPluginContext* context,
2598 const char* redirection)
2599 {
2600 _OrthancPluginOutputPlusArgument params;
2601 params.output = output;
2602 params.argument = redirection;
2603 context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2604 }
2605
2606
2607
2608 typedef struct
2609 {
2610 char** result;
2611 const char* argument;
2612 } _OrthancPluginRetrieveDynamicString;
2613
2627 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2628 OrthancPluginContext* context,
2629 const char* patientID)
2630 {
2631 char* result;
2632
2633 _OrthancPluginRetrieveDynamicString params;
2634 params.result = &result;
2635 params.argument = patientID;
2636
2637 if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2638 {
2639 /* Error */
2640 return NULL;
2641 }
2642 else
2643 {
2644 return result;
2645 }
2646 }
2647
2648
2662 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2663 OrthancPluginContext* context,
2664 const char* studyUID)
2665 {
2666 char* result;
2667
2668 _OrthancPluginRetrieveDynamicString params;
2669 params.result = &result;
2670 params.argument = studyUID;
2671
2672 if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2673 {
2674 /* Error */
2675 return NULL;
2676 }
2677 else
2678 {
2679 return result;
2680 }
2681 }
2682
2683
2698 OrthancPluginContext* context,
2699 const char* accessionNumber)
2700 {
2701 char* result;
2702
2703 _OrthancPluginRetrieveDynamicString params;
2704 params.result = &result;
2705 params.argument = accessionNumber;
2706
2707 if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2708 {
2709 /* Error */
2710 return NULL;
2711 }
2712 else
2713 {
2714 return result;
2715 }
2716 }
2717
2718
2732 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2733 OrthancPluginContext* context,
2734 const char* seriesUID)
2735 {
2736 char* result;
2737
2738 _OrthancPluginRetrieveDynamicString params;
2739 params.result = &result;
2740 params.argument = seriesUID;
2741
2742 if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2743 {
2744 /* Error */
2745 return NULL;
2746 }
2747 else
2748 {
2749 return result;
2750 }
2751 }
2752
2753
2767 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2768 OrthancPluginContext* context,
2769 const char* sopInstanceUID)
2770 {
2771 char* result;
2772
2773 _OrthancPluginRetrieveDynamicString params;
2774 params.result = &result;
2775 params.argument = sopInstanceUID;
2776
2777 if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2778 {
2779 /* Error */
2780 return NULL;
2781 }
2782 else
2783 {
2784 return result;
2785 }
2786 }
2787
2788
2789
2790 typedef struct
2791 {
2793 uint16_t status;
2794 } _OrthancPluginSendHttpStatusCode;
2795
2812 ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2813 OrthancPluginContext* context,
2815 uint16_t status)
2816 {
2817 _OrthancPluginSendHttpStatusCode params;
2818 params.output = output;
2819 params.status = status;
2820 context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2821 }
2822
2823
2835 ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2836 OrthancPluginContext* context,
2838 const char* realm)
2839 {
2840 _OrthancPluginOutputPlusArgument params;
2841 params.output = output;
2842 params.argument = realm;
2843 context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2844 }
2845
2846
2858 ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2859 OrthancPluginContext* context,
2861 const char* allowedMethods)
2862 {
2863 _OrthancPluginOutputPlusArgument params;
2864 params.output = output;
2865 params.argument = allowedMethods;
2866 context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2867 }
2868
2869
2870 typedef struct
2871 {
2873 const char* key;
2874 const char* value;
2875 } _OrthancPluginSetHttpHeader;
2876
2888 ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2889 OrthancPluginContext* context,
2891 const char* cookie,
2892 const char* value)
2893 {
2894 _OrthancPluginSetHttpHeader params;
2895 params.output = output;
2896 params.key = cookie;
2897 params.value = value;
2898 context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2899 }
2900
2901
2913 ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2914 OrthancPluginContext* context,
2916 const char* key,
2917 const char* value)
2918 {
2919 _OrthancPluginSetHttpHeader params;
2920 params.output = output;
2921 params.key = key;
2922 params.value = value;
2923 context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2924 }
2925
2926
2927 typedef struct
2928 {
2929 char** resultStringToFree;
2930 const char** resultString;
2931 int64_t* resultInt64;
2932 const char* key;
2933 const OrthancPluginDicomInstance* instance;
2934 OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2935 } _OrthancPluginAccessDicomInstance;
2936
2937
2949 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2950 OrthancPluginContext* context,
2951 const OrthancPluginDicomInstance* instance)
2952 {
2953 const char* result;
2954
2955 _OrthancPluginAccessDicomInstance params;
2956 memset(&params, 0, sizeof(params));
2957 params.resultString = &result;
2958 params.instance = instance;
2959
2960 if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2961 {
2962 /* Error */
2963 return NULL;
2964 }
2965 else
2966 {
2967 return result;
2968 }
2969 }
2970
2971
2982 ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
2983 OrthancPluginContext* context,
2984 const OrthancPluginDicomInstance* instance)
2985 {
2986 int64_t size;
2987
2988 _OrthancPluginAccessDicomInstance params;
2989 memset(&params, 0, sizeof(params));
2990 params.resultInt64 = &size;
2991 params.instance = instance;
2992
2993 if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
2994 {
2995 /* Error */
2996 return -1;
2997 }
2998 else
2999 {
3000 return size;
3001 }
3002 }
3003
3004
3015 ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData(
3016 OrthancPluginContext* context,
3017 const OrthancPluginDicomInstance* instance)
3018 {
3019 const char* result;
3020
3021 _OrthancPluginAccessDicomInstance params;
3022 memset(&params, 0, sizeof(params));
3023 params.resultString = &result;
3024 params.instance = instance;
3025
3026 if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
3027 {
3028 /* Error */
3029 return NULL;
3030 }
3031 else
3032 {
3033 return result;
3034 }
3035 }
3036
3037
3051 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
3052 OrthancPluginContext* context,
3053 const OrthancPluginDicomInstance* instance)
3054 {
3055 char* result;
3056
3057 _OrthancPluginAccessDicomInstance params;
3058 memset(&params, 0, sizeof(params));
3059 params.resultStringToFree = &result;
3060 params.instance = instance;
3061
3062 if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
3063 {
3064 /* Error */
3065 return NULL;
3066 }
3067 else
3068 {
3069 return result;
3070 }
3071 }
3072
3073
3089 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
3090 OrthancPluginContext* context,
3091 const OrthancPluginDicomInstance* instance)
3092 {
3093 char* result;
3094
3095 _OrthancPluginAccessDicomInstance params;
3096 memset(&params, 0, sizeof(params));
3097 params.resultStringToFree = &result;
3098 params.instance = instance;
3099
3100 if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
3101 {
3102 /* Error */
3103 return NULL;
3104 }
3105 else
3106 {
3107 return result;
3108 }
3109 }
3110
3111
3128 ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
3129 OrthancPluginContext* context,
3130 const OrthancPluginDicomInstance* instance,
3131 const char* metadata)
3132 {
3133 int64_t result;
3134
3135 _OrthancPluginAccessDicomInstance params;
3136 memset(&params, 0, sizeof(params));
3137 params.resultInt64 = &result;
3138 params.instance = instance;
3139 params.key = metadata;
3140
3141 if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3142 {
3143 /* Error */
3144 return -1;
3145 }
3146 else
3147 {
3148 return (result != 0);
3149 }
3150 }
3151
3152
3169 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
3170 OrthancPluginContext* context,
3171 const OrthancPluginDicomInstance* instance,
3172 const char* metadata)
3173 {
3174 const char* result;
3175
3176 _OrthancPluginAccessDicomInstance params;
3177 memset(&params, 0, sizeof(params));
3178 params.resultString = &result;
3179 params.instance = instance;
3180 params.key = metadata;
3181
3182 if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3183 {
3184 /* Error */
3185 return NULL;
3186 }
3187 else
3188 {
3189 return result;
3190 }
3191 }
3192
3193
3194
3195 typedef struct
3196 {
3200 OrthancPluginFree free;
3201 } _OrthancPluginRegisterStorageArea;
3202
3218 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
3219 OrthancPluginContext* context,
3223 {
3224 _OrthancPluginRegisterStorageArea params;
3225 params.create = create;
3226 params.read = read;
3227 params.remove = remove;
3228
3229#ifdef __cplusplus
3230 params.free = ::free;
3231#else
3232 params.free = free;
3233#endif
3234
3235 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3236 }
3237
3238
3239
3250 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3251 {
3252 char* result;
3253
3254 _OrthancPluginRetrieveDynamicString params;
3255 params.result = &result;
3256 params.argument = NULL;
3257
3258 if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3259 {
3260 /* Error */
3261 return NULL;
3262 }
3263 else
3264 {
3265 return result;
3266 }
3267 }
3268
3269
3280 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3281 {
3282 char* result;
3283
3284 _OrthancPluginRetrieveDynamicString params;
3285 params.result = &result;
3286 params.argument = NULL;
3287
3288 if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3289 {
3290 /* Error */
3291 return NULL;
3292 }
3293 else
3294 {
3295 return result;
3296 }
3297 }
3298
3299
3315 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3316 {
3317 char* result;
3318
3319 _OrthancPluginRetrieveDynamicString params;
3320 params.result = &result;
3321 params.argument = NULL;
3322
3323 if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3324 {
3325 /* Error */
3326 return NULL;
3327 }
3328 else
3329 {
3330 return result;
3331 }
3332 }
3333
3334
3335
3336 typedef struct
3337 {
3339 } _OrthancPluginOnChangeCallback;
3340
3361 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3362 OrthancPluginContext* context,
3364 {
3365 _OrthancPluginOnChangeCallback params;
3366 params.callback = callback;
3367
3368 context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3369 }
3370
3371
3372
3373 typedef struct
3374 {
3375 const char* plugin;
3376 _OrthancPluginProperty property;
3377 const char* value;
3378 } _OrthancPluginSetPluginProperty;
3379
3380
3392 ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3393 OrthancPluginContext* context,
3394 const char* uri)
3395 {
3396 _OrthancPluginSetPluginProperty params;
3397 params.plugin = OrthancPluginGetName();
3398 params.property = _OrthancPluginProperty_RootUri;
3399 params.value = uri;
3400
3401 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3402 }
3403
3404
3414 ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3415 OrthancPluginContext* context,
3416 const char* description)
3417 {
3418 _OrthancPluginSetPluginProperty params;
3419 params.plugin = OrthancPluginGetName();
3420 params.property = _OrthancPluginProperty_Description;
3421 params.value = description;
3422
3423 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3424 }
3425
3426
3436 ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3437 OrthancPluginContext* context,
3438 const char* javascript)
3439 {
3440 _OrthancPluginSetPluginProperty params;
3441 params.plugin = OrthancPluginGetName();
3442 params.property = _OrthancPluginProperty_OrthancExplorer;
3443 params.value = javascript;
3444
3445 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3446 }
3447
3448
3449 typedef struct
3450 {
3451 char** result;
3452 int32_t property;
3453 const char* value;
3454 } _OrthancPluginGlobalProperty;
3455
3456
3470 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3471 OrthancPluginContext* context,
3472 int32_t property,
3473 const char* defaultValue)
3474 {
3475 char* result;
3476
3477 _OrthancPluginGlobalProperty params;
3478 params.result = &result;
3479 params.property = property;
3480 params.value = defaultValue;
3481
3482 if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3483 {
3484 /* Error */
3485 return NULL;
3486 }
3487 else
3488 {
3489 return result;
3490 }
3491 }
3492
3493
3510 OrthancPluginContext* context,
3511 int32_t property,
3512 const char* value)
3513 {
3514 _OrthancPluginGlobalProperty params;
3515 params.result = NULL;
3516 params.property = property;
3517 params.value = value;
3518
3519 return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3520 }
3521
3522
3523
3524 typedef struct
3525 {
3526 int32_t *resultInt32;
3527 uint32_t *resultUint32;
3528 int64_t *resultInt64;
3529 uint64_t *resultUint64;
3530 } _OrthancPluginReturnSingleValue;
3531
3540 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3541 OrthancPluginContext* context)
3542 {
3543 uint32_t count = 0;
3544
3545 _OrthancPluginReturnSingleValue params;
3546 memset(&params, 0, sizeof(params));
3547 params.resultUint32 = &count;
3548
3549 if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3550 {
3551 /* Error */
3552 return 0;
3553 }
3554 else
3555 {
3556 return count;
3557 }
3558 }
3559
3560
3561
3574 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3575 OrthancPluginContext* context,
3576 uint32_t argument)
3577 {
3578 char* result;
3579
3580 _OrthancPluginGlobalProperty params;
3581 params.result = &result;
3582 params.property = (int32_t) argument;
3583 params.value = NULL;
3584
3585 if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3586 {
3587 /* Error */
3588 return NULL;
3589 }
3590 else
3591 {
3592 return result;
3593 }
3594 }
3595
3596
3606 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3607 OrthancPluginContext* context)
3608 {
3609 uint32_t count = 0;
3610
3611 _OrthancPluginReturnSingleValue params;
3612 memset(&params, 0, sizeof(params));
3613 params.resultUint32 = &count;
3614
3615 if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3616 {
3617 /* Error */
3618 return 0;
3619 }
3620 else
3621 {
3622 return count;
3623 }
3624 }
3625
3626
3627
3639 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3640 {
3641 char* result;
3642
3643 _OrthancPluginRetrieveDynamicString params;
3644 params.result = &result;
3645 params.argument = NULL;
3646
3647 if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3648 {
3649 /* Error */
3650 return NULL;
3651 }
3652 else
3653 {
3654 return result;
3655 }
3656 }
3657
3658
3659
3660 typedef struct
3661 {
3663 const char* subType;
3664 const char* contentType;
3665 } _OrthancPluginStartMultipartAnswer;
3666
3681 OrthancPluginContext* context,
3683 const char* subType,
3684 const char* contentType)
3685 {
3686 _OrthancPluginStartMultipartAnswer params;
3687 params.output = output;
3688 params.subType = subType;
3689 params.contentType = contentType;
3690 return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3691 }
3692
3693
3710 OrthancPluginContext* context,
3712 const void* answer,
3713 uint32_t answerSize)
3714 {
3715 _OrthancPluginAnswerBuffer params;
3716 params.output = output;
3717 params.answer = answer;
3718 params.answerSize = answerSize;
3719 params.mimeType = NULL;
3720 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3721 }
3722
3723
3724
3725 typedef struct
3726 {
3728 const void* source;
3729 uint32_t size;
3730 OrthancPluginCompressionType compression;
3731 uint8_t uncompress;
3732 } _OrthancPluginBufferCompression;
3733
3734
3752 OrthancPluginContext* context,
3754 const void* source,
3755 uint32_t size,
3756 OrthancPluginCompressionType compression,
3757 uint8_t uncompress)
3758 {
3759 _OrthancPluginBufferCompression params;
3760 params.target = target;
3761 params.source = source;
3762 params.size = size;
3763 params.compression = compression;
3764 params.uncompress = uncompress;
3765
3766 return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3767 }
3768
3769
3770
3771 typedef struct
3772 {
3774 const char* path;
3775 } _OrthancPluginReadFile;
3776
3789 OrthancPluginContext* context,
3791 const char* path)
3792 {
3793 _OrthancPluginReadFile params;
3794 params.target = target;
3795 params.path = path;
3796 return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3797 }
3798
3799
3800
3801 typedef struct
3802 {
3803 const char* path;
3804 const void* data;
3805 uint32_t size;
3806 } _OrthancPluginWriteFile;
3807
3820 OrthancPluginContext* context,
3821 const char* path,
3822 const void* data,
3823 uint32_t size)
3824 {
3825 _OrthancPluginWriteFile params;
3826 params.path = path;
3827 params.data = data;
3828 params.size = size;
3829 return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3830 }
3831
3832
3833
3834 typedef struct
3835 {
3836 const char** target;
3838 } _OrthancPluginGetErrorDescription;
3839
3850 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3851 OrthancPluginContext* context,
3853 {
3854 const char* result = NULL;
3855
3856 _OrthancPluginGetErrorDescription params;
3857 params.target = &result;
3858 params.error = error;
3859
3860 if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3861 result == NULL)
3862 {
3863 return "Unknown error code";
3864 }
3865 else
3866 {
3867 return result;
3868 }
3869 }
3870
3871
3872
3873 typedef struct
3874 {
3876 uint16_t status;
3877 const void* body;
3878 uint32_t bodySize;
3879 } _OrthancPluginSendHttpStatus;
3880
3903 ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3904 OrthancPluginContext* context,
3906 uint16_t status,
3907 const void* body,
3908 uint32_t bodySize)
3909 {
3910 _OrthancPluginSendHttpStatus params;
3911 params.output = output;
3912 params.status = status;
3913 params.body = body;
3914 params.bodySize = bodySize;
3915 context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3916 }
3917
3918
3919
3920 typedef struct
3921 {
3922 const OrthancPluginImage* image;
3923 uint32_t* resultUint32;
3924 OrthancPluginPixelFormat* resultPixelFormat;
3925 void** resultBuffer;
3926 } _OrthancPluginGetImageInfo;
3927
3928
3940 OrthancPluginContext* context,
3941 const OrthancPluginImage* image)
3942 {
3944
3945 _OrthancPluginGetImageInfo params;
3946 memset(&params, 0, sizeof(params));
3947 params.image = image;
3948 params.resultPixelFormat = &target;
3949
3950 if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3951 {
3953 }
3954 else
3955 {
3956 return (OrthancPluginPixelFormat) target;
3957 }
3958 }
3959
3960
3961
3972 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3973 OrthancPluginContext* context,
3974 const OrthancPluginImage* image)
3975 {
3976 uint32_t width;
3977
3978 _OrthancPluginGetImageInfo params;
3979 memset(&params, 0, sizeof(params));
3980 params.image = image;
3981 params.resultUint32 = &width;
3982
3983 if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
3984 {
3985 return 0;
3986 }
3987 else
3988 {
3989 return width;
3990 }
3991 }
3992
3993
3994
4005 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
4006 OrthancPluginContext* context,
4007 const OrthancPluginImage* image)
4008 {
4009 uint32_t height;
4010
4011 _OrthancPluginGetImageInfo params;
4012 memset(&params, 0, sizeof(params));
4013 params.image = image;
4014 params.resultUint32 = &height;
4015
4016 if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
4017 {
4018 return 0;
4019 }
4020 else
4021 {
4022 return height;
4023 }
4024 }
4025
4026
4027
4040 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
4041 OrthancPluginContext* context,
4042 const OrthancPluginImage* image)
4043 {
4044 uint32_t pitch;
4045
4046 _OrthancPluginGetImageInfo params;
4047 memset(&params, 0, sizeof(params));
4048 params.image = image;
4049 params.resultUint32 = &pitch;
4050
4051 if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
4052 {
4053 return 0;
4054 }
4055 else
4056 {
4057 return pitch;
4058 }
4059 }
4060
4061
4062
4074 ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
4075 OrthancPluginContext* context,
4076 const OrthancPluginImage* image)
4077 {
4078 void* target = NULL;
4079
4080 _OrthancPluginGetImageInfo params;
4081 memset(&params, 0, sizeof(params));
4082 params.resultBuffer = &target;
4083 params.image = image;
4084
4085 if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
4086 {
4087 return NULL;
4088 }
4089 else
4090 {
4091 return target;
4092 }
4093 }
4094
4095
4096 typedef struct
4097 {
4098 OrthancPluginImage** target;
4099 const void* data;
4100 uint32_t size;
4102 } _OrthancPluginUncompressImage;
4103
4104
4118 OrthancPluginContext* context,
4119 const void* data,
4120 uint32_t size,
4122 {
4123 OrthancPluginImage* target = NULL;
4124
4125 _OrthancPluginUncompressImage params;
4126 memset(&params, 0, sizeof(params));
4127 params.target = &target;
4128 params.data = data;
4129 params.size = size;
4130 params.format = format;
4131
4132 if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
4133 {
4134 return NULL;
4135 }
4136 else
4137 {
4138 return target;
4139 }
4140 }
4141
4142
4143
4144
4145 typedef struct
4146 {
4147 OrthancPluginImage* image;
4148 } _OrthancPluginFreeImage;
4149
4159 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
4160 OrthancPluginContext* context,
4161 OrthancPluginImage* image)
4162 {
4163 _OrthancPluginFreeImage params;
4164 params.image = image;
4165
4166 context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
4167 }
4168
4169
4170
4171
4172 typedef struct
4173 {
4175 OrthancPluginImageFormat imageFormat;
4176 OrthancPluginPixelFormat pixelFormat;
4177 uint32_t width;
4178 uint32_t height;
4179 uint32_t pitch;
4180 const void* buffer;
4181 uint8_t quality;
4182 } _OrthancPluginCompressImage;
4183
4184
4205 OrthancPluginContext* context,
4208 uint32_t width,
4209 uint32_t height,
4210 uint32_t pitch,
4211 const void* buffer)
4212 {
4213 _OrthancPluginCompressImage params;
4214 memset(&params, 0, sizeof(params));
4215 params.target = target;
4216 params.imageFormat = OrthancPluginImageFormat_Png;
4217 params.pixelFormat = format;
4218 params.width = width;
4219 params.height = height;
4220 params.pitch = pitch;
4221 params.buffer = buffer;
4222 params.quality = 0; /* Unused for PNG */
4223
4224 return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4225 }
4226
4227
4250 OrthancPluginContext* context,
4253 uint32_t width,
4254 uint32_t height,
4255 uint32_t pitch,
4256 const void* buffer,
4257 uint8_t quality)
4258 {
4259 _OrthancPluginCompressImage params;
4260 memset(&params, 0, sizeof(params));
4261 params.target = target;
4262 params.imageFormat = OrthancPluginImageFormat_Jpeg;
4263 params.pixelFormat = format;
4264 params.width = width;
4265 params.height = height;
4266 params.pitch = pitch;
4267 params.buffer = buffer;
4268 params.quality = quality;
4269
4270 return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4271 }
4272
4273
4274
4297 OrthancPluginContext* context,
4300 uint32_t width,
4301 uint32_t height,
4302 uint32_t pitch,
4303 const void* buffer,
4304 uint8_t quality)
4305 {
4306 _OrthancPluginCompressAndAnswerImage params;
4307 params.output = output;
4308 params.imageFormat = OrthancPluginImageFormat_Jpeg;
4309 params.pixelFormat = format;
4310 params.width = width;
4311 params.height = height;
4312 params.pitch = pitch;
4313 params.buffer = buffer;
4314 params.quality = quality;
4315 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4316 }
4317
4318
4319
4320
4321 typedef struct
4322 {
4325 const char* url;
4326 const char* username;
4327 const char* password;
4328 const void* body;
4329 uint32_t bodySize;
4330 } _OrthancPluginCallHttpClient;
4331
4332
4350 OrthancPluginContext* context,
4352 const char* url,
4353 const char* username,
4354 const char* password)
4355 {
4356 _OrthancPluginCallHttpClient params;
4357 memset(&params, 0, sizeof(params));
4358
4359 params.target = target;
4360 params.method = OrthancPluginHttpMethod_Get;
4361 params.url = url;
4362 params.username = username;
4363 params.password = password;
4364
4365 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4366 }
4367
4368
4388 OrthancPluginContext* context,
4390 const char* url,
4391 const void* body,
4392 uint32_t bodySize,
4393 const char* username,
4394 const char* password)
4395 {
4396 _OrthancPluginCallHttpClient params;
4397 memset(&params, 0, sizeof(params));
4398
4399 params.target = target;
4400 params.method = OrthancPluginHttpMethod_Post;
4401 params.url = url;
4402 params.body = body;
4403 params.bodySize = bodySize;
4404 params.username = username;
4405 params.password = password;
4406
4407 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4408 }
4409
4410
4430 OrthancPluginContext* context,
4432 const char* url,
4433 const void* body,
4434 uint32_t bodySize,
4435 const char* username,
4436 const char* password)
4437 {
4438 _OrthancPluginCallHttpClient params;
4439 memset(&params, 0, sizeof(params));
4440
4441 params.target = target;
4442 params.method = OrthancPluginHttpMethod_Put;
4443 params.url = url;
4444 params.body = body;
4445 params.bodySize = bodySize;
4446 params.username = username;
4447 params.password = password;
4448
4449 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4450 }
4451
4452
4468 OrthancPluginContext* context,
4469 const char* url,
4470 const char* username,
4471 const char* password)
4472 {
4473 _OrthancPluginCallHttpClient params;
4474 memset(&params, 0, sizeof(params));
4475
4476 params.method = OrthancPluginHttpMethod_Delete;
4477 params.url = url;
4478 params.username = username;
4479 params.password = password;
4480
4481 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4482 }
4483
4484
4485
4486 typedef struct
4487 {
4488 OrthancPluginImage** target;
4489 const OrthancPluginImage* source;
4490 OrthancPluginPixelFormat targetFormat;
4491 } _OrthancPluginConvertPixelFormat;
4492
4493
4506 OrthancPluginContext* context,
4507 const OrthancPluginImage* source,
4508 OrthancPluginPixelFormat targetFormat)
4509 {
4510 OrthancPluginImage* target = NULL;
4511
4512 _OrthancPluginConvertPixelFormat params;
4513 params.target = &target;
4514 params.source = source;
4515 params.targetFormat = targetFormat;
4516
4517 if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4518 {
4519 return NULL;
4520 }
4521 else
4522 {
4523 return target;
4524 }
4525 }
4526
4527
4528
4540 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4541 OrthancPluginContext* context)
4542 {
4543 uint32_t count = 0;
4544
4545 _OrthancPluginReturnSingleValue params;
4546 memset(&params, 0, sizeof(params));
4547 params.resultUint32 = &count;
4548
4549 if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4550 {
4551 /* Error */
4552 return 0;
4553 }
4554 else
4555 {
4556 return count;
4557 }
4558 }
4559
4560
4561
4562
4563 typedef struct
4564 {
4565 uint32_t fontIndex; /* in */
4566 const char** name; /* out */
4567 uint32_t* size; /* out */
4568 } _OrthancPluginGetFontInfo;
4569
4580 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4581 OrthancPluginContext* context,
4582 uint32_t fontIndex)
4583 {
4584 const char* result = NULL;
4585
4586 _OrthancPluginGetFontInfo params;
4587 memset(&params, 0, sizeof(params));
4588 params.name = &result;
4589 params.fontIndex = fontIndex;
4590
4591 if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4592 {
4593 return NULL;
4594 }
4595 else
4596 {
4597 return result;
4598 }
4599 }
4600
4601
4612 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4613 OrthancPluginContext* context,
4614 uint32_t fontIndex)
4615 {
4616 uint32_t result;
4617
4618 _OrthancPluginGetFontInfo params;
4619 memset(&params, 0, sizeof(params));
4620 params.size = &result;
4621 params.fontIndex = fontIndex;
4622
4623 if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4624 {
4625 return 0;
4626 }
4627 else
4628 {
4629 return result;
4630 }
4631 }
4632
4633
4634
4635 typedef struct
4636 {
4637 OrthancPluginImage* image;
4638 uint32_t fontIndex;
4639 const char* utf8Text;
4640 int32_t x;
4641 int32_t y;
4642 uint8_t r;
4643 uint8_t g;
4644 uint8_t b;
4645 } _OrthancPluginDrawText;
4646
4647
4666 OrthancPluginContext* context,
4667 OrthancPluginImage* image,
4668 uint32_t fontIndex,
4669 const char* utf8Text,
4670 int32_t x,
4671 int32_t y,
4672 uint8_t r,
4673 uint8_t g,
4674 uint8_t b)
4675 {
4676 _OrthancPluginDrawText params;
4677 memset(&params, 0, sizeof(params));
4678 params.image = image;
4679 params.fontIndex = fontIndex;
4680 params.utf8Text = utf8Text;
4681 params.x = x;
4682 params.y = y;
4683 params.r = r;
4684 params.g = g;
4685 params.b = b;
4686
4687 return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4688 }
4689
4690
4691
4692 typedef struct
4693 {
4694 OrthancPluginStorageArea* storageArea;
4695 const char* uuid;
4696 const void* content;
4697 uint64_t size;
4699 } _OrthancPluginStorageAreaCreate;
4700
4701
4720 OrthancPluginContext* context,
4721 OrthancPluginStorageArea* storageArea,
4722 const char* uuid,
4723 const void* content,
4724 uint64_t size,
4726 {
4727 _OrthancPluginStorageAreaCreate params;
4728 params.storageArea = storageArea;
4729 params.uuid = uuid;
4730 params.content = content;
4731 params.size = size;
4732 params.type = type;
4733
4734 return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4735 }
4736
4737
4738 typedef struct
4739 {
4741 OrthancPluginStorageArea* storageArea;
4742 const char* uuid;
4744 } _OrthancPluginStorageAreaRead;
4745
4746
4764 OrthancPluginContext* context,
4766 OrthancPluginStorageArea* storageArea,
4767 const char* uuid,
4769 {
4770 _OrthancPluginStorageAreaRead params;
4771 params.target = target;
4772 params.storageArea = storageArea;
4773 params.uuid = uuid;
4774 params.type = type;
4775
4776 return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4777 }
4778
4779
4780 typedef struct
4781 {
4782 OrthancPluginStorageArea* storageArea;
4783 const char* uuid;
4785 } _OrthancPluginStorageAreaRemove;
4786
4803 OrthancPluginContext* context,
4804 OrthancPluginStorageArea* storageArea,
4805 const char* uuid,
4807 {
4808 _OrthancPluginStorageAreaRemove params;
4809 params.storageArea = storageArea;
4810 params.uuid = uuid;
4811 params.type = type;
4812
4813 return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4814 }
4815
4816
4817
4818 typedef struct
4819 {
4820 OrthancPluginErrorCode* target;
4821 int32_t code;
4822 uint16_t httpStatus;
4823 const char* message;
4824 } _OrthancPluginRegisterErrorCode;
4825
4842 OrthancPluginContext* context,
4843 int32_t code,
4844 uint16_t httpStatus,
4845 const char* message)
4846 {
4848
4849 _OrthancPluginRegisterErrorCode params;
4850 params.target = &target;
4851 params.code = code;
4852 params.httpStatus = httpStatus;
4853 params.message = message;
4854
4855 if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4856 {
4857 return target;
4858 }
4859 else
4860 {
4861 /* There was an error while assigned the error. Use a generic code. */
4863 }
4864 }
4865
4866
4867
4868 typedef struct
4869 {
4870 uint16_t group;
4871 uint16_t element;
4873 const char* name;
4874 uint32_t minMultiplicity;
4875 uint32_t maxMultiplicity;
4876 } _OrthancPluginRegisterDictionaryTag;
4877
4898 OrthancPluginContext* context,
4899 uint16_t group,
4900 uint16_t element,
4902 const char* name,
4903 uint32_t minMultiplicity,
4904 uint32_t maxMultiplicity)
4905 {
4906 _OrthancPluginRegisterDictionaryTag params;
4907 params.group = group;
4908 params.element = element;
4909 params.vr = vr;
4910 params.name = name;
4911 params.minMultiplicity = minMultiplicity;
4912 params.maxMultiplicity = maxMultiplicity;
4913
4914 return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4915 }
4916
4917
4918
4919 typedef struct
4920 {
4921 uint16_t group;
4922 uint16_t element;
4924 const char* name;
4925 uint32_t minMultiplicity;
4926 uint32_t maxMultiplicity;
4927 const char* privateCreator;
4928 } _OrthancPluginRegisterPrivateDictionaryTag;
4929
4951 OrthancPluginContext* context,
4952 uint16_t group,
4953 uint16_t element,
4955 const char* name,
4956 uint32_t minMultiplicity,
4957 uint32_t maxMultiplicity,
4958 const char* privateCreator)
4959 {
4960 _OrthancPluginRegisterPrivateDictionaryTag params;
4961 params.group = group;
4962 params.element = element;
4963 params.vr = vr;
4964 params.name = name;
4965 params.minMultiplicity = minMultiplicity;
4966 params.maxMultiplicity = maxMultiplicity;
4967 params.privateCreator = privateCreator;
4968
4969 return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4970 }
4971
4972
4973
4974 typedef struct
4975 {
4976 OrthancPluginStorageArea* storageArea;
4978 } _OrthancPluginReconstructMainDicomTags;
4979
4995 OrthancPluginContext* context,
4996 OrthancPluginStorageArea* storageArea,
4998 {
4999 _OrthancPluginReconstructMainDicomTags params;
5000 params.level = level;
5001 params.storageArea = storageArea;
5002
5003 return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
5004 }
5005
5006
5007 typedef struct
5008 {
5009 char** result;
5010 const char* instanceId;
5011 const void* buffer;
5012 uint32_t size;
5015 uint32_t maxStringLength;
5016 } _OrthancPluginDicomToJson;
5017
5018
5038 ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
5039 OrthancPluginContext* context,
5040 const void* buffer,
5041 uint32_t size,
5044 uint32_t maxStringLength)
5045 {
5046 char* result;
5047
5048 _OrthancPluginDicomToJson params;
5049 memset(&params, 0, sizeof(params));
5050 params.result = &result;
5051 params.buffer = buffer;
5052 params.size = size;
5053 params.format = format;
5054 params.flags = flags;
5055 params.maxStringLength = maxStringLength;
5056
5057 if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
5058 {
5059 /* Error */
5060 return NULL;
5061 }
5062 else
5063 {
5064 return result;
5065 }
5066 }
5067
5068
5087 ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
5088 OrthancPluginContext* context,
5089 const char* instanceId,
5092 uint32_t maxStringLength)
5093 {
5094 char* result;
5095
5096 _OrthancPluginDicomToJson params;
5097 memset(&params, 0, sizeof(params));
5098 params.result = &result;
5099 params.instanceId = instanceId;
5100 params.format = format;
5101 params.flags = flags;
5102 params.maxStringLength = maxStringLength;
5103
5104 if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
5105 {
5106 /* Error */
5107 return NULL;
5108 }
5109 else
5110 {
5111 return result;
5112 }
5113 }
5114
5115
5116 typedef struct
5117 {
5119 const char* uri;
5120 uint32_t headersCount;
5121 const char* const* headersKeys;
5122 const char* const* headersValues;
5123 int32_t afterPlugins;
5124 } _OrthancPluginRestApiGet2;
5125
5146 OrthancPluginContext* context,
5148 const char* uri,
5149 uint32_t headersCount,
5150 const char* const* headersKeys,
5151 const char* const* headersValues,
5152 int32_t afterPlugins)
5153 {
5154 _OrthancPluginRestApiGet2 params;
5155 params.target = target;
5156 params.uri = uri;
5157 params.headersCount = headersCount;
5158 params.headersKeys = headersKeys;
5159 params.headersValues = headersValues;
5160 params.afterPlugins = afterPlugins;
5161
5162 return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
5163 }
5164
5165
5166
5167 typedef struct
5168 {
5170 } _OrthancPluginWorklistCallback;
5171
5184 OrthancPluginContext* context,
5186 {
5187 _OrthancPluginWorklistCallback params;
5188 params.callback = callback;
5189
5190 return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
5191 }
5192
5193
5194
5195 typedef struct
5196 {
5198 const OrthancPluginWorklistQuery* query;
5199 const void* dicom;
5200 uint32_t size;
5201 } _OrthancPluginWorklistAnswersOperation;
5202
5220 OrthancPluginContext* context,
5222 const OrthancPluginWorklistQuery* query,
5223 const void* dicom,
5224 uint32_t size)
5225 {
5226 _OrthancPluginWorklistAnswersOperation params;
5227 params.answers = answers;
5228 params.query = query;
5229 params.dicom = dicom;
5230 params.size = size;
5231
5232 return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
5233 }
5234
5235
5250 OrthancPluginContext* context,
5252 {
5253 _OrthancPluginWorklistAnswersOperation params;
5254 params.answers = answers;
5255 params.query = NULL;
5256 params.dicom = NULL;
5257 params.size = 0;
5258
5259 return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5260 }
5261
5262
5263 typedef struct
5264 {
5265 const OrthancPluginWorklistQuery* query;
5266 const void* dicom;
5267 uint32_t size;
5268 int32_t* isMatch;
5270 } _OrthancPluginWorklistQueryOperation;
5271
5287 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5288 OrthancPluginContext* context,
5289 const OrthancPluginWorklistQuery* query,
5290 const void* dicom,
5291 uint32_t size)
5292 {
5293 int32_t isMatch = 0;
5294
5295 _OrthancPluginWorklistQueryOperation params;
5296 params.query = query;
5297 params.dicom = dicom;
5298 params.size = size;
5299 params.isMatch = &isMatch;
5300 params.target = NULL;
5301
5302 if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5303 {
5304 return isMatch;
5305 }
5306 else
5307 {
5308 /* Error: Assume non-match */
5309 return 0;
5310 }
5311 }
5312
5313
5327 OrthancPluginContext* context,
5329 const OrthancPluginWorklistQuery* query)
5330 {
5331 _OrthancPluginWorklistQueryOperation params;
5332 params.query = query;
5333 params.dicom = NULL;
5334 params.size = 0;
5335 params.isMatch = NULL;
5336 params.target = target;
5337
5338 return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5339 }
5340
5341
5353 OrthancPluginContext* context,
5354 const OrthancPluginDicomInstance* instance)
5355 {
5357
5358 _OrthancPluginAccessDicomInstance params;
5359 memset(&params, 0, sizeof(params));
5360 params.resultOrigin = &origin;
5361 params.instance = instance;
5362
5363 if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5364 {
5365 /* Error */
5367 }
5368 else
5369 {
5370 return origin;
5371 }
5372 }
5373
5374
5375 typedef struct
5376 {
5378 const char* json;
5379 const OrthancPluginImage* pixelData;
5381 } _OrthancPluginCreateDicom;
5382
5409 OrthancPluginContext* context,
5411 const char* json,
5412 const OrthancPluginImage* pixelData,
5414 {
5415 _OrthancPluginCreateDicom params;
5416 params.target = target;
5417 params.json = json;
5418 params.pixelData = pixelData;
5419 params.flags = flags;
5420
5421 return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5422 }
5423
5424
5425 typedef struct
5426 {
5428 } _OrthancPluginDecodeImageCallback;
5429
5445 OrthancPluginContext* context,
5447 {
5448 _OrthancPluginDecodeImageCallback params;
5449 params.callback = callback;
5450
5451 return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5452 }
5453
5454
5455
5456 typedef struct
5457 {
5458 OrthancPluginImage** target;
5460 uint32_t width;
5461 uint32_t height;
5462 uint32_t pitch;
5463 void* buffer;
5464 const void* constBuffer;
5465 uint32_t bufferSize;
5466 uint32_t frameIndex;
5467 } _OrthancPluginCreateImage;
5468
5469
5483 OrthancPluginContext* context,
5485 uint32_t width,
5486 uint32_t height)
5487 {
5488 OrthancPluginImage* target = NULL;
5489
5490 _OrthancPluginCreateImage params;
5491 memset(&params, 0, sizeof(params));
5492 params.target = &target;
5493 params.format = format;
5494 params.width = width;
5495 params.height = height;
5496
5497 if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5498 {
5499 return NULL;
5500 }
5501 else
5502 {
5503 return target;
5504 }
5505 }
5506
5507
5526 OrthancPluginContext* context,
5528 uint32_t width,
5529 uint32_t height,
5530 uint32_t pitch,
5531 void* buffer)
5532 {
5533 OrthancPluginImage* target = NULL;
5534
5535 _OrthancPluginCreateImage params;
5536 memset(&params, 0, sizeof(params));
5537 params.target = &target;
5538 params.format = format;
5539 params.width = width;
5540 params.height = height;
5541 params.pitch = pitch;
5542 params.buffer = buffer;
5543
5544 if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5545 {
5546 return NULL;
5547 }
5548 else
5549 {
5550 return target;
5551 }
5552 }
5553
5554
5555
5572 OrthancPluginContext* context,
5573 const void* buffer,
5574 uint32_t bufferSize,
5575 uint32_t frameIndex)
5576 {
5577 OrthancPluginImage* target = NULL;
5578
5579 _OrthancPluginCreateImage params;
5580 memset(&params, 0, sizeof(params));
5581 params.target = &target;
5582 params.constBuffer = buffer;
5583 params.bufferSize = bufferSize;
5584 params.frameIndex = frameIndex;
5585
5586 if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5587 {
5588 return NULL;
5589 }
5590 else
5591 {
5592 return target;
5593 }
5594 }
5595
5596
5597
5598 typedef struct
5599 {
5600 char** result;
5601 const void* buffer;
5602 uint32_t size;
5603 } _OrthancPluginComputeHash;
5604
5617 ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5618 OrthancPluginContext* context,
5619 const void* buffer,
5620 uint32_t size)
5621 {
5622 char* result;
5623
5624 _OrthancPluginComputeHash params;
5625 params.result = &result;
5626 params.buffer = buffer;
5627 params.size = size;
5628
5629 if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5630 {
5631 /* Error */
5632 return NULL;
5633 }
5634 else
5635 {
5636 return result;
5637 }
5638 }
5639
5640
5653 ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5654 OrthancPluginContext* context,
5655 const void* buffer,
5656 uint32_t size)
5657 {
5658 char* result;
5659
5660 _OrthancPluginComputeHash params;
5661 params.result = &result;
5662 params.buffer = buffer;
5663 params.size = size;
5664
5665 if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5666 {
5667 /* Error */
5668 return NULL;
5669 }
5670 else
5671 {
5672 return result;
5673 }
5674 }
5675
5676
5677
5678 typedef struct
5679 {
5681 const char* name;
5682 } _OrthancPluginLookupDictionary;
5683
5700 OrthancPluginContext* context,
5702 const char* name)
5703 {
5704 _OrthancPluginLookupDictionary params;
5705 params.target = target;
5706 params.name = name;
5707 return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5708 }
5709
5710
5711
5712 typedef struct
5713 {
5715 const void* answer;
5716 uint32_t answerSize;
5717 uint32_t headersCount;
5718 const char* const* headersKeys;
5719 const char* const* headersValues;
5720 } _OrthancPluginSendMultipartItem2;
5721
5743 OrthancPluginContext* context,
5745 const void* answer,
5746 uint32_t answerSize,
5747 uint32_t headersCount,
5748 const char* const* headersKeys,
5749 const char* const* headersValues)
5750 {
5751 _OrthancPluginSendMultipartItem2 params;
5752 params.output = output;
5753 params.answer = answer;
5754 params.answerSize = answerSize;
5755 params.headersCount = headersCount;
5756 params.headersKeys = headersKeys;
5757 params.headersValues = headersValues;
5758
5759 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5760 }
5761
5762
5763 typedef struct
5764 {
5766 } _OrthancPluginIncomingHttpRequestFilter;
5767
5781 OrthancPluginContext* context,
5783 {
5784 _OrthancPluginIncomingHttpRequestFilter params;
5785 params.callback = callback;
5786
5787 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5788 }
5789
5790
5791
5792 typedef struct
5793 {
5794 OrthancPluginMemoryBuffer* answerBody;
5795 OrthancPluginMemoryBuffer* answerHeaders;
5796 uint16_t* httpStatus;
5798 const char* url;
5799 uint32_t headersCount;
5800 const char* const* headersKeys;
5801 const char* const* headersValues;
5802 const void* body;
5803 uint32_t bodySize;
5804 const char* username;
5805 const char* password;
5806 uint32_t timeout;
5807 const char* certificateFile;
5808 const char* certificateKeyFile;
5809 const char* certificateKeyPassword;
5810 uint8_t pkcs11;
5811 } _OrthancPluginCallHttpClient2;
5812
5813
5814
5856 OrthancPluginContext* context,
5857 OrthancPluginMemoryBuffer* answerBody,
5858 OrthancPluginMemoryBuffer* answerHeaders,
5859 uint16_t* httpStatus,
5861 const char* url,
5862 uint32_t headersCount,
5863 const char* const* headersKeys,
5864 const char* const* headersValues,
5865 const void* body,
5866 uint32_t bodySize,
5867 const char* username,
5868 const char* password,
5869 uint32_t timeout,
5870 const char* certificateFile,
5871 const char* certificateKeyFile,
5872 const char* certificateKeyPassword,
5873 uint8_t pkcs11)
5874 {
5875 _OrthancPluginCallHttpClient2 params;
5876 memset(&params, 0, sizeof(params));
5877
5878 params.answerBody = answerBody;
5879 params.answerHeaders = answerHeaders;
5880 params.httpStatus = httpStatus;
5881 params.method = method;
5882 params.url = url;
5883 params.headersCount = headersCount;
5884 params.headersKeys = headersKeys;
5885 params.headersValues = headersValues;
5886 params.body = body;
5887 params.bodySize = bodySize;
5888 params.username = username;
5889 params.password = password;
5890 params.timeout = timeout;
5891 params.certificateFile = certificateFile;
5892 params.certificateKeyFile = certificateKeyFile;
5893 params.certificateKeyPassword = certificateKeyPassword;
5894 params.pkcs11 = pkcs11;
5895
5896 return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5897 }
5898
5899
5910 ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5911 OrthancPluginContext* context)
5912 {
5913 char* result;
5914
5915 _OrthancPluginRetrieveDynamicString params;
5916 params.result = &result;
5917 params.argument = NULL;
5918
5919 if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5920 {
5921 /* Error */
5922 return NULL;
5923 }
5924 else
5925 {
5926 return result;
5927 }
5928 }
5929
5930
5931
5932
5933 typedef struct
5934 {
5936 } _OrthancPluginFindCallback;
5937
5950 OrthancPluginContext* context,
5952 {
5953 _OrthancPluginFindCallback params;
5954 params.callback = callback;
5955
5956 return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5957 }
5958
5959
5960 typedef struct
5961 {
5962 OrthancPluginFindAnswers *answers;
5963 const OrthancPluginFindQuery *query;
5964 const void *dicom;
5965 uint32_t size;
5966 uint32_t index;
5967 uint32_t *resultUint32;
5968 uint16_t *resultGroup;
5969 uint16_t *resultElement;
5970 char **resultString;
5971 } _OrthancPluginFindOperation;
5972
5989 OrthancPluginContext* context,
5990 OrthancPluginFindAnswers* answers,
5991 const void* dicom,
5992 uint32_t size)
5993 {
5994 _OrthancPluginFindOperation params;
5995 memset(&params, 0, sizeof(params));
5996 params.answers = answers;
5997 params.dicom = dicom;
5998 params.size = size;
5999
6000 return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
6001 }
6002
6003
6018 OrthancPluginContext* context,
6019 OrthancPluginFindAnswers* answers)
6020 {
6021 _OrthancPluginFindOperation params;
6022 memset(&params, 0, sizeof(params));
6023 params.answers = answers;
6024
6025 return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
6026 }
6027
6028
6029
6041 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
6042 OrthancPluginContext* context,
6043 const OrthancPluginFindQuery* query)
6044 {
6045 uint32_t count = 0;
6046
6047 _OrthancPluginFindOperation params;
6048 memset(&params, 0, sizeof(params));
6049 params.query = query;
6050 params.resultUint32 = &count;
6051
6052 if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
6053 {
6054 /* Error */
6055 return 0;
6056 }
6057 else
6058 {
6059 return count;
6060 }
6061 }
6062
6063
6079 OrthancPluginContext* context,
6080 uint16_t* group,
6081 uint16_t* element,
6082 const OrthancPluginFindQuery* query,
6083 uint32_t index)
6084 {
6085 _OrthancPluginFindOperation params;
6086 memset(&params, 0, sizeof(params));
6087 params.query = query;
6088 params.index = index;
6089 params.resultGroup = group;
6090 params.resultElement = element;
6091
6092 return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
6093 }
6094
6095
6109 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
6110 OrthancPluginContext* context,
6111 const OrthancPluginFindQuery* query,
6112 uint32_t index)
6113 {
6114 char* result;
6115
6116 _OrthancPluginFindOperation params;
6117 memset(&params, 0, sizeof(params));
6118 params.query = query;
6119 params.index = index;
6120 params.resultString = &result;
6121
6122 if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
6123 {
6124 /* Error */
6125 return NULL;
6126 }
6127 else
6128 {
6129 return result;
6130 }
6131 }
6132
6133
6147 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
6148 OrthancPluginContext* context,
6149 const OrthancPluginFindQuery* query,
6150 uint32_t index)
6151 {
6152 char* result;
6153
6154 _OrthancPluginFindOperation params;
6155 memset(&params, 0, sizeof(params));
6156 params.query = query;
6157 params.index = index;
6158 params.resultString = &result;
6159
6160 if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
6161 {
6162 /* Error */
6163 return NULL;
6164 }
6165 else
6166 {
6167 return result;
6168 }
6169 }
6170
6171
6172
6173
6174 typedef struct
6175 {
6177 OrthancPluginGetMoveSize getMoveSize;
6178 OrthancPluginApplyMove applyMove;
6179 OrthancPluginFreeMove freeMove;
6180 } _OrthancPluginMoveCallback;
6181
6196 OrthancPluginContext* context,
6198 OrthancPluginGetMoveSize getMoveSize,
6199 OrthancPluginApplyMove applyMove,
6200 OrthancPluginFreeMove freeMove)
6201 {
6202 _OrthancPluginMoveCallback params;
6203 params.callback = callback;
6204 params.getMoveSize = getMoveSize;
6205 params.applyMove = applyMove;
6206 params.freeMove = freeMove;
6207
6208 return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
6209 }
6210
6211
6212
6213 typedef struct
6214 {
6215 OrthancPluginFindMatcher** target;
6216 const void* query;
6217 uint32_t size;
6218 } _OrthancPluginCreateFindMatcher;
6219
6220
6235 OrthancPluginContext* context,
6236 const void* query,
6237 uint32_t size)
6238 {
6239 OrthancPluginFindMatcher* target = NULL;
6240
6241 _OrthancPluginCreateFindMatcher params;
6242 memset(&params, 0, sizeof(params));
6243 params.target = &target;
6244 params.query = query;
6245 params.size = size;
6246
6247 if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
6248 {
6249 return NULL;
6250 }
6251 else
6252 {
6253 return target;
6254 }
6255 }
6256
6257
6258 typedef struct
6259 {
6260 OrthancPluginFindMatcher* matcher;
6261 } _OrthancPluginFreeFindMatcher;
6262
6272 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6273 OrthancPluginContext* context,
6274 OrthancPluginFindMatcher* matcher)
6275 {
6276 _OrthancPluginFreeFindMatcher params;
6277 params.matcher = matcher;
6278
6279 context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6280 }
6281
6282
6283 typedef struct
6284 {
6285 const OrthancPluginFindMatcher* matcher;
6286 const void* dicom;
6287 uint32_t size;
6288 int32_t* isMatch;
6289 } _OrthancPluginFindMatcherIsMatch;
6290
6305 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6306 OrthancPluginContext* context,
6307 const OrthancPluginFindMatcher* matcher,
6308 const void* dicom,
6309 uint32_t size)
6310 {
6311 int32_t isMatch = 0;
6312
6313 _OrthancPluginFindMatcherIsMatch params;
6314 params.matcher = matcher;
6315 params.dicom = dicom;
6316 params.size = size;
6317 params.isMatch = &isMatch;
6318
6319 if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6320 {
6321 return isMatch;
6322 }
6323 else
6324 {
6325 /* Error: Assume non-match */
6326 return 0;
6327 }
6328 }
6329
6330
6331 typedef struct
6332 {
6334 } _OrthancPluginIncomingHttpRequestFilter2;
6335
6348 OrthancPluginContext* context,
6350 {
6351 _OrthancPluginIncomingHttpRequestFilter2 params;
6352 params.callback = callback;
6353
6354 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6355 }
6356
6357
6358
6359 typedef struct
6360 {
6361 OrthancPluginPeers** peers;
6362 } _OrthancPluginGetPeers;
6363
6376 OrthancPluginContext* context)
6377 {
6378 OrthancPluginPeers* peers = NULL;
6379
6380 _OrthancPluginGetPeers params;
6381 memset(&params, 0, sizeof(params));
6382 params.peers = &peers;
6383
6384 if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6385 {
6386 return NULL;
6387 }
6388 else
6389 {
6390 return peers;
6391 }
6392 }
6393
6394
6395 typedef struct
6396 {
6397 OrthancPluginPeers* peers;
6398 } _OrthancPluginFreePeers;
6399
6409 ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6410 OrthancPluginContext* context,
6411 OrthancPluginPeers* peers)
6412 {
6413 _OrthancPluginFreePeers params;
6414 params.peers = peers;
6415
6416 context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6417 }
6418
6419
6420 typedef struct
6421 {
6422 uint32_t* target;
6423 const OrthancPluginPeers* peers;
6424 } _OrthancPluginGetPeersCount;
6425
6439 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6440 OrthancPluginContext* context,
6441 const OrthancPluginPeers* peers)
6442 {
6443 uint32_t target = 0;
6444
6445 _OrthancPluginGetPeersCount params;
6446 memset(&params, 0, sizeof(params));
6447 params.target = &target;
6448 params.peers = peers;
6449
6450 if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6451 {
6452 /* Error */
6453 return 0;
6454 }
6455 else
6456 {
6457 return target;
6458 }
6459 }
6460
6461
6462 typedef struct
6463 {
6464 const char** target;
6465 const OrthancPluginPeers* peers;
6466 uint32_t peerIndex;
6467 const char* userProperty;
6468 } _OrthancPluginGetPeerProperty;
6469
6487 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6488 OrthancPluginContext* context,
6489 const OrthancPluginPeers* peers,
6490 uint32_t peerIndex)
6491 {
6492 const char* target = NULL;
6493
6494 _OrthancPluginGetPeerProperty params;
6495 memset(&params, 0, sizeof(params));
6496 params.target = &target;
6497 params.peers = peers;
6498 params.peerIndex = peerIndex;
6499 params.userProperty = NULL;
6500
6501 if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6502 {
6503 /* Error */
6504 return NULL;
6505 }
6506 else
6507 {
6508 return target;
6509 }
6510 }
6511
6512
6528 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6529 OrthancPluginContext* context,
6530 const OrthancPluginPeers* peers,
6531 uint32_t peerIndex)
6532 {
6533 const char* target = NULL;
6534
6535 _OrthancPluginGetPeerProperty params;
6536 memset(&params, 0, sizeof(params));
6537 params.target = &target;
6538 params.peers = peers;
6539 params.peerIndex = peerIndex;
6540 params.userProperty = NULL;
6541
6542 if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6543 {
6544 /* Error */
6545 return NULL;
6546 }
6547 else
6548 {
6549 return target;
6550 }
6551 }
6552
6553
6554
6574 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6575 OrthancPluginContext* context,
6576 const OrthancPluginPeers* peers,
6577 uint32_t peerIndex,
6578 const char* userProperty)
6579 {
6580 const char* target = NULL;
6581
6582 _OrthancPluginGetPeerProperty params;
6583 memset(&params, 0, sizeof(params));
6584 params.target = &target;
6585 params.peers = peers;
6586 params.peerIndex = peerIndex;
6587 params.userProperty = userProperty;
6588
6589 if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6590 {
6591 /* No such user property */
6592 return NULL;
6593 }
6594 else
6595 {
6596 return target;
6597 }
6598 }
6599
6600
6601
6602 typedef struct
6603 {
6604 OrthancPluginMemoryBuffer* answerBody;
6605 OrthancPluginMemoryBuffer* answerHeaders;
6606 uint16_t* httpStatus;
6607 const OrthancPluginPeers* peers;
6608 uint32_t peerIndex;
6610 const char* uri;
6611 uint32_t additionalHeadersCount;
6612 const char* const* additionalHeadersKeys;
6613 const char* const* additionalHeadersValues;
6614 const void* body;
6615 uint32_t bodySize;
6616 uint32_t timeout;
6617 } _OrthancPluginCallPeerApi;
6618
6656 OrthancPluginContext* context,
6657 OrthancPluginMemoryBuffer* answerBody,
6658 OrthancPluginMemoryBuffer* answerHeaders,
6659 uint16_t* httpStatus,
6660 const OrthancPluginPeers* peers,
6661 uint32_t peerIndex,
6663 const char* uri,
6664 uint32_t additionalHeadersCount,
6665 const char* const* additionalHeadersKeys,
6666 const char* const* additionalHeadersValues,
6667 const void* body,
6668 uint32_t bodySize,
6669 uint32_t timeout)
6670 {
6671 _OrthancPluginCallPeerApi params;
6672 memset(&params, 0, sizeof(params));
6673
6674 params.answerBody = answerBody;
6675 params.answerHeaders = answerHeaders;
6676 params.httpStatus = httpStatus;
6677 params.peers = peers;
6678 params.peerIndex = peerIndex;
6679 params.method = method;
6680 params.uri = uri;
6681 params.additionalHeadersCount = additionalHeadersCount;
6682 params.additionalHeadersKeys = additionalHeadersKeys;
6683 params.additionalHeadersValues = additionalHeadersValues;
6684 params.body = body;
6685 params.bodySize = bodySize;
6686 params.timeout = timeout;
6687
6688 return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6689 }
6690
6691
6692
6693
6694
6695 typedef struct
6696 {
6697 OrthancPluginJob** target;
6698 void *job;
6699 OrthancPluginJobFinalize finalize;
6700 const char *type;
6701 OrthancPluginJobGetProgress getProgress;
6702 OrthancPluginJobGetContent getContent;
6703 OrthancPluginJobGetSerialized getSerialized;
6707 } _OrthancPluginCreateJob;
6708
6742 OrthancPluginContext *context,
6743 void *job,
6744 OrthancPluginJobFinalize finalize,
6745 const char *type,
6746 OrthancPluginJobGetProgress getProgress,
6747 OrthancPluginJobGetContent getContent,
6748 OrthancPluginJobGetSerialized getSerialized,
6752 {
6753 OrthancPluginJob* target = NULL;
6754
6755 _OrthancPluginCreateJob params;
6756 memset(&params, 0, sizeof(params));
6757
6758 params.target = &target;
6759 params.job = job;
6760 params.finalize = finalize;
6761 params.type = type;
6762 params.getProgress = getProgress;
6763 params.getContent = getContent;
6764 params.getSerialized = getSerialized;
6765 params.step = step;
6766 params.stop = stop;
6767 params.reset = reset;
6768
6769 if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6770 target == NULL)
6771 {
6772 /* Error */
6773 return NULL;
6774 }
6775 else
6776 {
6777 return target;
6778 }
6779 }
6780
6781
6782 typedef struct
6783 {
6784 OrthancPluginJob** target;
6785 void *job;
6786 OrthancPluginJobFinalize finalize;
6787 const char *type;
6788 OrthancPluginJobGetProgress getProgress;
6789 OrthancPluginJobGetContent2 getContent;
6790 OrthancPluginJobGetSerialized2 getSerialized;
6794 } _OrthancPluginCreateJob2;
6795
6828 OrthancPluginContext *context,
6829 void *job,
6830 OrthancPluginJobFinalize finalize,
6831 const char *type,
6832 OrthancPluginJobGetProgress getProgress,
6833 OrthancPluginJobGetContent2 getContent,
6834 OrthancPluginJobGetSerialized2 getSerialized,
6838 {
6839 OrthancPluginJob* target = NULL;
6840
6841 _OrthancPluginCreateJob2 params;
6842 memset(&params, 0, sizeof(params));
6843
6844 params.target = &target;
6845 params.job = job;
6846 params.finalize = finalize;
6847 params.type = type;
6848 params.getProgress = getProgress;
6849 params.getContent = getContent;
6850 params.getSerialized = getSerialized;
6851 params.step = step;
6852 params.stop = stop;
6853 params.reset = reset;
6854
6855 if (context->InvokeService(context, _OrthancPluginService_CreateJob2, &params) != OrthancPluginErrorCode_Success ||
6856 target == NULL)
6857 {
6858 /* Error */
6859 return NULL;
6860 }
6861 else
6862 {
6863 return target;
6864 }
6865 }
6866
6867
6868 typedef struct
6869 {
6870 OrthancPluginJob* job;
6871 } _OrthancPluginFreeJob;
6872
6882 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6883 OrthancPluginContext* context,
6884 OrthancPluginJob* job)
6885 {
6886 _OrthancPluginFreeJob params;
6887 params.job = job;
6888
6889 context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6890 }
6891
6892
6893
6894 typedef struct
6895 {
6896 char** resultId;
6897 OrthancPluginJob *job;
6898 int priority;
6899 } _OrthancPluginSubmitJob;
6900
6914 ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6915 OrthancPluginContext *context,
6916 OrthancPluginJob *job,
6917 int priority)
6918 {
6919 char* resultId = NULL;
6920
6921 _OrthancPluginSubmitJob params;
6922 memset(&params, 0, sizeof(params));
6923
6924 params.resultId = &resultId;
6925 params.job = job;
6926 params.priority = priority;
6927
6928 if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6929 resultId == NULL)
6930 {
6931 /* Error */
6932 return NULL;
6933 }
6934 else
6935 {
6936 return resultId;
6937 }
6938 }
6939
6940
6941
6942 typedef struct
6943 {
6944 OrthancPluginJobsUnserializer unserializer;
6945 } _OrthancPluginJobsUnserializer;
6946
6959 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6960 OrthancPluginContext* context,
6961 OrthancPluginJobsUnserializer unserializer)
6962 {
6963 _OrthancPluginJobsUnserializer params;
6964 params.unserializer = unserializer;
6965
6966 context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6967 }
6968
6969
6970
6971 typedef struct
6972 {
6974 const char* details;
6975 uint8_t log;
6976 } _OrthancPluginSetHttpErrorDetails;
6977
6995 ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
6996 OrthancPluginContext* context,
6998 const char* details,
6999 uint8_t log)
7000 {
7001 _OrthancPluginSetHttpErrorDetails params;
7002 params.output = output;
7003 params.details = details;
7004 params.log = log;
7005 context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
7006 }
7007
7008
7009
7010 typedef struct
7011 {
7012 const char** result;
7013 const char* argument;
7014 } _OrthancPluginRetrieveStaticString;
7015
7027 ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
7028 OrthancPluginContext* context,
7029 const char* path)
7030 {
7031 const char* result = NULL;
7032
7033 _OrthancPluginRetrieveStaticString params;
7034 params.result = &result;
7035 params.argument = path;
7036
7037 if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
7038 {
7039 /* Error */
7040 return NULL;
7041 }
7042 else
7043 {
7044 return result;
7045 }
7046 }
7047
7048
7049
7050 typedef struct
7051 {
7052 const char* name;
7053 float value;
7055 } _OrthancPluginSetMetricsValue;
7056
7071 ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
7072 OrthancPluginContext* context,
7073 const char* name,
7074 float value,
7076 {
7077 _OrthancPluginSetMetricsValue params;
7078 params.name = name;
7079 params.value = value;
7080 params.type = type;
7081 context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
7082 }
7083
7084
7085
7086 typedef struct
7087 {
7089 } _OrthancPluginRegisterRefreshMetricsCallback;
7090
7102 OrthancPluginContext* context,
7104 {
7105 _OrthancPluginRegisterRefreshMetricsCallback params;
7106 params.callback = callback;
7107 context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
7108 }
7109
7110
7111
7112
7113 typedef struct
7114 {
7115 char** target;
7116 const void* dicom;
7117 uint32_t dicomSize;
7119 } _OrthancPluginEncodeDicomWeb;
7120
7137 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
7138 OrthancPluginContext* context,
7139 const void* dicom,
7140 uint32_t dicomSize,
7142 {
7143 char* target = NULL;
7144
7145 _OrthancPluginEncodeDicomWeb params;
7146 params.target = &target;
7147 params.dicom = dicom;
7148 params.dicomSize = dicomSize;
7149 params.callback = callback;
7150
7151 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
7152 {
7153 /* Error */
7154 return NULL;
7155 }
7156 else
7157 {
7158 return target;
7159 }
7160 }
7161
7162
7179 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
7180 OrthancPluginContext* context,
7181 const void* dicom,
7182 uint32_t dicomSize,
7184 {
7185 char* target = NULL;
7186
7187 _OrthancPluginEncodeDicomWeb params;
7188 params.target = &target;
7189 params.dicom = dicom;
7190 params.dicomSize = dicomSize;
7191 params.callback = callback;
7192
7193 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
7194 {
7195 /* Error */
7196 return NULL;
7197 }
7198 else
7199 {
7200 return target;
7201 }
7202 }
7203
7204
7205
7206 typedef struct
7207 {
7208 char** target;
7209 const void* dicom;
7210 uint32_t dicomSize;
7212 void* payload;
7213 } _OrthancPluginEncodeDicomWeb2;
7214
7231 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson2(
7232 OrthancPluginContext* context,
7233 const void* dicom,
7234 uint32_t dicomSize,
7236 void* payload)
7237 {
7238 char* target = NULL;
7239
7240 _OrthancPluginEncodeDicomWeb2 params;
7241 params.target = &target;
7242 params.dicom = dicom;
7243 params.dicomSize = dicomSize;
7244 params.callback = callback;
7245 params.payload = payload;
7246
7247 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson2, &params) != OrthancPluginErrorCode_Success)
7248 {
7249 /* Error */
7250 return NULL;
7251 }
7252 else
7253 {
7254 return target;
7255 }
7256 }
7257
7258
7275 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml2(
7276 OrthancPluginContext* context,
7277 const void* dicom,
7278 uint32_t dicomSize,
7280 void* payload)
7281 {
7282 char* target = NULL;
7283
7284 _OrthancPluginEncodeDicomWeb2 params;
7285 params.target = &target;
7286 params.dicom = dicom;
7287 params.dicomSize = dicomSize;
7288 params.callback = callback;
7289 params.payload = payload;
7290
7291 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml2, &params) != OrthancPluginErrorCode_Success)
7292 {
7293 /* Error */
7294 return NULL;
7295 }
7296 else
7297 {
7298 return target;
7299 }
7300 }
7301
7302
7303
7320 void* answer,
7321 const char* key,
7322 const char* value);
7323
7324
7341 void* answer,
7342 const void* data,
7343 uint32_t size);
7344
7345
7360 typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
7361
7362
7378
7379
7393 typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
7394
7395
7409 typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
7410
7411
7412 typedef struct
7413 {
7414 void* answer;
7417 uint16_t* httpStatus;
7419 const char* url;
7420 uint32_t headersCount;
7421 const char* const* headersKeys;
7422 const char* const* headersValues;
7423 void* request;
7428 const char* username;
7429 const char* password;
7430 uint32_t timeout;
7431 const char* certificateFile;
7432 const char* certificateKeyFile;
7433 const char* certificateKeyPassword;
7434 uint8_t pkcs11;
7435 } _OrthancPluginChunkedHttpClient;
7436
7437
7489 OrthancPluginContext* context,
7490 void* answer,
7493 uint16_t* httpStatus,
7495 const char* url,
7496 uint32_t headersCount,
7497 const char* const* headersKeys,
7498 const char* const* headersValues,
7499 void* request,
7504 const char* username,
7505 const char* password,
7506 uint32_t timeout,
7507 const char* certificateFile,
7508 const char* certificateKeyFile,
7509 const char* certificateKeyPassword,
7510 uint8_t pkcs11)
7511 {
7512 _OrthancPluginChunkedHttpClient params;
7513 memset(&params, 0, sizeof(params));
7514
7515 /* In common with OrthancPluginHttpClient() */
7516 params.httpStatus = httpStatus;
7517 params.method = method;
7518 params.url = url;
7519 params.headersCount = headersCount;
7520 params.headersKeys = headersKeys;
7521 params.headersValues = headersValues;
7522 params.username = username;
7523 params.password = password;
7524 params.timeout = timeout;
7525 params.certificateFile = certificateFile;
7526 params.certificateKeyFile = certificateKeyFile;
7527 params.certificateKeyPassword = certificateKeyPassword;
7528 params.pkcs11 = pkcs11;
7529
7530 /* For chunked body/answer */
7531 params.answer = answer;
7532 params.answerAddChunk = answerAddChunk;
7533 params.answerAddHeader = answerAddHeader;
7534 params.request = request;
7535 params.requestIsDone = requestIsDone;
7536 params.requestChunkData = requestChunkData;
7537 params.requestChunkSize = requestChunkSize;
7538 params.requestNext = requestNext;
7539
7540 return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7541 }
7542
7543
7544
7549 typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7550
7551
7552
7570 const char* url,
7571 const OrthancPluginHttpRequest* request);
7572
7573
7589 const void* data,
7590 uint32_t size);
7591
7592
7609 OrthancPluginRestOutput* output);
7610
7611
7627
7628 typedef struct
7629 {
7630 const char* pathRegularExpression;
7631 OrthancPluginRestCallback getHandler;
7633 OrthancPluginRestCallback deleteHandler;
7638 } _OrthancPluginChunkedRestCallback;
7639
7640
7671 OrthancPluginContext* context,
7672 const char* pathRegularExpression,
7673 OrthancPluginRestCallback getHandler,
7675 OrthancPluginRestCallback deleteHandler,
7680 {
7681 _OrthancPluginChunkedRestCallback params;
7682 params.pathRegularExpression = pathRegularExpression;
7683 params.getHandler = getHandler;
7684 params.postHandler = postHandler;
7685 params.deleteHandler = deleteHandler;
7686 params.putHandler = putHandler;
7687 params.addChunk = addChunk;
7688 params.execute = execute;
7689 params.finalize = finalize;
7690
7691 context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
7692 }
7693
7694
7695
7696
7697
7698 typedef struct
7699 {
7700 char** result;
7701 uint16_t group;
7702 uint16_t element;
7703 const char* privateCreator;
7704 } _OrthancPluginGetTagName;
7705
7721 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
7722 OrthancPluginContext* context,
7723 uint16_t group,
7724 uint16_t element,
7725 const char* privateCreator)
7726 {
7727 char* result;
7728
7729 _OrthancPluginGetTagName params;
7730 params.result = &result;
7731 params.group = group;
7732 params.element = element;
7733 params.privateCreator = privateCreator;
7734
7735 if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
7736 {
7737 /* Error */
7738 return NULL;
7739 }
7740 else
7741 {
7742 return result;
7743 }
7744 }
7745
7746
7747
7777 void** handler /* out */,
7778 const char* jobId,
7779 const char* transactionUid,
7780 const char* const* sopClassUids,
7781 const char* const* sopInstanceUids,
7782 uint32_t countInstances,
7783 const char* remoteAet,
7784 const char* calledAet);
7785
7786
7798 typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
7799
7800
7821 void* handler,
7822 const char* sopClassUid,
7823 const char* sopInstanceUid);
7824
7825
7826 typedef struct
7827 {
7831 } _OrthancPluginRegisterStorageCommitmentScpCallback;
7832
7847 OrthancPluginContext* context,
7851 {
7852 _OrthancPluginRegisterStorageCommitmentScpCallback params;
7853 params.factory = factory;
7854 params.destructor = destructor;
7855 params.lookup = lookup;
7856 return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
7857 }
7858
7859
7860
7887 const OrthancPluginDicomInstance* instance);
7888
7889
7890 typedef struct
7891 {
7893 } _OrthancPluginIncomingDicomInstanceFilter;
7894
7908 OrthancPluginContext* context,
7910 {
7911 _OrthancPluginIncomingDicomInstanceFilter params;
7912 params.callback = callback;
7913
7914 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, &params);
7915 }
7916
7917
7949 uint16_t* dimseStatus /* out */,
7950 const OrthancPluginDicomInstance* instance);
7951
7952
7953 typedef struct
7954 {
7956 } _OrthancPluginIncomingCStoreInstanceFilter;
7957
7971 OrthancPluginContext* context,
7973 {
7974 _OrthancPluginIncomingCStoreInstanceFilter params;
7975 params.callback = callback;
7976
7977 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingCStoreInstanceFilter, &params);
7978 }
7979
8016 OrthancPluginMemoryBuffer64* modifiedDicomBuffer,
8017 const void* receivedDicomBuffer,
8018 uint64_t receivedDicomBufferSize,
8020
8021
8022 typedef struct
8023 {
8025 } _OrthancPluginReceivedInstanceCallback;
8026
8048 OrthancPluginContext* context,
8050 {
8051 _OrthancPluginReceivedInstanceCallback params;
8052 params.callback = callback;
8053
8054 return context->InvokeService(context, _OrthancPluginService_RegisterReceivedInstanceCallback, &params);
8055 }
8056
8071 OrthancPluginContext* context,
8072 const OrthancPluginDicomInstance* instance)
8073 {
8074 char* result;
8075
8076 _OrthancPluginAccessDicomInstance params;
8077 memset(&params, 0, sizeof(params));
8078 params.resultStringToFree = &result;
8079 params.instance = instance;
8080
8081 if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, &params) != OrthancPluginErrorCode_Success)
8082 {
8083 /* Error */
8084 return NULL;
8085 }
8086 else
8087 {
8088 return result;
8089 }
8090 }
8091
8092
8105 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData(
8106 OrthancPluginContext* context,
8107 const OrthancPluginDicomInstance* instance)
8108 {
8109 int64_t hasPixelData;
8110
8111 _OrthancPluginAccessDicomInstance params;
8112 memset(&params, 0, sizeof(params));
8113 params.resultInt64 = &hasPixelData;
8114 params.instance = instance;
8115
8116 if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, &params) != OrthancPluginErrorCode_Success ||
8117 hasPixelData < 0 ||
8118 hasPixelData > 1)
8119 {
8120 /* Error */
8121 return -1;
8122 }
8123 else
8124 {
8125 return (hasPixelData != 0);
8126 }
8127 }
8128
8129
8130
8131
8132
8133
8134 typedef struct
8135 {
8137 const void* buffer;
8138 uint32_t size;
8139 const char* transferSyntax;
8140 } _OrthancPluginCreateDicomInstance;
8141
8156 OrthancPluginContext* context,
8157 const void* buffer,
8158 uint32_t size)
8159 {
8160 OrthancPluginDicomInstance* target = NULL;
8161
8162 _OrthancPluginCreateDicomInstance params;
8163 params.target = &target;
8164 params.buffer = buffer;
8165 params.size = size;
8166
8167 if (context->InvokeService(context, _OrthancPluginService_CreateDicomInstance, &params) != OrthancPluginErrorCode_Success)
8168 {
8169 /* Error */
8170 return NULL;
8171 }
8172 else
8173 {
8174 return target;
8175 }
8176 }
8177
8178 typedef struct
8179 {
8181 } _OrthancPluginFreeDicomInstance;
8182
8193 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeDicomInstance(
8194 OrthancPluginContext* context,
8196 {
8197 _OrthancPluginFreeDicomInstance params;
8198 params.dicom = dicom;
8199
8200 context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, &params);
8201 }
8202
8203
8204 typedef struct
8205 {
8206 uint32_t* targetUint32;
8207 OrthancPluginMemoryBuffer* targetBuffer;
8208 OrthancPluginImage** targetImage;
8209 char** targetStringToFree;
8210 const OrthancPluginDicomInstance* instance;
8211 uint32_t frameIndex;
8214 uint32_t maxStringLength;
8215 OrthancPluginDicomWebBinaryCallback2 dicomWebCallback;
8216 void* dicomWebPayload;
8217 } _OrthancPluginAccessDicomInstance2;
8218
8230 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetInstanceFramesCount(
8231 OrthancPluginContext* context,
8232 const OrthancPluginDicomInstance* instance)
8233 {
8234 uint32_t count;
8235
8236 _OrthancPluginAccessDicomInstance2 params;
8237 memset(&params, 0, sizeof(params));
8238 params.targetUint32 = &count;
8239 params.instance = instance;
8240
8241 if (context->InvokeService(context, _OrthancPluginService_GetInstanceFramesCount, &params) != OrthancPluginErrorCode_Success)
8242 {
8243 /* Error */
8244 return 0;
8245 }
8246 else
8247 {
8248 return count;
8249 }
8250 }
8251
8252
8271 OrthancPluginContext* context,
8273 const OrthancPluginDicomInstance* instance,
8274 uint32_t frameIndex)
8275 {
8276 _OrthancPluginAccessDicomInstance2 params;
8277 memset(&params, 0, sizeof(params));
8278 params.targetBuffer = target;
8279 params.instance = instance;
8280 params.frameIndex = frameIndex;
8281
8282 return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, &params);
8283 }
8284
8285
8299 OrthancPluginContext* context,
8300 const OrthancPluginDicomInstance* instance,
8301 uint32_t frameIndex)
8302 {
8303 OrthancPluginImage* target = NULL;
8304
8305 _OrthancPluginAccessDicomInstance2 params;
8306 memset(&params, 0, sizeof(params));
8307 params.targetImage = &target;
8308 params.instance = instance;
8309 params.frameIndex = frameIndex;
8310
8311 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDecodedFrame, &params) != OrthancPluginErrorCode_Success)
8312 {
8313 return NULL;
8314 }
8315 else
8316 {
8317 return target;
8318 }
8319 }
8320
8321
8338 OrthancPluginContext* context,
8339 const void* buffer,
8340 uint32_t size,
8341 const char* transferSyntax)
8342 {
8343 OrthancPluginDicomInstance* target = NULL;
8344
8345 _OrthancPluginCreateDicomInstance params;
8346 params.target = &target;
8347 params.buffer = buffer;
8348 params.size = size;
8349 params.transferSyntax = transferSyntax;
8350
8351 if (context->InvokeService(context, _OrthancPluginService_TranscodeDicomInstance, &params) != OrthancPluginErrorCode_Success)
8352 {
8353 /* Error */
8354 return NULL;
8355 }
8356 else
8357 {
8358 return target;
8359 }
8360 }
8361
8376 OrthancPluginContext* context,
8378 const OrthancPluginDicomInstance* instance)
8379 {
8380 _OrthancPluginAccessDicomInstance2 params;
8381 memset(&params, 0, sizeof(params));
8382 params.targetBuffer = target;
8383 params.instance = instance;
8384
8385 return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, &params);
8386 }
8387
8388
8407 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceAdvancedJson(
8408 OrthancPluginContext* context,
8409 const OrthancPluginDicomInstance* instance,
8412 uint32_t maxStringLength)
8413 {
8414 char* result = NULL;
8415
8416 _OrthancPluginAccessDicomInstance2 params;
8417 memset(&params, 0, sizeof(params));
8418 params.targetStringToFree = &result;
8419 params.instance = instance;
8420 params.format = format;
8421 params.flags = flags;
8422 params.maxStringLength = maxStringLength;
8423
8424 if (context->InvokeService(context, _OrthancPluginService_GetInstanceAdvancedJson, &params) != OrthancPluginErrorCode_Success)
8425 {
8426 /* Error */
8427 return NULL;
8428 }
8429 else
8430 {
8431 return result;
8432 }
8433 }
8434
8435
8450 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebJson(
8451 OrthancPluginContext* context,
8452 const OrthancPluginDicomInstance* instance,
8454 void* payload)
8455 {
8456 char* target = NULL;
8457
8458 _OrthancPluginAccessDicomInstance2 params;
8459 params.targetStringToFree = &target;
8460 params.instance = instance;
8461 params.dicomWebCallback = callback;
8462 params.dicomWebPayload = payload;
8463
8464 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebJson, &params) != OrthancPluginErrorCode_Success)
8465 {
8466 /* Error */
8467 return NULL;
8468 }
8469 else
8470 {
8471 return target;
8472 }
8473 }
8474
8475
8490 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebXml(
8491 OrthancPluginContext* context,
8492 const OrthancPluginDicomInstance* instance,
8494 void* payload)
8495 {
8496 char* target = NULL;
8497
8498 _OrthancPluginAccessDicomInstance2 params;
8499 params.targetStringToFree = &target;
8500 params.instance = instance;
8501 params.dicomWebCallback = callback;
8502 params.dicomWebPayload = payload;
8503
8504 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebXml, &params) != OrthancPluginErrorCode_Success)
8505 {
8506 /* Error */
8507 return NULL;
8508 }
8509 else
8510 {
8511 return target;
8512 }
8513 }
8514
8515
8516
8536 OrthancPluginMemoryBuffer* transcoded /* out */,
8537 const void* buffer,
8538 uint64_t size,
8539 const char* const* allowedSyntaxes,
8540 uint32_t countSyntaxes,
8541 uint8_t allowNewSopInstanceUid);
8542
8543
8544 typedef struct
8545 {
8547 } _OrthancPluginTranscoderCallback;
8548
8563 OrthancPluginContext* context,
8565 {
8566 _OrthancPluginTranscoderCallback params;
8567 params.callback = callback;
8568
8569 return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, &params);
8570 }
8571
8572
8573
8574 typedef struct
8575 {
8577 uint32_t size;
8578 } _OrthancPluginCreateMemoryBuffer;
8579
8598 OrthancPluginContext* context,
8600 uint32_t size)
8601 {
8602 _OrthancPluginCreateMemoryBuffer params;
8603 params.target = target;
8604 params.size = size;
8605
8606 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, &params);
8607 }
8608
8609
8636 OrthancPluginContext* context)
8637 {
8638 char* result;
8639
8640 _OrthancPluginRetrieveDynamicString params;
8641 params.result = &result;
8642 params.argument = NULL;
8643
8644 if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
8646 {
8647 /* Error */
8648 return NULL;
8649 }
8650 else
8651 {
8652 return result;
8653 }
8654 }
8655
8656
8657
8658 typedef struct
8659 {
8661 uint64_t size;
8662 } _OrthancPluginCreateMemoryBuffer64;
8663
8682 OrthancPluginContext* context,
8684 uint64_t size)
8685 {
8686 _OrthancPluginCreateMemoryBuffer64 params;
8687 params.target = target;
8688 params.size = size;
8689
8690 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer64, &params);
8691 }
8692
8693
8694 typedef struct
8695 {
8700 } _OrthancPluginRegisterStorageArea2;
8701
8718 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea2(
8719 OrthancPluginContext* context,
8724 {
8725 _OrthancPluginRegisterStorageArea2 params;
8726 params.create = create;
8727 params.readWhole = readWhole;
8728 params.readRange = readRange;
8729 params.remove = remove;
8730 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea2, &params);
8731 }
8732
8733
8734
8735 typedef struct
8736 {
8737 _OrthancPluginCreateDicom createDicom;
8738 const char* privateCreator;
8739 } _OrthancPluginCreateDicom2;
8740
8766 OrthancPluginContext* context,
8768 const char* json,
8769 const OrthancPluginImage* pixelData,
8771 const char* privateCreator)
8772 {
8773 _OrthancPluginCreateDicom2 params;
8774 params.createDicom.target = target;
8775 params.createDicom.json = json;
8776 params.createDicom.pixelData = pixelData;
8777 params.createDicom.flags = flags;
8778 params.privateCreator = privateCreator;
8779
8780 return context->InvokeService(context, _OrthancPluginService_CreateDicom2, &params);
8781 }
8782
8783
8784
8785
8786
8787
8788 typedef struct
8789 {
8790 OrthancPluginMemoryBuffer* answerBody;
8791 OrthancPluginMemoryBuffer* answerHeaders;
8792 uint16_t* httpStatus;
8794 const char* uri;
8795 uint32_t headersCount;
8796 const char* const* headersKeys;
8797 const char* const* headersValues;
8798 const void* body;
8799 uint32_t bodySize;
8800 uint8_t afterPlugins;
8801 } _OrthancPluginCallRestApi;
8802
8834 OrthancPluginContext* context,
8835 OrthancPluginMemoryBuffer* answerBody,
8836 OrthancPluginMemoryBuffer* answerHeaders,
8837 uint16_t* httpStatus,
8839 const char* uri,
8840 uint32_t headersCount,
8841 const char* const* headersKeys,
8842 const char* const* headersValues,
8843 const void* body,
8844 uint32_t bodySize,
8845 uint8_t afterPlugins)
8846 {
8847 _OrthancPluginCallRestApi params;
8848 memset(&params, 0, sizeof(params));
8849
8850 params.answerBody = answerBody;
8851 params.answerHeaders = answerHeaders;
8852 params.httpStatus = httpStatus;
8853 params.method = method;
8854 params.uri = uri;
8855 params.headersCount = headersCount;
8856 params.headersKeys = headersKeys;
8857 params.headersValues = headersValues;
8858 params.body = body;
8859 params.bodySize = bodySize;
8860 params.afterPlugins = afterPlugins;
8861
8862 return context->InvokeService(context, _OrthancPluginService_CallRestApi, &params);
8863 }
8864
8865
8866
8871 typedef struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection;
8872
8873
8892 const char* name,
8893 uint64_t size,
8894 const char* mimeType,
8895 const char* dateTime);
8896
8897
8913 const char* name,
8914 const char* dateTime);
8915
8916
8940 const void* data,
8941 uint64_t size,
8942 const char* mimeType,
8943 const char* dateTime);
8944
8945
8960 uint8_t* isExisting, /* out */
8961 uint32_t pathSize,
8962 const char* const* pathItems,
8963 void* payload);
8964
8965
8985 uint8_t* isExisting, /* out */
8989 uint32_t pathSize,
8990 const char* const* pathItems,
8991 void* payload);
8992
8993
9013 uint32_t pathSize,
9014 const char* const* pathItems,
9015 void* payload);
9016
9017
9034 uint8_t* isReadOnly, /* out */
9035 uint32_t pathSize,
9036 const char* const* pathItems,
9037 const void* data,
9038 uint64_t size,
9039 void* payload);
9040
9041
9056 uint8_t* isReadOnly, /* out */
9057 uint32_t pathSize,
9058 const char* const* pathItems,
9059 void* payload);
9060
9061
9076 uint8_t* isReadOnly, /* out */
9077 uint32_t pathSize,
9078 const char* const* pathItems,
9079 void* payload);
9080
9081
9082 typedef struct
9083 {
9084 const char* uri;
9091 void* payload;
9092 } _OrthancPluginRegisterWebDavCollection;
9093
9115 OrthancPluginContext* context,
9116 const char* uri,
9123 void* payload)
9124 {
9125 _OrthancPluginRegisterWebDavCollection params;
9126 params.uri = uri;
9127 params.isExistingFolder = isExistingFolder;
9128 params.listFolder = listFolder;
9129 params.retrieveFile = retrieveFile;
9130 params.storeFile = storeFile;
9131 params.createFolder = createFolder;
9132 params.deleteItem = deleteItem;
9133 params.payload = payload;
9134
9135 return context->InvokeService(context, _OrthancPluginService_RegisterWebDavCollection, &params);
9136 }
9137
9138
9147 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetDatabaseServerIdentifier(
9148 OrthancPluginContext* context)
9149 {
9150 const char* result;
9151
9152 _OrthancPluginRetrieveStaticString params;
9153 params.result = &result;
9154 params.argument = NULL;
9155
9156 if (context->InvokeService(context, _OrthancPluginService_GetDatabaseServerIdentifier, &params) != OrthancPluginErrorCode_Success)
9157 {
9158 /* Error */
9159 return NULL;
9160 }
9161 else
9162 {
9163 return result;
9164 }
9165 }
9166
9167
9176 void* backend,
9177 const void* request,
9178 uint64_t requestSize);
9179
9185 typedef void (*OrthancPluginFinalizeDatabaseBackendV4) (void* backend);
9186
9187 typedef struct
9188 {
9189 void* backend;
9190 uint32_t maxDatabaseRetries;
9193 } _OrthancPluginRegisterDatabaseBackendV4;
9194
9213 OrthancPluginContext* context,
9214 void* backend,
9215 uint32_t maxDatabaseRetries,
9218 {
9219 _OrthancPluginRegisterDatabaseBackendV4 params;
9220 params.backend = backend;
9221 params.maxDatabaseRetries = maxDatabaseRetries;
9222 params.operations = operations;
9223 params.finalize = finalize;
9224
9225 return context->InvokeService(context, _OrthancPluginService_RegisterDatabaseBackendV4, &params);
9226 }
9227
9228#ifdef __cplusplus
9229}
9230#endif
9231
9232
OrthancPluginErrorCode OrthancPluginRegisterDatabaseBackendV4(OrthancPluginContext *context, void *backend, uint32_t maxDatabaseRetries, OrthancPluginCallDatabaseBackendV4 operations, OrthancPluginFinalizeDatabaseBackendV4 finalize)
Definition: OrthancCPlugin.h:9212
OrthancPluginErrorCode(* OrthancPluginCallDatabaseBackendV4)(OrthancPluginMemoryBuffer64 *response, void *backend, const void *request, uint64_t requestSize)
Signature of a callback function that is triggered when the Orthanc core requests an operation from t...
Definition: OrthancCPlugin.h:9174
OrthancPluginReceivedInstanceAction(* OrthancPluginReceivedInstanceCallback)(OrthancPluginMemoryBuffer64 *modifiedDicomBuffer, const void *receivedDicomBuffer, uint64_t receivedDicomBufferSize, OrthancPluginInstanceOrigin origin)
Callback to keep/discard/modify a DICOM instance received by Orthanc from any source (C-STORE or REST...
Definition: OrthancCPlugin.h:8015
OrthancPluginErrorCode(* OrthancPluginWebDavAddFile)(OrthancPluginWebDavCollection *collection, const char *name, uint64_t size, const char *mimeType, const char *dateTime)
Declare a file while returning the content of a folder.
Definition: OrthancCPlugin.h:8890
int OrthancPluginCheckVersionAdvanced(OrthancPluginContext *context, int expectedMajor, int expectedMinor, int expectedRevision)
Check that the version of the hosting Orthanc is above a given version.
Definition: OrthancCPlugin.h:1880
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:3218
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:2183
void(* OrthancPluginDicomWebSetBinaryNode)(OrthancPluginDicomWebNode *node, OrthancPluginDicomWebBinaryMode mode, const char *bulkDataUri)
Signature of a function to set the content of a node encoding a binary DICOM tag, into a JSON or XML ...
Definition: OrthancCPlugin.h:1226
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5444
OrthancPluginChangeType
Definition: OrthancCPlugin.h:732
OrthancPluginErrorCode(* OrthancPluginStorageReadWhole)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type)
Callback for reading a whole file from the storage area.
Definition: OrthancCPlugin.h:1292
OrthancPluginErrorCode OrthancPluginRegisterIncomingCStoreInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingCStoreInstanceFilter callback)
Register a callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition: OrthancCPlugin.h:7970
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:1986
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:1204
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:7101
OrthancPluginErrorCode(* OrthancPluginWebDavCreateFolderCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback to create a folder.
Definition: OrthancCPlugin.h:9055
struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection
Opaque structure that represents a WebDAV collection.
Definition: OrthancCPlugin.h:8871
void(* OrthancPluginDicomWebBinaryCallback)(OrthancPluginDicomWebNode *node, OrthancPluginDicomWebSetBinaryNode setter, uint32_t levelDepth, const uint16_t *levelTagGroup, const uint16_t *levelTagElement, const uint32_t *levelIndex, uint16_t tagGroup, uint16_t tagElement, OrthancPluginValueRepresentation vr)
Callback executed to encode a binary tag in DICOMweb.
Definition: OrthancCPlugin.h:1761
OrthancPluginErrorCode(* OrthancPluginWebDavRetrieveFileCallback)(OrthancPluginWebDavCollection *collection, OrthancPluginWebDavRetrieveFile retrieveFile, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback for retrieving the content of a file.
Definition: OrthancCPlugin.h:9010
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition: OrthancCPlugin.h:7886
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4802
OrthancPluginErrorCode(* OrthancPluginTranscoderCallback)(OrthancPluginMemoryBuffer *transcoded, const void *buffer, uint64_t size, const char *const *allowedSyntaxes, uint32_t countSyntaxes, uint8_t allowNewSopInstanceUid)
Signature of a callback function to transcode a DICOM instance.
Definition: OrthancCPlugin.h:8535
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6347
OrthancPluginErrorCode(* OrthancPluginWebDavRetrieveFile)(OrthancPluginWebDavCollection *collection, const void *data, uint64_t size, const char *mimeType, const char *dateTime)
Retrieve the content of a file.
Definition: OrthancCPlugin.h:8938
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1272
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:2105
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3606
OrthancPluginErrorCode OrthancPluginRegisterReceivedInstanceCallback(OrthancPluginContext *context, OrthancPluginReceivedInstanceCallback callback)
Register a callback to keep/discard/modify a DICOM instance received by Orthanc from any source (C-ST...
Definition: OrthancCPlugin.h:8047
OrthancPluginErrorCode(* OrthancPluginWebDavListFolderCallback)(uint8_t *isExisting, OrthancPluginWebDavCollection *collection, OrthancPluginWebDavAddFile addFile, OrthancPluginWebDavAddFolder addFolder, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback for listing the content of a folder.
Definition: OrthancCPlugin.h:8984
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1715
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:1075
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3361
void OrthancPluginRegisterStorageArea2(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageReadWhole readWhole, OrthancPluginStorageReadRange readRange, OrthancPluginStorageRemove remove)
Register a custom storage area, with support for range request.
Definition: OrthancCPlugin.h:8718
OrthancPluginErrorCode(* OrthancPluginWebDavAddFolder)(OrthancPluginWebDavCollection *collection, const char *name, const char *dateTime)
Declare a subfolder while returning the content of a folder.
Definition: OrthancCPlugin.h:8911
OrthancPluginErrorCode OrthancPluginRegisterWebDavCollection(OrthancPluginContext *context, const char *uri, OrthancPluginWebDavIsExistingFolderCallback isExistingFolder, OrthancPluginWebDavListFolderCallback listFolder, OrthancPluginWebDavRetrieveFileCallback retrieveFile, OrthancPluginWebDavStoreFileCallback storeFile, OrthancPluginWebDavCreateFolderCallback createFolder, OrthancPluginWebDavDeleteItemCallback deleteItem, void *payload)
Register a WebDAV virtual filesystem.
Definition: OrthancCPlugin.h:9114
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:1418
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1172
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1733
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition: OrthancCPlugin.h:8562
OrthancPluginErrorCode(* OrthancPluginOnStoredInstanceCallback)(const OrthancPluginDicomInstance *instance, const char *instanceId)
Signature of a callback function that is triggered when Orthanc stores a new DICOM instance.
Definition: OrthancCPlugin.h:1183
OrthancPluginErrorCode(* OrthancPluginWebDavStoreFileCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, const void *data, uint64_t size, void *payload)
Callback to store a file.
Definition: OrthancCPlugin.h:9033
OrthancPluginErrorCode(* OrthancPluginWebDavDeleteItemCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback to remove a file or a folder.
Definition: OrthancCPlugin.h:9075
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:4994
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1333
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1245
void(* OrthancPluginDicomWebBinaryCallback2)(OrthancPluginDicomWebNode *node, OrthancPluginDicomWebSetBinaryNode setter, uint32_t levelDepth, const uint16_t *levelTagGroup, const uint16_t *levelTagElement, const uint32_t *levelIndex, uint16_t tagGroup, uint16_t tagElement, OrthancPluginValueRepresentation vr, void *payload)
Callback executed to encode a binary tag in DICOMweb.
Definition: OrthancCPlugin.h:1799
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:1193
void(* OrthancPluginFinalizeDatabaseBackendV4)(void *backend)
Signature of a callback function that is triggered when the database plugin must be finalized.
Definition: OrthancCPlugin.h:9185
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition: OrthancCPlugin.h:7549
OrthancPluginErrorCode(* OrthancPluginWebDavIsExistingFolderCallback)(uint8_t *isExisting, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback for testing the existence of a folder.
Definition: OrthancCPlugin.h:8959
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:1383
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6959
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1216
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:2145
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4763
OrthancPluginErrorCode(* OrthancPluginStorageReadRange)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type, uint64_t rangeStart)
Callback for reading a range of a file from the storage area.
Definition: OrthancCPlugin.h:1315
void OrthancPluginRegisterChunkedRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback getHandler, OrthancPluginServerChunkedRequestReaderFactory postHandler, OrthancPluginRestCallback deleteHandler, OrthancPluginServerChunkedRequestReaderFactory putHandler, OrthancPluginServerChunkedRequestReaderAddChunk addChunk, OrthancPluginServerChunkedRequestReaderExecute execute, OrthancPluginServerChunkedRequestReaderFinalize finalize)
Register a REST callback to handle chunked HTTP transfers.
Definition: OrthancCPlugin.h:7670
int32_t(* OrthancPluginIncomingCStoreInstanceFilter)(uint16_t *dimseStatus, const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition: OrthancCPlugin.h:7948
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition: OrthancCPlugin.h:7907
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5780
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:4719
@ OrthancPluginChangeType_OrthancStopped
Definition: OrthancCPlugin.h:744
@ OrthancPluginChangeType_OrthancStarted
Definition: OrthancCPlugin.h:743
@ OrthancPluginChangeType_Deleted
Definition: OrthancCPlugin.h:734
@ OrthancPluginChangeType_JobFailure
Definition: OrthancCPlugin.h:751
@ OrthancPluginChangeType_NewInstance
Definition: OrthancCPlugin.h:736
@ OrthancPluginChangeType_NewPatient
Definition: OrthancCPlugin.h:737
@ OrthancPluginChangeType_JobSubmitted
Definition: OrthancCPlugin.h:749
@ OrthancPluginChangeType_NewSeries
Definition: OrthancCPlugin.h:738
@ OrthancPluginChangeType_StablePatient
Definition: OrthancCPlugin.h:740
@ OrthancPluginChangeType_UpdatedPeers
Definition: OrthancCPlugin.h:747
@ OrthancPluginChangeType_StableStudy
Definition: OrthancCPlugin.h:742
@ OrthancPluginChangeType_CompletedSeries
Definition: OrthancCPlugin.h:733
@ OrthancPluginChangeType_NewChildInstance
Definition: OrthancCPlugin.h:735
@ OrthancPluginChangeType_UpdatedAttachment
Definition: OrthancCPlugin.h:745
@ OrthancPluginChangeType_UpdatedMetadata
Definition: OrthancCPlugin.h:746
@ OrthancPluginChangeType_StableSeries
Definition: OrthancCPlugin.h:741
@ OrthancPluginChangeType_UpdatedModalities
Definition: OrthancCPlugin.h:748
@ OrthancPluginChangeType_JobSuccess
Definition: OrthancCPlugin.h:750
@ OrthancPluginChangeType_NewStudy
Definition: OrthancCPlugin.h:739
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:6041
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1123
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1528
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:6017
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7798
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:1352
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:6195
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:6147
OrthancPluginErrorCode(* OrthancPluginStorageCommitmentFactory)(void **handler, const char *jobId, const char *transactionUid, const char *const *sopClassUids, const char *const *sopInstanceUids, uint32_t countInstances, const char *remoteAet, const char *calledAet)
Callback executed by the storage commitment SCP.
Definition: OrthancCPlugin.h:7776
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5949
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5326
OrthancPluginErrorCode(* OrthancPluginStorageCommitmentLookup)(OrthancPluginStorageCommitmentFailureReason *target, void *handler, const char *sopClassUid, const char *sopInstanceUid)
Callback to get the status of one DICOM instance in the storage commitment SCP.
Definition: OrthancCPlugin.h:7819
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:5287
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:5988
OrthancPluginErrorCode OrthancPluginRegisterStorageCommitmentScpCallback(OrthancPluginContext *context, OrthancPluginStorageCommitmentFactory factory, OrthancPluginStorageCommitmentDestructor destructor, OrthancPluginStorageCommitmentLookup lookup)
Register a callback to handle incoming requests to the storage commitment SCP.
Definition: OrthancCPlugin.h:7846
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1131
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1115
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1445
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1513
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:5183
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:6109
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5249
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:6078
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1542
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1107
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:1488
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:5219
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:8105
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:8490
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition: OrthancCPlugin.h:1083
OrthancPluginErrorCode OrthancPluginGetInstanceRawFrame(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Get the raw content of a frame in a DICOM instance.
Definition: OrthancCPlugin.h:8270
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2949
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:3051
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition: OrthancCPlugin.h:8337
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition: OrthancCPlugin.h:8155
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition: OrthancCPlugin.h:8230
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5352
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:2982
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:8450
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition: OrthancCPlugin.h:8070
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:3128
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition: OrthancCPlugin.h:8193
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition: OrthancCPlugin.h:8375
const char * OrthancPluginGetInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Get the value of some metadata associated with a given DICOM instance.
Definition: OrthancCPlugin.h:3169
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:3089
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:3015
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:8298
char * OrthancPluginGetInstanceAdvancedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomToJsonFormat format, OrthancPluginDicomToJsonFlags flags, uint32_t maxStringLength)
Format a DICOM memory buffer as a JSON string.
Definition: OrthancCPlugin.h:8407
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4505
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:608
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:4665
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:4249
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:4040
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3939
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5482
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4540
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:4005
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:4074
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:4159
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:4204
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5571
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:4117
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4580
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:777
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:1099
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:762
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3972
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:3751
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4612
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:5525
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1091
@ OrthancPluginPixelFormat_RGBA32
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:647
@ OrthancPluginPixelFormat_RGB48
Color image in RGB48 format.
Definition: OrthancCPlugin.h:657
@ OrthancPluginPixelFormat_Grayscale8
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:615
@ OrthancPluginPixelFormat_SignedGrayscale16
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:631
@ OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:673
@ OrthancPluginPixelFormat_RGB24
Color image in RGB24 format.
Definition: OrthancCPlugin.h:639
@ OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:681
@ OrthancPluginPixelFormat_Unknown
Definition: OrthancCPlugin.h:649
@ OrthancPluginPixelFormat_Grayscale64
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:689
@ OrthancPluginPixelFormat_Grayscale32
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:665
@ OrthancPluginPixelFormat_Grayscale16
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:623
@ OrthancPluginImageFormat_Png
Definition: OrthancCPlugin.h:778
@ OrthancPluginImageFormat_Jpeg
Definition: OrthancCPlugin.h:779
@ OrthancPluginImageFormat_Dicom
Definition: OrthancCPlugin.h:780
@ OrthancPluginCompressionType_Gzip
Definition: OrthancCPlugin.h:765
@ OrthancPluginCompressionType_ZlibWithSize
Definition: OrthancCPlugin.h:764
@ OrthancPluginCompressionType_Zlib
Definition: OrthancCPlugin.h:763
@ OrthancPluginCompressionType_GzipWithSize
Definition: OrthancCPlugin.h:766
OrthancPluginErrorCode OrthancPluginRestApiPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a POST call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2413
OrthancPluginErrorCode OrthancPluginRestApiPostAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a POST call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2448
OrthancPluginErrorCode OrthancPluginRestApiPutAfterPlugins(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a PUT call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2561
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2697
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2732
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3509
OrthancPluginErrorCode OrthancPluginRestApiPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri, const void *body, uint32_t bodySize)
Make a PUT call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2525
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3470
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2662
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2346
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2767
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:2376
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2627
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2477
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2500
OrthancPluginErrorCode OrthancPluginCallRestApi(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, OrthancPluginHttpMethod method, const char *uri, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, const void *body, uint32_t bodySize, uint8_t afterPlugins)
Call the REST API of Orthanc with full flexibility.
Definition: OrthancCPlugin.h:8833
char * OrthancPluginGenerateRestApiAuthorizationToken(OrthancPluginContext *context)
Generate a token to grant full access to the REST API of Orthanc.
Definition: OrthancCPlugin.h:8635
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:5145
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2313
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:2272
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2835
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:6995
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2858
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:2215
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2812
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2913
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2888
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2595
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:4296
OrthancPluginErrorCode OrthancPluginSendMultipartItem(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize)
Send an item as a part of some HTTP multipart answer.
Definition: OrthancCPlugin.h:3709
OrthancPluginErrorCode OrthancPluginSendMultipartItem2(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *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:5742
void OrthancPluginSendHttpStatus(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status, const void *body, uint32_t bodySize)
Send a HTTP status, with a custom body.
Definition: OrthancCPlugin.h:3903
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3680
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1682
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderExecute)(OrthancPluginServerChunkedRequestReader *reader, OrthancPluginRestOutput *output)
Callback invoked whenever the request body is entirely received.
Definition: OrthancCPlugin.h:7607
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 void *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:5855
struct _OrthancPluginJob_t OrthancPluginJob
Opaque structure to a job to be executed by Orthanc.
Definition: OrthancCPlugin.h:1155
OrthancPluginErrorCode OrthancPluginCreateDicom2(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *json, const OrthancPluginImage *pixelData, OrthancPluginCreateDicomFlags flags, const char *privateCreator)
Create a DICOM instance from a JSON string and an image, with a private creator.
Definition: OrthancCPlugin.h:8765
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:2069
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderFactory)(OrthancPluginServerChunkedRequestReader **reader, const char *url, const OrthancPluginHttpRequest *request)
Callback to create a reader to handle incoming chunked HTTP transfers.
Definition: OrthancCPlugin.h:7568
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:6272
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6409
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:4950
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:881
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:4897
OrthancPluginResourceType
Definition: OrthancCPlugin.h:715
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3819
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3540
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5617
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:201
struct _OrthancPluginPeers_t OrthancPluginPeers
Opaque structure to the set of remote Orthanc Peers that are known to the local Orthanc server.
Definition: OrthancCPlugin.h:1147
OrthancPluginErrorCode OrthancPluginHttpPost(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const void *body, uint32_t bodySize, const char *username, const char *password)
Issue a HTTP POST call.
Definition: OrthancCPlugin.h:4387
uint32_t(* OrthancPluginChunkedClientRequestGetChunkSize)(void *request)
Callback to read the size of the current request chunk during a chunked transfer.
Definition: OrthancCPlugin.h:7409
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4841
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, uint32_t size)
Create a 32-bit memory buffer.
Definition: OrthancCPlugin.h:8597
OrthancPluginJob * OrthancPluginCreateJob2(OrthancPluginContext *context, void *job, OrthancPluginJobFinalize finalize, const char *type, OrthancPluginJobGetProgress getProgress, OrthancPluginJobGetContent2 getContent, OrthancPluginJobGetSerialized2 getSerialized, OrthancPluginJobStep step, OrthancPluginJobStop stop, OrthancPluginJobReset reset)
Create a custom job.
Definition: OrthancCPlugin.h:6827
OrthancPluginDicomWebBinaryMode
Definition: OrthancCPlugin.h:970
OrthancPluginErrorCode(* OrthancPluginJobGetContent2)(OrthancPluginMemoryBuffer *target, void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1602
OrthancPluginErrorCode(* OrthancPluginChunkedClientRequestNext)(void *request)
Callback to advance in the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7377
struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode
Opaque structure that represents a node in a JSON or XML document used in DICOMweb.
Definition: OrthancCPlugin.h:1164
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1568
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7137
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:6234
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:845
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:927
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:866
void(* OrthancPluginServerChunkedRequestReaderFinalize)(OrthancPluginServerChunkedRequestReader *reader)
Callback invoked to release the resources associated with an incoming HTTP chunked transfer.
Definition: OrthancCPlugin.h:7625
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:6305
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:3436
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:2053
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6487
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6375
OrthancPluginConstraintType
Definition: OrthancCPlugin.h:896
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:3280
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3788
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1658
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5653
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3574
void OrthancPluginSetMetricsValue(OrthancPluginContext *context, const char *name, float value, OrthancPluginMetricsType type)
Set the value of a metrics.
Definition: OrthancCPlugin.h:7071
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderAddChunk)(OrthancPluginServerChunkedRequestReader *reader, const void *data, uint32_t size)
Callback invoked whenever a new data chunk is available during a chunked transfer.
Definition: OrthancCPlugin.h:7587
OrthancPluginReceivedInstanceAction
Definition: OrthancCPlugin.h:1017
OrthancPluginErrorCode OrthancPluginChunkedHttpClient(OrthancPluginContext *context, void *answer, OrthancPluginChunkedClientAnswerAddChunk answerAddChunk, OrthancPluginChunkedClientAnswerAddHeader answerAddHeader, uint16_t *httpStatus, OrthancPluginHttpMethod method, const char *url, uint32_t headersCount, const char *const *headersKeys, const char *const *headersValues, void *request, OrthancPluginChunkedClientRequestIsDone requestIsDone, OrthancPluginChunkedClientRequestGetChunkData requestChunkData, OrthancPluginChunkedClientRequestGetChunkSize requestChunkSize, OrthancPluginChunkedClientRequestNext requestNext, 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, using chunked HTTP transfers.
Definition: OrthancCPlugin.h:7488
int32_t(* OrthancPluginJobGetSerialized2)(OrthancPluginMemoryBuffer *target, void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1642
void OrthancPluginFreeMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:2021
OrthancPluginErrorCode OrthancPluginHttpPut(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const void *body, uint32_t bodySize, const char *username, const char *password)
Issue a HTTP PUT call.
Definition: OrthancCPlugin.h:4429
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:5038
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:5408
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:5087
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6882
const char * OrthancPluginGetDatabaseServerIdentifier(OrthancPluginContext *context)
Gets the DatabaseServerIdentifier.
Definition: OrthancCPlugin.h:9147
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int priority)
Submit a new job to the jobs engine of Orthanc.
Definition: OrthancCPlugin.h:6914
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5910
OrthancPluginStorageCommitmentFailureReason
Definition: OrthancCPlugin.h:983
OrthancPluginErrorCode(* OrthancPluginChunkedClientAnswerAddChunk)(void *answer, const void *data, uint32_t size)
Callback executed when an answer chunk is received during a chunked transfer.
Definition: OrthancCPlugin.h:7340
const char * OrthancPluginGetPeerUserProperty(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex, const char *userProperty)
Get some user-defined property of an Orthanc peer.
Definition: OrthancCPlugin.h:6574
OrthancPluginMetricsType
Definition: OrthancCPlugin.h:953
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:7027
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4467
uint8_t(* OrthancPluginChunkedClientRequestIsDone)(void *request)
Callback to know whether the request body is entirely read during a chunked transfer.
Definition: OrthancCPlugin.h:7360
const void *(* OrthancPluginChunkedClientRequestGetChunkData)(void *request)
Callback to read the current chunk of the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7393
OrthancPluginJob * OrthancPluginCreateJob(OrthancPluginContext *context, void *job, OrthancPluginJobFinalize finalize, const char *type, OrthancPluginJobGetProgress getProgress, OrthancPluginJobGetContent getContent, OrthancPluginJobGetSerialized getSerialized, OrthancPluginJobStep step, OrthancPluginJobStop stop, OrthancPluginJobReset reset)
Create a custom job.
Definition: OrthancCPlugin.h:6741
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:2005
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7179
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1622
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3639
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *target, uint64_t size)
Create a 64-bit memory buffer.
Definition: OrthancCPlugin.h:8681
OrthancPluginErrorCode(* OrthancPluginChunkedClientAnswerAddHeader)(void *answer, const char *key, const char *value)
Callback executed when a HTTP header is received during a chunked transfer.
Definition: OrthancCPlugin.h:7319
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6439
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1584
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:791
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:4349
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:941
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:3250
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:830
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:2037
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:3315
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:326
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:3392
char * OrthancPluginEncodeDicomWebXml2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7275
OrthancPluginErrorCode OrthancPluginCallPeerApi(OrthancPluginContext *context, OrthancPluginMemoryBuffer *answerBody, OrthancPluginMemoryBuffer *answerHeaders, uint16_t *httpStatus, const OrthancPluginPeers *peers, uint32_t peerIndex, OrthancPluginHttpMethod method, const char *uri, uint32_t additionalHeadersCount, const char *const *additionalHeadersKeys, const char *const *additionalHeadersValues, const void *body, uint32_t bodySize, uint32_t timeout)
Call the REST API of an Orthanc peer.
Definition: OrthancCPlugin.h:6655
struct _OrthancPluginFindMatcher_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:1139
char * OrthancPluginEncodeDicomWebJson2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7231
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5699
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:911
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1555
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1850
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1699
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3850
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginContentType
Definition: OrthancCPlugin.h:700
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6528
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:3414
char * OrthancPluginGetTagName(OrthancPluginContext *context, uint16_t group, uint16_t element, const char *privateCreator)
Returns the symbolic name of a DICOM tag.
Definition: OrthancCPlugin.h:7721
@ OrthancPluginIdentifierConstraint_Wildcard
Definition: OrthancCPlugin.h:885
@ OrthancPluginIdentifierConstraint_Equal
Definition: OrthancCPlugin.h:882
@ OrthancPluginIdentifierConstraint_SmallerOrEqual
Definition: OrthancCPlugin.h:883
@ OrthancPluginIdentifierConstraint_GreaterOrEqual
Definition: OrthancCPlugin.h:884
@ OrthancPluginResourceType_Instance
Definition: OrthancCPlugin.h:719
@ OrthancPluginResourceType_None
Definition: OrthancCPlugin.h:720
@ OrthancPluginResourceType_Series
Definition: OrthancCPlugin.h:718
@ OrthancPluginResourceType_Study
Definition: OrthancCPlugin.h:717
@ OrthancPluginResourceType_Patient
Definition: OrthancCPlugin.h:716
@ OrthancPluginErrorCode_CreateDicomBadParent
Definition: OrthancCPlugin.h:288
@ OrthancPluginErrorCode_MainDicomTagsMultiplyDefined
Definition: OrthancCPlugin.h:247
@ OrthancPluginErrorCode_SQLiteFlush
Definition: OrthancCPlugin.h:256
@ OrthancPluginErrorCode_IncompatibleDatabaseVersion
Definition: OrthancCPlugin.h:221
@ OrthancPluginErrorCode_BadSequenceOfCalls
Definition: OrthancCPlugin.h:209
@ OrthancPluginErrorCode_SharedLibrary
Definition: OrthancCPlugin.h:228
@ OrthancPluginErrorCode_NullPointer
Definition: OrthancCPlugin.h:238
@ OrthancPluginErrorCode_NotLuaPredicate
Definition: OrthancCPlugin.h:298
@ OrthancPluginErrorCode_LuaAlreadyExecuted
Definition: OrthancCPlugin.h:296
@ OrthancPluginErrorCode_NotAcceptable
Definition: OrthancCPlugin.h:237
@ OrthancPluginErrorCode_FullStorage
Definition: OrthancCPlugin.h:222
@ OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered
Definition: OrthancCPlugin.h:301
@ OrthancPluginErrorCode_InexistentFile
Definition: OrthancCPlugin.h:216
@ OrthancPluginErrorCode_CreateDicomParentEncoding
Definition: OrthancCPlugin.h:290
@ OrthancPluginErrorCode_CannotOrderSlices
Definition: OrthancCPlugin.h:304
@ OrthancPluginErrorCode_InternalError
Definition: OrthancCPlugin.h:202
@ OrthancPluginErrorCode_DiscontinuedAbi
Definition: OrthancCPlugin.h:243
@ OrthancPluginErrorCode_NoCFindHandler
Definition: OrthancCPlugin.h:274
@ OrthancPluginErrorCode_SQLiteCommitWithoutTransaction
Definition: OrthancCPlugin.h:254
@ OrthancPluginErrorCode_DatabasePlugin
Definition: OrthancCPlugin.h:234
@ OrthancPluginErrorCode_SQLiteStatementAlreadyUsed
Definition: OrthancCPlugin.h:251
@ OrthancPluginErrorCode_SQLiteCannotRun
Definition: OrthancCPlugin.h:257
@ OrthancPluginErrorCode_UnknownPluginService
Definition: OrthancCPlugin.h:229
@ OrthancPluginErrorCode_JsonToLuaTable
Definition: OrthancCPlugin.h:293
@ OrthancPluginErrorCode_CreateDicomOverrideTag
Definition: OrthancCPlugin.h:284
@ OrthancPluginErrorCode_SQLiteBindOutOfRange
Definition: OrthancCPlugin.h:259
@ OrthancPluginErrorCode_ParameterOutOfRange
Definition: OrthancCPlugin.h:206
@ OrthancPluginErrorCode_SQLiteRegisterFunction
Definition: OrthancCPlugin.h:255
@ OrthancPluginErrorCode_SQLiteTransactionBegin
Definition: OrthancCPlugin.h:263
@ OrthancPluginErrorCode_CreateDicomNoPayload
Definition: OrthancCPlugin.h:286
@ OrthancPluginErrorCode_Unauthorized
Definition: OrthancCPlugin.h:232
@ OrthancPluginErrorCode_RegularFileExpected
Definition: OrthancCPlugin.h:270
@ OrthancPluginErrorCode_DicomPortInUse
Definition: OrthancCPlugin.h:268
@ OrthancPluginErrorCode_BadApplicationEntityTitle
Definition: OrthancCPlugin.h:273
@ OrthancPluginErrorCode_NoCStoreHandler
Definition: OrthancCPlugin.h:276
@ OrthancPluginErrorCode_PathToExecutable
Definition: OrthancCPlugin.h:271
@ OrthancPluginErrorCode_NoSopClassOrInstance
Definition: OrthancCPlugin.h:278
@ OrthancPluginErrorCode_BadFont
Definition: OrthancCPlugin.h:233
@ OrthancPluginErrorCode_DatabaseUnavailable
Definition: OrthancCPlugin.h:239
@ OrthancPluginErrorCode_CannotCreateLua
Definition: OrthancCPlugin.h:294
@ OrthancPluginErrorCode_SQLiteExecute
Definition: OrthancCPlugin.h:252
@ OrthancPluginErrorCode_UriSyntax
Definition: OrthancCPlugin.h:215
@ OrthancPluginErrorCode_DirectoryOverFile
Definition: OrthancCPlugin.h:264
@ OrthancPluginErrorCode_Revision
Definition: OrthancCPlugin.h:246
@ OrthancPluginErrorCode_InexistentTag
Definition: OrthancCPlugin.h:224
@ OrthancPluginErrorCode_IncompatibleImageFormat
Definition: OrthancCPlugin.h:226
@ OrthancPluginErrorCode_UnsupportedMediaType
Definition: OrthancCPlugin.h:309
@ OrthancPluginErrorCode_DicomFindUnavailable
Definition: OrthancCPlugin.h:280
@ OrthancPluginErrorCode_SQLiteCannotStep
Definition: OrthancCPlugin.h:258
@ OrthancPluginErrorCode_CreateDicomParentIsInstance
Definition: OrthancCPlugin.h:289
@ OrthancPluginErrorCode_StorageAreaAlreadyRegistered
Definition: OrthancCPlugin.h:300
@ OrthancPluginErrorCode_LuaReturnsNoString
Definition: OrthancCPlugin.h:299
@ OrthancPluginErrorCode_UnknownResource
Definition: OrthancCPlugin.h:220
@ OrthancPluginErrorCode_CreateDicomNotString
Definition: OrthancCPlugin.h:283
@ OrthancPluginErrorCode_HttpPortInUse
Definition: OrthancCPlugin.h:267
@ OrthancPluginErrorCode_SslDisabled
Definition: OrthancCPlugin.h:303
@ OrthancPluginErrorCode_UnknownModality
Definition: OrthancCPlugin.h:291
@ OrthancPluginErrorCode_BadHttpStatusInRest
Definition: OrthancCPlugin.h:269
@ OrthancPluginErrorCode_BadGeometry
Definition: OrthancCPlugin.h:241
@ OrthancPluginErrorCode_AlreadyExistingTag
Definition: OrthancCPlugin.h:306
@ OrthancPluginErrorCode_FileStorageCannotWrite
Definition: OrthancCPlugin.h:265
@ OrthancPluginErrorCode_CreateDicomUseDataUriScheme
Definition: OrthancCPlugin.h:287
@ OrthancPluginErrorCode_DirectoryExpected
Definition: OrthancCPlugin.h:266
@ OrthancPluginErrorCode_NoCMoveHandler
Definition: OrthancCPlugin.h:275
@ OrthancPluginErrorCode_SQLitePrepareStatement
Definition: OrthancCPlugin.h:260
@ OrthancPluginErrorCode_CorruptedFile
Definition: OrthancCPlugin.h:223
@ OrthancPluginErrorCode_StorageAreaPlugin
Definition: OrthancCPlugin.h:235
@ OrthancPluginErrorCode_BadJobOrdering
Definition: OrthancCPlugin.h:292
@ OrthancPluginErrorCode_DatabaseCannotSerialize
Definition: OrthancCPlugin.h:245
@ OrthancPluginErrorCode_CanceledJob
Definition: OrthancCPlugin.h:240
@ OrthancPluginErrorCode_BadRange
Definition: OrthancCPlugin.h:244
@ OrthancPluginErrorCode_NotImplemented
Definition: OrthancCPlugin.h:205
@ OrthancPluginErrorCode_SslInitialization
Definition: OrthancCPlugin.h:242
@ OrthancPluginErrorCode_IncompatibleImageSize
Definition: OrthancCPlugin.h:227
@ OrthancPluginErrorCode_BadFileFormat
Definition: OrthancCPlugin.h:218
@ OrthancPluginErrorCode_BadRequest
Definition: OrthancCPlugin.h:211
@ OrthancPluginErrorCode_SystemCommand
Definition: OrthancCPlugin.h:213
@ OrthancPluginErrorCode_NoStorageCommitmentHandler
Definition: OrthancCPlugin.h:307
@ OrthancPluginErrorCode_SQLiteAlreadyOpened
Definition: OrthancCPlugin.h:249
@ OrthancPluginErrorCode_Plugin
Definition: OrthancCPlugin.h:204
@ OrthancPluginErrorCode_CannotExecuteLua
Definition: OrthancCPlugin.h:295
@ OrthancPluginErrorCode_SQLiteRollbackWithoutTransaction
Definition: OrthancCPlugin.h:253
@ OrthancPluginErrorCode_UnknownDicomTag
Definition: OrthancCPlugin.h:230
@ OrthancPluginErrorCode_NoPresentationContext
Definition: OrthancCPlugin.h:279
@ OrthancPluginErrorCode_EmptyRequest
Definition: OrthancCPlugin.h:236
@ OrthancPluginErrorCode_DatabaseNotInitialized
Definition: OrthancCPlugin.h:302
@ OrthancPluginErrorCode_DicomMoveUnavailable
Definition: OrthancCPlugin.h:281
@ OrthancPluginErrorCode_SQLiteTransactionCommit
Definition: OrthancCPlugin.h:262
@ OrthancPluginErrorCode_BadJson
Definition: OrthancCPlugin.h:231
@ OrthancPluginErrorCode_Success
Definition: OrthancCPlugin.h:203
@ OrthancPluginErrorCode_NetworkProtocol
Definition: OrthancCPlugin.h:212
@ OrthancPluginErrorCode_NoApplicationEntityFilter
Definition: OrthancCPlugin.h:277
@ OrthancPluginErrorCode_InexistentItem
Definition: OrthancCPlugin.h:210
@ OrthancPluginErrorCode_Timeout
Definition: OrthancCPlugin.h:219
@ OrthancPluginErrorCode_LuaBadOutput
Definition: OrthancCPlugin.h:297
@ OrthancPluginErrorCode_SQLiteTransactionAlreadyStarted
Definition: OrthancCPlugin.h:261
@ OrthancPluginErrorCode_NoCGetHandler
Definition: OrthancCPlugin.h:308
@ OrthancPluginErrorCode_SQLiteNotOpened
Definition: OrthancCPlugin.h:248
@ OrthancPluginErrorCode_ReadOnly
Definition: OrthancCPlugin.h:225
@ OrthancPluginErrorCode_CannotStoreInstance
Definition: OrthancCPlugin.h:282
@ OrthancPluginErrorCode_CannotWriteFile
Definition: OrthancCPlugin.h:217
@ OrthancPluginErrorCode_BadParameterType
Definition: OrthancCPlugin.h:208
@ OrthancPluginErrorCode_NotEnoughMemory
Definition: OrthancCPlugin.h:207
@ OrthancPluginErrorCode_CreateDicomUseContent
Definition: OrthancCPlugin.h:285
@ OrthancPluginErrorCode_Database
Definition: OrthancCPlugin.h:214
@ OrthancPluginErrorCode_SQLiteCannotOpen
Definition: OrthancCPlugin.h:250
@ OrthancPluginErrorCode_MakeDirectory
Definition: OrthancCPlugin.h:272
@ OrthancPluginErrorCode_NoWorklistHandler
Definition: OrthancCPlugin.h:305
@ OrthancPluginDicomWebBinaryMode_InlineBinary
Definition: OrthancCPlugin.h:972
@ OrthancPluginDicomWebBinaryMode_BulkDataUri
Definition: OrthancCPlugin.h:973
@ OrthancPluginDicomWebBinaryMode_Ignore
Definition: OrthancCPlugin.h:971
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii
Definition: OrthancCPlugin.h:851
@ OrthancPluginDicomToJsonFlags_IncludeBinary
Definition: OrthancCPlugin.h:847
@ OrthancPluginDicomToJsonFlags_IncludePixelData
Definition: OrthancCPlugin.h:850
@ OrthancPluginDicomToJsonFlags_IncludeUnknownTags
Definition: OrthancCPlugin.h:849
@ OrthancPluginDicomToJsonFlags_SkipGroupLengths
Definition: OrthancCPlugin.h:854
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
Definition: OrthancCPlugin.h:852
@ OrthancPluginDicomToJsonFlags_StopAfterPixelData
Definition: OrthancCPlugin.h:853
@ OrthancPluginDicomToJsonFlags_IncludePrivateTags
Definition: OrthancCPlugin.h:848
@ OrthancPluginJobStepStatus_Continue
Definition: OrthancCPlugin.h:930
@ OrthancPluginJobStepStatus_Success
Definition: OrthancCPlugin.h:928
@ OrthancPluginJobStepStatus_Failure
Definition: OrthancCPlugin.h:929
@ OrthancPluginCreateDicomFlags_DecodeDataUriScheme
Definition: OrthancCPlugin.h:868
@ OrthancPluginCreateDicomFlags_GenerateIdentifiers
Definition: OrthancCPlugin.h:869
@ OrthancPluginConstraintType_SmallerOrEqual
Definition: OrthancCPlugin.h:898
@ OrthancPluginConstraintType_List
Definition: OrthancCPlugin.h:901
@ OrthancPluginConstraintType_GreaterOrEqual
Definition: OrthancCPlugin.h:899
@ OrthancPluginConstraintType_Equal
Definition: OrthancCPlugin.h:897
@ OrthancPluginConstraintType_Wildcard
Definition: OrthancCPlugin.h:900
@ OrthancPluginReceivedInstanceAction_KeepAsIs
Definition: OrthancCPlugin.h:1018
@ OrthancPluginReceivedInstanceAction_Discard
Definition: OrthancCPlugin.h:1020
@ OrthancPluginReceivedInstanceAction_Modify
Definition: OrthancCPlugin.h:1019
@ OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
Definition: OrthancCPlugin.h:998
@ OrthancPluginStorageCommitmentFailureReason_Success
Definition: OrthancCPlugin.h:984
@ OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
Definition: OrthancCPlugin.h:1007
@ OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
Definition: OrthancCPlugin.h:1002
@ OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
Definition: OrthancCPlugin.h:994
@ OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
Definition: OrthancCPlugin.h:990
@ OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
Definition: OrthancCPlugin.h:987
@ OrthancPluginMetricsType_Default
Definition: OrthancCPlugin.h:954
@ OrthancPluginMetricsType_Timer
Definition: OrthancCPlugin.h:961
@ OrthancPluginValueRepresentation_PN
Definition: OrthancCPlugin.h:807
@ OrthancPluginValueRepresentation_UL
Definition: OrthancCPlugin.h:815
@ OrthancPluginValueRepresentation_UN
Definition: OrthancCPlugin.h:816
@ OrthancPluginValueRepresentation_DA
Definition: OrthancCPlugin.h:796
@ OrthancPluginValueRepresentation_OF
Definition: OrthancCPlugin.h:805
@ OrthancPluginValueRepresentation_OW
Definition: OrthancCPlugin.h:806
@ OrthancPluginValueRepresentation_CS
Definition: OrthancCPlugin.h:795
@ OrthancPluginValueRepresentation_US
Definition: OrthancCPlugin.h:817
@ OrthancPluginValueRepresentation_SH
Definition: OrthancCPlugin.h:808
@ OrthancPluginValueRepresentation_FL
Definition: OrthancCPlugin.h:800
@ OrthancPluginValueRepresentation_DT
Definition: OrthancCPlugin.h:798
@ OrthancPluginValueRepresentation_TM
Definition: OrthancCPlugin.h:813
@ OrthancPluginValueRepresentation_SQ
Definition: OrthancCPlugin.h:810
@ OrthancPluginValueRepresentation_DS
Definition: OrthancCPlugin.h:797
@ OrthancPluginValueRepresentation_OB
Definition: OrthancCPlugin.h:804
@ OrthancPluginValueRepresentation_SL
Definition: OrthancCPlugin.h:809
@ OrthancPluginValueRepresentation_ST
Definition: OrthancCPlugin.h:812
@ OrthancPluginValueRepresentation_IS
Definition: OrthancCPlugin.h:801
@ OrthancPluginValueRepresentation_LT
Definition: OrthancCPlugin.h:803
@ OrthancPluginValueRepresentation_SS
Definition: OrthancCPlugin.h:811
@ OrthancPluginValueRepresentation_UT
Definition: OrthancCPlugin.h:818
@ OrthancPluginValueRepresentation_LO
Definition: OrthancCPlugin.h:802
@ OrthancPluginValueRepresentation_AE
Definition: OrthancCPlugin.h:792
@ OrthancPluginValueRepresentation_FD
Definition: OrthancCPlugin.h:799
@ OrthancPluginValueRepresentation_UI
Definition: OrthancCPlugin.h:814
@ OrthancPluginValueRepresentation_AS
Definition: OrthancCPlugin.h:793
@ OrthancPluginValueRepresentation_AT
Definition: OrthancCPlugin.h:794
@ OrthancPluginJobStopReason_Failure
Definition: OrthancCPlugin.h:944
@ OrthancPluginJobStopReason_Success
Definition: OrthancCPlugin.h:942
@ OrthancPluginJobStopReason_Canceled
Definition: OrthancCPlugin.h:945
@ OrthancPluginJobStopReason_Paused
Definition: OrthancCPlugin.h:943
@ OrthancPluginDicomToJsonFormat_Full
Definition: OrthancCPlugin.h:831
@ OrthancPluginDicomToJsonFormat_Human
Definition: OrthancCPlugin.h:833
@ OrthancPluginDicomToJsonFormat_Short
Definition: OrthancCPlugin.h:832
@ OrthancPluginHttpMethod_Delete
Definition: OrthancCPlugin.h:330
@ OrthancPluginHttpMethod_Post
Definition: OrthancCPlugin.h:328
@ OrthancPluginHttpMethod_Put
Definition: OrthancCPlugin.h:329
@ OrthancPluginHttpMethod_Get
Definition: OrthancCPlugin.h:327
@ OrthancPluginInstanceOrigin_Unknown
Definition: OrthancCPlugin.h:912
@ OrthancPluginInstanceOrigin_RestApi
Definition: OrthancCPlugin.h:914
@ OrthancPluginInstanceOrigin_Lua
Definition: OrthancCPlugin.h:916
@ OrthancPluginInstanceOrigin_WebDav
Definition: OrthancCPlugin.h:917
@ OrthancPluginInstanceOrigin_DicomProtocol
Definition: OrthancCPlugin.h:913
@ OrthancPluginInstanceOrigin_Plugin
Definition: OrthancCPlugin.h:915
@ OrthancPluginContentType_Dicom
Definition: OrthancCPlugin.h:702
@ OrthancPluginContentType_DicomAsJson
Definition: OrthancCPlugin.h:703
@ OrthancPluginContentType_Unknown
Definition: OrthancCPlugin.h:701
@ OrthancPluginContentType_DicomUntilPixelData
Definition: OrthancCPlugin.h:704
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1832
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1836
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1837
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1835
uint16_t element
Definition: OrthancCPlugin.h:1834
uint16_t group
Definition: OrthancCPlugin.h:1833
The parameters of a REST request.
Definition: OrthancCPlugin.h:341
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:370
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:355
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:380
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:350
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:395
const void * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:375
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:365
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:390
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:345
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:360
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:400
A 64-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1056
uint64_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1065
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1060
A 32-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1034
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1043
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1038