Orthanc Plugin SDK 1.12.1
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 1
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 _OrthancPluginService_SetMetricsIntegerValue = 43, /* New in Orthanc 1.12.1 */
451
452 /* Registration of callbacks */
453 _OrthancPluginService_RegisterRestCallback = 1000,
454 _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
455 _OrthancPluginService_RegisterStorageArea = 1002,
456 _OrthancPluginService_RegisterOnChangeCallback = 1003,
457 _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
458 _OrthancPluginService_RegisterWorklistCallback = 1005,
459 _OrthancPluginService_RegisterDecodeImageCallback = 1006,
460 _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
461 _OrthancPluginService_RegisterFindCallback = 1008,
462 _OrthancPluginService_RegisterMoveCallback = 1009,
463 _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
464 _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
465 _OrthancPluginService_RegisterChunkedRestCallback = 1012, /* New in Orthanc 1.5.7 */
466 _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
467 _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
468 _OrthancPluginService_RegisterTranscoderCallback = 1015, /* New in Orthanc 1.7.0 */
469 _OrthancPluginService_RegisterStorageArea2 = 1016, /* New in Orthanc 1.9.0 */
470 _OrthancPluginService_RegisterIncomingCStoreInstanceFilter = 1017, /* New in Orthanc 1.10.0 */
471 _OrthancPluginService_RegisterReceivedInstanceCallback = 1018, /* New in Orthanc 1.10.0 */
472 _OrthancPluginService_RegisterWebDavCollection = 1019, /* New in Orthanc 1.10.1 */
473
474 /* Sending answers to REST calls */
475 _OrthancPluginService_AnswerBuffer = 2000,
476 _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
477 _OrthancPluginService_Redirect = 2002,
478 _OrthancPluginService_SendHttpStatusCode = 2003,
479 _OrthancPluginService_SendUnauthorized = 2004,
480 _OrthancPluginService_SendMethodNotAllowed = 2005,
481 _OrthancPluginService_SetCookie = 2006,
482 _OrthancPluginService_SetHttpHeader = 2007,
483 _OrthancPluginService_StartMultipartAnswer = 2008,
484 _OrthancPluginService_SendMultipartItem = 2009,
485 _OrthancPluginService_SendHttpStatus = 2010,
486 _OrthancPluginService_CompressAndAnswerImage = 2011,
487 _OrthancPluginService_SendMultipartItem2 = 2012,
488 _OrthancPluginService_SetHttpErrorDetails = 2013,
489
490 /* Access to the Orthanc database and API */
491 _OrthancPluginService_GetDicomForInstance = 3000,
492 _OrthancPluginService_RestApiGet = 3001,
493 _OrthancPluginService_RestApiPost = 3002,
494 _OrthancPluginService_RestApiDelete = 3003,
495 _OrthancPluginService_RestApiPut = 3004,
496 _OrthancPluginService_LookupPatient = 3005,
497 _OrthancPluginService_LookupStudy = 3006,
498 _OrthancPluginService_LookupSeries = 3007,
499 _OrthancPluginService_LookupInstance = 3008,
500 _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
501 _OrthancPluginService_RestApiGetAfterPlugins = 3010,
502 _OrthancPluginService_RestApiPostAfterPlugins = 3011,
503 _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
504 _OrthancPluginService_RestApiPutAfterPlugins = 3013,
505 _OrthancPluginService_ReconstructMainDicomTags = 3014,
506 _OrthancPluginService_RestApiGet2 = 3015,
507 _OrthancPluginService_CallRestApi = 3016, /* New in Orthanc 1.9.2 */
508
509 /* Access to DICOM instances */
510 _OrthancPluginService_GetInstanceRemoteAet = 4000,
511 _OrthancPluginService_GetInstanceSize = 4001,
512 _OrthancPluginService_GetInstanceData = 4002,
513 _OrthancPluginService_GetInstanceJson = 4003,
514 _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
515 _OrthancPluginService_HasInstanceMetadata = 4005,
516 _OrthancPluginService_GetInstanceMetadata = 4006,
517 _OrthancPluginService_GetInstanceOrigin = 4007,
518 _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
519 _OrthancPluginService_HasInstancePixelData = 4009,
520 _OrthancPluginService_CreateDicomInstance = 4010, /* New in Orthanc 1.7.0 */
521 _OrthancPluginService_FreeDicomInstance = 4011, /* New in Orthanc 1.7.0 */
522 _OrthancPluginService_GetInstanceFramesCount = 4012, /* New in Orthanc 1.7.0 */
523 _OrthancPluginService_GetInstanceRawFrame = 4013, /* New in Orthanc 1.7.0 */
524 _OrthancPluginService_GetInstanceDecodedFrame = 4014, /* New in Orthanc 1.7.0 */
525 _OrthancPluginService_TranscodeDicomInstance = 4015, /* New in Orthanc 1.7.0 */
526 _OrthancPluginService_SerializeDicomInstance = 4016, /* New in Orthanc 1.7.0 */
527 _OrthancPluginService_GetInstanceAdvancedJson = 4017, /* New in Orthanc 1.7.0 */
528 _OrthancPluginService_GetInstanceDicomWebJson = 4018, /* New in Orthanc 1.7.0 */
529 _OrthancPluginService_GetInstanceDicomWebXml = 4019, /* New in Orthanc 1.7.0 */
530 _OrthancPluginService_LoadDicomInstance = 4020, /* New in Orthanc 1.12.1 */
531
532 /* Services for plugins implementing a database back-end */
533 _OrthancPluginService_RegisterDatabaseBackend = 5000, /* New in Orthanc 0.8.6 */
534 _OrthancPluginService_DatabaseAnswer = 5001,
535 _OrthancPluginService_RegisterDatabaseBackendV2 = 5002, /* New in Orthanc 0.9.4 */
536 _OrthancPluginService_StorageAreaCreate = 5003,
537 _OrthancPluginService_StorageAreaRead = 5004,
538 _OrthancPluginService_StorageAreaRemove = 5005,
539 _OrthancPluginService_RegisterDatabaseBackendV3 = 5006, /* New in Orthanc 1.9.2 */
540 _OrthancPluginService_RegisterDatabaseBackendV4 = 5007, /* New in Orthanc 1.12.0 */
541
542 /* Primitives for handling images */
543 _OrthancPluginService_GetImagePixelFormat = 6000,
544 _OrthancPluginService_GetImageWidth = 6001,
545 _OrthancPluginService_GetImageHeight = 6002,
546 _OrthancPluginService_GetImagePitch = 6003,
547 _OrthancPluginService_GetImageBuffer = 6004,
548 _OrthancPluginService_UncompressImage = 6005,
549 _OrthancPluginService_FreeImage = 6006,
550 _OrthancPluginService_CompressImage = 6007,
551 _OrthancPluginService_ConvertPixelFormat = 6008,
552 _OrthancPluginService_GetFontsCount = 6009,
553 _OrthancPluginService_GetFontInfo = 6010,
554 _OrthancPluginService_DrawText = 6011,
555 _OrthancPluginService_CreateImage = 6012,
556 _OrthancPluginService_CreateImageAccessor = 6013,
557 _OrthancPluginService_DecodeDicomImage = 6014,
558
559 /* Primitives for handling C-Find, C-Move and worklists */
560 _OrthancPluginService_WorklistAddAnswer = 7000,
561 _OrthancPluginService_WorklistMarkIncomplete = 7001,
562 _OrthancPluginService_WorklistIsMatch = 7002,
563 _OrthancPluginService_WorklistGetDicomQuery = 7003,
564 _OrthancPluginService_FindAddAnswer = 7004,
565 _OrthancPluginService_FindMarkIncomplete = 7005,
566 _OrthancPluginService_GetFindQuerySize = 7006,
567 _OrthancPluginService_GetFindQueryTag = 7007,
568 _OrthancPluginService_GetFindQueryTagName = 7008,
569 _OrthancPluginService_GetFindQueryValue = 7009,
570 _OrthancPluginService_CreateFindMatcher = 7010,
571 _OrthancPluginService_FreeFindMatcher = 7011,
572 _OrthancPluginService_FindMatcherIsMatch = 7012,
573
574 /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
575 _OrthancPluginService_GetPeers = 8000,
576 _OrthancPluginService_FreePeers = 8001,
577 _OrthancPluginService_GetPeersCount = 8003,
578 _OrthancPluginService_GetPeerName = 8004,
579 _OrthancPluginService_GetPeerUrl = 8005,
580 _OrthancPluginService_CallPeerApi = 8006,
581 _OrthancPluginService_GetPeerUserProperty = 8007,
582
583 /* Primitives for handling jobs (new in 1.4.2) */
584 _OrthancPluginService_CreateJob = 9000, /* Deprecated since SDK 1.11.3 */
585 _OrthancPluginService_FreeJob = 9001,
586 _OrthancPluginService_SubmitJob = 9002,
587 _OrthancPluginService_RegisterJobsUnserializer = 9003,
588 _OrthancPluginService_CreateJob2 = 9004, /* New in SDK 1.11.3 */
589
590 _OrthancPluginService_INTERNAL = 0x7fffffff
591 } _OrthancPluginService;
592
593
594 typedef enum
595 {
596 _OrthancPluginProperty_Description = 1,
597 _OrthancPluginProperty_RootUri = 2,
598 _OrthancPluginProperty_OrthancExplorer = 3,
599
600 _OrthancPluginProperty_INTERNAL = 0x7fffffff
601 } _OrthancPluginProperty;
602
603
604
609 typedef enum
610 {
618
626
634
642
650
660
668
676
684
692
693 _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
695
696
697
701 typedef enum
702 {
708 _OrthancPluginContentType_INTERNAL = 0x7fffffff
710
711
712
716 typedef enum
717 {
724 _OrthancPluginResourceType_INTERNAL = 0x7fffffff
726
727
728
733 typedef enum
734 {
755 _OrthancPluginChangeType_INTERNAL = 0x7fffffff
757
758
763 typedef enum
764 {
770 _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
772
773
778 typedef enum
779 {
784 _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
786
787
792 typedef enum
793 {
822 _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
824
825
831 typedef enum
832 {
837 _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
839
840
846 typedef enum
847 {
848 OrthancPluginDicomToJsonFlags_None = 0,
858 _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
860
861
867 typedef enum
868 {
869 OrthancPluginCreateDicomFlags_None = 0,
873 _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
875
876
882 typedef enum
883 {
889 _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
891
892
897 typedef enum
898 {
905 _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
907
908
912 typedef enum
913 {
921 _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
923
924
928 typedef enum
929 {
934
935
942 typedef enum
943 {
949
950
954 typedef enum
955 {
965
966
971 typedef enum
972 {
977
978
984 typedef enum
985 {
1013
1014
1018 typedef enum
1019 {
1024 _OrthancPluginReceivedInstanceAction_INTERNAL = 0x7fffffff
1026
1027
1032 typedef enum
1033 {
1046 _OrthancPluginLoadDicomInstanceMode_INTERNAL = 0x7fffffff
1048
1049
1057 typedef struct
1058 {
1062 void* data;
1063
1067 uint32_t size;
1069
1070
1071
1079 typedef struct
1080 {
1084 void* data;
1085
1089 uint64_t size;
1091
1092
1093
1094
1099 typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
1100
1101
1102
1107 typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
1108
1109
1110
1115 typedef struct _OrthancPluginImage_t OrthancPluginImage;
1116
1117
1118
1123 typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
1124
1125
1126
1131 typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
1132
1133
1134
1139 typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
1140
1141
1142
1147 typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1148
1149
1150
1155 typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1156
1157
1158
1163 typedef struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher;
1164
1165
1166
1171 typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1172
1173
1174
1179 typedef struct _OrthancPluginJob_t OrthancPluginJob;
1180
1181
1182
1188 typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1189
1190
1191
1198 const char* url,
1199 const OrthancPluginHttpRequest* request);
1200
1201
1202
1208 const OrthancPluginDicomInstance* instance,
1209 const char* instanceId);
1210
1211
1212
1218 OrthancPluginChangeType changeType,
1219 OrthancPluginResourceType resourceType,
1220 const char* resourceId);
1221
1222
1223
1229 OrthancPluginImage** target,
1230 const void* dicom,
1231 const uint32_t size,
1232 uint32_t frameIndex);
1233
1234
1235
1240 typedef void (*OrthancPluginFree) (void* buffer);
1241
1242
1243
1253 const char* bulkDataUri);
1254
1255
1256
1270 const char* uuid,
1271 const void* content,
1272 int64_t size,
1274
1275
1276
1297 void** content,
1298 int64_t* size,
1299 const char* uuid,
1301
1302
1303
1318 const char* uuid,
1320
1321
1322
1341 const char* uuid,
1343 uint64_t rangeStart);
1344
1345
1346
1358 const char* uuid,
1360
1361
1362
1378 const OrthancPluginWorklistQuery* query,
1379 const char* issuerAet,
1380 const char* calledAet);
1381
1382
1383
1409 const char* uri,
1410 const char* ip,
1411 uint32_t headersCount,
1412 const char* const* headersKeys,
1413 const char* const* headersValues);
1414
1415
1416
1444 const char* uri,
1445 const char* ip,
1446 uint32_t headersCount,
1447 const char* const* headersKeys,
1448 const char* const* headersValues,
1449 uint32_t getArgumentsCount,
1450 const char* const* getArgumentsKeys,
1451 const char* const* getArgumentsValues);
1452
1453
1454
1470 OrthancPluginFindAnswers* answers,
1471 const OrthancPluginFindQuery* query,
1472 const char* issuerAet,
1473 const char* calledAet);
1474
1475
1476
1512 typedef void* (*OrthancPluginMoveCallback) (
1513 OrthancPluginResourceType resourceType,
1514 const char* patientId,
1515 const char* accessionNumber,
1516 const char* studyInstanceUid,
1517 const char* seriesInstanceUid,
1518 const char* sopInstanceUid,
1519 const char* originatorAet,
1520 const char* sourceAet,
1521 const char* targetAet,
1522 uint16_t originatorId);
1523
1524
1537 typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1538
1539
1552 typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1553
1554
1566 typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1567
1568
1579 typedef void (*OrthancPluginJobFinalize) (void* job);
1580
1581
1592 typedef float (*OrthancPluginJobGetProgress) (void* job);
1593
1594
1608 typedef const char* (*OrthancPluginJobGetContent) (void* job);
1609
1610
1627 void* job);
1628
1629
1646 typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1647
1648
1667 void* job);
1668
1669
1683
1684
1708
1709
1724
1725
1739 typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1740 const char* serialized);
1741
1742
1743
1759
1760
1761
1789 uint32_t levelDepth,
1790 const uint16_t* levelTagGroup,
1791 const uint16_t* levelTagElement,
1792 const uint32_t* levelIndex,
1793 uint16_t tagGroup,
1794 uint16_t tagElement,
1796
1797
1798
1827 uint32_t levelDepth,
1828 const uint16_t* levelTagGroup,
1829 const uint16_t* levelTagElement,
1830 const uint32_t* levelIndex,
1831 uint16_t tagGroup,
1832 uint16_t tagElement,
1834 void* payload);
1835
1836
1837
1841 typedef struct _OrthancPluginContext_t
1842 {
1843 void* pluginsManager;
1844 const char* orthancVersion;
1845 OrthancPluginFree Free;
1846 OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1847 _OrthancPluginService service,
1848 const void* params);
1850
1851
1852
1856 typedef struct
1857 {
1858 uint16_t group;
1859 uint16_t element;
1864
1865
1866
1875 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1876 OrthancPluginContext* context,
1877 char* str)
1878 {
1879 if (str != NULL)
1880 {
1881 context->Free(str);
1882 }
1883 }
1884
1885
1905 ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersionAdvanced(
1906 OrthancPluginContext* context,
1907 int expectedMajor,
1908 int expectedMinor,
1909 int expectedRevision)
1910 {
1911 int major, minor, revision;
1912
1913 if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1914 sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1915 sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1916 sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1917 sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1918 sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1919 sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1920 sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1921 sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1922 sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1923 sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1924 sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1925 sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1926 sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1927 sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1928 sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1929 sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1930 sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
1931 sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
1932 sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
1933 sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason) ||
1934 sizeof(int32_t) != sizeof(OrthancPluginLoadDicomInstanceMode))
1935 {
1936 /* Mismatch in the size of the enumerations */
1937 return 0;
1938 }
1939
1940 /* Assume compatibility with the mainline */
1941 if (!strcmp(context->orthancVersion, "mainline"))
1942 {
1943 return 1;
1944 }
1945
1946 /* Parse the version of the Orthanc core */
1947 if (
1948#ifdef _MSC_VER
1949 sscanf_s
1950#else
1951 sscanf
1952#endif
1953 (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1954 {
1955 return 0;
1956 }
1957
1958 /* Check the major number of the version */
1959
1960 if (major > expectedMajor)
1961 {
1962 return 1;
1963 }
1964
1965 if (major < expectedMajor)
1966 {
1967 return 0;
1968 }
1969
1970 /* Check the minor number of the version */
1971
1972 if (minor > expectedMinor)
1973 {
1974 return 1;
1975 }
1976
1977 if (minor < expectedMinor)
1978 {
1979 return 0;
1980 }
1981
1982 /* Check the revision number of the version */
1983
1984 if (revision >= expectedRevision)
1985 {
1986 return 1;
1987 }
1988 else
1989 {
1990 return 0;
1991 }
1992 }
1993
1994
2011 ORTHANC_PLUGIN_INLINE int OrthancPluginCheckVersion(
2012 OrthancPluginContext* context)
2013 {
2015 context,
2016 ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
2017 ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
2018 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
2019 }
2020
2021
2030 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
2031 OrthancPluginContext* context,
2033 {
2034 context->Free(buffer->data);
2035 }
2036
2037
2046 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer64(
2047 OrthancPluginContext* context,
2049 {
2050 context->Free(buffer->data);
2051 }
2052
2053
2062 ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
2063 OrthancPluginContext* context,
2064 const char* message)
2065 {
2066 context->InvokeService(context, _OrthancPluginService_LogError, message);
2067 }
2068
2069
2078 ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
2079 OrthancPluginContext* context,
2080 const char* message)
2081 {
2082 context->InvokeService(context, _OrthancPluginService_LogWarning, message);
2083 }
2084
2085
2094 ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
2095 OrthancPluginContext* context,
2096 const char* message)
2097 {
2098 context->InvokeService(context, _OrthancPluginService_LogInfo, message);
2099 }
2100
2101
2102
2103 typedef struct
2104 {
2105 const char* pathRegularExpression;
2107 } _OrthancPluginRestCallback;
2108
2130 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
2131 OrthancPluginContext* context,
2132 const char* pathRegularExpression,
2134 {
2135 _OrthancPluginRestCallback params;
2136 params.pathRegularExpression = pathRegularExpression;
2137 params.callback = callback;
2138 context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
2139 }
2140
2141
2142
2171 OrthancPluginContext* context,
2172 const char* pathRegularExpression,
2174 {
2175 _OrthancPluginRestCallback params;
2176 params.pathRegularExpression = pathRegularExpression;
2177 params.callback = callback;
2178 context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
2179 }
2180
2181
2182
2183 typedef struct
2184 {
2186 } _OrthancPluginOnStoredInstanceCallback;
2187
2209 OrthancPluginContext* context,
2211 {
2212 _OrthancPluginOnStoredInstanceCallback params;
2213 params.callback = callback;
2214
2215 context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
2216 }
2217
2218
2219
2220 typedef struct
2221 {
2223 const void* answer;
2224 uint32_t answerSize;
2225 const char* mimeType;
2226 } _OrthancPluginAnswerBuffer;
2227
2240 ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
2241 OrthancPluginContext* context,
2243 const void* answer,
2244 uint32_t answerSize,
2245 const char* mimeType)
2246 {
2247 _OrthancPluginAnswerBuffer params;
2248 params.output = output;
2249 params.answer = answer;
2250 params.answerSize = answerSize;
2251 params.mimeType = mimeType;
2252 context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
2253 }
2254
2255
2256 typedef struct
2257 {
2260 uint32_t width;
2261 uint32_t height;
2262 uint32_t pitch;
2263 const void* buffer;
2264 } _OrthancPluginCompressAndAnswerPngImage;
2265
2266 typedef struct
2267 {
2269 OrthancPluginImageFormat imageFormat;
2270 OrthancPluginPixelFormat pixelFormat;
2271 uint32_t width;
2272 uint32_t height;
2273 uint32_t pitch;
2274 const void* buffer;
2275 uint8_t quality;
2276 } _OrthancPluginCompressAndAnswerImage;
2277
2278
2297 ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2298 OrthancPluginContext* context,
2301 uint32_t width,
2302 uint32_t height,
2303 uint32_t pitch,
2304 const void* buffer)
2305 {
2306 _OrthancPluginCompressAndAnswerImage params;
2307 params.output = output;
2308 params.imageFormat = OrthancPluginImageFormat_Png;
2309 params.pixelFormat = format;
2310 params.width = width;
2311 params.height = height;
2312 params.pitch = pitch;
2313 params.buffer = buffer;
2314 params.quality = 0; /* No quality for PNG */
2315 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2316 }
2317
2318
2319
2320 typedef struct
2321 {
2323 const char* instanceId;
2324 } _OrthancPluginGetDicomForInstance;
2325
2339 OrthancPluginContext* context,
2341 const char* instanceId)
2342 {
2343 _OrthancPluginGetDicomForInstance params;
2344 params.target = target;
2345 params.instanceId = instanceId;
2346 return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2347 }
2348
2349
2350
2351 typedef struct
2352 {
2354 const char* uri;
2355 } _OrthancPluginRestApiGet;
2356
2372 OrthancPluginContext* context,
2374 const char* uri)
2375 {
2376 _OrthancPluginRestApiGet params;
2377 params.target = target;
2378 params.uri = uri;
2379 return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2380 }
2381
2382
2383
2402 OrthancPluginContext* context,
2404 const char* uri)
2405 {
2406 _OrthancPluginRestApiGet params;
2407 params.target = target;
2408 params.uri = uri;
2409 return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2410 }
2411
2412
2413
2414 typedef struct
2415 {
2417 const char* uri;
2418 const void* body;
2419 uint32_t bodySize;
2420 } _OrthancPluginRestApiPostPut;
2421
2439 OrthancPluginContext* context,
2441 const char* uri,
2442 const void* body,
2443 uint32_t bodySize)
2444 {
2445 _OrthancPluginRestApiPostPut params;
2446 params.target = target;
2447 params.uri = uri;
2448 params.body = body;
2449 params.bodySize = bodySize;
2450 return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2451 }
2452
2453
2474 OrthancPluginContext* context,
2476 const char* uri,
2477 const void* body,
2478 uint32_t bodySize)
2479 {
2480 _OrthancPluginRestApiPostPut params;
2481 params.target = target;
2482 params.uri = uri;
2483 params.body = body;
2484 params.bodySize = bodySize;
2485 return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2486 }
2487
2488
2489
2503 OrthancPluginContext* context,
2504 const char* uri)
2505 {
2506 return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2507 }
2508
2509
2526 OrthancPluginContext* context,
2527 const char* uri)
2528 {
2529 return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2530 }
2531
2532
2533
2551 OrthancPluginContext* context,
2553 const char* uri,
2554 const void* body,
2555 uint32_t bodySize)
2556 {
2557 _OrthancPluginRestApiPostPut params;
2558 params.target = target;
2559 params.uri = uri;
2560 params.body = body;
2561 params.bodySize = bodySize;
2562 return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2563 }
2564
2565
2566
2587 OrthancPluginContext* context,
2589 const char* uri,
2590 const void* body,
2591 uint32_t bodySize)
2592 {
2593 _OrthancPluginRestApiPostPut params;
2594 params.target = target;
2595 params.uri = uri;
2596 params.body = body;
2597 params.bodySize = bodySize;
2598 return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2599 }
2600
2601
2602
2603 typedef struct
2604 {
2606 const char* argument;
2607 } _OrthancPluginOutputPlusArgument;
2608
2620 ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2621 OrthancPluginContext* context,
2623 const char* redirection)
2624 {
2625 _OrthancPluginOutputPlusArgument params;
2626 params.output = output;
2627 params.argument = redirection;
2628 context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2629 }
2630
2631
2632
2633 typedef struct
2634 {
2635 char** result;
2636 const char* argument;
2637 } _OrthancPluginRetrieveDynamicString;
2638
2652 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2653 OrthancPluginContext* context,
2654 const char* patientID)
2655 {
2656 char* result;
2657
2658 _OrthancPluginRetrieveDynamicString params;
2659 params.result = &result;
2660 params.argument = patientID;
2661
2662 if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2663 {
2664 /* Error */
2665 return NULL;
2666 }
2667 else
2668 {
2669 return result;
2670 }
2671 }
2672
2673
2687 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2688 OrthancPluginContext* context,
2689 const char* studyUID)
2690 {
2691 char* result;
2692
2693 _OrthancPluginRetrieveDynamicString params;
2694 params.result = &result;
2695 params.argument = studyUID;
2696
2697 if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2698 {
2699 /* Error */
2700 return NULL;
2701 }
2702 else
2703 {
2704 return result;
2705 }
2706 }
2707
2708
2723 OrthancPluginContext* context,
2724 const char* accessionNumber)
2725 {
2726 char* result;
2727
2728 _OrthancPluginRetrieveDynamicString params;
2729 params.result = &result;
2730 params.argument = accessionNumber;
2731
2732 if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2733 {
2734 /* Error */
2735 return NULL;
2736 }
2737 else
2738 {
2739 return result;
2740 }
2741 }
2742
2743
2757 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2758 OrthancPluginContext* context,
2759 const char* seriesUID)
2760 {
2761 char* result;
2762
2763 _OrthancPluginRetrieveDynamicString params;
2764 params.result = &result;
2765 params.argument = seriesUID;
2766
2767 if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2768 {
2769 /* Error */
2770 return NULL;
2771 }
2772 else
2773 {
2774 return result;
2775 }
2776 }
2777
2778
2792 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2793 OrthancPluginContext* context,
2794 const char* sopInstanceUID)
2795 {
2796 char* result;
2797
2798 _OrthancPluginRetrieveDynamicString params;
2799 params.result = &result;
2800 params.argument = sopInstanceUID;
2801
2802 if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2803 {
2804 /* Error */
2805 return NULL;
2806 }
2807 else
2808 {
2809 return result;
2810 }
2811 }
2812
2813
2814
2815 typedef struct
2816 {
2818 uint16_t status;
2819 } _OrthancPluginSendHttpStatusCode;
2820
2837 ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2838 OrthancPluginContext* context,
2840 uint16_t status)
2841 {
2842 _OrthancPluginSendHttpStatusCode params;
2843 params.output = output;
2844 params.status = status;
2845 context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2846 }
2847
2848
2860 ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2861 OrthancPluginContext* context,
2863 const char* realm)
2864 {
2865 _OrthancPluginOutputPlusArgument params;
2866 params.output = output;
2867 params.argument = realm;
2868 context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2869 }
2870
2871
2883 ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2884 OrthancPluginContext* context,
2886 const char* allowedMethods)
2887 {
2888 _OrthancPluginOutputPlusArgument params;
2889 params.output = output;
2890 params.argument = allowedMethods;
2891 context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2892 }
2893
2894
2895 typedef struct
2896 {
2898 const char* key;
2899 const char* value;
2900 } _OrthancPluginSetHttpHeader;
2901
2913 ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2914 OrthancPluginContext* context,
2916 const char* cookie,
2917 const char* value)
2918 {
2919 _OrthancPluginSetHttpHeader params;
2920 params.output = output;
2921 params.key = cookie;
2922 params.value = value;
2923 context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2924 }
2925
2926
2938 ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2939 OrthancPluginContext* context,
2941 const char* key,
2942 const char* value)
2943 {
2944 _OrthancPluginSetHttpHeader params;
2945 params.output = output;
2946 params.key = key;
2947 params.value = value;
2948 context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2949 }
2950
2951
2952 typedef struct
2953 {
2954 char** resultStringToFree;
2955 const char** resultString;
2956 int64_t* resultInt64;
2957 const char* key;
2958 const OrthancPluginDicomInstance* instance;
2959 OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2960 } _OrthancPluginAccessDicomInstance;
2961
2962
2974 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2975 OrthancPluginContext* context,
2976 const OrthancPluginDicomInstance* instance)
2977 {
2978 const char* result;
2979
2980 _OrthancPluginAccessDicomInstance params;
2981 memset(&params, 0, sizeof(params));
2982 params.resultString = &result;
2983 params.instance = instance;
2984
2985 if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
2986 {
2987 /* Error */
2988 return NULL;
2989 }
2990 else
2991 {
2992 return result;
2993 }
2994 }
2995
2996
3007 ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
3008 OrthancPluginContext* context,
3009 const OrthancPluginDicomInstance* instance)
3010 {
3011 int64_t size;
3012
3013 _OrthancPluginAccessDicomInstance params;
3014 memset(&params, 0, sizeof(params));
3015 params.resultInt64 = &size;
3016 params.instance = instance;
3017
3018 if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
3019 {
3020 /* Error */
3021 return -1;
3022 }
3023 else
3024 {
3025 return size;
3026 }
3027 }
3028
3029
3040 ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData(
3041 OrthancPluginContext* context,
3042 const OrthancPluginDicomInstance* instance)
3043 {
3044 const char* result;
3045
3046 _OrthancPluginAccessDicomInstance params;
3047 memset(&params, 0, sizeof(params));
3048 params.resultString = &result;
3049 params.instance = instance;
3050
3051 if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
3052 {
3053 /* Error */
3054 return NULL;
3055 }
3056 else
3057 {
3058 return result;
3059 }
3060 }
3061
3062
3076 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
3077 OrthancPluginContext* context,
3078 const OrthancPluginDicomInstance* instance)
3079 {
3080 char* result;
3081
3082 _OrthancPluginAccessDicomInstance params;
3083 memset(&params, 0, sizeof(params));
3084 params.resultStringToFree = &result;
3085 params.instance = instance;
3086
3087 if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
3088 {
3089 /* Error */
3090 return NULL;
3091 }
3092 else
3093 {
3094 return result;
3095 }
3096 }
3097
3098
3114 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
3115 OrthancPluginContext* context,
3116 const OrthancPluginDicomInstance* instance)
3117 {
3118 char* result;
3119
3120 _OrthancPluginAccessDicomInstance params;
3121 memset(&params, 0, sizeof(params));
3122 params.resultStringToFree = &result;
3123 params.instance = instance;
3124
3125 if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
3126 {
3127 /* Error */
3128 return NULL;
3129 }
3130 else
3131 {
3132 return result;
3133 }
3134 }
3135
3136
3153 ORTHANC_PLUGIN_INLINE int OrthancPluginHasInstanceMetadata(
3154 OrthancPluginContext* context,
3155 const OrthancPluginDicomInstance* instance,
3156 const char* metadata)
3157 {
3158 int64_t result;
3159
3160 _OrthancPluginAccessDicomInstance params;
3161 memset(&params, 0, sizeof(params));
3162 params.resultInt64 = &result;
3163 params.instance = instance;
3164 params.key = metadata;
3165
3166 if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3167 {
3168 /* Error */
3169 return -1;
3170 }
3171 else
3172 {
3173 return (result != 0);
3174 }
3175 }
3176
3177
3194 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
3195 OrthancPluginContext* context,
3196 const OrthancPluginDicomInstance* instance,
3197 const char* metadata)
3198 {
3199 const char* result;
3200
3201 _OrthancPluginAccessDicomInstance params;
3202 memset(&params, 0, sizeof(params));
3203 params.resultString = &result;
3204 params.instance = instance;
3205 params.key = metadata;
3206
3207 if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3208 {
3209 /* Error */
3210 return NULL;
3211 }
3212 else
3213 {
3214 return result;
3215 }
3216 }
3217
3218
3219
3220 typedef struct
3221 {
3225 OrthancPluginFree free;
3226 } _OrthancPluginRegisterStorageArea;
3227
3243 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
3244 OrthancPluginContext* context,
3248 {
3249 _OrthancPluginRegisterStorageArea params;
3250 params.create = create;
3251 params.read = read;
3252 params.remove = remove;
3253
3254#ifdef __cplusplus
3255 params.free = ::free;
3256#else
3257 params.free = free;
3258#endif
3259
3260 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3261 }
3262
3263
3264
3275 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3276 {
3277 char* result;
3278
3279 _OrthancPluginRetrieveDynamicString params;
3280 params.result = &result;
3281 params.argument = NULL;
3282
3283 if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3284 {
3285 /* Error */
3286 return NULL;
3287 }
3288 else
3289 {
3290 return result;
3291 }
3292 }
3293
3294
3305 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3306 {
3307 char* result;
3308
3309 _OrthancPluginRetrieveDynamicString params;
3310 params.result = &result;
3311 params.argument = NULL;
3312
3313 if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3314 {
3315 /* Error */
3316 return NULL;
3317 }
3318 else
3319 {
3320 return result;
3321 }
3322 }
3323
3324
3340 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3341 {
3342 char* result;
3343
3344 _OrthancPluginRetrieveDynamicString params;
3345 params.result = &result;
3346 params.argument = NULL;
3347
3348 if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3349 {
3350 /* Error */
3351 return NULL;
3352 }
3353 else
3354 {
3355 return result;
3356 }
3357 }
3358
3359
3360
3361 typedef struct
3362 {
3364 } _OrthancPluginOnChangeCallback;
3365
3386 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3387 OrthancPluginContext* context,
3389 {
3390 _OrthancPluginOnChangeCallback params;
3391 params.callback = callback;
3392
3393 context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3394 }
3395
3396
3397
3398 typedef struct
3399 {
3400 const char* plugin;
3401 _OrthancPluginProperty property;
3402 const char* value;
3403 } _OrthancPluginSetPluginProperty;
3404
3405
3417 ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3418 OrthancPluginContext* context,
3419 const char* uri)
3420 {
3421 _OrthancPluginSetPluginProperty params;
3422 params.plugin = OrthancPluginGetName();
3423 params.property = _OrthancPluginProperty_RootUri;
3424 params.value = uri;
3425
3426 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3427 }
3428
3429
3439 ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3440 OrthancPluginContext* context,
3441 const char* description)
3442 {
3443 _OrthancPluginSetPluginProperty params;
3444 params.plugin = OrthancPluginGetName();
3445 params.property = _OrthancPluginProperty_Description;
3446 params.value = description;
3447
3448 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3449 }
3450
3451
3461 ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3462 OrthancPluginContext* context,
3463 const char* javascript)
3464 {
3465 _OrthancPluginSetPluginProperty params;
3466 params.plugin = OrthancPluginGetName();
3467 params.property = _OrthancPluginProperty_OrthancExplorer;
3468 params.value = javascript;
3469
3470 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3471 }
3472
3473
3474 typedef struct
3475 {
3476 char** result;
3477 int32_t property;
3478 const char* value;
3479 } _OrthancPluginGlobalProperty;
3480
3481
3495 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3496 OrthancPluginContext* context,
3497 int32_t property,
3498 const char* defaultValue)
3499 {
3500 char* result;
3501
3502 _OrthancPluginGlobalProperty params;
3503 params.result = &result;
3504 params.property = property;
3505 params.value = defaultValue;
3506
3507 if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3508 {
3509 /* Error */
3510 return NULL;
3511 }
3512 else
3513 {
3514 return result;
3515 }
3516 }
3517
3518
3535 OrthancPluginContext* context,
3536 int32_t property,
3537 const char* value)
3538 {
3539 _OrthancPluginGlobalProperty params;
3540 params.result = NULL;
3541 params.property = property;
3542 params.value = value;
3543
3544 return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3545 }
3546
3547
3548
3549 typedef struct
3550 {
3551 int32_t *resultInt32;
3552 uint32_t *resultUint32;
3553 int64_t *resultInt64;
3554 uint64_t *resultUint64;
3555 } _OrthancPluginReturnSingleValue;
3556
3565 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3566 OrthancPluginContext* context)
3567 {
3568 uint32_t count = 0;
3569
3570 _OrthancPluginReturnSingleValue params;
3571 memset(&params, 0, sizeof(params));
3572 params.resultUint32 = &count;
3573
3574 if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3575 {
3576 /* Error */
3577 return 0;
3578 }
3579 else
3580 {
3581 return count;
3582 }
3583 }
3584
3585
3586
3599 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3600 OrthancPluginContext* context,
3601 uint32_t argument)
3602 {
3603 char* result;
3604
3605 _OrthancPluginGlobalProperty params;
3606 params.result = &result;
3607 params.property = (int32_t) argument;
3608 params.value = NULL;
3609
3610 if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3611 {
3612 /* Error */
3613 return NULL;
3614 }
3615 else
3616 {
3617 return result;
3618 }
3619 }
3620
3621
3631 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3632 OrthancPluginContext* context)
3633 {
3634 uint32_t count = 0;
3635
3636 _OrthancPluginReturnSingleValue params;
3637 memset(&params, 0, sizeof(params));
3638 params.resultUint32 = &count;
3639
3640 if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3641 {
3642 /* Error */
3643 return 0;
3644 }
3645 else
3646 {
3647 return count;
3648 }
3649 }
3650
3651
3652
3664 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3665 {
3666 char* result;
3667
3668 _OrthancPluginRetrieveDynamicString params;
3669 params.result = &result;
3670 params.argument = NULL;
3671
3672 if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3673 {
3674 /* Error */
3675 return NULL;
3676 }
3677 else
3678 {
3679 return result;
3680 }
3681 }
3682
3683
3684
3685 typedef struct
3686 {
3688 const char* subType;
3689 const char* contentType;
3690 } _OrthancPluginStartMultipartAnswer;
3691
3706 OrthancPluginContext* context,
3708 const char* subType,
3709 const char* contentType)
3710 {
3711 _OrthancPluginStartMultipartAnswer params;
3712 params.output = output;
3713 params.subType = subType;
3714 params.contentType = contentType;
3715 return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3716 }
3717
3718
3735 OrthancPluginContext* context,
3737 const void* answer,
3738 uint32_t answerSize)
3739 {
3740 _OrthancPluginAnswerBuffer params;
3741 params.output = output;
3742 params.answer = answer;
3743 params.answerSize = answerSize;
3744 params.mimeType = NULL;
3745 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3746 }
3747
3748
3749
3750 typedef struct
3751 {
3753 const void* source;
3754 uint32_t size;
3755 OrthancPluginCompressionType compression;
3756 uint8_t uncompress;
3757 } _OrthancPluginBufferCompression;
3758
3759
3777 OrthancPluginContext* context,
3779 const void* source,
3780 uint32_t size,
3781 OrthancPluginCompressionType compression,
3782 uint8_t uncompress)
3783 {
3784 _OrthancPluginBufferCompression params;
3785 params.target = target;
3786 params.source = source;
3787 params.size = size;
3788 params.compression = compression;
3789 params.uncompress = uncompress;
3790
3791 return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3792 }
3793
3794
3795
3796 typedef struct
3797 {
3799 const char* path;
3800 } _OrthancPluginReadFile;
3801
3814 OrthancPluginContext* context,
3816 const char* path)
3817 {
3818 _OrthancPluginReadFile params;
3819 params.target = target;
3820 params.path = path;
3821 return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3822 }
3823
3824
3825
3826 typedef struct
3827 {
3828 const char* path;
3829 const void* data;
3830 uint32_t size;
3831 } _OrthancPluginWriteFile;
3832
3845 OrthancPluginContext* context,
3846 const char* path,
3847 const void* data,
3848 uint32_t size)
3849 {
3850 _OrthancPluginWriteFile params;
3851 params.path = path;
3852 params.data = data;
3853 params.size = size;
3854 return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3855 }
3856
3857
3858
3859 typedef struct
3860 {
3861 const char** target;
3863 } _OrthancPluginGetErrorDescription;
3864
3875 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3876 OrthancPluginContext* context,
3878 {
3879 const char* result = NULL;
3880
3881 _OrthancPluginGetErrorDescription params;
3882 params.target = &result;
3883 params.error = error;
3884
3885 if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3886 result == NULL)
3887 {
3888 return "Unknown error code";
3889 }
3890 else
3891 {
3892 return result;
3893 }
3894 }
3895
3896
3897
3898 typedef struct
3899 {
3901 uint16_t status;
3902 const void* body;
3903 uint32_t bodySize;
3904 } _OrthancPluginSendHttpStatus;
3905
3928 ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3929 OrthancPluginContext* context,
3931 uint16_t status,
3932 const void* body,
3933 uint32_t bodySize)
3934 {
3935 _OrthancPluginSendHttpStatus params;
3936 params.output = output;
3937 params.status = status;
3938 params.body = body;
3939 params.bodySize = bodySize;
3940 context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3941 }
3942
3943
3944
3945 typedef struct
3946 {
3947 const OrthancPluginImage* image;
3948 uint32_t* resultUint32;
3949 OrthancPluginPixelFormat* resultPixelFormat;
3950 void** resultBuffer;
3951 } _OrthancPluginGetImageInfo;
3952
3953
3965 OrthancPluginContext* context,
3966 const OrthancPluginImage* image)
3967 {
3969
3970 _OrthancPluginGetImageInfo params;
3971 memset(&params, 0, sizeof(params));
3972 params.image = image;
3973 params.resultPixelFormat = &target;
3974
3975 if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
3976 {
3978 }
3979 else
3980 {
3981 return (OrthancPluginPixelFormat) target;
3982 }
3983 }
3984
3985
3986
3997 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
3998 OrthancPluginContext* context,
3999 const OrthancPluginImage* image)
4000 {
4001 uint32_t width;
4002
4003 _OrthancPluginGetImageInfo params;
4004 memset(&params, 0, sizeof(params));
4005 params.image = image;
4006 params.resultUint32 = &width;
4007
4008 if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
4009 {
4010 return 0;
4011 }
4012 else
4013 {
4014 return width;
4015 }
4016 }
4017
4018
4019
4030 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
4031 OrthancPluginContext* context,
4032 const OrthancPluginImage* image)
4033 {
4034 uint32_t height;
4035
4036 _OrthancPluginGetImageInfo params;
4037 memset(&params, 0, sizeof(params));
4038 params.image = image;
4039 params.resultUint32 = &height;
4040
4041 if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
4042 {
4043 return 0;
4044 }
4045 else
4046 {
4047 return height;
4048 }
4049 }
4050
4051
4052
4065 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
4066 OrthancPluginContext* context,
4067 const OrthancPluginImage* image)
4068 {
4069 uint32_t pitch;
4070
4071 _OrthancPluginGetImageInfo params;
4072 memset(&params, 0, sizeof(params));
4073 params.image = image;
4074 params.resultUint32 = &pitch;
4075
4076 if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
4077 {
4078 return 0;
4079 }
4080 else
4081 {
4082 return pitch;
4083 }
4084 }
4085
4086
4087
4099 ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
4100 OrthancPluginContext* context,
4101 const OrthancPluginImage* image)
4102 {
4103 void* target = NULL;
4104
4105 _OrthancPluginGetImageInfo params;
4106 memset(&params, 0, sizeof(params));
4107 params.resultBuffer = &target;
4108 params.image = image;
4109
4110 if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
4111 {
4112 return NULL;
4113 }
4114 else
4115 {
4116 return target;
4117 }
4118 }
4119
4120
4121 typedef struct
4122 {
4123 OrthancPluginImage** target;
4124 const void* data;
4125 uint32_t size;
4127 } _OrthancPluginUncompressImage;
4128
4129
4143 OrthancPluginContext* context,
4144 const void* data,
4145 uint32_t size,
4147 {
4148 OrthancPluginImage* target = NULL;
4149
4150 _OrthancPluginUncompressImage params;
4151 memset(&params, 0, sizeof(params));
4152 params.target = &target;
4153 params.data = data;
4154 params.size = size;
4155 params.format = format;
4156
4157 if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
4158 {
4159 return NULL;
4160 }
4161 else
4162 {
4163 return target;
4164 }
4165 }
4166
4167
4168
4169
4170 typedef struct
4171 {
4172 OrthancPluginImage* image;
4173 } _OrthancPluginFreeImage;
4174
4184 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
4185 OrthancPluginContext* context,
4186 OrthancPluginImage* image)
4187 {
4188 _OrthancPluginFreeImage params;
4189 params.image = image;
4190
4191 context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
4192 }
4193
4194
4195
4196
4197 typedef struct
4198 {
4200 OrthancPluginImageFormat imageFormat;
4201 OrthancPluginPixelFormat pixelFormat;
4202 uint32_t width;
4203 uint32_t height;
4204 uint32_t pitch;
4205 const void* buffer;
4206 uint8_t quality;
4207 } _OrthancPluginCompressImage;
4208
4209
4230 OrthancPluginContext* context,
4233 uint32_t width,
4234 uint32_t height,
4235 uint32_t pitch,
4236 const void* buffer)
4237 {
4238 _OrthancPluginCompressImage params;
4239 memset(&params, 0, sizeof(params));
4240 params.target = target;
4241 params.imageFormat = OrthancPluginImageFormat_Png;
4242 params.pixelFormat = format;
4243 params.width = width;
4244 params.height = height;
4245 params.pitch = pitch;
4246 params.buffer = buffer;
4247 params.quality = 0; /* Unused for PNG */
4248
4249 return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4250 }
4251
4252
4275 OrthancPluginContext* context,
4278 uint32_t width,
4279 uint32_t height,
4280 uint32_t pitch,
4281 const void* buffer,
4282 uint8_t quality)
4283 {
4284 _OrthancPluginCompressImage params;
4285 memset(&params, 0, sizeof(params));
4286 params.target = target;
4287 params.imageFormat = OrthancPluginImageFormat_Jpeg;
4288 params.pixelFormat = format;
4289 params.width = width;
4290 params.height = height;
4291 params.pitch = pitch;
4292 params.buffer = buffer;
4293 params.quality = quality;
4294
4295 return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4296 }
4297
4298
4299
4322 OrthancPluginContext* context,
4325 uint32_t width,
4326 uint32_t height,
4327 uint32_t pitch,
4328 const void* buffer,
4329 uint8_t quality)
4330 {
4331 _OrthancPluginCompressAndAnswerImage params;
4332 params.output = output;
4333 params.imageFormat = OrthancPluginImageFormat_Jpeg;
4334 params.pixelFormat = format;
4335 params.width = width;
4336 params.height = height;
4337 params.pitch = pitch;
4338 params.buffer = buffer;
4339 params.quality = quality;
4340 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4341 }
4342
4343
4344
4345
4346 typedef struct
4347 {
4350 const char* url;
4351 const char* username;
4352 const char* password;
4353 const void* body;
4354 uint32_t bodySize;
4355 } _OrthancPluginCallHttpClient;
4356
4357
4375 OrthancPluginContext* context,
4377 const char* url,
4378 const char* username,
4379 const char* password)
4380 {
4381 _OrthancPluginCallHttpClient params;
4382 memset(&params, 0, sizeof(params));
4383
4384 params.target = target;
4385 params.method = OrthancPluginHttpMethod_Get;
4386 params.url = url;
4387 params.username = username;
4388 params.password = password;
4389
4390 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4391 }
4392
4393
4413 OrthancPluginContext* context,
4415 const char* url,
4416 const void* body,
4417 uint32_t bodySize,
4418 const char* username,
4419 const char* password)
4420 {
4421 _OrthancPluginCallHttpClient params;
4422 memset(&params, 0, sizeof(params));
4423
4424 params.target = target;
4425 params.method = OrthancPluginHttpMethod_Post;
4426 params.url = url;
4427 params.body = body;
4428 params.bodySize = bodySize;
4429 params.username = username;
4430 params.password = password;
4431
4432 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4433 }
4434
4435
4455 OrthancPluginContext* context,
4457 const char* url,
4458 const void* body,
4459 uint32_t bodySize,
4460 const char* username,
4461 const char* password)
4462 {
4463 _OrthancPluginCallHttpClient params;
4464 memset(&params, 0, sizeof(params));
4465
4466 params.target = target;
4467 params.method = OrthancPluginHttpMethod_Put;
4468 params.url = url;
4469 params.body = body;
4470 params.bodySize = bodySize;
4471 params.username = username;
4472 params.password = password;
4473
4474 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4475 }
4476
4477
4493 OrthancPluginContext* context,
4494 const char* url,
4495 const char* username,
4496 const char* password)
4497 {
4498 _OrthancPluginCallHttpClient params;
4499 memset(&params, 0, sizeof(params));
4500
4501 params.method = OrthancPluginHttpMethod_Delete;
4502 params.url = url;
4503 params.username = username;
4504 params.password = password;
4505
4506 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4507 }
4508
4509
4510
4511 typedef struct
4512 {
4513 OrthancPluginImage** target;
4514 const OrthancPluginImage* source;
4515 OrthancPluginPixelFormat targetFormat;
4516 } _OrthancPluginConvertPixelFormat;
4517
4518
4531 OrthancPluginContext* context,
4532 const OrthancPluginImage* source,
4533 OrthancPluginPixelFormat targetFormat)
4534 {
4535 OrthancPluginImage* target = NULL;
4536
4537 _OrthancPluginConvertPixelFormat params;
4538 params.target = &target;
4539 params.source = source;
4540 params.targetFormat = targetFormat;
4541
4542 if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4543 {
4544 return NULL;
4545 }
4546 else
4547 {
4548 return target;
4549 }
4550 }
4551
4552
4553
4565 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4566 OrthancPluginContext* context)
4567 {
4568 uint32_t count = 0;
4569
4570 _OrthancPluginReturnSingleValue params;
4571 memset(&params, 0, sizeof(params));
4572 params.resultUint32 = &count;
4573
4574 if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4575 {
4576 /* Error */
4577 return 0;
4578 }
4579 else
4580 {
4581 return count;
4582 }
4583 }
4584
4585
4586
4587
4588 typedef struct
4589 {
4590 uint32_t fontIndex; /* in */
4591 const char** name; /* out */
4592 uint32_t* size; /* out */
4593 } _OrthancPluginGetFontInfo;
4594
4605 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4606 OrthancPluginContext* context,
4607 uint32_t fontIndex)
4608 {
4609 const char* result = NULL;
4610
4611 _OrthancPluginGetFontInfo params;
4612 memset(&params, 0, sizeof(params));
4613 params.name = &result;
4614 params.fontIndex = fontIndex;
4615
4616 if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4617 {
4618 return NULL;
4619 }
4620 else
4621 {
4622 return result;
4623 }
4624 }
4625
4626
4637 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4638 OrthancPluginContext* context,
4639 uint32_t fontIndex)
4640 {
4641 uint32_t result;
4642
4643 _OrthancPluginGetFontInfo params;
4644 memset(&params, 0, sizeof(params));
4645 params.size = &result;
4646 params.fontIndex = fontIndex;
4647
4648 if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4649 {
4650 return 0;
4651 }
4652 else
4653 {
4654 return result;
4655 }
4656 }
4657
4658
4659
4660 typedef struct
4661 {
4662 OrthancPluginImage* image;
4663 uint32_t fontIndex;
4664 const char* utf8Text;
4665 int32_t x;
4666 int32_t y;
4667 uint8_t r;
4668 uint8_t g;
4669 uint8_t b;
4670 } _OrthancPluginDrawText;
4671
4672
4691 OrthancPluginContext* context,
4692 OrthancPluginImage* image,
4693 uint32_t fontIndex,
4694 const char* utf8Text,
4695 int32_t x,
4696 int32_t y,
4697 uint8_t r,
4698 uint8_t g,
4699 uint8_t b)
4700 {
4701 _OrthancPluginDrawText params;
4702 memset(&params, 0, sizeof(params));
4703 params.image = image;
4704 params.fontIndex = fontIndex;
4705 params.utf8Text = utf8Text;
4706 params.x = x;
4707 params.y = y;
4708 params.r = r;
4709 params.g = g;
4710 params.b = b;
4711
4712 return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4713 }
4714
4715
4716
4717 typedef struct
4718 {
4719 OrthancPluginStorageArea* storageArea;
4720 const char* uuid;
4721 const void* content;
4722 uint64_t size;
4724 } _OrthancPluginStorageAreaCreate;
4725
4726
4745 OrthancPluginContext* context,
4746 OrthancPluginStorageArea* storageArea,
4747 const char* uuid,
4748 const void* content,
4749 uint64_t size,
4751 {
4752 _OrthancPluginStorageAreaCreate params;
4753 params.storageArea = storageArea;
4754 params.uuid = uuid;
4755 params.content = content;
4756 params.size = size;
4757 params.type = type;
4758
4759 return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4760 }
4761
4762
4763 typedef struct
4764 {
4766 OrthancPluginStorageArea* storageArea;
4767 const char* uuid;
4769 } _OrthancPluginStorageAreaRead;
4770
4771
4789 OrthancPluginContext* context,
4791 OrthancPluginStorageArea* storageArea,
4792 const char* uuid,
4794 {
4795 _OrthancPluginStorageAreaRead params;
4796 params.target = target;
4797 params.storageArea = storageArea;
4798 params.uuid = uuid;
4799 params.type = type;
4800
4801 return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4802 }
4803
4804
4805 typedef struct
4806 {
4807 OrthancPluginStorageArea* storageArea;
4808 const char* uuid;
4810 } _OrthancPluginStorageAreaRemove;
4811
4828 OrthancPluginContext* context,
4829 OrthancPluginStorageArea* storageArea,
4830 const char* uuid,
4832 {
4833 _OrthancPluginStorageAreaRemove params;
4834 params.storageArea = storageArea;
4835 params.uuid = uuid;
4836 params.type = type;
4837
4838 return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4839 }
4840
4841
4842
4843 typedef struct
4844 {
4845 OrthancPluginErrorCode* target;
4846 int32_t code;
4847 uint16_t httpStatus;
4848 const char* message;
4849 } _OrthancPluginRegisterErrorCode;
4850
4867 OrthancPluginContext* context,
4868 int32_t code,
4869 uint16_t httpStatus,
4870 const char* message)
4871 {
4873
4874 _OrthancPluginRegisterErrorCode params;
4875 params.target = &target;
4876 params.code = code;
4877 params.httpStatus = httpStatus;
4878 params.message = message;
4879
4880 if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4881 {
4882 return target;
4883 }
4884 else
4885 {
4886 /* There was an error while assigned the error. Use a generic code. */
4888 }
4889 }
4890
4891
4892
4893 typedef struct
4894 {
4895 uint16_t group;
4896 uint16_t element;
4898 const char* name;
4899 uint32_t minMultiplicity;
4900 uint32_t maxMultiplicity;
4901 } _OrthancPluginRegisterDictionaryTag;
4902
4923 OrthancPluginContext* context,
4924 uint16_t group,
4925 uint16_t element,
4927 const char* name,
4928 uint32_t minMultiplicity,
4929 uint32_t maxMultiplicity)
4930 {
4931 _OrthancPluginRegisterDictionaryTag params;
4932 params.group = group;
4933 params.element = element;
4934 params.vr = vr;
4935 params.name = name;
4936 params.minMultiplicity = minMultiplicity;
4937 params.maxMultiplicity = maxMultiplicity;
4938
4939 return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4940 }
4941
4942
4943
4944 typedef struct
4945 {
4946 uint16_t group;
4947 uint16_t element;
4949 const char* name;
4950 uint32_t minMultiplicity;
4951 uint32_t maxMultiplicity;
4952 const char* privateCreator;
4953 } _OrthancPluginRegisterPrivateDictionaryTag;
4954
4976 OrthancPluginContext* context,
4977 uint16_t group,
4978 uint16_t element,
4980 const char* name,
4981 uint32_t minMultiplicity,
4982 uint32_t maxMultiplicity,
4983 const char* privateCreator)
4984 {
4985 _OrthancPluginRegisterPrivateDictionaryTag params;
4986 params.group = group;
4987 params.element = element;
4988 params.vr = vr;
4989 params.name = name;
4990 params.minMultiplicity = minMultiplicity;
4991 params.maxMultiplicity = maxMultiplicity;
4992 params.privateCreator = privateCreator;
4993
4994 return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
4995 }
4996
4997
4998
4999 typedef struct
5000 {
5001 OrthancPluginStorageArea* storageArea;
5003 } _OrthancPluginReconstructMainDicomTags;
5004
5020 OrthancPluginContext* context,
5021 OrthancPluginStorageArea* storageArea,
5023 {
5024 _OrthancPluginReconstructMainDicomTags params;
5025 params.level = level;
5026 params.storageArea = storageArea;
5027
5028 return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
5029 }
5030
5031
5032 typedef struct
5033 {
5034 char** result;
5035 const char* instanceId;
5036 const void* buffer;
5037 uint32_t size;
5040 uint32_t maxStringLength;
5041 } _OrthancPluginDicomToJson;
5042
5043
5063 ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
5064 OrthancPluginContext* context,
5065 const void* buffer,
5066 uint32_t size,
5069 uint32_t maxStringLength)
5070 {
5071 char* result;
5072
5073 _OrthancPluginDicomToJson params;
5074 memset(&params, 0, sizeof(params));
5075 params.result = &result;
5076 params.buffer = buffer;
5077 params.size = size;
5078 params.format = format;
5079 params.flags = flags;
5080 params.maxStringLength = maxStringLength;
5081
5082 if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
5083 {
5084 /* Error */
5085 return NULL;
5086 }
5087 else
5088 {
5089 return result;
5090 }
5091 }
5092
5093
5112 ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
5113 OrthancPluginContext* context,
5114 const char* instanceId,
5117 uint32_t maxStringLength)
5118 {
5119 char* result;
5120
5121 _OrthancPluginDicomToJson params;
5122 memset(&params, 0, sizeof(params));
5123 params.result = &result;
5124 params.instanceId = instanceId;
5125 params.format = format;
5126 params.flags = flags;
5127 params.maxStringLength = maxStringLength;
5128
5129 if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
5130 {
5131 /* Error */
5132 return NULL;
5133 }
5134 else
5135 {
5136 return result;
5137 }
5138 }
5139
5140
5141 typedef struct
5142 {
5144 const char* uri;
5145 uint32_t headersCount;
5146 const char* const* headersKeys;
5147 const char* const* headersValues;
5148 int32_t afterPlugins;
5149 } _OrthancPluginRestApiGet2;
5150
5171 OrthancPluginContext* context,
5173 const char* uri,
5174 uint32_t headersCount,
5175 const char* const* headersKeys,
5176 const char* const* headersValues,
5177 int32_t afterPlugins)
5178 {
5179 _OrthancPluginRestApiGet2 params;
5180 params.target = target;
5181 params.uri = uri;
5182 params.headersCount = headersCount;
5183 params.headersKeys = headersKeys;
5184 params.headersValues = headersValues;
5185 params.afterPlugins = afterPlugins;
5186
5187 return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
5188 }
5189
5190
5191
5192 typedef struct
5193 {
5195 } _OrthancPluginWorklistCallback;
5196
5209 OrthancPluginContext* context,
5211 {
5212 _OrthancPluginWorklistCallback params;
5213 params.callback = callback;
5214
5215 return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
5216 }
5217
5218
5219
5220 typedef struct
5221 {
5223 const OrthancPluginWorklistQuery* query;
5224 const void* dicom;
5225 uint32_t size;
5226 } _OrthancPluginWorklistAnswersOperation;
5227
5245 OrthancPluginContext* context,
5247 const OrthancPluginWorklistQuery* query,
5248 const void* dicom,
5249 uint32_t size)
5250 {
5251 _OrthancPluginWorklistAnswersOperation params;
5252 params.answers = answers;
5253 params.query = query;
5254 params.dicom = dicom;
5255 params.size = size;
5256
5257 return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
5258 }
5259
5260
5275 OrthancPluginContext* context,
5277 {
5278 _OrthancPluginWorklistAnswersOperation params;
5279 params.answers = answers;
5280 params.query = NULL;
5281 params.dicom = NULL;
5282 params.size = 0;
5283
5284 return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5285 }
5286
5287
5288 typedef struct
5289 {
5290 const OrthancPluginWorklistQuery* query;
5291 const void* dicom;
5292 uint32_t size;
5293 int32_t* isMatch;
5295 } _OrthancPluginWorklistQueryOperation;
5296
5312 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5313 OrthancPluginContext* context,
5314 const OrthancPluginWorklistQuery* query,
5315 const void* dicom,
5316 uint32_t size)
5317 {
5318 int32_t isMatch = 0;
5319
5320 _OrthancPluginWorklistQueryOperation params;
5321 params.query = query;
5322 params.dicom = dicom;
5323 params.size = size;
5324 params.isMatch = &isMatch;
5325 params.target = NULL;
5326
5327 if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5328 {
5329 return isMatch;
5330 }
5331 else
5332 {
5333 /* Error: Assume non-match */
5334 return 0;
5335 }
5336 }
5337
5338
5352 OrthancPluginContext* context,
5354 const OrthancPluginWorklistQuery* query)
5355 {
5356 _OrthancPluginWorklistQueryOperation params;
5357 params.query = query;
5358 params.dicom = NULL;
5359 params.size = 0;
5360 params.isMatch = NULL;
5361 params.target = target;
5362
5363 return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5364 }
5365
5366
5378 OrthancPluginContext* context,
5379 const OrthancPluginDicomInstance* instance)
5380 {
5382
5383 _OrthancPluginAccessDicomInstance params;
5384 memset(&params, 0, sizeof(params));
5385 params.resultOrigin = &origin;
5386 params.instance = instance;
5387
5388 if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5389 {
5390 /* Error */
5392 }
5393 else
5394 {
5395 return origin;
5396 }
5397 }
5398
5399
5400 typedef struct
5401 {
5403 const char* json;
5404 const OrthancPluginImage* pixelData;
5406 } _OrthancPluginCreateDicom;
5407
5434 OrthancPluginContext* context,
5436 const char* json,
5437 const OrthancPluginImage* pixelData,
5439 {
5440 _OrthancPluginCreateDicom params;
5441 params.target = target;
5442 params.json = json;
5443 params.pixelData = pixelData;
5444 params.flags = flags;
5445
5446 return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5447 }
5448
5449
5450 typedef struct
5451 {
5453 } _OrthancPluginDecodeImageCallback;
5454
5470 OrthancPluginContext* context,
5472 {
5473 _OrthancPluginDecodeImageCallback params;
5474 params.callback = callback;
5475
5476 return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5477 }
5478
5479
5480
5481 typedef struct
5482 {
5483 OrthancPluginImage** target;
5485 uint32_t width;
5486 uint32_t height;
5487 uint32_t pitch;
5488 void* buffer;
5489 const void* constBuffer;
5490 uint32_t bufferSize;
5491 uint32_t frameIndex;
5492 } _OrthancPluginCreateImage;
5493
5494
5508 OrthancPluginContext* context,
5510 uint32_t width,
5511 uint32_t height)
5512 {
5513 OrthancPluginImage* target = NULL;
5514
5515 _OrthancPluginCreateImage params;
5516 memset(&params, 0, sizeof(params));
5517 params.target = &target;
5518 params.format = format;
5519 params.width = width;
5520 params.height = height;
5521
5522 if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5523 {
5524 return NULL;
5525 }
5526 else
5527 {
5528 return target;
5529 }
5530 }
5531
5532
5551 OrthancPluginContext* context,
5553 uint32_t width,
5554 uint32_t height,
5555 uint32_t pitch,
5556 void* buffer)
5557 {
5558 OrthancPluginImage* target = NULL;
5559
5560 _OrthancPluginCreateImage params;
5561 memset(&params, 0, sizeof(params));
5562 params.target = &target;
5563 params.format = format;
5564 params.width = width;
5565 params.height = height;
5566 params.pitch = pitch;
5567 params.buffer = buffer;
5568
5569 if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5570 {
5571 return NULL;
5572 }
5573 else
5574 {
5575 return target;
5576 }
5577 }
5578
5579
5580
5597 OrthancPluginContext* context,
5598 const void* buffer,
5599 uint32_t bufferSize,
5600 uint32_t frameIndex)
5601 {
5602 OrthancPluginImage* target = NULL;
5603
5604 _OrthancPluginCreateImage params;
5605 memset(&params, 0, sizeof(params));
5606 params.target = &target;
5607 params.constBuffer = buffer;
5608 params.bufferSize = bufferSize;
5609 params.frameIndex = frameIndex;
5610
5611 if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5612 {
5613 return NULL;
5614 }
5615 else
5616 {
5617 return target;
5618 }
5619 }
5620
5621
5622
5623 typedef struct
5624 {
5625 char** result;
5626 const void* buffer;
5627 uint32_t size;
5628 } _OrthancPluginComputeHash;
5629
5642 ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5643 OrthancPluginContext* context,
5644 const void* buffer,
5645 uint32_t size)
5646 {
5647 char* result;
5648
5649 _OrthancPluginComputeHash params;
5650 params.result = &result;
5651 params.buffer = buffer;
5652 params.size = size;
5653
5654 if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5655 {
5656 /* Error */
5657 return NULL;
5658 }
5659 else
5660 {
5661 return result;
5662 }
5663 }
5664
5665
5678 ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5679 OrthancPluginContext* context,
5680 const void* buffer,
5681 uint32_t size)
5682 {
5683 char* result;
5684
5685 _OrthancPluginComputeHash params;
5686 params.result = &result;
5687 params.buffer = buffer;
5688 params.size = size;
5689
5690 if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5691 {
5692 /* Error */
5693 return NULL;
5694 }
5695 else
5696 {
5697 return result;
5698 }
5699 }
5700
5701
5702
5703 typedef struct
5704 {
5706 const char* name;
5707 } _OrthancPluginLookupDictionary;
5708
5725 OrthancPluginContext* context,
5727 const char* name)
5728 {
5729 _OrthancPluginLookupDictionary params;
5730 params.target = target;
5731 params.name = name;
5732 return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5733 }
5734
5735
5736
5737 typedef struct
5738 {
5740 const void* answer;
5741 uint32_t answerSize;
5742 uint32_t headersCount;
5743 const char* const* headersKeys;
5744 const char* const* headersValues;
5745 } _OrthancPluginSendMultipartItem2;
5746
5768 OrthancPluginContext* context,
5770 const void* answer,
5771 uint32_t answerSize,
5772 uint32_t headersCount,
5773 const char* const* headersKeys,
5774 const char* const* headersValues)
5775 {
5776 _OrthancPluginSendMultipartItem2 params;
5777 params.output = output;
5778 params.answer = answer;
5779 params.answerSize = answerSize;
5780 params.headersCount = headersCount;
5781 params.headersKeys = headersKeys;
5782 params.headersValues = headersValues;
5783
5784 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5785 }
5786
5787
5788 typedef struct
5789 {
5791 } _OrthancPluginIncomingHttpRequestFilter;
5792
5806 OrthancPluginContext* context,
5808 {
5809 _OrthancPluginIncomingHttpRequestFilter params;
5810 params.callback = callback;
5811
5812 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5813 }
5814
5815
5816
5817 typedef struct
5818 {
5819 OrthancPluginMemoryBuffer* answerBody;
5820 OrthancPluginMemoryBuffer* answerHeaders;
5821 uint16_t* httpStatus;
5823 const char* url;
5824 uint32_t headersCount;
5825 const char* const* headersKeys;
5826 const char* const* headersValues;
5827 const void* body;
5828 uint32_t bodySize;
5829 const char* username;
5830 const char* password;
5831 uint32_t timeout;
5832 const char* certificateFile;
5833 const char* certificateKeyFile;
5834 const char* certificateKeyPassword;
5835 uint8_t pkcs11;
5836 } _OrthancPluginCallHttpClient2;
5837
5838
5839
5881 OrthancPluginContext* context,
5882 OrthancPluginMemoryBuffer* answerBody,
5883 OrthancPluginMemoryBuffer* answerHeaders,
5884 uint16_t* httpStatus,
5886 const char* url,
5887 uint32_t headersCount,
5888 const char* const* headersKeys,
5889 const char* const* headersValues,
5890 const void* body,
5891 uint32_t bodySize,
5892 const char* username,
5893 const char* password,
5894 uint32_t timeout,
5895 const char* certificateFile,
5896 const char* certificateKeyFile,
5897 const char* certificateKeyPassword,
5898 uint8_t pkcs11)
5899 {
5900 _OrthancPluginCallHttpClient2 params;
5901 memset(&params, 0, sizeof(params));
5902
5903 params.answerBody = answerBody;
5904 params.answerHeaders = answerHeaders;
5905 params.httpStatus = httpStatus;
5906 params.method = method;
5907 params.url = url;
5908 params.headersCount = headersCount;
5909 params.headersKeys = headersKeys;
5910 params.headersValues = headersValues;
5911 params.body = body;
5912 params.bodySize = bodySize;
5913 params.username = username;
5914 params.password = password;
5915 params.timeout = timeout;
5916 params.certificateFile = certificateFile;
5917 params.certificateKeyFile = certificateKeyFile;
5918 params.certificateKeyPassword = certificateKeyPassword;
5919 params.pkcs11 = pkcs11;
5920
5921 return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5922 }
5923
5924
5935 ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5936 OrthancPluginContext* context)
5937 {
5938 char* result;
5939
5940 _OrthancPluginRetrieveDynamicString params;
5941 params.result = &result;
5942 params.argument = NULL;
5943
5944 if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5945 {
5946 /* Error */
5947 return NULL;
5948 }
5949 else
5950 {
5951 return result;
5952 }
5953 }
5954
5955
5956
5957
5958 typedef struct
5959 {
5961 } _OrthancPluginFindCallback;
5962
5975 OrthancPluginContext* context,
5977 {
5978 _OrthancPluginFindCallback params;
5979 params.callback = callback;
5980
5981 return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
5982 }
5983
5984
5985 typedef struct
5986 {
5987 OrthancPluginFindAnswers *answers;
5988 const OrthancPluginFindQuery *query;
5989 const void *dicom;
5990 uint32_t size;
5991 uint32_t index;
5992 uint32_t *resultUint32;
5993 uint16_t *resultGroup;
5994 uint16_t *resultElement;
5995 char **resultString;
5996 } _OrthancPluginFindOperation;
5997
6014 OrthancPluginContext* context,
6015 OrthancPluginFindAnswers* answers,
6016 const void* dicom,
6017 uint32_t size)
6018 {
6019 _OrthancPluginFindOperation params;
6020 memset(&params, 0, sizeof(params));
6021 params.answers = answers;
6022 params.dicom = dicom;
6023 params.size = size;
6024
6025 return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
6026 }
6027
6028
6043 OrthancPluginContext* context,
6044 OrthancPluginFindAnswers* answers)
6045 {
6046 _OrthancPluginFindOperation params;
6047 memset(&params, 0, sizeof(params));
6048 params.answers = answers;
6049
6050 return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
6051 }
6052
6053
6054
6066 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
6067 OrthancPluginContext* context,
6068 const OrthancPluginFindQuery* query)
6069 {
6070 uint32_t count = 0;
6071
6072 _OrthancPluginFindOperation params;
6073 memset(&params, 0, sizeof(params));
6074 params.query = query;
6075 params.resultUint32 = &count;
6076
6077 if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
6078 {
6079 /* Error */
6080 return 0;
6081 }
6082 else
6083 {
6084 return count;
6085 }
6086 }
6087
6088
6104 OrthancPluginContext* context,
6105 uint16_t* group,
6106 uint16_t* element,
6107 const OrthancPluginFindQuery* query,
6108 uint32_t index)
6109 {
6110 _OrthancPluginFindOperation params;
6111 memset(&params, 0, sizeof(params));
6112 params.query = query;
6113 params.index = index;
6114 params.resultGroup = group;
6115 params.resultElement = element;
6116
6117 return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
6118 }
6119
6120
6134 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
6135 OrthancPluginContext* context,
6136 const OrthancPluginFindQuery* query,
6137 uint32_t index)
6138 {
6139 char* result;
6140
6141 _OrthancPluginFindOperation params;
6142 memset(&params, 0, sizeof(params));
6143 params.query = query;
6144 params.index = index;
6145 params.resultString = &result;
6146
6147 if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
6148 {
6149 /* Error */
6150 return NULL;
6151 }
6152 else
6153 {
6154 return result;
6155 }
6156 }
6157
6158
6172 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
6173 OrthancPluginContext* context,
6174 const OrthancPluginFindQuery* query,
6175 uint32_t index)
6176 {
6177 char* result;
6178
6179 _OrthancPluginFindOperation params;
6180 memset(&params, 0, sizeof(params));
6181 params.query = query;
6182 params.index = index;
6183 params.resultString = &result;
6184
6185 if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
6186 {
6187 /* Error */
6188 return NULL;
6189 }
6190 else
6191 {
6192 return result;
6193 }
6194 }
6195
6196
6197
6198
6199 typedef struct
6200 {
6202 OrthancPluginGetMoveSize getMoveSize;
6203 OrthancPluginApplyMove applyMove;
6204 OrthancPluginFreeMove freeMove;
6205 } _OrthancPluginMoveCallback;
6206
6221 OrthancPluginContext* context,
6223 OrthancPluginGetMoveSize getMoveSize,
6224 OrthancPluginApplyMove applyMove,
6225 OrthancPluginFreeMove freeMove)
6226 {
6227 _OrthancPluginMoveCallback params;
6228 params.callback = callback;
6229 params.getMoveSize = getMoveSize;
6230 params.applyMove = applyMove;
6231 params.freeMove = freeMove;
6232
6233 return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
6234 }
6235
6236
6237
6238 typedef struct
6239 {
6240 OrthancPluginFindMatcher** target;
6241 const void* query;
6242 uint32_t size;
6243 } _OrthancPluginCreateFindMatcher;
6244
6245
6260 OrthancPluginContext* context,
6261 const void* query,
6262 uint32_t size)
6263 {
6264 OrthancPluginFindMatcher* target = NULL;
6265
6266 _OrthancPluginCreateFindMatcher params;
6267 memset(&params, 0, sizeof(params));
6268 params.target = &target;
6269 params.query = query;
6270 params.size = size;
6271
6272 if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
6273 {
6274 return NULL;
6275 }
6276 else
6277 {
6278 return target;
6279 }
6280 }
6281
6282
6283 typedef struct
6284 {
6285 OrthancPluginFindMatcher* matcher;
6286 } _OrthancPluginFreeFindMatcher;
6287
6297 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6298 OrthancPluginContext* context,
6299 OrthancPluginFindMatcher* matcher)
6300 {
6301 _OrthancPluginFreeFindMatcher params;
6302 params.matcher = matcher;
6303
6304 context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6305 }
6306
6307
6308 typedef struct
6309 {
6310 const OrthancPluginFindMatcher* matcher;
6311 const void* dicom;
6312 uint32_t size;
6313 int32_t* isMatch;
6314 } _OrthancPluginFindMatcherIsMatch;
6315
6330 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6331 OrthancPluginContext* context,
6332 const OrthancPluginFindMatcher* matcher,
6333 const void* dicom,
6334 uint32_t size)
6335 {
6336 int32_t isMatch = 0;
6337
6338 _OrthancPluginFindMatcherIsMatch params;
6339 params.matcher = matcher;
6340 params.dicom = dicom;
6341 params.size = size;
6342 params.isMatch = &isMatch;
6343
6344 if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6345 {
6346 return isMatch;
6347 }
6348 else
6349 {
6350 /* Error: Assume non-match */
6351 return 0;
6352 }
6353 }
6354
6355
6356 typedef struct
6357 {
6359 } _OrthancPluginIncomingHttpRequestFilter2;
6360
6373 OrthancPluginContext* context,
6375 {
6376 _OrthancPluginIncomingHttpRequestFilter2 params;
6377 params.callback = callback;
6378
6379 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6380 }
6381
6382
6383
6384 typedef struct
6385 {
6386 OrthancPluginPeers** peers;
6387 } _OrthancPluginGetPeers;
6388
6401 OrthancPluginContext* context)
6402 {
6403 OrthancPluginPeers* peers = NULL;
6404
6405 _OrthancPluginGetPeers params;
6406 memset(&params, 0, sizeof(params));
6407 params.peers = &peers;
6408
6409 if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6410 {
6411 return NULL;
6412 }
6413 else
6414 {
6415 return peers;
6416 }
6417 }
6418
6419
6420 typedef struct
6421 {
6422 OrthancPluginPeers* peers;
6423 } _OrthancPluginFreePeers;
6424
6434 ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6435 OrthancPluginContext* context,
6436 OrthancPluginPeers* peers)
6437 {
6438 _OrthancPluginFreePeers params;
6439 params.peers = peers;
6440
6441 context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6442 }
6443
6444
6445 typedef struct
6446 {
6447 uint32_t* target;
6448 const OrthancPluginPeers* peers;
6449 } _OrthancPluginGetPeersCount;
6450
6464 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6465 OrthancPluginContext* context,
6466 const OrthancPluginPeers* peers)
6467 {
6468 uint32_t target = 0;
6469
6470 _OrthancPluginGetPeersCount params;
6471 memset(&params, 0, sizeof(params));
6472 params.target = &target;
6473 params.peers = peers;
6474
6475 if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6476 {
6477 /* Error */
6478 return 0;
6479 }
6480 else
6481 {
6482 return target;
6483 }
6484 }
6485
6486
6487 typedef struct
6488 {
6489 const char** target;
6490 const OrthancPluginPeers* peers;
6491 uint32_t peerIndex;
6492 const char* userProperty;
6493 } _OrthancPluginGetPeerProperty;
6494
6512 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6513 OrthancPluginContext* context,
6514 const OrthancPluginPeers* peers,
6515 uint32_t peerIndex)
6516 {
6517 const char* target = NULL;
6518
6519 _OrthancPluginGetPeerProperty params;
6520 memset(&params, 0, sizeof(params));
6521 params.target = &target;
6522 params.peers = peers;
6523 params.peerIndex = peerIndex;
6524 params.userProperty = NULL;
6525
6526 if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6527 {
6528 /* Error */
6529 return NULL;
6530 }
6531 else
6532 {
6533 return target;
6534 }
6535 }
6536
6537
6553 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6554 OrthancPluginContext* context,
6555 const OrthancPluginPeers* peers,
6556 uint32_t peerIndex)
6557 {
6558 const char* target = NULL;
6559
6560 _OrthancPluginGetPeerProperty params;
6561 memset(&params, 0, sizeof(params));
6562 params.target = &target;
6563 params.peers = peers;
6564 params.peerIndex = peerIndex;
6565 params.userProperty = NULL;
6566
6567 if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6568 {
6569 /* Error */
6570 return NULL;
6571 }
6572 else
6573 {
6574 return target;
6575 }
6576 }
6577
6578
6579
6599 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6600 OrthancPluginContext* context,
6601 const OrthancPluginPeers* peers,
6602 uint32_t peerIndex,
6603 const char* userProperty)
6604 {
6605 const char* target = NULL;
6606
6607 _OrthancPluginGetPeerProperty params;
6608 memset(&params, 0, sizeof(params));
6609 params.target = &target;
6610 params.peers = peers;
6611 params.peerIndex = peerIndex;
6612 params.userProperty = userProperty;
6613
6614 if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6615 {
6616 /* No such user property */
6617 return NULL;
6618 }
6619 else
6620 {
6621 return target;
6622 }
6623 }
6624
6625
6626
6627 typedef struct
6628 {
6629 OrthancPluginMemoryBuffer* answerBody;
6630 OrthancPluginMemoryBuffer* answerHeaders;
6631 uint16_t* httpStatus;
6632 const OrthancPluginPeers* peers;
6633 uint32_t peerIndex;
6635 const char* uri;
6636 uint32_t additionalHeadersCount;
6637 const char* const* additionalHeadersKeys;
6638 const char* const* additionalHeadersValues;
6639 const void* body;
6640 uint32_t bodySize;
6641 uint32_t timeout;
6642 } _OrthancPluginCallPeerApi;
6643
6681 OrthancPluginContext* context,
6682 OrthancPluginMemoryBuffer* answerBody,
6683 OrthancPluginMemoryBuffer* answerHeaders,
6684 uint16_t* httpStatus,
6685 const OrthancPluginPeers* peers,
6686 uint32_t peerIndex,
6688 const char* uri,
6689 uint32_t additionalHeadersCount,
6690 const char* const* additionalHeadersKeys,
6691 const char* const* additionalHeadersValues,
6692 const void* body,
6693 uint32_t bodySize,
6694 uint32_t timeout)
6695 {
6696 _OrthancPluginCallPeerApi params;
6697 memset(&params, 0, sizeof(params));
6698
6699 params.answerBody = answerBody;
6700 params.answerHeaders = answerHeaders;
6701 params.httpStatus = httpStatus;
6702 params.peers = peers;
6703 params.peerIndex = peerIndex;
6704 params.method = method;
6705 params.uri = uri;
6706 params.additionalHeadersCount = additionalHeadersCount;
6707 params.additionalHeadersKeys = additionalHeadersKeys;
6708 params.additionalHeadersValues = additionalHeadersValues;
6709 params.body = body;
6710 params.bodySize = bodySize;
6711 params.timeout = timeout;
6712
6713 return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6714 }
6715
6716
6717
6718
6719
6720 typedef struct
6721 {
6722 OrthancPluginJob** target;
6723 void *job;
6724 OrthancPluginJobFinalize finalize;
6725 const char *type;
6726 OrthancPluginJobGetProgress getProgress;
6727 OrthancPluginJobGetContent getContent;
6728 OrthancPluginJobGetSerialized getSerialized;
6732 } _OrthancPluginCreateJob;
6733
6767 OrthancPluginContext *context,
6768 void *job,
6769 OrthancPluginJobFinalize finalize,
6770 const char *type,
6771 OrthancPluginJobGetProgress getProgress,
6772 OrthancPluginJobGetContent getContent,
6773 OrthancPluginJobGetSerialized getSerialized,
6777 {
6778 OrthancPluginJob* target = NULL;
6779
6780 _OrthancPluginCreateJob params;
6781 memset(&params, 0, sizeof(params));
6782
6783 params.target = &target;
6784 params.job = job;
6785 params.finalize = finalize;
6786 params.type = type;
6787 params.getProgress = getProgress;
6788 params.getContent = getContent;
6789 params.getSerialized = getSerialized;
6790 params.step = step;
6791 params.stop = stop;
6792 params.reset = reset;
6793
6794 if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6795 target == NULL)
6796 {
6797 /* Error */
6798 return NULL;
6799 }
6800 else
6801 {
6802 return target;
6803 }
6804 }
6805
6806
6807 typedef struct
6808 {
6809 OrthancPluginJob** target;
6810 void *job;
6811 OrthancPluginJobFinalize finalize;
6812 const char *type;
6813 OrthancPluginJobGetProgress getProgress;
6814 OrthancPluginJobGetContent2 getContent;
6815 OrthancPluginJobGetSerialized2 getSerialized;
6819 } _OrthancPluginCreateJob2;
6820
6853 OrthancPluginContext *context,
6854 void *job,
6855 OrthancPluginJobFinalize finalize,
6856 const char *type,
6857 OrthancPluginJobGetProgress getProgress,
6858 OrthancPluginJobGetContent2 getContent,
6859 OrthancPluginJobGetSerialized2 getSerialized,
6863 {
6864 OrthancPluginJob* target = NULL;
6865
6866 _OrthancPluginCreateJob2 params;
6867 memset(&params, 0, sizeof(params));
6868
6869 params.target = &target;
6870 params.job = job;
6871 params.finalize = finalize;
6872 params.type = type;
6873 params.getProgress = getProgress;
6874 params.getContent = getContent;
6875 params.getSerialized = getSerialized;
6876 params.step = step;
6877 params.stop = stop;
6878 params.reset = reset;
6879
6880 if (context->InvokeService(context, _OrthancPluginService_CreateJob2, &params) != OrthancPluginErrorCode_Success ||
6881 target == NULL)
6882 {
6883 /* Error */
6884 return NULL;
6885 }
6886 else
6887 {
6888 return target;
6889 }
6890 }
6891
6892
6893 typedef struct
6894 {
6895 OrthancPluginJob* job;
6896 } _OrthancPluginFreeJob;
6897
6907 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6908 OrthancPluginContext* context,
6909 OrthancPluginJob* job)
6910 {
6911 _OrthancPluginFreeJob params;
6912 params.job = job;
6913
6914 context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6915 }
6916
6917
6918
6919 typedef struct
6920 {
6921 char** resultId;
6922 OrthancPluginJob *job;
6923 int priority;
6924 } _OrthancPluginSubmitJob;
6925
6939 ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6940 OrthancPluginContext *context,
6941 OrthancPluginJob *job,
6942 int priority)
6943 {
6944 char* resultId = NULL;
6945
6946 _OrthancPluginSubmitJob params;
6947 memset(&params, 0, sizeof(params));
6948
6949 params.resultId = &resultId;
6950 params.job = job;
6951 params.priority = priority;
6952
6953 if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6954 resultId == NULL)
6955 {
6956 /* Error */
6957 return NULL;
6958 }
6959 else
6960 {
6961 return resultId;
6962 }
6963 }
6964
6965
6966
6967 typedef struct
6968 {
6969 OrthancPluginJobsUnserializer unserializer;
6970 } _OrthancPluginJobsUnserializer;
6971
6984 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
6985 OrthancPluginContext* context,
6986 OrthancPluginJobsUnserializer unserializer)
6987 {
6988 _OrthancPluginJobsUnserializer params;
6989 params.unserializer = unserializer;
6990
6991 context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
6992 }
6993
6994
6995
6996 typedef struct
6997 {
6999 const char* details;
7000 uint8_t log;
7001 } _OrthancPluginSetHttpErrorDetails;
7002
7020 ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
7021 OrthancPluginContext* context,
7023 const char* details,
7024 uint8_t log)
7025 {
7026 _OrthancPluginSetHttpErrorDetails params;
7027 params.output = output;
7028 params.details = details;
7029 params.log = log;
7030 context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
7031 }
7032
7033
7034
7035 typedef struct
7036 {
7037 const char** result;
7038 const char* argument;
7039 } _OrthancPluginRetrieveStaticString;
7040
7052 ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
7053 OrthancPluginContext* context,
7054 const char* path)
7055 {
7056 const char* result = NULL;
7057
7058 _OrthancPluginRetrieveStaticString params;
7059 params.result = &result;
7060 params.argument = path;
7061
7062 if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
7063 {
7064 /* Error */
7065 return NULL;
7066 }
7067 else
7068 {
7069 return result;
7070 }
7071 }
7072
7073
7074
7075 typedef struct
7076 {
7077 const char* name;
7078 float value;
7080 } _OrthancPluginSetMetricsValue;
7081
7098 ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
7099 OrthancPluginContext* context,
7100 const char* name,
7101 float value,
7103 {
7104 _OrthancPluginSetMetricsValue params;
7105 params.name = name;
7106 params.value = value;
7107 params.type = type;
7108 context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
7109 }
7110
7111
7112
7113 typedef struct
7114 {
7116 } _OrthancPluginRegisterRefreshMetricsCallback;
7117
7130 OrthancPluginContext* context,
7132 {
7133 _OrthancPluginRegisterRefreshMetricsCallback params;
7134 params.callback = callback;
7135 context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
7136 }
7137
7138
7139
7140
7141 typedef struct
7142 {
7143 char** target;
7144 const void* dicom;
7145 uint32_t dicomSize;
7147 } _OrthancPluginEncodeDicomWeb;
7148
7165 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
7166 OrthancPluginContext* context,
7167 const void* dicom,
7168 uint32_t dicomSize,
7170 {
7171 char* target = NULL;
7172
7173 _OrthancPluginEncodeDicomWeb params;
7174 params.target = &target;
7175 params.dicom = dicom;
7176 params.dicomSize = dicomSize;
7177 params.callback = callback;
7178
7179 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
7180 {
7181 /* Error */
7182 return NULL;
7183 }
7184 else
7185 {
7186 return target;
7187 }
7188 }
7189
7190
7207 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
7208 OrthancPluginContext* context,
7209 const void* dicom,
7210 uint32_t dicomSize,
7212 {
7213 char* target = NULL;
7214
7215 _OrthancPluginEncodeDicomWeb params;
7216 params.target = &target;
7217 params.dicom = dicom;
7218 params.dicomSize = dicomSize;
7219 params.callback = callback;
7220
7221 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
7222 {
7223 /* Error */
7224 return NULL;
7225 }
7226 else
7227 {
7228 return target;
7229 }
7230 }
7231
7232
7233
7234 typedef struct
7235 {
7236 char** target;
7237 const void* dicom;
7238 uint32_t dicomSize;
7240 void* payload;
7241 } _OrthancPluginEncodeDicomWeb2;
7242
7259 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson2(
7260 OrthancPluginContext* context,
7261 const void* dicom,
7262 uint32_t dicomSize,
7264 void* payload)
7265 {
7266 char* target = NULL;
7267
7268 _OrthancPluginEncodeDicomWeb2 params;
7269 params.target = &target;
7270 params.dicom = dicom;
7271 params.dicomSize = dicomSize;
7272 params.callback = callback;
7273 params.payload = payload;
7274
7275 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson2, &params) != OrthancPluginErrorCode_Success)
7276 {
7277 /* Error */
7278 return NULL;
7279 }
7280 else
7281 {
7282 return target;
7283 }
7284 }
7285
7286
7303 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml2(
7304 OrthancPluginContext* context,
7305 const void* dicom,
7306 uint32_t dicomSize,
7308 void* payload)
7309 {
7310 char* target = NULL;
7311
7312 _OrthancPluginEncodeDicomWeb2 params;
7313 params.target = &target;
7314 params.dicom = dicom;
7315 params.dicomSize = dicomSize;
7316 params.callback = callback;
7317 params.payload = payload;
7318
7319 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml2, &params) != OrthancPluginErrorCode_Success)
7320 {
7321 /* Error */
7322 return NULL;
7323 }
7324 else
7325 {
7326 return target;
7327 }
7328 }
7329
7330
7331
7348 void* answer,
7349 const char* key,
7350 const char* value);
7351
7352
7369 void* answer,
7370 const void* data,
7371 uint32_t size);
7372
7373
7388 typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
7389
7390
7406
7407
7421 typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
7422
7423
7437 typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
7438
7439
7440 typedef struct
7441 {
7442 void* answer;
7445 uint16_t* httpStatus;
7447 const char* url;
7448 uint32_t headersCount;
7449 const char* const* headersKeys;
7450 const char* const* headersValues;
7451 void* request;
7456 const char* username;
7457 const char* password;
7458 uint32_t timeout;
7459 const char* certificateFile;
7460 const char* certificateKeyFile;
7461 const char* certificateKeyPassword;
7462 uint8_t pkcs11;
7463 } _OrthancPluginChunkedHttpClient;
7464
7465
7517 OrthancPluginContext* context,
7518 void* answer,
7521 uint16_t* httpStatus,
7523 const char* url,
7524 uint32_t headersCount,
7525 const char* const* headersKeys,
7526 const char* const* headersValues,
7527 void* request,
7532 const char* username,
7533 const char* password,
7534 uint32_t timeout,
7535 const char* certificateFile,
7536 const char* certificateKeyFile,
7537 const char* certificateKeyPassword,
7538 uint8_t pkcs11)
7539 {
7540 _OrthancPluginChunkedHttpClient params;
7541 memset(&params, 0, sizeof(params));
7542
7543 /* In common with OrthancPluginHttpClient() */
7544 params.httpStatus = httpStatus;
7545 params.method = method;
7546 params.url = url;
7547 params.headersCount = headersCount;
7548 params.headersKeys = headersKeys;
7549 params.headersValues = headersValues;
7550 params.username = username;
7551 params.password = password;
7552 params.timeout = timeout;
7553 params.certificateFile = certificateFile;
7554 params.certificateKeyFile = certificateKeyFile;
7555 params.certificateKeyPassword = certificateKeyPassword;
7556 params.pkcs11 = pkcs11;
7557
7558 /* For chunked body/answer */
7559 params.answer = answer;
7560 params.answerAddChunk = answerAddChunk;
7561 params.answerAddHeader = answerAddHeader;
7562 params.request = request;
7563 params.requestIsDone = requestIsDone;
7564 params.requestChunkData = requestChunkData;
7565 params.requestChunkSize = requestChunkSize;
7566 params.requestNext = requestNext;
7567
7568 return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7569 }
7570
7571
7572
7577 typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7578
7579
7580
7598 const char* url,
7599 const OrthancPluginHttpRequest* request);
7600
7601
7617 const void* data,
7618 uint32_t size);
7619
7620
7637 OrthancPluginRestOutput* output);
7638
7639
7655
7656 typedef struct
7657 {
7658 const char* pathRegularExpression;
7659 OrthancPluginRestCallback getHandler;
7661 OrthancPluginRestCallback deleteHandler;
7666 } _OrthancPluginChunkedRestCallback;
7667
7668
7699 OrthancPluginContext* context,
7700 const char* pathRegularExpression,
7701 OrthancPluginRestCallback getHandler,
7703 OrthancPluginRestCallback deleteHandler,
7708 {
7709 _OrthancPluginChunkedRestCallback params;
7710 params.pathRegularExpression = pathRegularExpression;
7711 params.getHandler = getHandler;
7712 params.postHandler = postHandler;
7713 params.deleteHandler = deleteHandler;
7714 params.putHandler = putHandler;
7715 params.addChunk = addChunk;
7716 params.execute = execute;
7717 params.finalize = finalize;
7718
7719 context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
7720 }
7721
7722
7723
7724
7725
7726 typedef struct
7727 {
7728 char** result;
7729 uint16_t group;
7730 uint16_t element;
7731 const char* privateCreator;
7732 } _OrthancPluginGetTagName;
7733
7749 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
7750 OrthancPluginContext* context,
7751 uint16_t group,
7752 uint16_t element,
7753 const char* privateCreator)
7754 {
7755 char* result;
7756
7757 _OrthancPluginGetTagName params;
7758 params.result = &result;
7759 params.group = group;
7760 params.element = element;
7761 params.privateCreator = privateCreator;
7762
7763 if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
7764 {
7765 /* Error */
7766 return NULL;
7767 }
7768 else
7769 {
7770 return result;
7771 }
7772 }
7773
7774
7775
7805 void** handler /* out */,
7806 const char* jobId,
7807 const char* transactionUid,
7808 const char* const* sopClassUids,
7809 const char* const* sopInstanceUids,
7810 uint32_t countInstances,
7811 const char* remoteAet,
7812 const char* calledAet);
7813
7814
7826 typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
7827
7828
7849 void* handler,
7850 const char* sopClassUid,
7851 const char* sopInstanceUid);
7852
7853
7854 typedef struct
7855 {
7859 } _OrthancPluginRegisterStorageCommitmentScpCallback;
7860
7875 OrthancPluginContext* context,
7879 {
7880 _OrthancPluginRegisterStorageCommitmentScpCallback params;
7881 params.factory = factory;
7882 params.destructor = destructor;
7883 params.lookup = lookup;
7884 return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
7885 }
7886
7887
7888
7915 const OrthancPluginDicomInstance* instance);
7916
7917
7918 typedef struct
7919 {
7921 } _OrthancPluginIncomingDicomInstanceFilter;
7922
7936 OrthancPluginContext* context,
7938 {
7939 _OrthancPluginIncomingDicomInstanceFilter params;
7940 params.callback = callback;
7941
7942 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, &params);
7943 }
7944
7945
7977 uint16_t* dimseStatus /* out */,
7978 const OrthancPluginDicomInstance* instance);
7979
7980
7981 typedef struct
7982 {
7984 } _OrthancPluginIncomingCStoreInstanceFilter;
7985
7999 OrthancPluginContext* context,
8001 {
8002 _OrthancPluginIncomingCStoreInstanceFilter params;
8003 params.callback = callback;
8004
8005 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingCStoreInstanceFilter, &params);
8006 }
8007
8044 OrthancPluginMemoryBuffer64* modifiedDicomBuffer,
8045 const void* receivedDicomBuffer,
8046 uint64_t receivedDicomBufferSize,
8048
8049
8050 typedef struct
8051 {
8053 } _OrthancPluginReceivedInstanceCallback;
8054
8076 OrthancPluginContext* context,
8078 {
8079 _OrthancPluginReceivedInstanceCallback params;
8080 params.callback = callback;
8081
8082 return context->InvokeService(context, _OrthancPluginService_RegisterReceivedInstanceCallback, &params);
8083 }
8084
8099 OrthancPluginContext* context,
8100 const OrthancPluginDicomInstance* instance)
8101 {
8102 char* result;
8103
8104 _OrthancPluginAccessDicomInstance params;
8105 memset(&params, 0, sizeof(params));
8106 params.resultStringToFree = &result;
8107 params.instance = instance;
8108
8109 if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, &params) != OrthancPluginErrorCode_Success)
8110 {
8111 /* Error */
8112 return NULL;
8113 }
8114 else
8115 {
8116 return result;
8117 }
8118 }
8119
8120
8133 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData(
8134 OrthancPluginContext* context,
8135 const OrthancPluginDicomInstance* instance)
8136 {
8137 int64_t hasPixelData;
8138
8139 _OrthancPluginAccessDicomInstance params;
8140 memset(&params, 0, sizeof(params));
8141 params.resultInt64 = &hasPixelData;
8142 params.instance = instance;
8143
8144 if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, &params) != OrthancPluginErrorCode_Success ||
8145 hasPixelData < 0 ||
8146 hasPixelData > 1)
8147 {
8148 /* Error */
8149 return -1;
8150 }
8151 else
8152 {
8153 return (hasPixelData != 0);
8154 }
8155 }
8156
8157
8158
8159
8160
8161
8162 typedef struct
8163 {
8165 const void* buffer;
8166 uint32_t size;
8167 const char* transferSyntax;
8168 } _OrthancPluginCreateDicomInstance;
8169
8184 OrthancPluginContext* context,
8185 const void* buffer,
8186 uint32_t size)
8187 {
8188 OrthancPluginDicomInstance* target = NULL;
8189
8190 _OrthancPluginCreateDicomInstance params;
8191 params.target = &target;
8192 params.buffer = buffer;
8193 params.size = size;
8194
8195 if (context->InvokeService(context, _OrthancPluginService_CreateDicomInstance, &params) != OrthancPluginErrorCode_Success)
8196 {
8197 /* Error */
8198 return NULL;
8199 }
8200 else
8201 {
8202 return target;
8203 }
8204 }
8205
8206 typedef struct
8207 {
8209 } _OrthancPluginFreeDicomInstance;
8210
8221 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeDicomInstance(
8222 OrthancPluginContext* context,
8224 {
8225 _OrthancPluginFreeDicomInstance params;
8226 params.dicom = dicom;
8227
8228 context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, &params);
8229 }
8230
8231
8232 typedef struct
8233 {
8234 uint32_t* targetUint32;
8235 OrthancPluginMemoryBuffer* targetBuffer;
8236 OrthancPluginImage** targetImage;
8237 char** targetStringToFree;
8238 const OrthancPluginDicomInstance* instance;
8239 uint32_t frameIndex;
8242 uint32_t maxStringLength;
8243 OrthancPluginDicomWebBinaryCallback2 dicomWebCallback;
8244 void* dicomWebPayload;
8245 } _OrthancPluginAccessDicomInstance2;
8246
8258 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetInstanceFramesCount(
8259 OrthancPluginContext* context,
8260 const OrthancPluginDicomInstance* instance)
8261 {
8262 uint32_t count;
8263
8264 _OrthancPluginAccessDicomInstance2 params;
8265 memset(&params, 0, sizeof(params));
8266 params.targetUint32 = &count;
8267 params.instance = instance;
8268
8269 if (context->InvokeService(context, _OrthancPluginService_GetInstanceFramesCount, &params) != OrthancPluginErrorCode_Success)
8270 {
8271 /* Error */
8272 return 0;
8273 }
8274 else
8275 {
8276 return count;
8277 }
8278 }
8279
8280
8299 OrthancPluginContext* context,
8301 const OrthancPluginDicomInstance* instance,
8302 uint32_t frameIndex)
8303 {
8304 _OrthancPluginAccessDicomInstance2 params;
8305 memset(&params, 0, sizeof(params));
8306 params.targetBuffer = target;
8307 params.instance = instance;
8308 params.frameIndex = frameIndex;
8309
8310 return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, &params);
8311 }
8312
8313
8327 OrthancPluginContext* context,
8328 const OrthancPluginDicomInstance* instance,
8329 uint32_t frameIndex)
8330 {
8331 OrthancPluginImage* target = NULL;
8332
8333 _OrthancPluginAccessDicomInstance2 params;
8334 memset(&params, 0, sizeof(params));
8335 params.targetImage = &target;
8336 params.instance = instance;
8337 params.frameIndex = frameIndex;
8338
8339 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDecodedFrame, &params) != OrthancPluginErrorCode_Success)
8340 {
8341 return NULL;
8342 }
8343 else
8344 {
8345 return target;
8346 }
8347 }
8348
8349
8366 OrthancPluginContext* context,
8367 const void* buffer,
8368 uint32_t size,
8369 const char* transferSyntax)
8370 {
8371 OrthancPluginDicomInstance* target = NULL;
8372
8373 _OrthancPluginCreateDicomInstance params;
8374 params.target = &target;
8375 params.buffer = buffer;
8376 params.size = size;
8377 params.transferSyntax = transferSyntax;
8378
8379 if (context->InvokeService(context, _OrthancPluginService_TranscodeDicomInstance, &params) != OrthancPluginErrorCode_Success)
8380 {
8381 /* Error */
8382 return NULL;
8383 }
8384 else
8385 {
8386 return target;
8387 }
8388 }
8389
8404 OrthancPluginContext* context,
8406 const OrthancPluginDicomInstance* instance)
8407 {
8408 _OrthancPluginAccessDicomInstance2 params;
8409 memset(&params, 0, sizeof(params));
8410 params.targetBuffer = target;
8411 params.instance = instance;
8412
8413 return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, &params);
8414 }
8415
8416
8435 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceAdvancedJson(
8436 OrthancPluginContext* context,
8437 const OrthancPluginDicomInstance* instance,
8440 uint32_t maxStringLength)
8441 {
8442 char* result = NULL;
8443
8444 _OrthancPluginAccessDicomInstance2 params;
8445 memset(&params, 0, sizeof(params));
8446 params.targetStringToFree = &result;
8447 params.instance = instance;
8448 params.format = format;
8449 params.flags = flags;
8450 params.maxStringLength = maxStringLength;
8451
8452 if (context->InvokeService(context, _OrthancPluginService_GetInstanceAdvancedJson, &params) != OrthancPluginErrorCode_Success)
8453 {
8454 /* Error */
8455 return NULL;
8456 }
8457 else
8458 {
8459 return result;
8460 }
8461 }
8462
8463
8478 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebJson(
8479 OrthancPluginContext* context,
8480 const OrthancPluginDicomInstance* instance,
8482 void* payload)
8483 {
8484 char* target = NULL;
8485
8486 _OrthancPluginAccessDicomInstance2 params;
8487 params.targetStringToFree = &target;
8488 params.instance = instance;
8489 params.dicomWebCallback = callback;
8490 params.dicomWebPayload = payload;
8491
8492 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebJson, &params) != OrthancPluginErrorCode_Success)
8493 {
8494 /* Error */
8495 return NULL;
8496 }
8497 else
8498 {
8499 return target;
8500 }
8501 }
8502
8503
8518 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebXml(
8519 OrthancPluginContext* context,
8520 const OrthancPluginDicomInstance* instance,
8522 void* payload)
8523 {
8524 char* target = NULL;
8525
8526 _OrthancPluginAccessDicomInstance2 params;
8527 params.targetStringToFree = &target;
8528 params.instance = instance;
8529 params.dicomWebCallback = callback;
8530 params.dicomWebPayload = payload;
8531
8532 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebXml, &params) != OrthancPluginErrorCode_Success)
8533 {
8534 /* Error */
8535 return NULL;
8536 }
8537 else
8538 {
8539 return target;
8540 }
8541 }
8542
8543
8544
8564 OrthancPluginMemoryBuffer* transcoded /* out */,
8565 const void* buffer,
8566 uint64_t size,
8567 const char* const* allowedSyntaxes,
8568 uint32_t countSyntaxes,
8569 uint8_t allowNewSopInstanceUid);
8570
8571
8572 typedef struct
8573 {
8575 } _OrthancPluginTranscoderCallback;
8576
8591 OrthancPluginContext* context,
8593 {
8594 _OrthancPluginTranscoderCallback params;
8595 params.callback = callback;
8596
8597 return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, &params);
8598 }
8599
8600
8601
8602 typedef struct
8603 {
8605 uint32_t size;
8606 } _OrthancPluginCreateMemoryBuffer;
8607
8626 OrthancPluginContext* context,
8628 uint32_t size)
8629 {
8630 _OrthancPluginCreateMemoryBuffer params;
8631 params.target = target;
8632 params.size = size;
8633
8634 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, &params);
8635 }
8636
8637
8664 OrthancPluginContext* context)
8665 {
8666 char* result;
8667
8668 _OrthancPluginRetrieveDynamicString params;
8669 params.result = &result;
8670 params.argument = NULL;
8671
8672 if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
8674 {
8675 /* Error */
8676 return NULL;
8677 }
8678 else
8679 {
8680 return result;
8681 }
8682 }
8683
8684
8685
8686 typedef struct
8687 {
8689 uint64_t size;
8690 } _OrthancPluginCreateMemoryBuffer64;
8691
8710 OrthancPluginContext* context,
8712 uint64_t size)
8713 {
8714 _OrthancPluginCreateMemoryBuffer64 params;
8715 params.target = target;
8716 params.size = size;
8717
8718 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer64, &params);
8719 }
8720
8721
8722 typedef struct
8723 {
8728 } _OrthancPluginRegisterStorageArea2;
8729
8746 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea2(
8747 OrthancPluginContext* context,
8752 {
8753 _OrthancPluginRegisterStorageArea2 params;
8754 params.create = create;
8755 params.readWhole = readWhole;
8756 params.readRange = readRange;
8757 params.remove = remove;
8758 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea2, &params);
8759 }
8760
8761
8762
8763 typedef struct
8764 {
8765 _OrthancPluginCreateDicom createDicom;
8766 const char* privateCreator;
8767 } _OrthancPluginCreateDicom2;
8768
8794 OrthancPluginContext* context,
8796 const char* json,
8797 const OrthancPluginImage* pixelData,
8799 const char* privateCreator)
8800 {
8801 _OrthancPluginCreateDicom2 params;
8802 params.createDicom.target = target;
8803 params.createDicom.json = json;
8804 params.createDicom.pixelData = pixelData;
8805 params.createDicom.flags = flags;
8806 params.privateCreator = privateCreator;
8807
8808 return context->InvokeService(context, _OrthancPluginService_CreateDicom2, &params);
8809 }
8810
8811
8812
8813
8814
8815
8816 typedef struct
8817 {
8818 OrthancPluginMemoryBuffer* answerBody;
8819 OrthancPluginMemoryBuffer* answerHeaders;
8820 uint16_t* httpStatus;
8822 const char* uri;
8823 uint32_t headersCount;
8824 const char* const* headersKeys;
8825 const char* const* headersValues;
8826 const void* body;
8827 uint32_t bodySize;
8828 uint8_t afterPlugins;
8829 } _OrthancPluginCallRestApi;
8830
8862 OrthancPluginContext* context,
8863 OrthancPluginMemoryBuffer* answerBody,
8864 OrthancPluginMemoryBuffer* answerHeaders,
8865 uint16_t* httpStatus,
8867 const char* uri,
8868 uint32_t headersCount,
8869 const char* const* headersKeys,
8870 const char* const* headersValues,
8871 const void* body,
8872 uint32_t bodySize,
8873 uint8_t afterPlugins)
8874 {
8875 _OrthancPluginCallRestApi params;
8876 memset(&params, 0, sizeof(params));
8877
8878 params.answerBody = answerBody;
8879 params.answerHeaders = answerHeaders;
8880 params.httpStatus = httpStatus;
8881 params.method = method;
8882 params.uri = uri;
8883 params.headersCount = headersCount;
8884 params.headersKeys = headersKeys;
8885 params.headersValues = headersValues;
8886 params.body = body;
8887 params.bodySize = bodySize;
8888 params.afterPlugins = afterPlugins;
8889
8890 return context->InvokeService(context, _OrthancPluginService_CallRestApi, &params);
8891 }
8892
8893
8894
8899 typedef struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection;
8900
8901
8920 const char* name,
8921 uint64_t size,
8922 const char* mimeType,
8923 const char* dateTime);
8924
8925
8941 const char* name,
8942 const char* dateTime);
8943
8944
8968 const void* data,
8969 uint64_t size,
8970 const char* mimeType,
8971 const char* dateTime);
8972
8973
8988 uint8_t* isExisting, /* out */
8989 uint32_t pathSize,
8990 const char* const* pathItems,
8991 void* payload);
8992
8993
9013 uint8_t* isExisting, /* out */
9017 uint32_t pathSize,
9018 const char* const* pathItems,
9019 void* payload);
9020
9021
9041 uint32_t pathSize,
9042 const char* const* pathItems,
9043 void* payload);
9044
9045
9062 uint8_t* isReadOnly, /* out */
9063 uint32_t pathSize,
9064 const char* const* pathItems,
9065 const void* data,
9066 uint64_t size,
9067 void* payload);
9068
9069
9084 uint8_t* isReadOnly, /* out */
9085 uint32_t pathSize,
9086 const char* const* pathItems,
9087 void* payload);
9088
9089
9104 uint8_t* isReadOnly, /* out */
9105 uint32_t pathSize,
9106 const char* const* pathItems,
9107 void* payload);
9108
9109
9110 typedef struct
9111 {
9112 const char* uri;
9119 void* payload;
9120 } _OrthancPluginRegisterWebDavCollection;
9121
9143 OrthancPluginContext* context,
9144 const char* uri,
9151 void* payload)
9152 {
9153 _OrthancPluginRegisterWebDavCollection params;
9154 params.uri = uri;
9155 params.isExistingFolder = isExistingFolder;
9156 params.listFolder = listFolder;
9157 params.retrieveFile = retrieveFile;
9158 params.storeFile = storeFile;
9159 params.createFolder = createFolder;
9160 params.deleteItem = deleteItem;
9161 params.payload = payload;
9162
9163 return context->InvokeService(context, _OrthancPluginService_RegisterWebDavCollection, &params);
9164 }
9165
9166
9175 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetDatabaseServerIdentifier(
9176 OrthancPluginContext* context)
9177 {
9178 const char* result;
9179
9180 _OrthancPluginRetrieveStaticString params;
9181 params.result = &result;
9182 params.argument = NULL;
9183
9184 if (context->InvokeService(context, _OrthancPluginService_GetDatabaseServerIdentifier, &params) != OrthancPluginErrorCode_Success)
9185 {
9186 /* Error */
9187 return NULL;
9188 }
9189 else
9190 {
9191 return result;
9192 }
9193 }
9194
9195
9204 void* backend,
9205 const void* request,
9206 uint64_t requestSize);
9207
9213 typedef void (*OrthancPluginFinalizeDatabaseBackendV4) (void* backend);
9214
9215 typedef struct
9216 {
9217 void* backend;
9218 uint32_t maxDatabaseRetries;
9221 } _OrthancPluginRegisterDatabaseBackendV4;
9222
9241 OrthancPluginContext* context,
9242 void* backend,
9243 uint32_t maxDatabaseRetries,
9246 {
9247 _OrthancPluginRegisterDatabaseBackendV4 params;
9248 params.backend = backend;
9249 params.maxDatabaseRetries = maxDatabaseRetries;
9250 params.operations = operations;
9251 params.finalize = finalize;
9252
9253 return context->InvokeService(context, _OrthancPluginService_RegisterDatabaseBackendV4, &params);
9254 }
9255
9256
9257 typedef struct
9258 {
9260 const char* instanceId;
9262 } _OrthancPluginLoadDicomInstance;
9263
9278 OrthancPluginContext* context,
9279 const char* instanceId,
9281 {
9282 OrthancPluginDicomInstance* target = NULL;
9283
9284 _OrthancPluginLoadDicomInstance params;
9285 params.target = &target;
9286 params.instanceId = instanceId;
9287 params.mode = mode;
9288
9289 if (context->InvokeService(context, _OrthancPluginService_LoadDicomInstance, &params) != OrthancPluginErrorCode_Success)
9290 {
9291 /* Error */
9292 return NULL;
9293 }
9294 else
9295 {
9296 return target;
9297 }
9298 }
9299
9300
9301 typedef struct
9302 {
9303 const char* name;
9304 int64_t value;
9306 } _OrthancPluginSetMetricsIntegerValue;
9307
9323 ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsIntegerValue(
9324 OrthancPluginContext* context,
9325 const char* name,
9326 int64_t value,
9328 {
9329 _OrthancPluginSetMetricsIntegerValue params;
9330 params.name = name;
9331 params.value = value;
9332 params.type = type;
9333 context->InvokeService(context, _OrthancPluginService_SetMetricsIntegerValue, &params);
9334 }
9335
9336
9337#ifdef __cplusplus
9338}
9339#endif
9340
9341
OrthancPluginErrorCode OrthancPluginRegisterDatabaseBackendV4(OrthancPluginContext *context, void *backend, uint32_t maxDatabaseRetries, OrthancPluginCallDatabaseBackendV4 operations, OrthancPluginFinalizeDatabaseBackendV4 finalize)
Definition: OrthancCPlugin.h:9240
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:9202
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:8043
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:8918
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:1905
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:3243
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:2208
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:1250
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5469
OrthancPluginChangeType
Definition: OrthancCPlugin.h:734
OrthancPluginErrorCode(* OrthancPluginStorageReadWhole)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type)
Callback for reading a whole file from the storage area.
Definition: OrthancCPlugin.h:1316
OrthancPluginErrorCode OrthancPluginRegisterIncomingCStoreInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingCStoreInstanceFilter callback)
Register a callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition: OrthancCPlugin.h:7998
int OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:2011
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:1228
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:7129
OrthancPluginErrorCode(* OrthancPluginWebDavCreateFolderCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback to create a folder.
Definition: OrthancCPlugin.h:9083
struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection
Opaque structure that represents a WebDAV collection.
Definition: OrthancCPlugin.h:8899
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:1786
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:9038
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition: OrthancCPlugin.h:7914
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4827
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:8563
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6372
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:8966
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1296
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:2130
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3631
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:8075
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:9012
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1739
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:1099
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3386
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:8746
OrthancPluginErrorCode(* OrthancPluginWebDavAddFolder)(OrthancPluginWebDavCollection *collection, const char *name, const char *dateTime)
Declare a subfolder while returning the content of a folder.
Definition: OrthancCPlugin.h:8939
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:9142
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:1442
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1196
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1758
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition: OrthancCPlugin.h:8590
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:1207
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:9061
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:9103
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:5019
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1357
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1269
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:1824
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:1217
void(* OrthancPluginFinalizeDatabaseBackendV4)(void *backend)
Signature of a callback function that is triggered when the database plugin must be finalized.
Definition: OrthancCPlugin.h:9213
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition: OrthancCPlugin.h:7577
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:8987
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:1407
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:6984
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1240
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:2170
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4788
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:1339
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:7698
int32_t(* OrthancPluginIncomingCStoreInstanceFilter)(uint16_t *dimseStatus, const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition: OrthancCPlugin.h:7976
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition: OrthancCPlugin.h:7935
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5805
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:4744
@ OrthancPluginChangeType_OrthancStopped
Definition: OrthancCPlugin.h:746
@ OrthancPluginChangeType_OrthancStarted
Definition: OrthancCPlugin.h:745
@ OrthancPluginChangeType_Deleted
Definition: OrthancCPlugin.h:736
@ OrthancPluginChangeType_JobFailure
Definition: OrthancCPlugin.h:753
@ OrthancPluginChangeType_NewInstance
Definition: OrthancCPlugin.h:738
@ OrthancPluginChangeType_NewPatient
Definition: OrthancCPlugin.h:739
@ OrthancPluginChangeType_JobSubmitted
Definition: OrthancCPlugin.h:751
@ OrthancPluginChangeType_NewSeries
Definition: OrthancCPlugin.h:740
@ OrthancPluginChangeType_StablePatient
Definition: OrthancCPlugin.h:742
@ OrthancPluginChangeType_UpdatedPeers
Definition: OrthancCPlugin.h:749
@ OrthancPluginChangeType_StableStudy
Definition: OrthancCPlugin.h:744
@ OrthancPluginChangeType_CompletedSeries
Definition: OrthancCPlugin.h:735
@ OrthancPluginChangeType_NewChildInstance
Definition: OrthancCPlugin.h:737
@ OrthancPluginChangeType_UpdatedAttachment
Definition: OrthancCPlugin.h:747
@ OrthancPluginChangeType_UpdatedMetadata
Definition: OrthancCPlugin.h:748
@ OrthancPluginChangeType_StableSeries
Definition: OrthancCPlugin.h:743
@ OrthancPluginChangeType_UpdatedModalities
Definition: OrthancCPlugin.h:750
@ OrthancPluginChangeType_JobSuccess
Definition: OrthancCPlugin.h:752
@ OrthancPluginChangeType_NewStudy
Definition: OrthancCPlugin.h:741
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:6066
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1147
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1552
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:6042
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7826
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:1376
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:6220
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:6172
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:7804
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5974
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5351
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:7847
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:5312
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:6013
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:7874
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1155
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1139
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1469
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1537
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:5208
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:6134
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5274
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:6103
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1566
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1131
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:1512
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:5244
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:8133
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:8518
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition: OrthancCPlugin.h:1107
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:8298
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2974
OrthancPluginDicomInstance * OrthancPluginLoadDicomInstance(OrthancPluginContext *context, const char *instanceId, OrthancPluginLoadDicomInstanceMode mode)
Load a DICOM instance from the Orthanc server.
Definition: OrthancCPlugin.h:9277
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:3076
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition: OrthancCPlugin.h:8365
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition: OrthancCPlugin.h:8183
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition: OrthancCPlugin.h:8258
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5377
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:3007
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:8478
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition: OrthancCPlugin.h:8098
int OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:3153
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition: OrthancCPlugin.h:8221
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition: OrthancCPlugin.h:8403
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:3194
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:3114
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:3040
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:8326
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:8435
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4530
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:610
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:4690
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:4274
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:4065
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3964
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5507
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4565
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:4030
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:4099
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:4184
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:4229
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5596
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:4142
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4605
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:779
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:1123
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:764
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:3997
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:3776
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4637
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:5550
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1115
@ OrthancPluginPixelFormat_RGBA32
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:649
@ OrthancPluginPixelFormat_RGB48
Color image in RGB48 format.
Definition: OrthancCPlugin.h:659
@ OrthancPluginPixelFormat_Grayscale8
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:617
@ OrthancPluginPixelFormat_SignedGrayscale16
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:633
@ OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:675
@ OrthancPluginPixelFormat_RGB24
Color image in RGB24 format.
Definition: OrthancCPlugin.h:641
@ OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:683
@ OrthancPluginPixelFormat_Unknown
Definition: OrthancCPlugin.h:651
@ OrthancPluginPixelFormat_Grayscale64
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:691
@ OrthancPluginPixelFormat_Grayscale32
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:667
@ OrthancPluginPixelFormat_Grayscale16
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:625
@ OrthancPluginImageFormat_Png
Definition: OrthancCPlugin.h:780
@ OrthancPluginImageFormat_Jpeg
Definition: OrthancCPlugin.h:781
@ OrthancPluginImageFormat_Dicom
Definition: OrthancCPlugin.h:782
@ OrthancPluginCompressionType_Gzip
Definition: OrthancCPlugin.h:767
@ OrthancPluginCompressionType_ZlibWithSize
Definition: OrthancCPlugin.h:766
@ OrthancPluginCompressionType_Zlib
Definition: OrthancCPlugin.h:765
@ OrthancPluginCompressionType_GzipWithSize
Definition: OrthancCPlugin.h:768
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:2438
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:2473
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:2586
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2722
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2757
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3534
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:2550
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3495
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2687
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2371
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2792
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:2401
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2652
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2502
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2525
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:8861
char * OrthancPluginGenerateRestApiAuthorizationToken(OrthancPluginContext *context)
Generate a token to grant full access to the REST API of Orthanc.
Definition: OrthancCPlugin.h:8663
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:5170
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2338
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:2297
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2860
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:7020
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2883
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:2240
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2837
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2938
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2913
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2620
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:4321
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:3734
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:5767
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:3928
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3705
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1706
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderExecute)(OrthancPluginServerChunkedRequestReader *reader, OrthancPluginRestOutput *output)
Callback invoked whenever the request body is entirely received.
Definition: OrthancCPlugin.h:7635
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:5880
struct _OrthancPluginJob_t OrthancPluginJob
Opaque structure to a job to be executed by Orthanc.
Definition: OrthancCPlugin.h:1179
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:8793
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:2094
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderFactory)(OrthancPluginServerChunkedRequestReader **reader, const char *url, const OrthancPluginHttpRequest *request)
Callback to create a reader to handle incoming chunked HTTP transfers.
Definition: OrthancCPlugin.h:7596
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:6297
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6434
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:4975
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:883
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:4922
OrthancPluginResourceType
Definition: OrthancCPlugin.h:717
void OrthancPluginSetMetricsIntegerValue(OrthancPluginContext *context, const char *name, int64_t value, OrthancPluginMetricsType type)
Set the value of an integer metrics.
Definition: OrthancCPlugin.h:9323
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3844
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3565
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5642
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:1171
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:4412
uint32_t(* OrthancPluginChunkedClientRequestGetChunkSize)(void *request)
Callback to read the size of the current request chunk during a chunked transfer.
Definition: OrthancCPlugin.h:7437
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4866
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, uint32_t size)
Create a 32-bit memory buffer.
Definition: OrthancCPlugin.h:8625
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:6852
OrthancPluginDicomWebBinaryMode
Definition: OrthancCPlugin.h:972
OrthancPluginErrorCode(* OrthancPluginJobGetContent2)(OrthancPluginMemoryBuffer *target, void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1626
OrthancPluginErrorCode(* OrthancPluginChunkedClientRequestNext)(void *request)
Callback to advance in the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7405
struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode
Opaque structure that represents a node in a JSON or XML document used in DICOMweb.
Definition: OrthancCPlugin.h:1188
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1592
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7165
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:6259
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:847
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:929
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:868
void(* OrthancPluginServerChunkedRequestReaderFinalize)(OrthancPluginServerChunkedRequestReader *reader)
Callback invoked to release the resources associated with an incoming HTTP chunked transfer.
Definition: OrthancCPlugin.h:7653
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:6330
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:3461
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:2078
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6512
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6400
OrthancPluginConstraintType
Definition: OrthancCPlugin.h:898
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:3305
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3813
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1682
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5678
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3599
void OrthancPluginSetMetricsValue(OrthancPluginContext *context, const char *name, float value, OrthancPluginMetricsType type)
Set the value of a floating-point metrics.
Definition: OrthancCPlugin.h:7098
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:7615
OrthancPluginReceivedInstanceAction
Definition: OrthancCPlugin.h:1019
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:7516
int32_t(* OrthancPluginJobGetSerialized2)(OrthancPluginMemoryBuffer *target, void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1666
void OrthancPluginFreeMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:2046
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:4454
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:5063
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:5433
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:5112
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6907
const char * OrthancPluginGetDatabaseServerIdentifier(OrthancPluginContext *context)
Gets the DatabaseServerIdentifier.
Definition: OrthancCPlugin.h:9175
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int priority)
Submit a new job to the jobs engine of Orthanc.
Definition: OrthancCPlugin.h:6939
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5935
OrthancPluginStorageCommitmentFailureReason
Definition: OrthancCPlugin.h:985
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:7368
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:6599
OrthancPluginMetricsType
Definition: OrthancCPlugin.h:955
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:7052
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4492
uint8_t(* OrthancPluginChunkedClientRequestIsDone)(void *request)
Callback to know whether the request body is entirely read during a chunked transfer.
Definition: OrthancCPlugin.h:7388
const void *(* OrthancPluginChunkedClientRequestGetChunkData)(void *request)
Callback to read the current chunk of the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7421
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:6766
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:2030
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7207
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1646
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3664
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *target, uint64_t size)
Create a 64-bit memory buffer.
Definition: OrthancCPlugin.h:8709
OrthancPluginLoadDicomInstanceMode
Definition: OrthancCPlugin.h:1033
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:7347
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6464
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1608
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:793
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:4374
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:943
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:3275
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:832
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:2062
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:3340
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:3417
char * OrthancPluginEncodeDicomWebXml2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7303
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:6680
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:1163
char * OrthancPluginEncodeDicomWebJson2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7259
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5724
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:913
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1579
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1875
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1723
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3875
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginContentType
Definition: OrthancCPlugin.h:702
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6553
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:3439
char * OrthancPluginGetTagName(OrthancPluginContext *context, uint16_t group, uint16_t element, const char *privateCreator)
Returns the symbolic name of a DICOM tag.
Definition: OrthancCPlugin.h:7749
@ OrthancPluginIdentifierConstraint_Wildcard
Definition: OrthancCPlugin.h:887
@ OrthancPluginIdentifierConstraint_Equal
Definition: OrthancCPlugin.h:884
@ OrthancPluginIdentifierConstraint_SmallerOrEqual
Definition: OrthancCPlugin.h:885
@ OrthancPluginIdentifierConstraint_GreaterOrEqual
Definition: OrthancCPlugin.h:886
@ OrthancPluginResourceType_Instance
Definition: OrthancCPlugin.h:721
@ OrthancPluginResourceType_None
Definition: OrthancCPlugin.h:722
@ OrthancPluginResourceType_Series
Definition: OrthancCPlugin.h:720
@ OrthancPluginResourceType_Study
Definition: OrthancCPlugin.h:719
@ OrthancPluginResourceType_Patient
Definition: OrthancCPlugin.h:718
@ 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:974
@ OrthancPluginDicomWebBinaryMode_BulkDataUri
Definition: OrthancCPlugin.h:975
@ OrthancPluginDicomWebBinaryMode_Ignore
Definition: OrthancCPlugin.h:973
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii
Definition: OrthancCPlugin.h:853
@ OrthancPluginDicomToJsonFlags_IncludeBinary
Definition: OrthancCPlugin.h:849
@ OrthancPluginDicomToJsonFlags_IncludePixelData
Definition: OrthancCPlugin.h:852
@ OrthancPluginDicomToJsonFlags_IncludeUnknownTags
Definition: OrthancCPlugin.h:851
@ OrthancPluginDicomToJsonFlags_SkipGroupLengths
Definition: OrthancCPlugin.h:856
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
Definition: OrthancCPlugin.h:854
@ OrthancPluginDicomToJsonFlags_StopAfterPixelData
Definition: OrthancCPlugin.h:855
@ OrthancPluginDicomToJsonFlags_IncludePrivateTags
Definition: OrthancCPlugin.h:850
@ OrthancPluginJobStepStatus_Continue
Definition: OrthancCPlugin.h:932
@ OrthancPluginJobStepStatus_Success
Definition: OrthancCPlugin.h:930
@ OrthancPluginJobStepStatus_Failure
Definition: OrthancCPlugin.h:931
@ OrthancPluginCreateDicomFlags_DecodeDataUriScheme
Definition: OrthancCPlugin.h:870
@ OrthancPluginCreateDicomFlags_GenerateIdentifiers
Definition: OrthancCPlugin.h:871
@ OrthancPluginConstraintType_SmallerOrEqual
Definition: OrthancCPlugin.h:900
@ OrthancPluginConstraintType_List
Definition: OrthancCPlugin.h:903
@ OrthancPluginConstraintType_GreaterOrEqual
Definition: OrthancCPlugin.h:901
@ OrthancPluginConstraintType_Equal
Definition: OrthancCPlugin.h:899
@ OrthancPluginConstraintType_Wildcard
Definition: OrthancCPlugin.h:902
@ OrthancPluginReceivedInstanceAction_KeepAsIs
Definition: OrthancCPlugin.h:1020
@ OrthancPluginReceivedInstanceAction_Discard
Definition: OrthancCPlugin.h:1022
@ OrthancPluginReceivedInstanceAction_Modify
Definition: OrthancCPlugin.h:1021
@ OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
Definition: OrthancCPlugin.h:1000
@ OrthancPluginStorageCommitmentFailureReason_Success
Definition: OrthancCPlugin.h:986
@ OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
Definition: OrthancCPlugin.h:1009
@ OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
Definition: OrthancCPlugin.h:1004
@ OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
Definition: OrthancCPlugin.h:996
@ OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
Definition: OrthancCPlugin.h:992
@ OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
Definition: OrthancCPlugin.h:989
@ OrthancPluginMetricsType_Default
Definition: OrthancCPlugin.h:956
@ OrthancPluginMetricsType_Timer
Definition: OrthancCPlugin.h:963
@ OrthancPluginLoadDicomInstanceMode_UntilPixelData
Definition: OrthancCPlugin.h:1037
@ OrthancPluginLoadDicomInstanceMode_WholeDicom
Definition: OrthancCPlugin.h:1034
@ OrthancPluginLoadDicomInstanceMode_EmptyPixelData
Definition: OrthancCPlugin.h:1041
@ OrthancPluginValueRepresentation_PN
Definition: OrthancCPlugin.h:809
@ OrthancPluginValueRepresentation_UL
Definition: OrthancCPlugin.h:817
@ OrthancPluginValueRepresentation_UN
Definition: OrthancCPlugin.h:818
@ OrthancPluginValueRepresentation_DA
Definition: OrthancCPlugin.h:798
@ OrthancPluginValueRepresentation_OF
Definition: OrthancCPlugin.h:807
@ OrthancPluginValueRepresentation_OW
Definition: OrthancCPlugin.h:808
@ OrthancPluginValueRepresentation_CS
Definition: OrthancCPlugin.h:797
@ OrthancPluginValueRepresentation_US
Definition: OrthancCPlugin.h:819
@ OrthancPluginValueRepresentation_SH
Definition: OrthancCPlugin.h:810
@ OrthancPluginValueRepresentation_FL
Definition: OrthancCPlugin.h:802
@ OrthancPluginValueRepresentation_DT
Definition: OrthancCPlugin.h:800
@ OrthancPluginValueRepresentation_TM
Definition: OrthancCPlugin.h:815
@ OrthancPluginValueRepresentation_SQ
Definition: OrthancCPlugin.h:812
@ OrthancPluginValueRepresentation_DS
Definition: OrthancCPlugin.h:799
@ OrthancPluginValueRepresentation_OB
Definition: OrthancCPlugin.h:806
@ OrthancPluginValueRepresentation_SL
Definition: OrthancCPlugin.h:811
@ OrthancPluginValueRepresentation_ST
Definition: OrthancCPlugin.h:814
@ OrthancPluginValueRepresentation_IS
Definition: OrthancCPlugin.h:803
@ OrthancPluginValueRepresentation_LT
Definition: OrthancCPlugin.h:805
@ OrthancPluginValueRepresentation_SS
Definition: OrthancCPlugin.h:813
@ OrthancPluginValueRepresentation_UT
Definition: OrthancCPlugin.h:820
@ OrthancPluginValueRepresentation_LO
Definition: OrthancCPlugin.h:804
@ OrthancPluginValueRepresentation_AE
Definition: OrthancCPlugin.h:794
@ OrthancPluginValueRepresentation_FD
Definition: OrthancCPlugin.h:801
@ OrthancPluginValueRepresentation_UI
Definition: OrthancCPlugin.h:816
@ OrthancPluginValueRepresentation_AS
Definition: OrthancCPlugin.h:795
@ OrthancPluginValueRepresentation_AT
Definition: OrthancCPlugin.h:796
@ OrthancPluginJobStopReason_Failure
Definition: OrthancCPlugin.h:946
@ OrthancPluginJobStopReason_Success
Definition: OrthancCPlugin.h:944
@ OrthancPluginJobStopReason_Canceled
Definition: OrthancCPlugin.h:947
@ OrthancPluginJobStopReason_Paused
Definition: OrthancCPlugin.h:945
@ OrthancPluginDicomToJsonFormat_Full
Definition: OrthancCPlugin.h:833
@ OrthancPluginDicomToJsonFormat_Human
Definition: OrthancCPlugin.h:835
@ OrthancPluginDicomToJsonFormat_Short
Definition: OrthancCPlugin.h:834
@ 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:914
@ OrthancPluginInstanceOrigin_RestApi
Definition: OrthancCPlugin.h:916
@ OrthancPluginInstanceOrigin_Lua
Definition: OrthancCPlugin.h:918
@ OrthancPluginInstanceOrigin_WebDav
Definition: OrthancCPlugin.h:919
@ OrthancPluginInstanceOrigin_DicomProtocol
Definition: OrthancCPlugin.h:915
@ OrthancPluginInstanceOrigin_Plugin
Definition: OrthancCPlugin.h:917
@ OrthancPluginContentType_Dicom
Definition: OrthancCPlugin.h:704
@ OrthancPluginContentType_DicomAsJson
Definition: OrthancCPlugin.h:705
@ OrthancPluginContentType_Unknown
Definition: OrthancCPlugin.h:703
@ OrthancPluginContentType_DicomUntilPixelData
Definition: OrthancCPlugin.h:706
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1857
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1861
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1862
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1860
uint16_t element
Definition: OrthancCPlugin.h:1859
uint16_t group
Definition: OrthancCPlugin.h:1858
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:1080
uint64_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1089
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1084
A 32-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1058
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1067
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1062