Orthanc Plugin SDK 1.12.8
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1
52
53
54
74
75
76
81
82
83
105
106
107
108#pragma once
109
110
111#include <stdio.h>
112#include <string.h>
113
114#ifdef _WIN32
115# define ORTHANC_PLUGINS_API __declspec(dllexport)
116#elif __GNUC__ >= 4
117# define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default")))
118#else
119# define ORTHANC_PLUGINS_API
120#endif
121
122#define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
123#define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 12
124#define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 8
125
126
127#if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
128#define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
129 (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
130 (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
131 (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
132 (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
133 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
134#endif
135
136
137
138/********************************************************************
139 ** Check that function inlining is properly supported. The use of
140 ** inlining is required, to avoid the duplication of object code
141 ** between two compilation modules that would use the Orthanc Plugin
142 ** API.
143 ********************************************************************/
144
145/* If the auto-detection of the "inline" keyword below does not work
146 automatically and that your compiler is known to properly support
147 inlining, uncomment the following #define and adapt the definition
148 of "static inline". */
149
150/* #define ORTHANC_PLUGIN_INLINE static inline */
151
152#ifndef ORTHANC_PLUGIN_INLINE
153# if __STDC_VERSION__ >= 199901L
154/* This is C99 or above: http://predef.sourceforge.net/prestd.html */
155# define ORTHANC_PLUGIN_INLINE static inline
156# elif defined(__cplusplus)
157/* This is C++ */
158# define ORTHANC_PLUGIN_INLINE static inline
159# elif defined(__GNUC__)
160/* This is GCC running in C89 mode */
161# define ORTHANC_PLUGIN_INLINE static __inline
162# elif defined(_MSC_VER)
163/* This is Visual Studio running in C89 mode */
164# define ORTHANC_PLUGIN_INLINE static __inline
165# else
166# error Your compiler is not known to support the "inline" keyword
167# endif
168#endif
169
170
171#ifndef ORTHANC_PLUGIN_DEPRECATED
172# if defined(_MSC_VER)
173# define ORTHANC_PLUGIN_DEPRECATED __declspec(deprecated)
174# elif __GNUC__ >= 4
175# define ORTHANC_PLUGIN_DEPRECATED __attribute__ ((deprecated))
176# elif defined(__clang__)
177# define ORTHANC_PLUGIN_DEPRECATED __attribute__ ((deprecated))
178# else
179# pragma message("WARNING: You need to implement ORTHANC_PLUGINS_DEPRECATED for this compiler")
180# define ORTHANC_PLUGIN_DEPRECATED
181# endif
182#endif
183
184
185
186/********************************************************************
187 ** Inclusion of standard libraries.
188 ********************************************************************/
189
195#include <stdint.h>
196
197#include <stdlib.h>
198
199
200
201/********************************************************************
202 ** Definition of the Orthanc Plugin API.
203 ********************************************************************/
204
206
207#ifdef __cplusplus
208extern "C"
209{
210#endif
211
215 typedef enum
216 {
329
330 _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
332
333
338 ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
339
340
344 typedef enum
345 {
350
351 _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
353
354
359 typedef struct
360 {
365
369 uint32_t groupsCount;
370
374 const char* const* groups;
375
379 uint32_t getCount;
380
384 const char* const* getKeys;
385
389 const char* const* getValues;
390
394 const void* body;
395
399 uint32_t bodySize;
400
401
402 /* --------------------------------------------------
403 New in version 0.8.1
404 -------------------------------------------------- */
405
409 uint32_t headersCount;
410
414 const char* const* headersKeys;
415
419 const char* const* headersValues;
420
422
423
424 typedef enum
425 {
426 /* Generic services */
427 _OrthancPluginService_LogInfo = 1,
428 _OrthancPluginService_LogWarning = 2,
429 _OrthancPluginService_LogError = 3,
430 _OrthancPluginService_GetOrthancPath = 4,
431 _OrthancPluginService_GetOrthancDirectory = 5,
432 _OrthancPluginService_GetConfigurationPath = 6,
433 _OrthancPluginService_SetPluginProperty = 7,
434 _OrthancPluginService_GetGlobalProperty = 8,
435 _OrthancPluginService_SetGlobalProperty = 9,
436 _OrthancPluginService_GetCommandLineArgumentsCount = 10,
437 _OrthancPluginService_GetCommandLineArgument = 11,
438 _OrthancPluginService_GetExpectedDatabaseVersion = 12,
439 _OrthancPluginService_GetConfiguration = 13,
440 _OrthancPluginService_BufferCompression = 14,
441 _OrthancPluginService_ReadFile = 15,
442 _OrthancPluginService_WriteFile = 16,
443 _OrthancPluginService_GetErrorDescription = 17,
444 _OrthancPluginService_CallHttpClient = 18,
445 _OrthancPluginService_RegisterErrorCode = 19,
446 _OrthancPluginService_RegisterDictionaryTag = 20,
447 _OrthancPluginService_DicomBufferToJson = 21,
448 _OrthancPluginService_DicomInstanceToJson = 22,
449 _OrthancPluginService_CreateDicom = 23,
450 _OrthancPluginService_ComputeMd5 = 24,
451 _OrthancPluginService_ComputeSha1 = 25,
452 _OrthancPluginService_LookupDictionary = 26,
453 _OrthancPluginService_CallHttpClient2 = 27,
454 _OrthancPluginService_GenerateUuid = 28,
455 _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
456 _OrthancPluginService_AutodetectMimeType = 30,
457 _OrthancPluginService_SetMetricsValue = 31,
458 _OrthancPluginService_EncodeDicomWebJson = 32,
459 _OrthancPluginService_EncodeDicomWebXml = 33,
460 _OrthancPluginService_ChunkedHttpClient = 34, /* New in Orthanc 1.5.7 */
461 _OrthancPluginService_GetTagName = 35, /* New in Orthanc 1.5.7 */
462 _OrthancPluginService_EncodeDicomWebJson2 = 36, /* New in Orthanc 1.7.0 */
463 _OrthancPluginService_EncodeDicomWebXml2 = 37, /* New in Orthanc 1.7.0 */
464 _OrthancPluginService_CreateMemoryBuffer = 38, /* New in Orthanc 1.7.0 */
465 _OrthancPluginService_GenerateRestApiAuthorizationToken = 39, /* New in Orthanc 1.8.1 */
466 _OrthancPluginService_CreateMemoryBuffer64 = 40, /* New in Orthanc 1.9.0 */
467 _OrthancPluginService_CreateDicom2 = 41, /* New in Orthanc 1.9.0 */
468 _OrthancPluginService_GetDatabaseServerIdentifier = 42, /* New in Orthanc 1.11.1 */
469 _OrthancPluginService_SetMetricsIntegerValue = 43, /* New in Orthanc 1.12.1 */
470 _OrthancPluginService_SetCurrentThreadName = 44, /* New in Orthanc 1.12.2 */
471 _OrthancPluginService_LogMessage = 45, /* New in Orthanc 1.12.4 */
472 _OrthancPluginService_AdoptDicomInstance = 46, /* New in Orthanc 1.12.8 */
473 _OrthancPluginService_GetAttachmentCustomData = 47, /* New in Orthanc 1.12.8 */
474 _OrthancPluginService_SetAttachmentCustomData = 48, /* New in Orthanc 1.12.8 */
475 _OrthancPluginService_StoreKeyValue = 49, /* New in Orthanc 1.12.8 */
476 _OrthancPluginService_DeleteKeyValue = 50, /* New in Orthanc 1.12.8 */
477 _OrthancPluginService_GetKeyValue = 51, /* New in Orthanc 1.12.8 */
478 _OrthancPluginService_CreateKeysValuesIterator = 52, /* New in Orthanc 1.12.8 */
479 _OrthancPluginService_FreeKeysValuesIterator = 53, /* New in Orthanc 1.12.8 */
480 _OrthancPluginService_KeysValuesIteratorNext = 54, /* New in Orthanc 1.12.8 */
481 _OrthancPluginService_KeysValuesIteratorGetKey = 55, /* New in Orthanc 1.12.8 */
482 _OrthancPluginService_KeysValuesIteratorGetValue = 56, /* New in Orthanc 1.12.8 */
483 _OrthancPluginService_EnqueueValue = 57, /* New in Orthanc 1.12.8 */
484 _OrthancPluginService_DequeueValue = 58, /* New in Orthanc 1.12.8 */
485 _OrthancPluginService_GetQueueSize = 59, /* New in Orthanc 1.12.8 */
486
487 /* Registration of callbacks */
488 _OrthancPluginService_RegisterRestCallback = 1000,
489 _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
490 _OrthancPluginService_RegisterStorageArea = 1002,
491 _OrthancPluginService_RegisterOnChangeCallback = 1003,
492 _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
493 _OrthancPluginService_RegisterWorklistCallback = 1005,
494 _OrthancPluginService_RegisterDecodeImageCallback = 1006,
495 _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
496 _OrthancPluginService_RegisterFindCallback = 1008,
497 _OrthancPluginService_RegisterMoveCallback = 1009,
498 _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
499 _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
500 _OrthancPluginService_RegisterChunkedRestCallback = 1012, /* New in Orthanc 1.5.7 */
501 _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
502 _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
503 _OrthancPluginService_RegisterTranscoderCallback = 1015, /* New in Orthanc 1.7.0 */
504 _OrthancPluginService_RegisterStorageArea2 = 1016, /* New in Orthanc 1.9.0 */
505 _OrthancPluginService_RegisterIncomingCStoreInstanceFilter = 1017, /* New in Orthanc 1.10.0 */
506 _OrthancPluginService_RegisterReceivedInstanceCallback = 1018, /* New in Orthanc 1.10.0 */
507 _OrthancPluginService_RegisterWebDavCollection = 1019, /* New in Orthanc 1.10.1 */
508 _OrthancPluginService_RegisterStorageArea3 = 1020, /* New in Orthanc 1.12.8 */
509
510 /* Sending answers to REST calls */
511 _OrthancPluginService_AnswerBuffer = 2000,
512 _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
513 _OrthancPluginService_Redirect = 2002,
514 _OrthancPluginService_SendHttpStatusCode = 2003,
515 _OrthancPluginService_SendUnauthorized = 2004,
516 _OrthancPluginService_SendMethodNotAllowed = 2005,
517 _OrthancPluginService_SetCookie = 2006,
518 _OrthancPluginService_SetHttpHeader = 2007,
519 _OrthancPluginService_StartMultipartAnswer = 2008,
520 _OrthancPluginService_SendMultipartItem = 2009,
521 _OrthancPluginService_SendHttpStatus = 2010,
522 _OrthancPluginService_CompressAndAnswerImage = 2011,
523 _OrthancPluginService_SendMultipartItem2 = 2012,
524 _OrthancPluginService_SetHttpErrorDetails = 2013,
525 _OrthancPluginService_StartStreamAnswer = 2014,
526 _OrthancPluginService_SendStreamChunk = 2015,
527
528 /* Access to the Orthanc database and API */
529 _OrthancPluginService_GetDicomForInstance = 3000,
530 _OrthancPluginService_RestApiGet = 3001,
531 _OrthancPluginService_RestApiPost = 3002,
532 _OrthancPluginService_RestApiDelete = 3003,
533 _OrthancPluginService_RestApiPut = 3004,
534 _OrthancPluginService_LookupPatient = 3005,
535 _OrthancPluginService_LookupStudy = 3006,
536 _OrthancPluginService_LookupSeries = 3007,
537 _OrthancPluginService_LookupInstance = 3008,
538 _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
539 _OrthancPluginService_RestApiGetAfterPlugins = 3010,
540 _OrthancPluginService_RestApiPostAfterPlugins = 3011,
541 _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
542 _OrthancPluginService_RestApiPutAfterPlugins = 3013,
543 _OrthancPluginService_ReconstructMainDicomTags = 3014,
544 _OrthancPluginService_RestApiGet2 = 3015,
545 _OrthancPluginService_CallRestApi = 3016, /* New in Orthanc 1.9.2 */
546
547 /* Access to DICOM instances */
548 _OrthancPluginService_GetInstanceRemoteAet = 4000,
549 _OrthancPluginService_GetInstanceSize = 4001,
550 _OrthancPluginService_GetInstanceData = 4002,
551 _OrthancPluginService_GetInstanceJson = 4003,
552 _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
553 _OrthancPluginService_HasInstanceMetadata = 4005,
554 _OrthancPluginService_GetInstanceMetadata = 4006,
555 _OrthancPluginService_GetInstanceOrigin = 4007,
556 _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
557 _OrthancPluginService_HasInstancePixelData = 4009,
558 _OrthancPluginService_CreateDicomInstance = 4010, /* New in Orthanc 1.7.0 */
559 _OrthancPluginService_FreeDicomInstance = 4011, /* New in Orthanc 1.7.0 */
560 _OrthancPluginService_GetInstanceFramesCount = 4012, /* New in Orthanc 1.7.0 */
561 _OrthancPluginService_GetInstanceRawFrame = 4013, /* New in Orthanc 1.7.0 */
562 _OrthancPluginService_GetInstanceDecodedFrame = 4014, /* New in Orthanc 1.7.0 */
563 _OrthancPluginService_TranscodeDicomInstance = 4015, /* New in Orthanc 1.7.0 */
564 _OrthancPluginService_SerializeDicomInstance = 4016, /* New in Orthanc 1.7.0 */
565 _OrthancPluginService_GetInstanceAdvancedJson = 4017, /* New in Orthanc 1.7.0 */
566 _OrthancPluginService_GetInstanceDicomWebJson = 4018, /* New in Orthanc 1.7.0 */
567 _OrthancPluginService_GetInstanceDicomWebXml = 4019, /* New in Orthanc 1.7.0 */
568 _OrthancPluginService_LoadDicomInstance = 4020, /* New in Orthanc 1.12.1 */
569
570 /* Services for plugins implementing a database back-end */
571 _OrthancPluginService_RegisterDatabaseBackend = 5000, /* New in Orthanc 0.8.6 */
572 _OrthancPluginService_DatabaseAnswer = 5001,
573 _OrthancPluginService_RegisterDatabaseBackendV2 = 5002, /* New in Orthanc 0.9.4 */
574 _OrthancPluginService_StorageAreaCreate = 5003,
575 _OrthancPluginService_StorageAreaRead = 5004,
576 _OrthancPluginService_StorageAreaRemove = 5005,
577 _OrthancPluginService_RegisterDatabaseBackendV3 = 5006, /* New in Orthanc 1.9.2 */
578 _OrthancPluginService_RegisterDatabaseBackendV4 = 5007, /* New in Orthanc 1.12.0 */
579
580 /* Primitives for handling images */
581 _OrthancPluginService_GetImagePixelFormat = 6000,
582 _OrthancPluginService_GetImageWidth = 6001,
583 _OrthancPluginService_GetImageHeight = 6002,
584 _OrthancPluginService_GetImagePitch = 6003,
585 _OrthancPluginService_GetImageBuffer = 6004,
586 _OrthancPluginService_UncompressImage = 6005,
587 _OrthancPluginService_FreeImage = 6006,
588 _OrthancPluginService_CompressImage = 6007,
589 _OrthancPluginService_ConvertPixelFormat = 6008,
590 _OrthancPluginService_GetFontsCount = 6009,
591 _OrthancPluginService_GetFontInfo = 6010,
592 _OrthancPluginService_DrawText = 6011,
593 _OrthancPluginService_CreateImage = 6012,
594 _OrthancPluginService_CreateImageAccessor = 6013,
595 _OrthancPluginService_DecodeDicomImage = 6014,
596
597 /* Primitives for handling C-Find, C-Move and worklists */
598 _OrthancPluginService_WorklistAddAnswer = 7000,
599 _OrthancPluginService_WorklistMarkIncomplete = 7001,
600 _OrthancPluginService_WorklistIsMatch = 7002,
601 _OrthancPluginService_WorklistGetDicomQuery = 7003,
602 _OrthancPluginService_FindAddAnswer = 7004,
603 _OrthancPluginService_FindMarkIncomplete = 7005,
604 _OrthancPluginService_GetFindQuerySize = 7006,
605 _OrthancPluginService_GetFindQueryTag = 7007,
606 _OrthancPluginService_GetFindQueryTagName = 7008,
607 _OrthancPluginService_GetFindQueryValue = 7009,
608 _OrthancPluginService_CreateFindMatcher = 7010,
609 _OrthancPluginService_FreeFindMatcher = 7011,
610 _OrthancPluginService_FindMatcherIsMatch = 7012,
611
612 /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
613 _OrthancPluginService_GetPeers = 8000,
614 _OrthancPluginService_FreePeers = 8001,
615 _OrthancPluginService_GetPeersCount = 8003,
616 _OrthancPluginService_GetPeerName = 8004,
617 _OrthancPluginService_GetPeerUrl = 8005,
618 _OrthancPluginService_CallPeerApi = 8006,
619 _OrthancPluginService_GetPeerUserProperty = 8007,
620
621 /* Primitives for handling jobs (new in 1.4.2) */
622 _OrthancPluginService_CreateJob = 9000, /* Deprecated since SDK 1.11.3 */
623 _OrthancPluginService_FreeJob = 9001,
624 _OrthancPluginService_SubmitJob = 9002,
625 _OrthancPluginService_RegisterJobsUnserializer = 9003,
626 _OrthancPluginService_CreateJob2 = 9004, /* New in SDK 1.11.3 */
627
628 _OrthancPluginService_INTERNAL = 0x7fffffff
629 } _OrthancPluginService;
630
631
632 typedef enum
633 {
634 _OrthancPluginProperty_Description = 1,
635 _OrthancPluginProperty_RootUri = 2,
636 _OrthancPluginProperty_OrthancExplorer = 3,
637
638 _OrthancPluginProperty_INTERNAL = 0x7fffffff
639 } _OrthancPluginProperty;
640
641
642
733
734
735
748
749
750
764
765
766
796
797
812
813
818 typedef enum
819 {
823
824 _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
826
827
864
865
871 typedef enum
872 {
876
877 _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
879
880
900
901
907 typedef enum
908 {
912
913 _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
915
916
931
932
947
948
963
964
974
975
989
990
1005
1006
1017
1018
1067
1068
1080
1081
1108
1109
1116 typedef enum
1117 {
1122
1123 _OrthancPluginLogLevel_INTERNAL = 0x7fffffff
1125
1126
1145
1146
1160
1164 typedef enum
1165 {
1168
1169 _OrthancPluginQueueOrigin_INTERNAL = 0x7fffffff
1171
1172
1173
1181 typedef struct
1182 {
1186 void* data;
1187
1191 uint32_t size;
1193
1194
1195
1203 typedef struct
1204 {
1208 void* data;
1209
1213 uint64_t size;
1215
1216
1217
1218
1223 typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
1224
1225
1226
1231 typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
1232
1233
1234
1239 typedef struct _OrthancPluginImage_t OrthancPluginImage;
1240
1241
1242
1247 typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
1248
1249
1250
1255 typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
1256
1257
1258
1263 typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
1264
1265
1266
1271 typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1272
1273
1274
1279 typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1280
1281
1282
1287 typedef struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher;
1288
1289
1290
1295 typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1296
1297
1298
1303 typedef struct _OrthancPluginJob_t OrthancPluginJob;
1304
1305
1306
1312 typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1313
1314
1315
1322 const char* url,
1323 const OrthancPluginHttpRequest* request);
1324
1325
1326
1332 const OrthancPluginDicomInstance* instance,
1333 const char* instanceId);
1334
1335
1336
1342 OrthancPluginChangeType changeType,
1343 OrthancPluginResourceType resourceType,
1344 const char* resourceId);
1345
1346
1347
1353 OrthancPluginImage** target,
1354 const void* dicom,
1355 const uint32_t size,
1356 uint32_t frameIndex);
1357
1358
1359
1364 typedef void (*OrthancPluginFree) (void* buffer);
1365
1366
1367
1377 const char* bulkDataUri);
1378
1379
1380
1394 const char* uuid,
1395 const void* content,
1396 int64_t size,
1398
1399
1400
1420 void** content,
1421 int64_t* size,
1422 const char* uuid,
1424
1425
1426
1441 const char* uuid,
1443
1444
1445
1464 const char* uuid,
1466 uint64_t rangeStart);
1467
1468
1469
1481 const char* uuid,
1483
1484
1485
1505 OrthancPluginMemoryBuffer* customData,
1506 const char* uuid,
1507 const void* content,
1508 uint64_t size,
1510 OrthancPluginCompressionType compressionType,
1511 const OrthancPluginDicomInstance* dicomInstance);
1512
1513
1514
1535 const char* uuid,
1537 uint64_t rangeStart,
1538 const void* customData,
1539 uint32_t customDataSize);
1540
1541
1542
1557 const char* uuid,
1559 const void* customData,
1560 uint32_t customDataSize);
1561
1562
1578 const OrthancPluginWorklistQuery* query,
1579 const char* issuerAet,
1580 const char* calledAet);
1581
1582
1583
1609 const char* uri,
1610 const char* ip,
1611 uint32_t headersCount,
1612 const char* const* headersKeys,
1613 const char* const* headersValues);
1614
1615
1616
1648 const char* uri,
1649 const char* ip,
1650 uint32_t headersCount,
1651 const char* const* headersKeys,
1652 const char* const* headersValues,
1653 uint32_t getArgumentsCount,
1654 const char* const* getArgumentsKeys,
1655 const char* const* getArgumentsValues);
1656
1657
1658
1674 OrthancPluginFindAnswers* answers,
1675 const OrthancPluginFindQuery* query,
1676 const char* issuerAet,
1677 const char* calledAet);
1678
1679
1680
1716 typedef void* (*OrthancPluginMoveCallback) (
1717 OrthancPluginResourceType resourceType,
1718 const char* patientId,
1719 const char* accessionNumber,
1720 const char* studyInstanceUid,
1721 const char* seriesInstanceUid,
1722 const char* sopInstanceUid,
1723 const char* originatorAet,
1724 const char* sourceAet,
1725 const char* targetAet,
1726 uint16_t originatorId);
1727
1728
1741 typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1742
1743
1756 typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1757
1758
1770 typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1771
1772
1783 typedef void (*OrthancPluginJobFinalize) (void* job);
1784
1785
1796 typedef float (*OrthancPluginJobGetProgress) (void* job);
1797
1798
1812 typedef const char* (*OrthancPluginJobGetContent) (void* job);
1813
1814
1831 void* job);
1832
1833
1850 typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1851
1852
1871 void* job);
1872
1873
1887
1888
1912
1913
1928
1929
1943 typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1944 const char* serialized);
1945
1946
1947
1963
1964
1965
1993 uint32_t levelDepth,
1994 const uint16_t* levelTagGroup,
1995 const uint16_t* levelTagElement,
1996 const uint32_t* levelIndex,
1997 uint16_t tagGroup,
1998 uint16_t tagElement,
2000
2001
2002
2031 uint32_t levelDepth,
2032 const uint16_t* levelTagGroup,
2033 const uint16_t* levelTagElement,
2034 const uint32_t* levelIndex,
2035 uint16_t tagGroup,
2036 uint16_t tagElement,
2038 void* payload);
2039
2040
2041
2045 typedef struct _OrthancPluginContext_t
2046 {
2047 void* pluginsManager;
2048 const char* orthancVersion;
2049 OrthancPluginFree Free;
2050 OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
2051 _OrthancPluginService service,
2052 const void* params);
2054
2055
2056
2068
2069
2070
2079 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
2080 OrthancPluginContext* context,
2081 char* str)
2082 {
2083 if (str != NULL)
2084 {
2085 context->Free(str);
2086 }
2087 }
2088
2089
2109 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginCheckVersionAdvanced(
2110 OrthancPluginContext* context,
2111 int32_t expectedMajor,
2112 int32_t expectedMinor,
2113 int32_t expectedRevision)
2114 {
2115 int32_t major, minor, revision;
2116
2117 if (sizeof(int) != sizeof(int32_t) || /* Ensure binary compatibility with Orthanc SDK <= 1.12.1 */
2118 sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
2119 sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
2120 sizeof(int32_t) != sizeof(_OrthancPluginService) ||
2121 sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
2122 sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
2123 sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
2124 sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
2125 sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
2126 sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
2127 sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
2128 sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
2129 sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
2130 sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
2131 sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
2132 sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
2133 sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
2134 sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
2135 sizeof(int32_t) != sizeof(OrthancPluginJobStopReason) ||
2136 sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
2137 sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
2138 sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
2139 sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason) ||
2140 sizeof(int32_t) != sizeof(OrthancPluginReceivedInstanceAction) ||
2141 sizeof(int32_t) != sizeof(OrthancPluginLoadDicomInstanceMode) ||
2142 sizeof(int32_t) != sizeof(OrthancPluginLogLevel) ||
2143 sizeof(int32_t) != sizeof(OrthancPluginLogCategory) ||
2144 sizeof(int32_t) != sizeof(OrthancPluginStoreStatus) ||
2145 sizeof(int32_t) != sizeof(OrthancPluginQueueOrigin))
2146 {
2147 /* Mismatch in the size of the enumerations */
2148 return 0;
2149 }
2150
2151 /* Assume compatibility with the mainline */
2152 if (!strcmp(context->orthancVersion, "mainline"))
2153 {
2154 return 1;
2155 }
2156
2157 /* Parse the version of the Orthanc core */
2158 if (
2159#ifdef _MSC_VER
2160 sscanf_s
2161#else
2162 sscanf
2163#endif
2164 (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
2165 {
2166 return 0;
2167 }
2168
2169 /* Check the major number of the version */
2170
2171 if (major > expectedMajor)
2172 {
2173 return 1;
2174 }
2175
2176 if (major < expectedMajor)
2177 {
2178 return 0;
2179 }
2180
2181 /* Check the minor number of the version */
2182
2183 if (minor > expectedMinor)
2184 {
2185 return 1;
2186 }
2187
2188 if (minor < expectedMinor)
2189 {
2190 return 0;
2191 }
2192
2193 /* Check the revision number of the version */
2194
2195 if (revision >= expectedRevision)
2196 {
2197 return 1;
2198 }
2199 else
2200 {
2201 return 0;
2202 }
2203 }
2204
2205
2222 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginCheckVersion(
2223 OrthancPluginContext* context)
2224 {
2226 context,
2227 ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
2228 ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
2229 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
2230 }
2231
2232
2241 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
2242 OrthancPluginContext* context,
2244 {
2245 context->Free(buffer->data);
2246 }
2247
2248
2257 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer64(
2258 OrthancPluginContext* context,
2260 {
2261 context->Free(buffer->data);
2262 }
2263
2264
2273 ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
2274 OrthancPluginContext* context,
2275 const char* message)
2276 {
2277 context->InvokeService(context, _OrthancPluginService_LogError, message);
2278 }
2279
2280
2289 ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
2290 OrthancPluginContext* context,
2291 const char* message)
2292 {
2293 context->InvokeService(context, _OrthancPluginService_LogWarning, message);
2294 }
2295
2296
2305 ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
2306 OrthancPluginContext* context,
2307 const char* message)
2308 {
2309 context->InvokeService(context, _OrthancPluginService_LogInfo, message);
2310 }
2311
2312
2313
2314 typedef struct
2315 {
2316 const char* pathRegularExpression;
2318 } _OrthancPluginRestCallback;
2319
2341 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
2342 OrthancPluginContext* context,
2343 const char* pathRegularExpression,
2345 {
2346 _OrthancPluginRestCallback params;
2347 params.pathRegularExpression = pathRegularExpression;
2348 params.callback = callback;
2349 context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
2350 }
2351
2352
2353
2382 OrthancPluginContext* context,
2383 const char* pathRegularExpression,
2385 {
2386 _OrthancPluginRestCallback params;
2387 params.pathRegularExpression = pathRegularExpression;
2388 params.callback = callback;
2389 context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
2390 }
2391
2392
2393
2394 typedef struct
2395 {
2397 } _OrthancPluginOnStoredInstanceCallback;
2398
2420 OrthancPluginContext* context,
2422 {
2423 _OrthancPluginOnStoredInstanceCallback params;
2424 params.callback = callback;
2425
2426 context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
2427 }
2428
2429
2430
2431 typedef struct
2432 {
2434 const void* answer;
2435 uint32_t answerSize;
2436 const char* mimeType;
2437 } _OrthancPluginAnswerBuffer;
2438
2451 ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
2452 OrthancPluginContext* context,
2454 const void* answer,
2455 uint32_t answerSize,
2456 const char* mimeType)
2457 {
2458 _OrthancPluginAnswerBuffer params;
2459 params.output = output;
2460 params.answer = answer;
2461 params.answerSize = answerSize;
2462 params.mimeType = mimeType;
2463 context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
2464 }
2465
2466
2467 typedef struct
2468 {
2471 uint32_t width;
2472 uint32_t height;
2473 uint32_t pitch;
2474 const void* buffer;
2475 } _OrthancPluginCompressAndAnswerPngImage;
2476
2477 typedef struct
2478 {
2480 OrthancPluginImageFormat imageFormat;
2481 OrthancPluginPixelFormat pixelFormat;
2482 uint32_t width;
2483 uint32_t height;
2484 uint32_t pitch;
2485 const void* buffer;
2486 uint8_t quality;
2487 } _OrthancPluginCompressAndAnswerImage;
2488
2489
2508 ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2509 OrthancPluginContext* context,
2512 uint32_t width,
2513 uint32_t height,
2514 uint32_t pitch,
2515 const void* buffer)
2516 {
2517 _OrthancPluginCompressAndAnswerImage params;
2518 params.output = output;
2519 params.imageFormat = OrthancPluginImageFormat_Png;
2520 params.pixelFormat = format;
2521 params.width = width;
2522 params.height = height;
2523 params.pitch = pitch;
2524 params.buffer = buffer;
2525 params.quality = 0; /* No quality for PNG */
2526 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2527 }
2528
2529
2530
2531 typedef struct
2532 {
2534 const char* instanceId;
2535 } _OrthancPluginGetDicomForInstance;
2536
2550 OrthancPluginContext* context,
2552 const char* instanceId)
2553 {
2554 _OrthancPluginGetDicomForInstance params;
2555 params.target = target;
2556 params.instanceId = instanceId;
2557 return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2558 }
2559
2560
2561
2562 typedef struct
2563 {
2565 const char* uri;
2566 } _OrthancPluginRestApiGet;
2567
2583 OrthancPluginContext* context,
2585 const char* uri)
2586 {
2587 _OrthancPluginRestApiGet params;
2588 params.target = target;
2589 params.uri = uri;
2590 return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2591 }
2592
2593
2594
2613 OrthancPluginContext* context,
2615 const char* uri)
2616 {
2617 _OrthancPluginRestApiGet params;
2618 params.target = target;
2619 params.uri = uri;
2620 return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2621 }
2622
2623
2624
2625 typedef struct
2626 {
2628 const char* uri;
2629 const void* body;
2630 uint32_t bodySize;
2631 } _OrthancPluginRestApiPostPut;
2632
2650 OrthancPluginContext* context,
2652 const char* uri,
2653 const void* body,
2654 uint32_t bodySize)
2655 {
2656 _OrthancPluginRestApiPostPut params;
2657 params.target = target;
2658 params.uri = uri;
2659 params.body = body;
2660 params.bodySize = bodySize;
2661 return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2662 }
2663
2664
2685 OrthancPluginContext* context,
2687 const char* uri,
2688 const void* body,
2689 uint32_t bodySize)
2690 {
2691 _OrthancPluginRestApiPostPut params;
2692 params.target = target;
2693 params.uri = uri;
2694 params.body = body;
2695 params.bodySize = bodySize;
2696 return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2697 }
2698
2699
2700
2714 OrthancPluginContext* context,
2715 const char* uri)
2716 {
2717 return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2718 }
2719
2720
2737 OrthancPluginContext* context,
2738 const char* uri)
2739 {
2740 return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2741 }
2742
2743
2744
2762 OrthancPluginContext* context,
2764 const char* uri,
2765 const void* body,
2766 uint32_t bodySize)
2767 {
2768 _OrthancPluginRestApiPostPut params;
2769 params.target = target;
2770 params.uri = uri;
2771 params.body = body;
2772 params.bodySize = bodySize;
2773 return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2774 }
2775
2776
2777
2798 OrthancPluginContext* context,
2800 const char* uri,
2801 const void* body,
2802 uint32_t bodySize)
2803 {
2804 _OrthancPluginRestApiPostPut params;
2805 params.target = target;
2806 params.uri = uri;
2807 params.body = body;
2808 params.bodySize = bodySize;
2809 return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2810 }
2811
2812
2813
2814 typedef struct
2815 {
2817 const char* argument;
2818 } _OrthancPluginOutputPlusArgument;
2819
2831 ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2832 OrthancPluginContext* context,
2834 const char* redirection)
2835 {
2836 _OrthancPluginOutputPlusArgument params;
2837 params.output = output;
2838 params.argument = redirection;
2839 context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2840 }
2841
2842
2843
2844 typedef struct
2845 {
2846 char** result;
2847 const char* argument;
2848 } _OrthancPluginRetrieveDynamicString;
2849
2863 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2864 OrthancPluginContext* context,
2865 const char* patientID)
2866 {
2867 char* result;
2868
2869 _OrthancPluginRetrieveDynamicString params;
2870 params.result = &result;
2871 params.argument = patientID;
2872
2873 if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2874 {
2875 /* Error */
2876 return NULL;
2877 }
2878 else
2879 {
2880 return result;
2881 }
2882 }
2883
2884
2898 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2899 OrthancPluginContext* context,
2900 const char* studyUID)
2901 {
2902 char* result;
2903
2904 _OrthancPluginRetrieveDynamicString params;
2905 params.result = &result;
2906 params.argument = studyUID;
2907
2908 if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2909 {
2910 /* Error */
2911 return NULL;
2912 }
2913 else
2914 {
2915 return result;
2916 }
2917 }
2918
2919
2934 OrthancPluginContext* context,
2935 const char* accessionNumber)
2936 {
2937 char* result;
2938
2939 _OrthancPluginRetrieveDynamicString params;
2940 params.result = &result;
2941 params.argument = accessionNumber;
2942
2943 if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2944 {
2945 /* Error */
2946 return NULL;
2947 }
2948 else
2949 {
2950 return result;
2951 }
2952 }
2953
2954
2968 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2969 OrthancPluginContext* context,
2970 const char* seriesUID)
2971 {
2972 char* result;
2973
2974 _OrthancPluginRetrieveDynamicString params;
2975 params.result = &result;
2976 params.argument = seriesUID;
2977
2978 if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2979 {
2980 /* Error */
2981 return NULL;
2982 }
2983 else
2984 {
2985 return result;
2986 }
2987 }
2988
2989
3003 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
3004 OrthancPluginContext* context,
3005 const char* sopInstanceUID)
3006 {
3007 char* result;
3008
3009 _OrthancPluginRetrieveDynamicString params;
3010 params.result = &result;
3011 params.argument = sopInstanceUID;
3012
3013 if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
3014 {
3015 /* Error */
3016 return NULL;
3017 }
3018 else
3019 {
3020 return result;
3021 }
3022 }
3023
3024
3025
3026 typedef struct
3027 {
3029 uint16_t status;
3030 } _OrthancPluginSendHttpStatusCode;
3031
3048 ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
3049 OrthancPluginContext* context,
3051 uint16_t status)
3052 {
3053 _OrthancPluginSendHttpStatusCode params;
3054 params.output = output;
3055 params.status = status;
3056 context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
3057 }
3058
3059
3071 ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
3072 OrthancPluginContext* context,
3074 const char* realm)
3075 {
3076 _OrthancPluginOutputPlusArgument params;
3077 params.output = output;
3078 params.argument = realm;
3079 context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
3080 }
3081
3082
3094 ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
3095 OrthancPluginContext* context,
3097 const char* allowedMethods)
3098 {
3099 _OrthancPluginOutputPlusArgument params;
3100 params.output = output;
3101 params.argument = allowedMethods;
3102 context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
3103 }
3104
3105
3106 typedef struct
3107 {
3109 const char* key;
3110 const char* value;
3111 } _OrthancPluginSetHttpHeader;
3112
3124 ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
3125 OrthancPluginContext* context,
3127 const char* cookie,
3128 const char* value)
3129 {
3130 _OrthancPluginSetHttpHeader params;
3131 params.output = output;
3132 params.key = cookie;
3133 params.value = value;
3134 context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
3135 }
3136
3137
3149 ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
3150 OrthancPluginContext* context,
3152 const char* key,
3153 const char* value)
3154 {
3155 _OrthancPluginSetHttpHeader params;
3156 params.output = output;
3157 params.key = key;
3158 params.value = value;
3159 context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
3160 }
3161
3162
3163 typedef struct
3164 {
3165 char** resultStringToFree;
3166 const char** resultString;
3167 int64_t* resultInt64;
3168 const char* key;
3169 const OrthancPluginDicomInstance* instance;
3170 OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
3171 } _OrthancPluginAccessDicomInstance;
3172
3173
3185 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
3186 OrthancPluginContext* context,
3187 const OrthancPluginDicomInstance* instance)
3188 {
3189 const char* result;
3190
3191 _OrthancPluginAccessDicomInstance params;
3192 memset(&params, 0, sizeof(params));
3193 params.resultString = &result;
3194 params.instance = instance;
3195
3196 if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
3197 {
3198 /* Error */
3199 return NULL;
3200 }
3201 else
3202 {
3203 return result;
3204 }
3205 }
3206
3207
3218 ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
3219 OrthancPluginContext* context,
3220 const OrthancPluginDicomInstance* instance)
3221 {
3222 int64_t size;
3223
3224 _OrthancPluginAccessDicomInstance params;
3225 memset(&params, 0, sizeof(params));
3226 params.resultInt64 = &size;
3227 params.instance = instance;
3228
3229 if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
3230 {
3231 /* Error */
3232 return -1;
3233 }
3234 else
3235 {
3236 return size;
3237 }
3238 }
3239
3240
3251 ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData(
3252 OrthancPluginContext* context,
3253 const OrthancPluginDicomInstance* instance)
3254 {
3255 const char* result;
3256
3257 _OrthancPluginAccessDicomInstance params;
3258 memset(&params, 0, sizeof(params));
3259 params.resultString = &result;
3260 params.instance = instance;
3261
3262 if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
3263 {
3264 /* Error */
3265 return NULL;
3266 }
3267 else
3268 {
3269 return result;
3270 }
3271 }
3272
3273
3287 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
3288 OrthancPluginContext* context,
3289 const OrthancPluginDicomInstance* instance)
3290 {
3291 char* result;
3292
3293 _OrthancPluginAccessDicomInstance params;
3294 memset(&params, 0, sizeof(params));
3295 params.resultStringToFree = &result;
3296 params.instance = instance;
3297
3298 if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
3299 {
3300 /* Error */
3301 return NULL;
3302 }
3303 else
3304 {
3305 return result;
3306 }
3307 }
3308
3309
3325 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
3326 OrthancPluginContext* context,
3327 const OrthancPluginDicomInstance* instance)
3328 {
3329 char* result;
3330
3331 _OrthancPluginAccessDicomInstance params;
3332 memset(&params, 0, sizeof(params));
3333 params.resultStringToFree = &result;
3334 params.instance = instance;
3335
3336 if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
3337 {
3338 /* Error */
3339 return NULL;
3340 }
3341 else
3342 {
3343 return result;
3344 }
3345 }
3346
3347
3364 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstanceMetadata(
3365 OrthancPluginContext* context,
3366 const OrthancPluginDicomInstance* instance,
3367 const char* metadata)
3368 {
3369 int64_t result;
3370
3371 _OrthancPluginAccessDicomInstance params;
3372 memset(&params, 0, sizeof(params));
3373 params.resultInt64 = &result;
3374 params.instance = instance;
3375 params.key = metadata;
3376
3377 if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3378 {
3379 /* Error */
3380 return -1;
3381 }
3382 else
3383 {
3384 return (result != 0);
3385 }
3386 }
3387
3388
3405 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
3406 OrthancPluginContext* context,
3407 const OrthancPluginDicomInstance* instance,
3408 const char* metadata)
3409 {
3410 const char* result;
3411
3412 _OrthancPluginAccessDicomInstance params;
3413 memset(&params, 0, sizeof(params));
3414 params.resultString = &result;
3415 params.instance = instance;
3416 params.key = metadata;
3417
3418 if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3419 {
3420 /* Error */
3421 return NULL;
3422 }
3423 else
3424 {
3425 return result;
3426 }
3427 }
3428
3429
3430
3431 typedef struct
3432 {
3436 OrthancPluginFree free;
3437 } _OrthancPluginRegisterStorageArea;
3438
3454 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
3455 OrthancPluginContext* context,
3459 {
3460 _OrthancPluginRegisterStorageArea params;
3461 params.create = create;
3462 params.read = read;
3463 params.remove = remove;
3464
3465#ifdef __cplusplus
3466 params.free = ::free;
3467#else
3468 params.free = free;
3469#endif
3470
3471 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3472 }
3473
3474
3475
3486 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3487 {
3488 char* result;
3489
3490 _OrthancPluginRetrieveDynamicString params;
3491 params.result = &result;
3492 params.argument = NULL;
3493
3494 if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3495 {
3496 /* Error */
3497 return NULL;
3498 }
3499 else
3500 {
3501 return result;
3502 }
3503 }
3504
3505
3516 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3517 {
3518 char* result;
3519
3520 _OrthancPluginRetrieveDynamicString params;
3521 params.result = &result;
3522 params.argument = NULL;
3523
3524 if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3525 {
3526 /* Error */
3527 return NULL;
3528 }
3529 else
3530 {
3531 return result;
3532 }
3533 }
3534
3535
3551 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3552 {
3553 char* result;
3554
3555 _OrthancPluginRetrieveDynamicString params;
3556 params.result = &result;
3557 params.argument = NULL;
3558
3559 if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3560 {
3561 /* Error */
3562 return NULL;
3563 }
3564 else
3565 {
3566 return result;
3567 }
3568 }
3569
3570
3571
3572 typedef struct
3573 {
3575 } _OrthancPluginOnChangeCallback;
3576
3597 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3598 OrthancPluginContext* context,
3600 {
3601 _OrthancPluginOnChangeCallback params;
3602 params.callback = callback;
3603
3604 context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3605 }
3606
3607
3608
3609 typedef struct
3610 {
3611 const char* plugin;
3612 _OrthancPluginProperty property;
3613 const char* value;
3614 } _OrthancPluginSetPluginProperty;
3615
3616
3632 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3633 OrthancPluginContext* context,
3634 const char* uri)
3635 {
3636 _OrthancPluginSetPluginProperty params;
3637 params.plugin = OrthancPluginGetName();
3638 params.property = _OrthancPluginProperty_RootUri;
3639 params.value = uri;
3640
3641 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3642 }
3643
3644
3657 ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri2(
3658 OrthancPluginContext* context,
3659 const char* plugin,
3660 const char* uri)
3661 {
3662 _OrthancPluginSetPluginProperty params;
3663 params.plugin = plugin;
3664 params.property = _OrthancPluginProperty_RootUri;
3665 params.value = uri;
3666
3667 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3668 }
3669
3670
3684 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3685 OrthancPluginContext* context,
3686 const char* description)
3687 {
3688 _OrthancPluginSetPluginProperty params;
3689 params.plugin = OrthancPluginGetName();
3690 params.property = _OrthancPluginProperty_Description;
3691 params.value = description;
3692
3693 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3694 }
3695
3696
3707 ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription2(
3708 OrthancPluginContext* context,
3709 const char* plugin,
3710 const char* description)
3711 {
3712 _OrthancPluginSetPluginProperty params;
3713 params.plugin = plugin;
3714 params.property = _OrthancPluginProperty_Description;
3715 params.value = description;
3716
3717 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3718 }
3719
3720
3734 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3735 OrthancPluginContext* context,
3736 const char* javascript)
3737 {
3738 _OrthancPluginSetPluginProperty params;
3739 params.plugin = OrthancPluginGetName();
3740 params.property = _OrthancPluginProperty_OrthancExplorer;
3741 params.value = javascript;
3742
3743 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3744 }
3745
3746
3757 ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer2(
3758 OrthancPluginContext* context,
3759 const char* plugin,
3760 const char* javascript)
3761 {
3762 _OrthancPluginSetPluginProperty params;
3763 params.plugin = plugin;
3764 params.property = _OrthancPluginProperty_OrthancExplorer;
3765 params.value = javascript;
3766
3767 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3768 }
3769
3770
3771 typedef struct
3772 {
3773 char** result;
3774 int32_t property;
3775 const char* value;
3776 } _OrthancPluginGlobalProperty;
3777
3778
3792 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3793 OrthancPluginContext* context,
3794 int32_t property,
3795 const char* defaultValue)
3796 {
3797 char* result;
3798
3799 _OrthancPluginGlobalProperty params;
3800 params.result = &result;
3801 params.property = property;
3802 params.value = defaultValue;
3803
3804 if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3805 {
3806 /* Error */
3807 return NULL;
3808 }
3809 else
3810 {
3811 return result;
3812 }
3813 }
3814
3815
3832 OrthancPluginContext* context,
3833 int32_t property,
3834 const char* value)
3835 {
3836 _OrthancPluginGlobalProperty params;
3837 params.result = NULL;
3838 params.property = property;
3839 params.value = value;
3840
3841 return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3842 }
3843
3844
3845
3846 typedef struct
3847 {
3848 int32_t *resultInt32;
3849 uint32_t *resultUint32;
3850 int64_t *resultInt64;
3851 uint64_t *resultUint64;
3852 } _OrthancPluginReturnSingleValue;
3853
3862 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3863 OrthancPluginContext* context)
3864 {
3865 uint32_t count = 0;
3866
3867 _OrthancPluginReturnSingleValue params;
3868 memset(&params, 0, sizeof(params));
3869 params.resultUint32 = &count;
3870
3871 if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3872 {
3873 /* Error */
3874 return 0;
3875 }
3876 else
3877 {
3878 return count;
3879 }
3880 }
3881
3882
3883
3896 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3897 OrthancPluginContext* context,
3898 uint32_t argument)
3899 {
3900 char* result;
3901
3902 _OrthancPluginGlobalProperty params;
3903 params.result = &result;
3904 params.property = (int32_t) argument;
3905 params.value = NULL;
3906
3907 if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3908 {
3909 /* Error */
3910 return NULL;
3911 }
3912 else
3913 {
3914 return result;
3915 }
3916 }
3917
3918
3928 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3929 OrthancPluginContext* context)
3930 {
3931 uint32_t count = 0;
3932
3933 _OrthancPluginReturnSingleValue params;
3934 memset(&params, 0, sizeof(params));
3935 params.resultUint32 = &count;
3936
3937 if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3938 {
3939 /* Error */
3940 return 0;
3941 }
3942 else
3943 {
3944 return count;
3945 }
3946 }
3947
3948
3949
3961 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3962 {
3963 char* result;
3964
3965 _OrthancPluginRetrieveDynamicString params;
3966 params.result = &result;
3967 params.argument = NULL;
3968
3969 if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3970 {
3971 /* Error */
3972 return NULL;
3973 }
3974 else
3975 {
3976 return result;
3977 }
3978 }
3979
3980
3981
3982 typedef struct
3983 {
3985 const char* subType;
3986 const char* contentType;
3987 } _OrthancPluginStartMultipartAnswer;
3988
4003 OrthancPluginContext* context,
4005 const char* subType,
4006 const char* contentType)
4007 {
4008 _OrthancPluginStartMultipartAnswer params;
4009 params.output = output;
4010 params.subType = subType;
4011 params.contentType = contentType;
4012 return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
4013 }
4014
4015
4032 OrthancPluginContext* context,
4034 const void* answer,
4035 uint32_t answerSize)
4036 {
4037 _OrthancPluginAnswerBuffer params;
4038 params.output = output;
4039 params.answer = answer;
4040 params.answerSize = answerSize;
4041 params.mimeType = NULL;
4042 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
4043 }
4044
4045
4046
4047 typedef struct
4048 {
4050 const void* source;
4051 uint32_t size;
4052 OrthancPluginCompressionType compression;
4053 uint8_t uncompress;
4054 } _OrthancPluginBufferCompression;
4055
4056
4074 OrthancPluginContext* context,
4076 const void* source,
4077 uint32_t size,
4078 OrthancPluginCompressionType compression,
4079 uint8_t uncompress)
4080 {
4081 _OrthancPluginBufferCompression params;
4082 params.target = target;
4083 params.source = source;
4084 params.size = size;
4085 params.compression = compression;
4086 params.uncompress = uncompress;
4087
4088 return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
4089 }
4090
4091
4092
4093 typedef struct
4094 {
4096 const char* path;
4097 } _OrthancPluginReadFile;
4098
4111 OrthancPluginContext* context,
4113 const char* path)
4114 {
4115 _OrthancPluginReadFile params;
4116 params.target = target;
4117 params.path = path;
4118 return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
4119 }
4120
4121
4122
4123 typedef struct
4124 {
4125 const char* path;
4126 const void* data;
4127 uint32_t size;
4128 } _OrthancPluginWriteFile;
4129
4142 OrthancPluginContext* context,
4143 const char* path,
4144 const void* data,
4145 uint32_t size)
4146 {
4147 _OrthancPluginWriteFile params;
4148 params.path = path;
4149 params.data = data;
4150 params.size = size;
4151 return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
4152 }
4153
4154
4155
4156 typedef struct
4157 {
4158 const char** target;
4160 } _OrthancPluginGetErrorDescription;
4161
4172 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
4173 OrthancPluginContext* context,
4175 {
4176 const char* result = NULL;
4177
4178 _OrthancPluginGetErrorDescription params;
4179 params.target = &result;
4180 params.error = error;
4181
4182 if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
4183 result == NULL)
4184 {
4185 return "Unknown error code";
4186 }
4187 else
4188 {
4189 return result;
4190 }
4191 }
4192
4193
4194
4195 typedef struct
4196 {
4198 uint16_t status;
4199 const void* body;
4200 uint32_t bodySize;
4201 } _OrthancPluginSendHttpStatus;
4202
4225 ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
4226 OrthancPluginContext* context,
4228 uint16_t status,
4229 const void* body,
4230 uint32_t bodySize)
4231 {
4232 _OrthancPluginSendHttpStatus params;
4233 params.output = output;
4234 params.status = status;
4235 params.body = body;
4236 params.bodySize = bodySize;
4237 context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
4238 }
4239
4240
4241
4242 typedef struct
4243 {
4244 const OrthancPluginImage* image;
4245 uint32_t* resultUint32;
4246 OrthancPluginPixelFormat* resultPixelFormat;
4247 void** resultBuffer;
4248 } _OrthancPluginGetImageInfo;
4249
4250
4262 OrthancPluginContext* context,
4263 const OrthancPluginImage* image)
4264 {
4266
4267 _OrthancPluginGetImageInfo params;
4268 memset(&params, 0, sizeof(params));
4269 params.image = image;
4270 params.resultPixelFormat = &target;
4271
4272 if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
4273 {
4275 }
4276 else
4277 {
4278 return (OrthancPluginPixelFormat) target;
4279 }
4280 }
4281
4282
4283
4294 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
4295 OrthancPluginContext* context,
4296 const OrthancPluginImage* image)
4297 {
4298 uint32_t width;
4299
4300 _OrthancPluginGetImageInfo params;
4301 memset(&params, 0, sizeof(params));
4302 params.image = image;
4303 params.resultUint32 = &width;
4304
4305 if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
4306 {
4307 return 0;
4308 }
4309 else
4310 {
4311 return width;
4312 }
4313 }
4314
4315
4316
4327 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
4328 OrthancPluginContext* context,
4329 const OrthancPluginImage* image)
4330 {
4331 uint32_t height;
4332
4333 _OrthancPluginGetImageInfo params;
4334 memset(&params, 0, sizeof(params));
4335 params.image = image;
4336 params.resultUint32 = &height;
4337
4338 if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
4339 {
4340 return 0;
4341 }
4342 else
4343 {
4344 return height;
4345 }
4346 }
4347
4348
4349
4362 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
4363 OrthancPluginContext* context,
4364 const OrthancPluginImage* image)
4365 {
4366 uint32_t pitch;
4367
4368 _OrthancPluginGetImageInfo params;
4369 memset(&params, 0, sizeof(params));
4370 params.image = image;
4371 params.resultUint32 = &pitch;
4372
4373 if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
4374 {
4375 return 0;
4376 }
4377 else
4378 {
4379 return pitch;
4380 }
4381 }
4382
4383
4384
4396 ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
4397 OrthancPluginContext* context,
4398 const OrthancPluginImage* image)
4399 {
4400 void* target = NULL;
4401
4402 _OrthancPluginGetImageInfo params;
4403 memset(&params, 0, sizeof(params));
4404 params.resultBuffer = &target;
4405 params.image = image;
4406
4407 if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
4408 {
4409 return NULL;
4410 }
4411 else
4412 {
4413 return target;
4414 }
4415 }
4416
4417
4418 typedef struct
4419 {
4420 OrthancPluginImage** target;
4421 const void* data;
4422 uint32_t size;
4424 } _OrthancPluginUncompressImage;
4425
4426
4440 OrthancPluginContext* context,
4441 const void* data,
4442 uint32_t size,
4444 {
4445 OrthancPluginImage* target = NULL;
4446
4447 _OrthancPluginUncompressImage params;
4448 memset(&params, 0, sizeof(params));
4449 params.target = &target;
4450 params.data = data;
4451 params.size = size;
4452 params.format = format;
4453
4454 if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
4455 {
4456 return NULL;
4457 }
4458 else
4459 {
4460 return target;
4461 }
4462 }
4463
4464
4465
4466
4467 typedef struct
4468 {
4469 OrthancPluginImage* image;
4470 } _OrthancPluginFreeImage;
4471
4481 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
4482 OrthancPluginContext* context,
4483 OrthancPluginImage* image)
4484 {
4485 _OrthancPluginFreeImage params;
4486 params.image = image;
4487
4488 context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
4489 }
4490
4491
4492
4493
4494 typedef struct
4495 {
4497 OrthancPluginImageFormat imageFormat;
4498 OrthancPluginPixelFormat pixelFormat;
4499 uint32_t width;
4500 uint32_t height;
4501 uint32_t pitch;
4502 const void* buffer;
4503 uint8_t quality;
4504 } _OrthancPluginCompressImage;
4505
4506
4527 OrthancPluginContext* context,
4530 uint32_t width,
4531 uint32_t height,
4532 uint32_t pitch,
4533 const void* buffer)
4534 {
4535 _OrthancPluginCompressImage params;
4536 memset(&params, 0, sizeof(params));
4537 params.target = target;
4538 params.imageFormat = OrthancPluginImageFormat_Png;
4539 params.pixelFormat = format;
4540 params.width = width;
4541 params.height = height;
4542 params.pitch = pitch;
4543 params.buffer = buffer;
4544 params.quality = 0; /* Unused for PNG */
4545
4546 return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4547 }
4548
4549
4572 OrthancPluginContext* context,
4575 uint32_t width,
4576 uint32_t height,
4577 uint32_t pitch,
4578 const void* buffer,
4579 uint8_t quality)
4580 {
4581 _OrthancPluginCompressImage params;
4582 memset(&params, 0, sizeof(params));
4583 params.target = target;
4584 params.imageFormat = OrthancPluginImageFormat_Jpeg;
4585 params.pixelFormat = format;
4586 params.width = width;
4587 params.height = height;
4588 params.pitch = pitch;
4589 params.buffer = buffer;
4590 params.quality = quality;
4591
4592 return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4593 }
4594
4595
4596
4619 OrthancPluginContext* context,
4622 uint32_t width,
4623 uint32_t height,
4624 uint32_t pitch,
4625 const void* buffer,
4626 uint8_t quality)
4627 {
4628 _OrthancPluginCompressAndAnswerImage params;
4629 params.output = output;
4630 params.imageFormat = OrthancPluginImageFormat_Jpeg;
4631 params.pixelFormat = format;
4632 params.width = width;
4633 params.height = height;
4634 params.pitch = pitch;
4635 params.buffer = buffer;
4636 params.quality = quality;
4637 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4638 }
4639
4640
4641
4642
4643 typedef struct
4644 {
4647 const char* url;
4648 const char* username;
4649 const char* password;
4650 const void* body;
4651 uint32_t bodySize;
4652 } _OrthancPluginCallHttpClient;
4653
4654
4672 OrthancPluginContext* context,
4674 const char* url,
4675 const char* username,
4676 const char* password)
4677 {
4678 _OrthancPluginCallHttpClient params;
4679 memset(&params, 0, sizeof(params));
4680
4681 params.target = target;
4682 params.method = OrthancPluginHttpMethod_Get;
4683 params.url = url;
4684 params.username = username;
4685 params.password = password;
4686
4687 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4688 }
4689
4690
4710 OrthancPluginContext* context,
4712 const char* url,
4713 const void* body,
4714 uint32_t bodySize,
4715 const char* username,
4716 const char* password)
4717 {
4718 _OrthancPluginCallHttpClient params;
4719 memset(&params, 0, sizeof(params));
4720
4721 params.target = target;
4722 params.method = OrthancPluginHttpMethod_Post;
4723 params.url = url;
4724 params.body = body;
4725 params.bodySize = bodySize;
4726 params.username = username;
4727 params.password = password;
4728
4729 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4730 }
4731
4732
4752 OrthancPluginContext* context,
4754 const char* url,
4755 const void* body,
4756 uint32_t bodySize,
4757 const char* username,
4758 const char* password)
4759 {
4760 _OrthancPluginCallHttpClient params;
4761 memset(&params, 0, sizeof(params));
4762
4763 params.target = target;
4764 params.method = OrthancPluginHttpMethod_Put;
4765 params.url = url;
4766 params.body = body;
4767 params.bodySize = bodySize;
4768 params.username = username;
4769 params.password = password;
4770
4771 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4772 }
4773
4774
4790 OrthancPluginContext* context,
4791 const char* url,
4792 const char* username,
4793 const char* password)
4794 {
4795 _OrthancPluginCallHttpClient params;
4796 memset(&params, 0, sizeof(params));
4797
4798 params.method = OrthancPluginHttpMethod_Delete;
4799 params.url = url;
4800 params.username = username;
4801 params.password = password;
4802
4803 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4804 }
4805
4806
4807
4808 typedef struct
4809 {
4810 OrthancPluginImage** target;
4811 const OrthancPluginImage* source;
4812 OrthancPluginPixelFormat targetFormat;
4813 } _OrthancPluginConvertPixelFormat;
4814
4815
4828 OrthancPluginContext* context,
4829 const OrthancPluginImage* source,
4830 OrthancPluginPixelFormat targetFormat)
4831 {
4832 OrthancPluginImage* target = NULL;
4833
4834 _OrthancPluginConvertPixelFormat params;
4835 params.target = &target;
4836 params.source = source;
4837 params.targetFormat = targetFormat;
4838
4839 if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4840 {
4841 return NULL;
4842 }
4843 else
4844 {
4845 return target;
4846 }
4847 }
4848
4849
4850
4862 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4863 OrthancPluginContext* context)
4864 {
4865 uint32_t count = 0;
4866
4867 _OrthancPluginReturnSingleValue params;
4868 memset(&params, 0, sizeof(params));
4869 params.resultUint32 = &count;
4870
4871 if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4872 {
4873 /* Error */
4874 return 0;
4875 }
4876 else
4877 {
4878 return count;
4879 }
4880 }
4881
4882
4883
4884
4885 typedef struct
4886 {
4887 uint32_t fontIndex; /* in */
4888 const char** name; /* out */
4889 uint32_t* size; /* out */
4890 } _OrthancPluginGetFontInfo;
4891
4902 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4903 OrthancPluginContext* context,
4904 uint32_t fontIndex)
4905 {
4906 const char* result = NULL;
4907
4908 _OrthancPluginGetFontInfo params;
4909 memset(&params, 0, sizeof(params));
4910 params.name = &result;
4911 params.fontIndex = fontIndex;
4912
4913 if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4914 {
4915 return NULL;
4916 }
4917 else
4918 {
4919 return result;
4920 }
4921 }
4922
4923
4934 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4935 OrthancPluginContext* context,
4936 uint32_t fontIndex)
4937 {
4938 uint32_t result;
4939
4940 _OrthancPluginGetFontInfo params;
4941 memset(&params, 0, sizeof(params));
4942 params.size = &result;
4943 params.fontIndex = fontIndex;
4944
4945 if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4946 {
4947 return 0;
4948 }
4949 else
4950 {
4951 return result;
4952 }
4953 }
4954
4955
4956
4957 typedef struct
4958 {
4959 OrthancPluginImage* image;
4960 uint32_t fontIndex;
4961 const char* utf8Text;
4962 int32_t x;
4963 int32_t y;
4964 uint8_t r;
4965 uint8_t g;
4966 uint8_t b;
4967 } _OrthancPluginDrawText;
4968
4969
4988 OrthancPluginContext* context,
4989 OrthancPluginImage* image,
4990 uint32_t fontIndex,
4991 const char* utf8Text,
4992 int32_t x,
4993 int32_t y,
4994 uint8_t r,
4995 uint8_t g,
4996 uint8_t b)
4997 {
4998 _OrthancPluginDrawText params;
4999 memset(&params, 0, sizeof(params));
5000 params.image = image;
5001 params.fontIndex = fontIndex;
5002 params.utf8Text = utf8Text;
5003 params.x = x;
5004 params.y = y;
5005 params.r = r;
5006 params.g = g;
5007 params.b = b;
5008
5009 return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
5010 }
5011
5012
5013
5014 typedef struct
5015 {
5016 OrthancPluginStorageArea* storageArea;
5017 const char* uuid;
5018 const void* content;
5019 uint64_t size;
5021 } _OrthancPluginStorageAreaCreate;
5022
5023
5043 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginStorageAreaCreate(
5044 OrthancPluginContext* context,
5045 OrthancPluginStorageArea* storageArea,
5046 const char* uuid,
5047 const void* content,
5048 uint64_t size,
5050 {
5051 _OrthancPluginStorageAreaCreate params;
5052 params.storageArea = storageArea;
5053 params.uuid = uuid;
5054 params.content = content;
5055 params.size = size;
5056 params.type = type;
5057
5058 return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
5059 }
5060
5061
5062 typedef struct
5063 {
5065 OrthancPluginStorageArea* storageArea;
5066 const char* uuid;
5068 } _OrthancPluginStorageAreaRead;
5069
5070
5089 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginStorageAreaRead(
5090 OrthancPluginContext* context,
5092 OrthancPluginStorageArea* storageArea,
5093 const char* uuid,
5095 {
5096 _OrthancPluginStorageAreaRead params;
5097 params.target = target;
5098 params.storageArea = storageArea;
5099 params.uuid = uuid;
5100 params.type = type;
5101
5102 return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
5103 }
5104
5105
5106 typedef struct
5107 {
5108 OrthancPluginStorageArea* storageArea;
5109 const char* uuid;
5111 } _OrthancPluginStorageAreaRemove;
5112
5130 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginStorageAreaRemove(
5131 OrthancPluginContext* context,
5132 OrthancPluginStorageArea* storageArea,
5133 const char* uuid,
5135 {
5136 _OrthancPluginStorageAreaRemove params;
5137 params.storageArea = storageArea;
5138 params.uuid = uuid;
5139 params.type = type;
5140
5141 return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
5142 }
5143
5144
5145
5146 typedef struct
5147 {
5148 OrthancPluginErrorCode* target;
5149 int32_t code;
5150 uint16_t httpStatus;
5151 const char* message;
5152 } _OrthancPluginRegisterErrorCode;
5153
5170 OrthancPluginContext* context,
5171 int32_t code,
5172 uint16_t httpStatus,
5173 const char* message)
5174 {
5176
5177 _OrthancPluginRegisterErrorCode params;
5178 params.target = &target;
5179 params.code = code;
5180 params.httpStatus = httpStatus;
5181 params.message = message;
5182
5183 if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
5184 {
5185 return target;
5186 }
5187 else
5188 {
5189 /* There was an error while assigned the error. Use a generic code. */
5191 }
5192 }
5193
5194
5195
5196 typedef struct
5197 {
5198 uint16_t group;
5199 uint16_t element;
5201 const char* name;
5202 uint32_t minMultiplicity;
5203 uint32_t maxMultiplicity;
5204 } _OrthancPluginRegisterDictionaryTag;
5205
5226 OrthancPluginContext* context,
5227 uint16_t group,
5228 uint16_t element,
5230 const char* name,
5231 uint32_t minMultiplicity,
5232 uint32_t maxMultiplicity)
5233 {
5234 _OrthancPluginRegisterDictionaryTag params;
5235 params.group = group;
5236 params.element = element;
5237 params.vr = vr;
5238 params.name = name;
5239 params.minMultiplicity = minMultiplicity;
5240 params.maxMultiplicity = maxMultiplicity;
5241
5242 return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
5243 }
5244
5245
5246
5247 typedef struct
5248 {
5249 uint16_t group;
5250 uint16_t element;
5252 const char* name;
5253 uint32_t minMultiplicity;
5254 uint32_t maxMultiplicity;
5255 const char* privateCreator;
5256 } _OrthancPluginRegisterPrivateDictionaryTag;
5257
5279 OrthancPluginContext* context,
5280 uint16_t group,
5281 uint16_t element,
5283 const char* name,
5284 uint32_t minMultiplicity,
5285 uint32_t maxMultiplicity,
5286 const char* privateCreator)
5287 {
5288 _OrthancPluginRegisterPrivateDictionaryTag params;
5289 params.group = group;
5290 params.element = element;
5291 params.vr = vr;
5292 params.name = name;
5293 params.minMultiplicity = minMultiplicity;
5294 params.maxMultiplicity = maxMultiplicity;
5295 params.privateCreator = privateCreator;
5296
5297 return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
5298 }
5299
5300
5301
5302 typedef struct
5303 {
5304 OrthancPluginStorageArea* storageArea;
5306 } _OrthancPluginReconstructMainDicomTags;
5307
5323 OrthancPluginContext* context,
5324 OrthancPluginStorageArea* storageArea,
5326 {
5327 _OrthancPluginReconstructMainDicomTags params;
5328 params.level = level;
5329 params.storageArea = storageArea;
5330
5331 return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
5332 }
5333
5334
5335 typedef struct
5336 {
5337 char** result;
5338 const char* instanceId;
5339 const void* buffer;
5340 uint32_t size;
5343 uint32_t maxStringLength;
5344 } _OrthancPluginDicomToJson;
5345
5346
5366 ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
5367 OrthancPluginContext* context,
5368 const void* buffer,
5369 uint32_t size,
5372 uint32_t maxStringLength)
5373 {
5374 char* result;
5375
5376 _OrthancPluginDicomToJson params;
5377 memset(&params, 0, sizeof(params));
5378 params.result = &result;
5379 params.buffer = buffer;
5380 params.size = size;
5381 params.format = format;
5382 params.flags = flags;
5383 params.maxStringLength = maxStringLength;
5384
5385 if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
5386 {
5387 /* Error */
5388 return NULL;
5389 }
5390 else
5391 {
5392 return result;
5393 }
5394 }
5395
5396
5415 ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
5416 OrthancPluginContext* context,
5417 const char* instanceId,
5420 uint32_t maxStringLength)
5421 {
5422 char* result;
5423
5424 _OrthancPluginDicomToJson params;
5425 memset(&params, 0, sizeof(params));
5426 params.result = &result;
5427 params.instanceId = instanceId;
5428 params.format = format;
5429 params.flags = flags;
5430 params.maxStringLength = maxStringLength;
5431
5432 if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
5433 {
5434 /* Error */
5435 return NULL;
5436 }
5437 else
5438 {
5439 return result;
5440 }
5441 }
5442
5443
5444 typedef struct
5445 {
5447 const char* uri;
5448 uint32_t headersCount;
5449 const char* const* headersKeys;
5450 const char* const* headersValues;
5451 int32_t afterPlugins;
5452 } _OrthancPluginRestApiGet2;
5453
5474 OrthancPluginContext* context,
5476 const char* uri,
5477 uint32_t headersCount,
5478 const char* const* headersKeys,
5479 const char* const* headersValues,
5480 int32_t afterPlugins)
5481 {
5482 _OrthancPluginRestApiGet2 params;
5483 params.target = target;
5484 params.uri = uri;
5485 params.headersCount = headersCount;
5486 params.headersKeys = headersKeys;
5487 params.headersValues = headersValues;
5488 params.afterPlugins = afterPlugins;
5489
5490 return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
5491 }
5492
5493
5494
5495 typedef struct
5496 {
5498 } _OrthancPluginWorklistCallback;
5499
5512 OrthancPluginContext* context,
5514 {
5515 _OrthancPluginWorklistCallback params;
5516 params.callback = callback;
5517
5518 return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
5519 }
5520
5521
5522
5523 typedef struct
5524 {
5526 const OrthancPluginWorklistQuery* query;
5527 const void* dicom;
5528 uint32_t size;
5529 } _OrthancPluginWorklistAnswersOperation;
5530
5548 OrthancPluginContext* context,
5550 const OrthancPluginWorklistQuery* query,
5551 const void* dicom,
5552 uint32_t size)
5553 {
5554 _OrthancPluginWorklistAnswersOperation params;
5555 params.answers = answers;
5556 params.query = query;
5557 params.dicom = dicom;
5558 params.size = size;
5559
5560 return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
5561 }
5562
5563
5578 OrthancPluginContext* context,
5580 {
5581 _OrthancPluginWorklistAnswersOperation params;
5582 params.answers = answers;
5583 params.query = NULL;
5584 params.dicom = NULL;
5585 params.size = 0;
5586
5587 return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5588 }
5589
5590
5591 typedef struct
5592 {
5593 const OrthancPluginWorklistQuery* query;
5594 const void* dicom;
5595 uint32_t size;
5596 int32_t* isMatch;
5598 } _OrthancPluginWorklistQueryOperation;
5599
5615 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5616 OrthancPluginContext* context,
5617 const OrthancPluginWorklistQuery* query,
5618 const void* dicom,
5619 uint32_t size)
5620 {
5621 int32_t isMatch = 0;
5622
5623 _OrthancPluginWorklistQueryOperation params;
5624 params.query = query;
5625 params.dicom = dicom;
5626 params.size = size;
5627 params.isMatch = &isMatch;
5628 params.target = NULL;
5629
5630 if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5631 {
5632 return isMatch;
5633 }
5634 else
5635 {
5636 /* Error: Assume non-match */
5637 return 0;
5638 }
5639 }
5640
5641
5655 OrthancPluginContext* context,
5657 const OrthancPluginWorklistQuery* query)
5658 {
5659 _OrthancPluginWorklistQueryOperation params;
5660 params.query = query;
5661 params.dicom = NULL;
5662 params.size = 0;
5663 params.isMatch = NULL;
5664 params.target = target;
5665
5666 return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5667 }
5668
5669
5681 OrthancPluginContext* context,
5682 const OrthancPluginDicomInstance* instance)
5683 {
5685
5686 _OrthancPluginAccessDicomInstance params;
5687 memset(&params, 0, sizeof(params));
5688 params.resultOrigin = &origin;
5689 params.instance = instance;
5690
5691 if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5692 {
5693 /* Error */
5695 }
5696 else
5697 {
5698 return origin;
5699 }
5700 }
5701
5702
5703 typedef struct
5704 {
5706 const char* json;
5707 const OrthancPluginImage* pixelData;
5709 } _OrthancPluginCreateDicom;
5710
5737 OrthancPluginContext* context,
5739 const char* json,
5740 const OrthancPluginImage* pixelData,
5742 {
5743 _OrthancPluginCreateDicom params;
5744 params.target = target;
5745 params.json = json;
5746 params.pixelData = pixelData;
5747 params.flags = flags;
5748
5749 return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5750 }
5751
5752
5753 typedef struct
5754 {
5756 } _OrthancPluginDecodeImageCallback;
5757
5773 OrthancPluginContext* context,
5775 {
5776 _OrthancPluginDecodeImageCallback params;
5777 params.callback = callback;
5778
5779 return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5780 }
5781
5782
5783
5784 typedef struct
5785 {
5786 OrthancPluginImage** target;
5788 uint32_t width;
5789 uint32_t height;
5790 uint32_t pitch;
5791 void* buffer;
5792 const void* constBuffer;
5793 uint32_t bufferSize;
5794 uint32_t frameIndex;
5795 } _OrthancPluginCreateImage;
5796
5797
5811 OrthancPluginContext* context,
5813 uint32_t width,
5814 uint32_t height)
5815 {
5816 OrthancPluginImage* target = NULL;
5817
5818 _OrthancPluginCreateImage params;
5819 memset(&params, 0, sizeof(params));
5820 params.target = &target;
5821 params.format = format;
5822 params.width = width;
5823 params.height = height;
5824
5825 if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5826 {
5827 return NULL;
5828 }
5829 else
5830 {
5831 return target;
5832 }
5833 }
5834
5835
5854 OrthancPluginContext* context,
5856 uint32_t width,
5857 uint32_t height,
5858 uint32_t pitch,
5859 void* buffer)
5860 {
5861 OrthancPluginImage* target = NULL;
5862
5863 _OrthancPluginCreateImage params;
5864 memset(&params, 0, sizeof(params));
5865 params.target = &target;
5866 params.format = format;
5867 params.width = width;
5868 params.height = height;
5869 params.pitch = pitch;
5870 params.buffer = buffer;
5871
5872 if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5873 {
5874 return NULL;
5875 }
5876 else
5877 {
5878 return target;
5879 }
5880 }
5881
5882
5883
5900 OrthancPluginContext* context,
5901 const void* buffer,
5902 uint32_t bufferSize,
5903 uint32_t frameIndex)
5904 {
5905 OrthancPluginImage* target = NULL;
5906
5907 _OrthancPluginCreateImage params;
5908 memset(&params, 0, sizeof(params));
5909 params.target = &target;
5910 params.constBuffer = buffer;
5911 params.bufferSize = bufferSize;
5912 params.frameIndex = frameIndex;
5913
5914 if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5915 {
5916 return NULL;
5917 }
5918 else
5919 {
5920 return target;
5921 }
5922 }
5923
5924
5925
5926 typedef struct
5927 {
5928 char** result;
5929 const void* buffer;
5930 uint32_t size;
5931 } _OrthancPluginComputeHash;
5932
5945 ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5946 OrthancPluginContext* context,
5947 const void* buffer,
5948 uint32_t size)
5949 {
5950 char* result;
5951
5952 _OrthancPluginComputeHash params;
5953 params.result = &result;
5954 params.buffer = buffer;
5955 params.size = size;
5956
5957 if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5958 {
5959 /* Error */
5960 return NULL;
5961 }
5962 else
5963 {
5964 return result;
5965 }
5966 }
5967
5968
5981 ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5982 OrthancPluginContext* context,
5983 const void* buffer,
5984 uint32_t size)
5985 {
5986 char* result;
5987
5988 _OrthancPluginComputeHash params;
5989 params.result = &result;
5990 params.buffer = buffer;
5991 params.size = size;
5992
5993 if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5994 {
5995 /* Error */
5996 return NULL;
5997 }
5998 else
5999 {
6000 return result;
6001 }
6002 }
6003
6004
6005
6006 typedef struct
6007 {
6009 const char* name;
6010 } _OrthancPluginLookupDictionary;
6011
6028 OrthancPluginContext* context,
6030 const char* name)
6031 {
6032 _OrthancPluginLookupDictionary params;
6033 params.target = target;
6034 params.name = name;
6035 return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
6036 }
6037
6038
6039
6040 typedef struct
6041 {
6043 const void* answer;
6044 uint32_t answerSize;
6045 uint32_t headersCount;
6046 const char* const* headersKeys;
6047 const char* const* headersValues;
6048 } _OrthancPluginSendMultipartItem2;
6049
6071 OrthancPluginContext* context,
6073 const void* answer,
6074 uint32_t answerSize,
6075 uint32_t headersCount,
6076 const char* const* headersKeys,
6077 const char* const* headersValues)
6078 {
6079 _OrthancPluginSendMultipartItem2 params;
6080 params.output = output;
6081 params.answer = answer;
6082 params.answerSize = answerSize;
6083 params.headersCount = headersCount;
6084 params.headersKeys = headersKeys;
6085 params.headersValues = headersValues;
6086
6087 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
6088 }
6089
6090
6091 typedef struct
6092 {
6094 } _OrthancPluginIncomingHttpRequestFilter;
6095
6108 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(
6109 OrthancPluginContext* context,
6111 {
6112 _OrthancPluginIncomingHttpRequestFilter params;
6113 params.callback = callback;
6114
6115 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
6116 }
6117
6118
6119
6120 typedef struct
6121 {
6122 OrthancPluginMemoryBuffer* answerBody;
6123 OrthancPluginMemoryBuffer* answerHeaders;
6124 uint16_t* httpStatus;
6126 const char* url;
6127 uint32_t headersCount;
6128 const char* const* headersKeys;
6129 const char* const* headersValues;
6130 const void* body;
6131 uint32_t bodySize;
6132 const char* username;
6133 const char* password;
6134 uint32_t timeout;
6135 const char* certificateFile;
6136 const char* certificateKeyFile;
6137 const char* certificateKeyPassword;
6138 uint8_t pkcs11;
6139 } _OrthancPluginCallHttpClient2;
6140
6141
6142
6184 OrthancPluginContext* context,
6185 OrthancPluginMemoryBuffer* answerBody,
6186 OrthancPluginMemoryBuffer* answerHeaders,
6187 uint16_t* httpStatus,
6189 const char* url,
6190 uint32_t headersCount,
6191 const char* const* headersKeys,
6192 const char* const* headersValues,
6193 const void* body,
6194 uint32_t bodySize,
6195 const char* username,
6196 const char* password,
6197 uint32_t timeout,
6198 const char* certificateFile,
6199 const char* certificateKeyFile,
6200 const char* certificateKeyPassword,
6201 uint8_t pkcs11)
6202 {
6203 _OrthancPluginCallHttpClient2 params;
6204 memset(&params, 0, sizeof(params));
6205
6206 params.answerBody = answerBody;
6207 params.answerHeaders = answerHeaders;
6208 params.httpStatus = httpStatus;
6209 params.method = method;
6210 params.url = url;
6211 params.headersCount = headersCount;
6212 params.headersKeys = headersKeys;
6213 params.headersValues = headersValues;
6214 params.body = body;
6215 params.bodySize = bodySize;
6216 params.username = username;
6217 params.password = password;
6218 params.timeout = timeout;
6219 params.certificateFile = certificateFile;
6220 params.certificateKeyFile = certificateKeyFile;
6221 params.certificateKeyPassword = certificateKeyPassword;
6222 params.pkcs11 = pkcs11;
6223
6224 return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
6225 }
6226
6227
6238 ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
6239 OrthancPluginContext* context)
6240 {
6241 char* result;
6242
6243 _OrthancPluginRetrieveDynamicString params;
6244 params.result = &result;
6245 params.argument = NULL;
6246
6247 if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
6248 {
6249 /* Error */
6250 return NULL;
6251 }
6252 else
6253 {
6254 return result;
6255 }
6256 }
6257
6258
6259
6260
6261 typedef struct
6262 {
6264 } _OrthancPluginFindCallback;
6265
6278 OrthancPluginContext* context,
6280 {
6281 _OrthancPluginFindCallback params;
6282 params.callback = callback;
6283
6284 return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
6285 }
6286
6287
6288 typedef struct
6289 {
6290 OrthancPluginFindAnswers *answers;
6291 const OrthancPluginFindQuery *query;
6292 const void *dicom;
6293 uint32_t size;
6294 uint32_t index;
6295 uint32_t *resultUint32;
6296 uint16_t *resultGroup;
6297 uint16_t *resultElement;
6298 char **resultString;
6299 } _OrthancPluginFindOperation;
6300
6317 OrthancPluginContext* context,
6318 OrthancPluginFindAnswers* answers,
6319 const void* dicom,
6320 uint32_t size)
6321 {
6322 _OrthancPluginFindOperation params;
6323 memset(&params, 0, sizeof(params));
6324 params.answers = answers;
6325 params.dicom = dicom;
6326 params.size = size;
6327
6328 return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
6329 }
6330
6331
6346 OrthancPluginContext* context,
6347 OrthancPluginFindAnswers* answers)
6348 {
6349 _OrthancPluginFindOperation params;
6350 memset(&params, 0, sizeof(params));
6351 params.answers = answers;
6352
6353 return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
6354 }
6355
6356
6357
6369 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
6370 OrthancPluginContext* context,
6371 const OrthancPluginFindQuery* query)
6372 {
6373 uint32_t count = 0;
6374
6375 _OrthancPluginFindOperation params;
6376 memset(&params, 0, sizeof(params));
6377 params.query = query;
6378 params.resultUint32 = &count;
6379
6380 if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
6381 {
6382 /* Error */
6383 return 0;
6384 }
6385 else
6386 {
6387 return count;
6388 }
6389 }
6390
6391
6407 OrthancPluginContext* context,
6408 uint16_t* group,
6409 uint16_t* element,
6410 const OrthancPluginFindQuery* query,
6411 uint32_t index)
6412 {
6413 _OrthancPluginFindOperation params;
6414 memset(&params, 0, sizeof(params));
6415 params.query = query;
6416 params.index = index;
6417 params.resultGroup = group;
6418 params.resultElement = element;
6419
6420 return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
6421 }
6422
6423
6437 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
6438 OrthancPluginContext* context,
6439 const OrthancPluginFindQuery* query,
6440 uint32_t index)
6441 {
6442 char* result;
6443
6444 _OrthancPluginFindOperation params;
6445 memset(&params, 0, sizeof(params));
6446 params.query = query;
6447 params.index = index;
6448 params.resultString = &result;
6449
6450 if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
6451 {
6452 /* Error */
6453 return NULL;
6454 }
6455 else
6456 {
6457 return result;
6458 }
6459 }
6460
6461
6475 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
6476 OrthancPluginContext* context,
6477 const OrthancPluginFindQuery* query,
6478 uint32_t index)
6479 {
6480 char* result;
6481
6482 _OrthancPluginFindOperation params;
6483 memset(&params, 0, sizeof(params));
6484 params.query = query;
6485 params.index = index;
6486 params.resultString = &result;
6487
6488 if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
6489 {
6490 /* Error */
6491 return NULL;
6492 }
6493 else
6494 {
6495 return result;
6496 }
6497 }
6498
6499
6500
6501
6502 typedef struct
6503 {
6505 OrthancPluginGetMoveSize getMoveSize;
6506 OrthancPluginApplyMove applyMove;
6507 OrthancPluginFreeMove freeMove;
6508 } _OrthancPluginMoveCallback;
6509
6524 OrthancPluginContext* context,
6526 OrthancPluginGetMoveSize getMoveSize,
6527 OrthancPluginApplyMove applyMove,
6528 OrthancPluginFreeMove freeMove)
6529 {
6530 _OrthancPluginMoveCallback params;
6531 params.callback = callback;
6532 params.getMoveSize = getMoveSize;
6533 params.applyMove = applyMove;
6534 params.freeMove = freeMove;
6535
6536 return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
6537 }
6538
6539
6540
6541 typedef struct
6542 {
6543 OrthancPluginFindMatcher** target;
6544 const void* query;
6545 uint32_t size;
6546 } _OrthancPluginCreateFindMatcher;
6547
6548
6563 OrthancPluginContext* context,
6564 const void* query,
6565 uint32_t size)
6566 {
6567 OrthancPluginFindMatcher* target = NULL;
6568
6569 _OrthancPluginCreateFindMatcher params;
6570 memset(&params, 0, sizeof(params));
6571 params.target = &target;
6572 params.query = query;
6573 params.size = size;
6574
6575 if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
6576 {
6577 return NULL;
6578 }
6579 else
6580 {
6581 return target;
6582 }
6583 }
6584
6585
6586 typedef struct
6587 {
6588 OrthancPluginFindMatcher* matcher;
6589 } _OrthancPluginFreeFindMatcher;
6590
6600 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6601 OrthancPluginContext* context,
6602 OrthancPluginFindMatcher* matcher)
6603 {
6604 _OrthancPluginFreeFindMatcher params;
6605 params.matcher = matcher;
6606
6607 context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6608 }
6609
6610
6611 typedef struct
6612 {
6613 const OrthancPluginFindMatcher* matcher;
6614 const void* dicom;
6615 uint32_t size;
6616 int32_t* isMatch;
6617 } _OrthancPluginFindMatcherIsMatch;
6618
6633 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6634 OrthancPluginContext* context,
6635 const OrthancPluginFindMatcher* matcher,
6636 const void* dicom,
6637 uint32_t size)
6638 {
6639 int32_t isMatch = 0;
6640
6641 _OrthancPluginFindMatcherIsMatch params;
6642 params.matcher = matcher;
6643 params.dicom = dicom;
6644 params.size = size;
6645 params.isMatch = &isMatch;
6646
6647 if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6648 {
6649 return isMatch;
6650 }
6651 else
6652 {
6653 /* Error: Assume non-match */
6654 return 0;
6655 }
6656 }
6657
6658
6659 typedef struct
6660 {
6662 } _OrthancPluginIncomingHttpRequestFilter2;
6663
6676 OrthancPluginContext* context,
6678 {
6679 _OrthancPluginIncomingHttpRequestFilter2 params;
6680 params.callback = callback;
6681
6682 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6683 }
6684
6685
6686
6687 typedef struct
6688 {
6689 OrthancPluginPeers** peers;
6690 } _OrthancPluginGetPeers;
6691
6704 OrthancPluginContext* context)
6705 {
6706 OrthancPluginPeers* peers = NULL;
6707
6708 _OrthancPluginGetPeers params;
6709 memset(&params, 0, sizeof(params));
6710 params.peers = &peers;
6711
6712 if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6713 {
6714 return NULL;
6715 }
6716 else
6717 {
6718 return peers;
6719 }
6720 }
6721
6722
6723 typedef struct
6724 {
6725 OrthancPluginPeers* peers;
6726 } _OrthancPluginFreePeers;
6727
6737 ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6738 OrthancPluginContext* context,
6739 OrthancPluginPeers* peers)
6740 {
6741 _OrthancPluginFreePeers params;
6742 params.peers = peers;
6743
6744 context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6745 }
6746
6747
6748 typedef struct
6749 {
6750 uint32_t* target;
6751 const OrthancPluginPeers* peers;
6752 } _OrthancPluginGetPeersCount;
6753
6767 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6768 OrthancPluginContext* context,
6769 const OrthancPluginPeers* peers)
6770 {
6771 uint32_t target = 0;
6772
6773 _OrthancPluginGetPeersCount params;
6774 memset(&params, 0, sizeof(params));
6775 params.target = &target;
6776 params.peers = peers;
6777
6778 if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6779 {
6780 /* Error */
6781 return 0;
6782 }
6783 else
6784 {
6785 return target;
6786 }
6787 }
6788
6789
6790 typedef struct
6791 {
6792 const char** target;
6793 const OrthancPluginPeers* peers;
6794 uint32_t peerIndex;
6795 const char* userProperty;
6796 } _OrthancPluginGetPeerProperty;
6797
6815 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6816 OrthancPluginContext* context,
6817 const OrthancPluginPeers* peers,
6818 uint32_t peerIndex)
6819 {
6820 const char* target = NULL;
6821
6822 _OrthancPluginGetPeerProperty params;
6823 memset(&params, 0, sizeof(params));
6824 params.target = &target;
6825 params.peers = peers;
6826 params.peerIndex = peerIndex;
6827 params.userProperty = NULL;
6828
6829 if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6830 {
6831 /* Error */
6832 return NULL;
6833 }
6834 else
6835 {
6836 return target;
6837 }
6838 }
6839
6840
6856 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6857 OrthancPluginContext* context,
6858 const OrthancPluginPeers* peers,
6859 uint32_t peerIndex)
6860 {
6861 const char* target = NULL;
6862
6863 _OrthancPluginGetPeerProperty params;
6864 memset(&params, 0, sizeof(params));
6865 params.target = &target;
6866 params.peers = peers;
6867 params.peerIndex = peerIndex;
6868 params.userProperty = NULL;
6869
6870 if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6871 {
6872 /* Error */
6873 return NULL;
6874 }
6875 else
6876 {
6877 return target;
6878 }
6879 }
6880
6881
6882
6902 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6903 OrthancPluginContext* context,
6904 const OrthancPluginPeers* peers,
6905 uint32_t peerIndex,
6906 const char* userProperty)
6907 {
6908 const char* target = NULL;
6909
6910 _OrthancPluginGetPeerProperty params;
6911 memset(&params, 0, sizeof(params));
6912 params.target = &target;
6913 params.peers = peers;
6914 params.peerIndex = peerIndex;
6915 params.userProperty = userProperty;
6916
6917 if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6918 {
6919 /* No such user property */
6920 return NULL;
6921 }
6922 else
6923 {
6924 return target;
6925 }
6926 }
6927
6928
6929
6930 typedef struct
6931 {
6932 OrthancPluginMemoryBuffer* answerBody;
6933 OrthancPluginMemoryBuffer* answerHeaders;
6934 uint16_t* httpStatus;
6935 const OrthancPluginPeers* peers;
6936 uint32_t peerIndex;
6938 const char* uri;
6939 uint32_t additionalHeadersCount;
6940 const char* const* additionalHeadersKeys;
6941 const char* const* additionalHeadersValues;
6942 const void* body;
6943 uint32_t bodySize;
6944 uint32_t timeout;
6945 } _OrthancPluginCallPeerApi;
6946
6984 OrthancPluginContext* context,
6985 OrthancPluginMemoryBuffer* answerBody,
6986 OrthancPluginMemoryBuffer* answerHeaders,
6987 uint16_t* httpStatus,
6988 const OrthancPluginPeers* peers,
6989 uint32_t peerIndex,
6991 const char* uri,
6992 uint32_t additionalHeadersCount,
6993 const char* const* additionalHeadersKeys,
6994 const char* const* additionalHeadersValues,
6995 const void* body,
6996 uint32_t bodySize,
6997 uint32_t timeout)
6998 {
6999 _OrthancPluginCallPeerApi params;
7000 memset(&params, 0, sizeof(params));
7001
7002 params.answerBody = answerBody;
7003 params.answerHeaders = answerHeaders;
7004 params.httpStatus = httpStatus;
7005 params.peers = peers;
7006 params.peerIndex = peerIndex;
7007 params.method = method;
7008 params.uri = uri;
7009 params.additionalHeadersCount = additionalHeadersCount;
7010 params.additionalHeadersKeys = additionalHeadersKeys;
7011 params.additionalHeadersValues = additionalHeadersValues;
7012 params.body = body;
7013 params.bodySize = bodySize;
7014 params.timeout = timeout;
7015
7016 return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
7017 }
7018
7019
7020
7021
7022
7023 typedef struct
7024 {
7025 OrthancPluginJob** target;
7026 void *job;
7027 OrthancPluginJobFinalize finalize;
7028 const char *type;
7029 OrthancPluginJobGetProgress getProgress;
7030 OrthancPluginJobGetContent getContent;
7031 OrthancPluginJobGetSerialized getSerialized;
7035 } _OrthancPluginCreateJob;
7036
7069 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE OrthancPluginJob *OrthancPluginCreateJob(
7070 OrthancPluginContext *context,
7071 void *job,
7072 OrthancPluginJobFinalize finalize,
7073 const char *type,
7074 OrthancPluginJobGetProgress getProgress,
7075 OrthancPluginJobGetContent getContent,
7076 OrthancPluginJobGetSerialized getSerialized,
7080 {
7081 OrthancPluginJob* target = NULL;
7082
7083 _OrthancPluginCreateJob params;
7084 memset(&params, 0, sizeof(params));
7085
7086 params.target = &target;
7087 params.job = job;
7088 params.finalize = finalize;
7089 params.type = type;
7090 params.getProgress = getProgress;
7091 params.getContent = getContent;
7092 params.getSerialized = getSerialized;
7093 params.step = step;
7094 params.stop = stop;
7095 params.reset = reset;
7096
7097 if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
7098 target == NULL)
7099 {
7100 /* Error */
7101 return NULL;
7102 }
7103 else
7104 {
7105 return target;
7106 }
7107 }
7108
7109
7110 typedef struct
7111 {
7112 OrthancPluginJob** target;
7113 void *job;
7114 OrthancPluginJobFinalize finalize;
7115 const char *type;
7116 OrthancPluginJobGetProgress getProgress;
7117 OrthancPluginJobGetContent2 getContent;
7118 OrthancPluginJobGetSerialized2 getSerialized;
7122 } _OrthancPluginCreateJob2;
7123
7156 OrthancPluginContext *context,
7157 void *job,
7158 OrthancPluginJobFinalize finalize,
7159 const char *type,
7160 OrthancPluginJobGetProgress getProgress,
7161 OrthancPluginJobGetContent2 getContent,
7162 OrthancPluginJobGetSerialized2 getSerialized,
7166 {
7167 OrthancPluginJob* target = NULL;
7168
7169 _OrthancPluginCreateJob2 params;
7170 memset(&params, 0, sizeof(params));
7171
7172 params.target = &target;
7173 params.job = job;
7174 params.finalize = finalize;
7175 params.type = type;
7176 params.getProgress = getProgress;
7177 params.getContent = getContent;
7178 params.getSerialized = getSerialized;
7179 params.step = step;
7180 params.stop = stop;
7181 params.reset = reset;
7182
7183 if (context->InvokeService(context, _OrthancPluginService_CreateJob2, &params) != OrthancPluginErrorCode_Success ||
7184 target == NULL)
7185 {
7186 /* Error */
7187 return NULL;
7188 }
7189 else
7190 {
7191 return target;
7192 }
7193 }
7194
7195
7196 typedef struct
7197 {
7198 OrthancPluginJob* job;
7199 } _OrthancPluginFreeJob;
7200
7210 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
7211 OrthancPluginContext* context,
7212 OrthancPluginJob* job)
7213 {
7214 _OrthancPluginFreeJob params;
7215 params.job = job;
7216
7217 context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
7218 }
7219
7220
7221
7222 typedef struct
7223 {
7224 char** resultId;
7225 OrthancPluginJob *job;
7226 int32_t priority;
7227 } _OrthancPluginSubmitJob;
7228
7242 ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
7243 OrthancPluginContext *context,
7244 OrthancPluginJob *job,
7245 int32_t priority)
7246 {
7247 char* resultId = NULL;
7248
7249 _OrthancPluginSubmitJob params;
7250 memset(&params, 0, sizeof(params));
7251
7252 params.resultId = &resultId;
7253 params.job = job;
7254 params.priority = priority;
7255
7256 if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
7257 resultId == NULL)
7258 {
7259 /* Error */
7260 return NULL;
7261 }
7262 else
7263 {
7264 return resultId;
7265 }
7266 }
7267
7268
7269
7270 typedef struct
7271 {
7272 OrthancPluginJobsUnserializer unserializer;
7273 } _OrthancPluginJobsUnserializer;
7274
7287 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
7288 OrthancPluginContext* context,
7289 OrthancPluginJobsUnserializer unserializer)
7290 {
7291 _OrthancPluginJobsUnserializer params;
7292 params.unserializer = unserializer;
7293
7294 context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
7295 }
7296
7297
7298
7299 typedef struct
7300 {
7302 const char* details;
7303 uint8_t log;
7304 } _OrthancPluginSetHttpErrorDetails;
7305
7323 ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
7324 OrthancPluginContext* context,
7326 const char* details,
7327 uint8_t log)
7328 {
7329 _OrthancPluginSetHttpErrorDetails params;
7330 params.output = output;
7331 params.details = details;
7332 params.log = log;
7333 context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
7334 }
7335
7336
7337
7338 typedef struct
7339 {
7340 const char** result;
7341 const char* argument;
7342 } _OrthancPluginRetrieveStaticString;
7343
7355 ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
7356 OrthancPluginContext* context,
7357 const char* path)
7358 {
7359 const char* result = NULL;
7360
7361 _OrthancPluginRetrieveStaticString params;
7362 params.result = &result;
7363 params.argument = path;
7364
7365 if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
7366 {
7367 /* Error */
7368 return NULL;
7369 }
7370 else
7371 {
7372 return result;
7373 }
7374 }
7375
7376
7377
7378 typedef struct
7379 {
7380 const char* name;
7381 float value;
7383 } _OrthancPluginSetMetricsValue;
7384
7401 ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
7402 OrthancPluginContext* context,
7403 const char* name,
7404 float value,
7406 {
7407 _OrthancPluginSetMetricsValue params;
7408 params.name = name;
7409 params.value = value;
7410 params.type = type;
7411 context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
7412 }
7413
7414
7415
7416 typedef struct
7417 {
7419 } _OrthancPluginRegisterRefreshMetricsCallback;
7420
7433 OrthancPluginContext* context,
7435 {
7436 _OrthancPluginRegisterRefreshMetricsCallback params;
7437 params.callback = callback;
7438 context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
7439 }
7440
7441
7442
7443
7444 typedef struct
7445 {
7446 char** target;
7447 const void* dicom;
7448 uint32_t dicomSize;
7450 } _OrthancPluginEncodeDicomWeb;
7451
7468 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
7469 OrthancPluginContext* context,
7470 const void* dicom,
7471 uint32_t dicomSize,
7473 {
7474 char* target = NULL;
7475
7476 _OrthancPluginEncodeDicomWeb params;
7477 params.target = &target;
7478 params.dicom = dicom;
7479 params.dicomSize = dicomSize;
7480 params.callback = callback;
7481
7482 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
7483 {
7484 /* Error */
7485 return NULL;
7486 }
7487 else
7488 {
7489 return target;
7490 }
7491 }
7492
7493
7510 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
7511 OrthancPluginContext* context,
7512 const void* dicom,
7513 uint32_t dicomSize,
7515 {
7516 char* target = NULL;
7517
7518 _OrthancPluginEncodeDicomWeb params;
7519 params.target = &target;
7520 params.dicom = dicom;
7521 params.dicomSize = dicomSize;
7522 params.callback = callback;
7523
7524 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
7525 {
7526 /* Error */
7527 return NULL;
7528 }
7529 else
7530 {
7531 return target;
7532 }
7533 }
7534
7535
7536
7537 typedef struct
7538 {
7539 char** target;
7540 const void* dicom;
7541 uint32_t dicomSize;
7543 void* payload;
7544 } _OrthancPluginEncodeDicomWeb2;
7545
7562 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson2(
7563 OrthancPluginContext* context,
7564 const void* dicom,
7565 uint32_t dicomSize,
7567 void* payload)
7568 {
7569 char* target = NULL;
7570
7571 _OrthancPluginEncodeDicomWeb2 params;
7572 params.target = &target;
7573 params.dicom = dicom;
7574 params.dicomSize = dicomSize;
7575 params.callback = callback;
7576 params.payload = payload;
7577
7578 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson2, &params) != OrthancPluginErrorCode_Success)
7579 {
7580 /* Error */
7581 return NULL;
7582 }
7583 else
7584 {
7585 return target;
7586 }
7587 }
7588
7589
7606 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml2(
7607 OrthancPluginContext* context,
7608 const void* dicom,
7609 uint32_t dicomSize,
7611 void* payload)
7612 {
7613 char* target = NULL;
7614
7615 _OrthancPluginEncodeDicomWeb2 params;
7616 params.target = &target;
7617 params.dicom = dicom;
7618 params.dicomSize = dicomSize;
7619 params.callback = callback;
7620 params.payload = payload;
7621
7622 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml2, &params) != OrthancPluginErrorCode_Success)
7623 {
7624 /* Error */
7625 return NULL;
7626 }
7627 else
7628 {
7629 return target;
7630 }
7631 }
7632
7633
7634
7651 void* answer,
7652 const char* key,
7653 const char* value);
7654
7655
7672 void* answer,
7673 const void* data,
7674 uint32_t size);
7675
7676
7691 typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
7692
7693
7709
7710
7724 typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
7725
7726
7740 typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
7741
7742
7743 typedef struct
7744 {
7745 void* answer;
7748 uint16_t* httpStatus;
7750 const char* url;
7751 uint32_t headersCount;
7752 const char* const* headersKeys;
7753 const char* const* headersValues;
7754 void* request;
7759 const char* username;
7760 const char* password;
7761 uint32_t timeout;
7762 const char* certificateFile;
7763 const char* certificateKeyFile;
7764 const char* certificateKeyPassword;
7765 uint8_t pkcs11;
7766 } _OrthancPluginChunkedHttpClient;
7767
7768
7820 OrthancPluginContext* context,
7821 void* answer,
7824 uint16_t* httpStatus,
7826 const char* url,
7827 uint32_t headersCount,
7828 const char* const* headersKeys,
7829 const char* const* headersValues,
7830 void* request,
7835 const char* username,
7836 const char* password,
7837 uint32_t timeout,
7838 const char* certificateFile,
7839 const char* certificateKeyFile,
7840 const char* certificateKeyPassword,
7841 uint8_t pkcs11)
7842 {
7843 _OrthancPluginChunkedHttpClient params;
7844 memset(&params, 0, sizeof(params));
7845
7846 /* In common with OrthancPluginHttpClient() */
7847 params.httpStatus = httpStatus;
7848 params.method = method;
7849 params.url = url;
7850 params.headersCount = headersCount;
7851 params.headersKeys = headersKeys;
7852 params.headersValues = headersValues;
7853 params.username = username;
7854 params.password = password;
7855 params.timeout = timeout;
7856 params.certificateFile = certificateFile;
7857 params.certificateKeyFile = certificateKeyFile;
7858 params.certificateKeyPassword = certificateKeyPassword;
7859 params.pkcs11 = pkcs11;
7860
7861 /* For chunked body/answer */
7862 params.answer = answer;
7863 params.answerAddChunk = answerAddChunk;
7864 params.answerAddHeader = answerAddHeader;
7865 params.request = request;
7866 params.requestIsDone = requestIsDone;
7867 params.requestChunkData = requestChunkData;
7868 params.requestChunkSize = requestChunkSize;
7869 params.requestNext = requestNext;
7870
7871 return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7872 }
7873
7874
7875
7880 typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7881
7882
7883
7901 const char* url,
7902 const OrthancPluginHttpRequest* request);
7903
7904
7920 const void* data,
7921 uint32_t size);
7922
7923
7940 OrthancPluginRestOutput* output);
7941
7942
7958
7959 typedef struct
7960 {
7961 const char* pathRegularExpression;
7962 OrthancPluginRestCallback getHandler;
7964 OrthancPluginRestCallback deleteHandler;
7969 } _OrthancPluginChunkedRestCallback;
7970
7971
8002 OrthancPluginContext* context,
8003 const char* pathRegularExpression,
8004 OrthancPluginRestCallback getHandler,
8006 OrthancPluginRestCallback deleteHandler,
8011 {
8012 _OrthancPluginChunkedRestCallback params;
8013 params.pathRegularExpression = pathRegularExpression;
8014 params.getHandler = getHandler;
8015 params.postHandler = postHandler;
8016 params.deleteHandler = deleteHandler;
8017 params.putHandler = putHandler;
8018 params.addChunk = addChunk;
8019 params.execute = execute;
8020 params.finalize = finalize;
8021
8022 context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
8023 }
8024
8025
8026
8027
8028
8029 typedef struct
8030 {
8031 char** result;
8032 uint16_t group;
8033 uint16_t element;
8034 const char* privateCreator;
8035 } _OrthancPluginGetTagName;
8036
8052 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
8053 OrthancPluginContext* context,
8054 uint16_t group,
8055 uint16_t element,
8056 const char* privateCreator)
8057 {
8058 char* result;
8059
8060 _OrthancPluginGetTagName params;
8061 params.result = &result;
8062 params.group = group;
8063 params.element = element;
8064 params.privateCreator = privateCreator;
8065
8066 if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
8067 {
8068 /* Error */
8069 return NULL;
8070 }
8071 else
8072 {
8073 return result;
8074 }
8075 }
8076
8077
8078
8108 void** handler /* out */,
8109 const char* jobId,
8110 const char* transactionUid,
8111 const char* const* sopClassUids,
8112 const char* const* sopInstanceUids,
8113 uint32_t countInstances,
8114 const char* remoteAet,
8115 const char* calledAet);
8116
8117
8129 typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
8130
8131
8152 void* handler,
8153 const char* sopClassUid,
8154 const char* sopInstanceUid);
8155
8156
8157 typedef struct
8158 {
8162 } _OrthancPluginRegisterStorageCommitmentScpCallback;
8163
8178 OrthancPluginContext* context,
8182 {
8183 _OrthancPluginRegisterStorageCommitmentScpCallback params;
8184 params.factory = factory;
8185 params.destructor = destructor;
8186 params.lookup = lookup;
8187 return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
8188 }
8189
8190
8191
8218 const OrthancPluginDicomInstance* instance);
8219
8220
8221 typedef struct
8222 {
8224 } _OrthancPluginIncomingDicomInstanceFilter;
8225
8239 OrthancPluginContext* context,
8241 {
8242 _OrthancPluginIncomingDicomInstanceFilter params;
8243 params.callback = callback;
8244
8245 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, &params);
8246 }
8247
8248
8280 uint16_t* dimseStatus /* out */,
8281 const OrthancPluginDicomInstance* instance);
8282
8283
8284 typedef struct
8285 {
8287 } _OrthancPluginIncomingCStoreInstanceFilter;
8288
8302 OrthancPluginContext* context,
8304 {
8305 _OrthancPluginIncomingCStoreInstanceFilter params;
8306 params.callback = callback;
8307
8308 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingCStoreInstanceFilter, &params);
8309 }
8310
8347 OrthancPluginMemoryBuffer64* modifiedDicomBuffer,
8348 const void* receivedDicomBuffer,
8349 uint64_t receivedDicomBufferSize,
8351
8352
8353 typedef struct
8354 {
8356 } _OrthancPluginReceivedInstanceCallback;
8357
8379 OrthancPluginContext* context,
8381 {
8382 _OrthancPluginReceivedInstanceCallback params;
8383 params.callback = callback;
8384
8385 return context->InvokeService(context, _OrthancPluginService_RegisterReceivedInstanceCallback, &params);
8386 }
8387
8402 OrthancPluginContext* context,
8403 const OrthancPluginDicomInstance* instance)
8404 {
8405 char* result;
8406
8407 _OrthancPluginAccessDicomInstance params;
8408 memset(&params, 0, sizeof(params));
8409 params.resultStringToFree = &result;
8410 params.instance = instance;
8411
8412 if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, &params) != OrthancPluginErrorCode_Success)
8413 {
8414 /* Error */
8415 return NULL;
8416 }
8417 else
8418 {
8419 return result;
8420 }
8421 }
8422
8423
8436 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData(
8437 OrthancPluginContext* context,
8438 const OrthancPluginDicomInstance* instance)
8439 {
8440 int64_t hasPixelData;
8441
8442 _OrthancPluginAccessDicomInstance params;
8443 memset(&params, 0, sizeof(params));
8444 params.resultInt64 = &hasPixelData;
8445 params.instance = instance;
8446
8447 if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, &params) != OrthancPluginErrorCode_Success ||
8448 hasPixelData < 0 ||
8449 hasPixelData > 1)
8450 {
8451 /* Error */
8452 return -1;
8453 }
8454 else
8455 {
8456 return (hasPixelData != 0);
8457 }
8458 }
8459
8460
8461
8462
8463
8464
8465 typedef struct
8466 {
8468 const void* buffer;
8469 uint32_t size;
8470 const char* transferSyntax;
8471 } _OrthancPluginCreateDicomInstance;
8472
8487 OrthancPluginContext* context,
8488 const void* buffer,
8489 uint32_t size)
8490 {
8491 OrthancPluginDicomInstance* target = NULL;
8492
8493 _OrthancPluginCreateDicomInstance params;
8494 params.target = &target;
8495 params.buffer = buffer;
8496 params.size = size;
8497
8498 if (context->InvokeService(context, _OrthancPluginService_CreateDicomInstance, &params) != OrthancPluginErrorCode_Success)
8499 {
8500 /* Error */
8501 return NULL;
8502 }
8503 else
8504 {
8505 return target;
8506 }
8507 }
8508
8509 typedef struct
8510 {
8512 } _OrthancPluginFreeDicomInstance;
8513
8524 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeDicomInstance(
8525 OrthancPluginContext* context,
8527 {
8528 _OrthancPluginFreeDicomInstance params;
8529 params.dicom = dicom;
8530
8531 context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, &params);
8532 }
8533
8534
8535 typedef struct
8536 {
8537 uint32_t* targetUint32;
8538 OrthancPluginMemoryBuffer* targetBuffer;
8539 OrthancPluginImage** targetImage;
8540 char** targetStringToFree;
8541 const OrthancPluginDicomInstance* instance;
8542 uint32_t frameIndex;
8545 uint32_t maxStringLength;
8546 OrthancPluginDicomWebBinaryCallback2 dicomWebCallback;
8547 void* dicomWebPayload;
8548 } _OrthancPluginAccessDicomInstance2;
8549
8561 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetInstanceFramesCount(
8562 OrthancPluginContext* context,
8563 const OrthancPluginDicomInstance* instance)
8564 {
8565 uint32_t count;
8566
8567 _OrthancPluginAccessDicomInstance2 params;
8568 memset(&params, 0, sizeof(params));
8569 params.targetUint32 = &count;
8570 params.instance = instance;
8571
8572 if (context->InvokeService(context, _OrthancPluginService_GetInstanceFramesCount, &params) != OrthancPluginErrorCode_Success)
8573 {
8574 /* Error */
8575 return 0;
8576 }
8577 else
8578 {
8579 return count;
8580 }
8581 }
8582
8583
8602 OrthancPluginContext* context,
8604 const OrthancPluginDicomInstance* instance,
8605 uint32_t frameIndex)
8606 {
8607 _OrthancPluginAccessDicomInstance2 params;
8608 memset(&params, 0, sizeof(params));
8609 params.targetBuffer = target;
8610 params.instance = instance;
8611 params.frameIndex = frameIndex;
8612
8613 return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, &params);
8614 }
8615
8616
8630 OrthancPluginContext* context,
8631 const OrthancPluginDicomInstance* instance,
8632 uint32_t frameIndex)
8633 {
8634 OrthancPluginImage* target = NULL;
8635
8636 _OrthancPluginAccessDicomInstance2 params;
8637 memset(&params, 0, sizeof(params));
8638 params.targetImage = &target;
8639 params.instance = instance;
8640 params.frameIndex = frameIndex;
8641
8642 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDecodedFrame, &params) != OrthancPluginErrorCode_Success)
8643 {
8644 return NULL;
8645 }
8646 else
8647 {
8648 return target;
8649 }
8650 }
8651
8652
8669 OrthancPluginContext* context,
8670 const void* buffer,
8671 uint32_t size,
8672 const char* transferSyntax)
8673 {
8674 OrthancPluginDicomInstance* target = NULL;
8675
8676 _OrthancPluginCreateDicomInstance params;
8677 params.target = &target;
8678 params.buffer = buffer;
8679 params.size = size;
8680 params.transferSyntax = transferSyntax;
8681
8682 if (context->InvokeService(context, _OrthancPluginService_TranscodeDicomInstance, &params) != OrthancPluginErrorCode_Success)
8683 {
8684 /* Error */
8685 return NULL;
8686 }
8687 else
8688 {
8689 return target;
8690 }
8691 }
8692
8707 OrthancPluginContext* context,
8709 const OrthancPluginDicomInstance* instance)
8710 {
8711 _OrthancPluginAccessDicomInstance2 params;
8712 memset(&params, 0, sizeof(params));
8713 params.targetBuffer = target;
8714 params.instance = instance;
8715
8716 return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, &params);
8717 }
8718
8719
8738 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceAdvancedJson(
8739 OrthancPluginContext* context,
8740 const OrthancPluginDicomInstance* instance,
8743 uint32_t maxStringLength)
8744 {
8745 char* result = NULL;
8746
8747 _OrthancPluginAccessDicomInstance2 params;
8748 memset(&params, 0, sizeof(params));
8749 params.targetStringToFree = &result;
8750 params.instance = instance;
8751 params.format = format;
8752 params.flags = flags;
8753 params.maxStringLength = maxStringLength;
8754
8755 if (context->InvokeService(context, _OrthancPluginService_GetInstanceAdvancedJson, &params) != OrthancPluginErrorCode_Success)
8756 {
8757 /* Error */
8758 return NULL;
8759 }
8760 else
8761 {
8762 return result;
8763 }
8764 }
8765
8766
8781 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebJson(
8782 OrthancPluginContext* context,
8783 const OrthancPluginDicomInstance* instance,
8785 void* payload)
8786 {
8787 char* target = NULL;
8788
8789 _OrthancPluginAccessDicomInstance2 params;
8790 params.targetStringToFree = &target;
8791 params.instance = instance;
8792 params.dicomWebCallback = callback;
8793 params.dicomWebPayload = payload;
8794
8795 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebJson, &params) != OrthancPluginErrorCode_Success)
8796 {
8797 /* Error */
8798 return NULL;
8799 }
8800 else
8801 {
8802 return target;
8803 }
8804 }
8805
8806
8821 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebXml(
8822 OrthancPluginContext* context,
8823 const OrthancPluginDicomInstance* instance,
8825 void* payload)
8826 {
8827 char* target = NULL;
8828
8829 _OrthancPluginAccessDicomInstance2 params;
8830 params.targetStringToFree = &target;
8831 params.instance = instance;
8832 params.dicomWebCallback = callback;
8833 params.dicomWebPayload = payload;
8834
8835 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebXml, &params) != OrthancPluginErrorCode_Success)
8836 {
8837 /* Error */
8838 return NULL;
8839 }
8840 else
8841 {
8842 return target;
8843 }
8844 }
8845
8846
8847
8867 OrthancPluginMemoryBuffer* transcoded /* out */,
8868 const void* buffer,
8869 uint64_t size,
8870 const char* const* allowedSyntaxes,
8871 uint32_t countSyntaxes,
8872 uint8_t allowNewSopInstanceUid);
8873
8874
8875 typedef struct
8876 {
8878 } _OrthancPluginTranscoderCallback;
8879
8894 OrthancPluginContext* context,
8896 {
8897 _OrthancPluginTranscoderCallback params;
8898 params.callback = callback;
8899
8900 return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, &params);
8901 }
8902
8903
8904
8905 typedef struct
8906 {
8908 uint32_t size;
8909 } _OrthancPluginCreateMemoryBuffer;
8910
8929 OrthancPluginContext* context,
8931 uint32_t size)
8932 {
8933 _OrthancPluginCreateMemoryBuffer params;
8934 params.target = target;
8935 params.size = size;
8936
8937 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, &params);
8938 }
8939
8940
8967 OrthancPluginContext* context)
8968 {
8969 char* result;
8970
8971 _OrthancPluginRetrieveDynamicString params;
8972 params.result = &result;
8973 params.argument = NULL;
8974
8975 if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
8977 {
8978 /* Error */
8979 return NULL;
8980 }
8981 else
8982 {
8983 return result;
8984 }
8985 }
8986
8987
8988
8989 typedef struct
8990 {
8992 uint64_t size;
8993 } _OrthancPluginCreateMemoryBuffer64;
8994
9013 OrthancPluginContext* context,
9015 uint64_t size)
9016 {
9017 _OrthancPluginCreateMemoryBuffer64 params;
9018 params.target = target;
9019 params.size = size;
9020
9021 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer64, &params);
9022 }
9023
9024
9025 typedef struct
9026 {
9031 } _OrthancPluginRegisterStorageArea2;
9032
9050 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea2(
9051 OrthancPluginContext* context,
9056 {
9057 _OrthancPluginRegisterStorageArea2 params;
9058 params.create = create;
9059 params.readWhole = readWhole;
9060 params.readRange = readRange;
9061 params.remove = remove;
9062 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea2, &params);
9063 }
9064
9065
9066
9067 typedef struct
9068 {
9069 _OrthancPluginCreateDicom createDicom;
9070 const char* privateCreator;
9071 } _OrthancPluginCreateDicom2;
9072
9098 OrthancPluginContext* context,
9100 const char* json,
9101 const OrthancPluginImage* pixelData,
9103 const char* privateCreator)
9104 {
9105 _OrthancPluginCreateDicom2 params;
9106 params.createDicom.target = target;
9107 params.createDicom.json = json;
9108 params.createDicom.pixelData = pixelData;
9109 params.createDicom.flags = flags;
9110 params.privateCreator = privateCreator;
9111
9112 return context->InvokeService(context, _OrthancPluginService_CreateDicom2, &params);
9113 }
9114
9115
9116
9117
9118
9119
9120 typedef struct
9121 {
9122 OrthancPluginMemoryBuffer* answerBody;
9123 OrthancPluginMemoryBuffer* answerHeaders;
9124 uint16_t* httpStatus;
9126 const char* uri;
9127 uint32_t headersCount;
9128 const char* const* headersKeys;
9129 const char* const* headersValues;
9130 const void* body;
9131 uint32_t bodySize;
9132 uint8_t afterPlugins;
9133 } _OrthancPluginCallRestApi;
9134
9166 OrthancPluginContext* context,
9167 OrthancPluginMemoryBuffer* answerBody,
9168 OrthancPluginMemoryBuffer* answerHeaders,
9169 uint16_t* httpStatus,
9171 const char* uri,
9172 uint32_t headersCount,
9173 const char* const* headersKeys,
9174 const char* const* headersValues,
9175 const void* body,
9176 uint32_t bodySize,
9177 uint8_t afterPlugins)
9178 {
9179 _OrthancPluginCallRestApi params;
9180 memset(&params, 0, sizeof(params));
9181
9182 params.answerBody = answerBody;
9183 params.answerHeaders = answerHeaders;
9184 params.httpStatus = httpStatus;
9185 params.method = method;
9186 params.uri = uri;
9187 params.headersCount = headersCount;
9188 params.headersKeys = headersKeys;
9189 params.headersValues = headersValues;
9190 params.body = body;
9191 params.bodySize = bodySize;
9192 params.afterPlugins = afterPlugins;
9193
9194 return context->InvokeService(context, _OrthancPluginService_CallRestApi, &params);
9195 }
9196
9197
9198
9203 typedef struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection;
9204
9205
9224 const char* name,
9225 uint64_t size,
9226 const char* mimeType,
9227 const char* dateTime);
9228
9229
9245 const char* name,
9246 const char* dateTime);
9247
9248
9272 const void* data,
9273 uint64_t size,
9274 const char* mimeType,
9275 const char* dateTime);
9276
9277
9292 uint8_t* isExisting, /* out */
9293 uint32_t pathSize,
9294 const char* const* pathItems,
9295 void* payload);
9296
9297
9317 uint8_t* isExisting, /* out */
9321 uint32_t pathSize,
9322 const char* const* pathItems,
9323 void* payload);
9324
9325
9345 uint32_t pathSize,
9346 const char* const* pathItems,
9347 void* payload);
9348
9349
9366 uint8_t* isReadOnly, /* out */
9367 uint32_t pathSize,
9368 const char* const* pathItems,
9369 const void* data,
9370 uint64_t size,
9371 void* payload);
9372
9373
9388 uint8_t* isReadOnly, /* out */
9389 uint32_t pathSize,
9390 const char* const* pathItems,
9391 void* payload);
9392
9393
9408 uint8_t* isReadOnly, /* out */
9409 uint32_t pathSize,
9410 const char* const* pathItems,
9411 void* payload);
9412
9413
9414 typedef struct
9415 {
9416 const char* uri;
9423 void* payload;
9424 } _OrthancPluginRegisterWebDavCollection;
9425
9447 OrthancPluginContext* context,
9448 const char* uri,
9455 void* payload)
9456 {
9457 _OrthancPluginRegisterWebDavCollection params;
9458 params.uri = uri;
9459 params.isExistingFolder = isExistingFolder;
9460 params.listFolder = listFolder;
9461 params.retrieveFile = retrieveFile;
9462 params.storeFile = storeFile;
9463 params.createFolder = createFolder;
9464 params.deleteItem = deleteItem;
9465 params.payload = payload;
9466
9467 return context->InvokeService(context, _OrthancPluginService_RegisterWebDavCollection, &params);
9468 }
9469
9470
9479 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetDatabaseServerIdentifier(
9480 OrthancPluginContext* context)
9481 {
9482 const char* result;
9483
9484 _OrthancPluginRetrieveStaticString params;
9485 params.result = &result;
9486 params.argument = NULL;
9487
9488 if (context->InvokeService(context, _OrthancPluginService_GetDatabaseServerIdentifier, &params) != OrthancPluginErrorCode_Success)
9489 {
9490 /* Error */
9491 return NULL;
9492 }
9493 else
9494 {
9495 return result;
9496 }
9497 }
9498
9499
9500 typedef struct
9501 {
9505 } _OrthancPluginRegisterStorageArea3;
9506
9521 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea3(
9522 OrthancPluginContext* context,
9526 {
9527 _OrthancPluginRegisterStorageArea3 params;
9528 params.create = create;
9529 params.readRange = readRange;
9530 params.remove = remove;
9531 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea3, &params);
9532 }
9533
9542 void* backend,
9543 const void* request,
9544 uint64_t requestSize);
9545
9551 typedef void (*OrthancPluginFinalizeDatabaseBackendV4) (void* backend);
9552
9553 typedef struct
9554 {
9555 void* backend;
9556 uint32_t maxDatabaseRetries;
9559 } _OrthancPluginRegisterDatabaseBackendV4;
9560
9579 OrthancPluginContext* context,
9580 void* backend,
9581 uint32_t maxDatabaseRetries,
9584 {
9585 _OrthancPluginRegisterDatabaseBackendV4 params;
9586 params.backend = backend;
9587 params.maxDatabaseRetries = maxDatabaseRetries;
9588 params.operations = operations;
9589 params.finalize = finalize;
9590
9591 return context->InvokeService(context, _OrthancPluginService_RegisterDatabaseBackendV4, &params);
9592 }
9593
9594
9595 typedef struct
9596 {
9598 const char* instanceId;
9600 } _OrthancPluginLoadDicomInstance;
9601
9616 OrthancPluginContext* context,
9617 const char* instanceId,
9619 {
9620 OrthancPluginDicomInstance* target = NULL;
9621
9622 _OrthancPluginLoadDicomInstance params;
9623 params.target = &target;
9624 params.instanceId = instanceId;
9625 params.mode = mode;
9626
9627 if (context->InvokeService(context, _OrthancPluginService_LoadDicomInstance, &params) != OrthancPluginErrorCode_Success)
9628 {
9629 /* Error */
9630 return NULL;
9631 }
9632 else
9633 {
9634 return target;
9635 }
9636 }
9637
9638
9639 typedef struct
9640 {
9641 const char* name;
9642 int64_t value;
9644 } _OrthancPluginSetMetricsIntegerValue;
9645
9661 ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsIntegerValue(
9662 OrthancPluginContext* context,
9663 const char* name,
9664 int64_t value,
9666 {
9667 _OrthancPluginSetMetricsIntegerValue params;
9668 params.name = name;
9669 params.value = value;
9670 params.type = type;
9671 context->InvokeService(context, _OrthancPluginService_SetMetricsIntegerValue, &params);
9672 }
9673
9674
9689 OrthancPluginContext* context,
9690 const char* threadName)
9691 {
9692 return context->InvokeService(context, _OrthancPluginService_SetCurrentThreadName, threadName);
9693 }
9694
9695
9696 typedef struct
9697 {
9698 /* Note: This structure is also defined in Logging.h and it must be binary compatible */
9699 const char* message;
9700 const char* plugin;
9701 const char* file;
9702 uint32_t line;
9703 OrthancPluginLogCategory category;
9705 } _OrthancPluginLogMessage;
9706
9707
9721 ORTHANC_PLUGIN_INLINE void OrthancPluginLogMessage(
9722 OrthancPluginContext* context,
9723 const char* message,
9724 const char* plugin,
9725 const char* file,
9726 uint32_t line,
9727 OrthancPluginLogCategory category,
9729 {
9730 _OrthancPluginLogMessage m;
9731 m.message = message;
9732 m.plugin = plugin;
9733 m.file = file;
9734 m.line = line;
9735 m.category = category;
9736 m.level = level;
9737 context->InvokeService(context, _OrthancPluginService_LogMessage, &m);
9738 }
9739
9740
9741 typedef struct
9742 {
9744 const char* contentType;
9745 } _OrthancPluginStartStreamAnswer;
9746
9760 OrthancPluginContext* context,
9762 const char* contentType)
9763 {
9764 _OrthancPluginStartStreamAnswer params;
9765 params.output = output;
9766 params.contentType = contentType;
9767 return context->InvokeService(context, _OrthancPluginService_StartStreamAnswer, &params);
9768 }
9769
9770
9787 OrthancPluginContext* context,
9789 const void* answer,
9790 uint32_t answerSize)
9791 {
9792 _OrthancPluginAnswerBuffer params;
9793 params.output = output;
9794 params.answer = answer;
9795 params.answerSize = answerSize;
9796 params.mimeType = NULL;
9797 return context->InvokeService(context, _OrthancPluginService_SendStreamChunk, &params);
9798 }
9799
9800
9801 typedef struct
9802 {
9803 OrthancPluginMemoryBuffer* instanceId;
9804 OrthancPluginMemoryBuffer* attachmentUuid;
9805 OrthancPluginStoreStatus* storeStatus;
9806 const void* dicom;
9807 uint64_t dicomSize;
9808 const void* customData;
9809 uint32_t customDataSize;
9810 } _OrthancPluginAdoptDicomInstance;
9811
9851 OrthancPluginContext* context,
9852 OrthancPluginMemoryBuffer* instanceId, /* out */
9853 OrthancPluginMemoryBuffer* attachmentUuid, /* out */
9854 OrthancPluginStoreStatus* storeStatus, /* out */
9855 const void* dicom,
9856 uint64_t dicomSize,
9857 const void* customData,
9858 uint32_t customDataSize)
9859 {
9860 _OrthancPluginAdoptDicomInstance params;
9861 params.instanceId = instanceId;
9862 params.attachmentUuid = attachmentUuid;
9863 params.storeStatus = storeStatus;
9864 params.dicom = dicom;
9865 params.dicomSize = dicomSize;
9866 params.customData = customData;
9867 params.customDataSize = customDataSize;
9868
9869 return context->InvokeService(context, _OrthancPluginService_AdoptDicomInstance, &params);
9870 }
9871
9872
9873 typedef struct
9874 {
9875 OrthancPluginMemoryBuffer* customData;
9876 const char* attachmentUuid;
9877 } _OrthancPluginGetAttachmentCustomData;
9878
9892 OrthancPluginContext* context,
9893 OrthancPluginMemoryBuffer* customData, /* out */
9894 const char* attachmentUuid /* in */)
9895 {
9896 _OrthancPluginGetAttachmentCustomData params;
9897 params.customData = customData;
9898 params.attachmentUuid = attachmentUuid;
9899
9900 return context->InvokeService(context, _OrthancPluginService_GetAttachmentCustomData, &params);
9901 }
9902
9903
9904 typedef struct
9905 {
9906 const char* attachmentUuid;
9907 const void* customData;
9908 uint32_t customDataSize;
9909 } _OrthancPluginSetAttachmentCustomData;
9910
9924 OrthancPluginContext* context,
9925 const char* attachmentUuid, /* in */
9926 const void* customData, /* in */
9927 uint32_t customDataSize /* in */)
9928 {
9929 _OrthancPluginSetAttachmentCustomData params;
9930 params.attachmentUuid = attachmentUuid;
9931 params.customData = customData;
9932 params.customDataSize = customDataSize;
9933
9934 return context->InvokeService(context, _OrthancPluginService_SetAttachmentCustomData, &params);
9935 }
9936
9937
9938 typedef struct
9939 {
9940 const char* storeId;
9941 const char* key;
9942 const void* value;
9943 uint32_t valueSize;
9944 } _OrthancPluginStoreKeyValue;
9945
9957 OrthancPluginContext* context,
9958 const char* storeId, /* in */
9959 const char* key, /* in */
9960 const void* value, /* in */
9961 uint32_t valueSize /* in */)
9962 {
9963 _OrthancPluginStoreKeyValue params;
9964 params.storeId = storeId;
9965 params.key = key;
9966 params.value = value;
9967 params.valueSize = valueSize;
9968
9969 return context->InvokeService(context, _OrthancPluginService_StoreKeyValue, &params);
9970 }
9971
9972 typedef struct
9973 {
9974 const char* storeId;
9975 const char* key;
9976 } _OrthancPluginDeleteKeyValue;
9977
9987 OrthancPluginContext* context,
9988 const char* storeId, /* in */
9989 const char* key /* in */)
9990 {
9991 _OrthancPluginDeleteKeyValue params;
9992 params.storeId = storeId;
9993 params.key = key;
9994
9995 return context->InvokeService(context, _OrthancPluginService_DeleteKeyValue, &params);
9996 }
9997
9998 typedef struct
9999 {
10000 uint8_t* found;
10002 const char* storeId;
10003 const char* key;
10004 } _OrthancPluginGetKeyValue;
10005
10018 OrthancPluginContext* context,
10019 uint8_t* found, /* out */
10020 OrthancPluginMemoryBuffer* target, /* out */
10021 const char* storeId, /* in */
10022 const char* key /* in */)
10023 {
10024 _OrthancPluginGetKeyValue params;
10025 params.found = found;
10026 params.target = target;
10027 params.storeId = storeId;
10028 params.key = key;
10029
10030 return context->InvokeService(context, _OrthancPluginService_GetKeyValue, &params);
10031 }
10032
10033
10039 typedef struct _OrthancPluginKeysValuesIterator_t OrthancPluginKeysValuesIterator;
10040
10041
10042
10043 typedef struct
10044 {
10046 const char* storeId;
10047 } _OrthancPluginCreateKeysValuesIterator;
10048
10049
10061 OrthancPluginContext* context,
10062 const char* storeId)
10063 {
10064 OrthancPluginKeysValuesIterator* target = NULL;
10065
10066 _OrthancPluginCreateKeysValuesIterator params;
10067 params.target = &target;
10068 params.storeId = storeId;
10069
10070 if (context->InvokeService(context, _OrthancPluginService_CreateKeysValuesIterator, &params) != OrthancPluginErrorCode_Success)
10071 {
10072 return NULL;
10073 }
10074 else
10075 {
10076 return target;
10077 }
10078 }
10079
10080
10081 typedef struct
10082 {
10084 } _OrthancPluginFreeKeysValuesIterator;
10085
10092 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeKeysValuesIterator(
10093 OrthancPluginContext* context,
10095 {
10096 _OrthancPluginFreeKeysValuesIterator params;
10097 params.iterator = iterator;
10098
10099 context->InvokeService(context, _OrthancPluginService_FreeKeysValuesIterator, &params);
10100 }
10101
10102
10103 typedef struct
10104 {
10105 uint8_t* done;
10107 } _OrthancPluginKeysValuesIteratorNext;
10108
10120 OrthancPluginContext* context,
10121 uint8_t* done, /* out */
10122 OrthancPluginKeysValuesIterator* iterator /* in */)
10123 {
10124 _OrthancPluginKeysValuesIteratorNext params;
10125 params.done = done;
10126 params.iterator = iterator;
10127
10128 return context->InvokeService(context, _OrthancPluginService_KeysValuesIteratorNext, &params);
10129 }
10130
10131
10132 typedef struct
10133 {
10134 const char** target;
10136 } _OrthancPluginKeysValuesIteratorGetKey;
10137
10148 ORTHANC_PLUGIN_INLINE const char* OrthancPluginKeysValuesIteratorGetKey(
10149 OrthancPluginContext* context,
10151 {
10152 const char* target = NULL;
10153
10154 _OrthancPluginKeysValuesIteratorGetKey params;
10155 params.target = &target;
10156 params.iterator = iterator;
10157
10158 if (context->InvokeService(context, _OrthancPluginService_KeysValuesIteratorGetKey, &params) == OrthancPluginErrorCode_Success)
10159 {
10160 return target;
10161 }
10162 else
10163 {
10164 return NULL;
10165 }
10166 }
10167
10168
10169 typedef struct
10170 {
10173 } _OrthancPluginKeysValuesIteratorGetValue;
10174
10188 OrthancPluginContext* context,
10189 OrthancPluginMemoryBuffer* target /* out */,
10190 OrthancPluginKeysValuesIterator* iterator /* in */)
10191 {
10192 _OrthancPluginKeysValuesIteratorGetValue params;
10193 params.target = target;
10194 params.iterator = iterator;
10195
10196 return context->InvokeService(context, _OrthancPluginService_KeysValuesIteratorGetValue, &params);
10197 }
10198
10199
10200
10201 typedef struct
10202 {
10203 const char* queueId;
10204 const void* value;
10205 uint32_t valueSize;
10206 } _OrthancPluginEnqueueValue;
10207
10218 OrthancPluginContext* context,
10219 const char* queueId, /* in */
10220 const void* value, /* in */
10221 uint32_t valueSize /* in */)
10222 {
10223 _OrthancPluginEnqueueValue params;
10224 params.queueId = queueId;
10225 params.value = value;
10226 params.valueSize = valueSize;
10227
10228 return context->InvokeService(context, _OrthancPluginService_EnqueueValue, &params);
10229 }
10230
10231 typedef struct
10232 {
10233 uint8_t* found;
10235 const char* queueId;
10237 } _OrthancPluginDequeueValue;
10238
10251 OrthancPluginContext* context,
10252 uint8_t* found, /* out */
10253 OrthancPluginMemoryBuffer* target, /* out */
10254 const char* queueId, /* in */
10255 OrthancPluginQueueOrigin origin /* in */)
10256 {
10257 _OrthancPluginDequeueValue params;
10258 params.found = found;
10259 params.target = target;
10260 params.queueId = queueId;
10261 params.origin = origin;
10262
10263 return context->InvokeService(context, _OrthancPluginService_DequeueValue, &params);
10264 }
10265
10266 typedef struct
10267 {
10268 const char* queueId;
10269 uint64_t* size;
10270 } _OrthancPluginGetQueueSize;
10271
10281 OrthancPluginContext* context,
10282 const char* queueId, /* in */
10283 uint64_t* size /* out */)
10284 {
10285 _OrthancPluginGetQueueSize params;
10286 params.queueId = queueId;
10287 params.size = size;
10288
10289 return context->InvokeService(context, _OrthancPluginService_GetQueueSize, &params);
10290 }
10291
10292#ifdef __cplusplus
10293}
10294#endif
10295
10296
10298
OrthancPluginErrorCode OrthancPluginRegisterDatabaseBackendV4(OrthancPluginContext *context, void *backend, uint32_t maxDatabaseRetries, OrthancPluginCallDatabaseBackendV4 operations, OrthancPluginFinalizeDatabaseBackendV4 finalize)
Register a custom database back-end.
Definition OrthancCPlugin.h:9578
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:9540
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:8346
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:9222
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition OrthancCPlugin.h:3454
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition OrthancCPlugin.h:2419
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:1374
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition OrthancCPlugin.h:5772
OrthancPluginChangeType
Definition OrthancCPlugin.h:773
OrthancPluginErrorCode(* OrthancPluginStorageReadWhole)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type)
Callback for reading a whole file from the storage area.
Definition OrthancCPlugin.h:1439
OrthancPluginErrorCode OrthancPluginRegisterIncomingCStoreInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingCStoreInstanceFilter callback)
Register a callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition OrthancCPlugin.h:8301
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:1352
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition OrthancCPlugin.h:7432
OrthancPluginErrorCode(* OrthancPluginWebDavCreateFolderCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback to create a folder.
Definition OrthancCPlugin.h:9387
OrthancPluginErrorCode(* OrthancPluginStorageReadRange2)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type, uint64_t rangeStart, const void *customData, uint32_t customDataSize)
Callback for reading a range of a file from the storage area.
Definition OrthancCPlugin.h:1533
struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection
Opaque structure that represents a WebDAV collection.
Definition OrthancCPlugin.h:9203
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:1990
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:9342
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition OrthancCPlugin.h:8217
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition OrthancCPlugin.h:5130
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:8866
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition OrthancCPlugin.h:6675
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:9270
void OrthancPluginRegisterStorageArea3(OrthancPluginContext *context, OrthancPluginStorageCreate2 create, OrthancPluginStorageReadRange2 readRange, OrthancPluginStorageRemove2 remove)
Register a custom storage area, with support for custom data.
Definition OrthancCPlugin.h:9521
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition OrthancCPlugin.h:1419
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition OrthancCPlugin.h:2341
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition OrthancCPlugin.h:3928
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:8378
int32_t OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition OrthancCPlugin.h:2222
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:9316
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition OrthancCPlugin.h:1943
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition OrthancCPlugin.h:1223
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition OrthancCPlugin.h:3597
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:9050
OrthancPluginErrorCode(* OrthancPluginWebDavAddFolder)(OrthancPluginWebDavCollection *collection, const char *name, const char *dateTime)
Declare a subfolder while returning the content of a folder.
Definition OrthancCPlugin.h:9243
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:9446
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:1646
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition OrthancCPlugin.h:1320
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition OrthancCPlugin.h:1962
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition OrthancCPlugin.h:8893
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:1331
OrthancPluginErrorCode(* OrthancPluginStorageCreate2)(OrthancPluginMemoryBuffer *customData, const char *uuid, const void *content, uint64_t size, OrthancPluginContentType type, OrthancPluginCompressionType compressionType, const OrthancPluginDicomInstance *dicomInstance)
Callback for writing to the storage area.
Definition OrthancCPlugin.h:1504
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:9365
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:9407
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition OrthancCPlugin.h:5322
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition OrthancCPlugin.h:1480
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition OrthancCPlugin.h:1393
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:2028
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:1341
void(* OrthancPluginFinalizeDatabaseBackendV4)(void *backend)
Signature of a callback function that is triggered when the database plugin must be finalized.
Definition OrthancCPlugin.h:9551
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition OrthancCPlugin.h:7880
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:9291
struct _OrthancPluginKeysValuesIterator_t OrthancPluginKeysValuesIterator
Opaque structure that represents an iterator over the keys and values of a key-value store.
Definition OrthancCPlugin.h:10039
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:1607
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition OrthancCPlugin.h:7287
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition OrthancCPlugin.h:1364
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition OrthancCPlugin.h:2381
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition OrthancCPlugin.h:5089
OrthancPluginErrorCode(* OrthancPluginStorageRemove2)(const char *uuid, OrthancPluginContentType type, const void *customData, uint32_t customDataSize)
Callback for removing a file from the storage area.
Definition OrthancCPlugin.h:1556
int32_t OrthancPluginCheckVersionAdvanced(OrthancPluginContext *context, int32_t expectedMajor, int32_t expectedMinor, int32_t expectedRevision)
Check that the version of the hosting Orthanc is above a given version.
Definition OrthancCPlugin.h:2109
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:1462
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:8001
int32_t(* OrthancPluginIncomingCStoreInstanceFilter)(uint16_t *dimseStatus, const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition OrthancCPlugin.h:8279
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition OrthancCPlugin.h:8238
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition OrthancCPlugin.h:6108
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:5043
@ OrthancPluginChangeType_OrthancStopped
Definition OrthancCPlugin.h:785
@ OrthancPluginChangeType_OrthancStarted
Definition OrthancCPlugin.h:784
@ OrthancPluginChangeType_Deleted
Definition OrthancCPlugin.h:775
@ OrthancPluginChangeType_JobFailure
Definition OrthancCPlugin.h:792
@ OrthancPluginChangeType_NewInstance
Definition OrthancCPlugin.h:777
@ OrthancPluginChangeType_NewPatient
Definition OrthancCPlugin.h:778
@ OrthancPluginChangeType_JobSubmitted
Definition OrthancCPlugin.h:790
@ OrthancPluginChangeType_NewSeries
Definition OrthancCPlugin.h:779
@ OrthancPluginChangeType_StablePatient
Definition OrthancCPlugin.h:781
@ OrthancPluginChangeType_UpdatedPeers
Definition OrthancCPlugin.h:788
@ OrthancPluginChangeType_StableStudy
Definition OrthancCPlugin.h:783
@ OrthancPluginChangeType_CompletedSeries
Definition OrthancCPlugin.h:774
@ OrthancPluginChangeType_NewChildInstance
Definition OrthancCPlugin.h:776
@ OrthancPluginChangeType_UpdatedAttachment
Definition OrthancCPlugin.h:786
@ OrthancPluginChangeType_UpdatedMetadata
Definition OrthancCPlugin.h:787
@ OrthancPluginChangeType_StableSeries
Definition OrthancCPlugin.h:782
@ OrthancPluginChangeType_UpdatedModalities
Definition OrthancCPlugin.h:789
@ OrthancPluginChangeType_JobSuccess
Definition OrthancCPlugin.h:791
@ OrthancPluginChangeType_NewStudy
Definition OrthancCPlugin.h:780
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition OrthancCPlugin.h:6369
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition OrthancCPlugin.h:1271
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition OrthancCPlugin.h:1756
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition OrthancCPlugin.h:6345
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition OrthancCPlugin.h:8129
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:1576
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition OrthancCPlugin.h:6523
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:6475
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:8107
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition OrthancCPlugin.h:6277
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition OrthancCPlugin.h:5654
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:8150
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition OrthancCPlugin.h:5615
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition OrthancCPlugin.h:6316
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:8177
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition OrthancCPlugin.h:1279
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition OrthancCPlugin.h:1263
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition OrthancCPlugin.h:1673
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition OrthancCPlugin.h:1741
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition OrthancCPlugin.h:5511
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:6437
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition OrthancCPlugin.h:5577
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:6406
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition OrthancCPlugin.h:1770
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition OrthancCPlugin.h:1255
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:1716
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:5547
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition OrthancCPlugin.h:8436
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition OrthancCPlugin.h:8821
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition OrthancCPlugin.h:1231
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:8601
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition OrthancCPlugin.h:3185
OrthancPluginDicomInstance * OrthancPluginLoadDicomInstance(OrthancPluginContext *context, const char *instanceId, OrthancPluginLoadDicomInstanceMode mode)
Load a DICOM instance from the Orthanc server.
Definition OrthancCPlugin.h:9615
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition OrthancCPlugin.h:3287
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition OrthancCPlugin.h:8668
int32_t OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition OrthancCPlugin.h:3364
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition OrthancCPlugin.h:8486
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition OrthancCPlugin.h:8561
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition OrthancCPlugin.h:5680
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition OrthancCPlugin.h:3218
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition OrthancCPlugin.h:8781
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition OrthancCPlugin.h:8401
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition OrthancCPlugin.h:8524
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition OrthancCPlugin.h:8706
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:3405
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition OrthancCPlugin.h:3325
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition OrthancCPlugin.h:3251
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition OrthancCPlugin.h:8629
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:8738
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition OrthancCPlugin.h:4827
OrthancPluginPixelFormat
Definition OrthancCPlugin.h:648
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:4987
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:4571
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition OrthancCPlugin.h:4362
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition OrthancCPlugin.h:4261
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition OrthancCPlugin.h:5810
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition OrthancCPlugin.h:4862
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition OrthancCPlugin.h:4327
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition OrthancCPlugin.h:4396
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition OrthancCPlugin.h:4481
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:4526
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition OrthancCPlugin.h:5899
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition OrthancCPlugin.h:4439
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition OrthancCPlugin.h:4902
OrthancPluginImageFormat
Definition OrthancCPlugin.h:819
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition OrthancCPlugin.h:1247
OrthancPluginCompressionType
Definition OrthancCPlugin.h:803
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition OrthancCPlugin.h:4294
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:4073
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition OrthancCPlugin.h:4934
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:5853
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition OrthancCPlugin.h:1239
@ OrthancPluginPixelFormat_RGBA32
Color image in RGBA32 format.
Definition OrthancCPlugin.h:687
@ OrthancPluginPixelFormat_RGB48
Color image in RGB48 format.
Definition OrthancCPlugin.h:697
@ OrthancPluginPixelFormat_Grayscale8
Graylevel 8bpp image.
Definition OrthancCPlugin.h:655
@ OrthancPluginPixelFormat_SignedGrayscale16
Graylevel, signed 16bpp image.
Definition OrthancCPlugin.h:671
@ OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition OrthancCPlugin.h:713
@ OrthancPluginPixelFormat_RGB24
Color image in RGB24 format.
Definition OrthancCPlugin.h:679
@ OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition OrthancCPlugin.h:721
@ OrthancPluginPixelFormat_Unknown
Definition OrthancCPlugin.h:689
@ OrthancPluginPixelFormat_Grayscale64
Graylevel, unsigned 64bpp image.
Definition OrthancCPlugin.h:729
@ OrthancPluginPixelFormat_Grayscale32
Graylevel, unsigned 32bpp image.
Definition OrthancCPlugin.h:705
@ OrthancPluginPixelFormat_Grayscale16
Graylevel, unsigned 16bpp image.
Definition OrthancCPlugin.h:663
@ OrthancPluginImageFormat_Png
Definition OrthancCPlugin.h:820
@ OrthancPluginImageFormat_Jpeg
Definition OrthancCPlugin.h:821
@ OrthancPluginImageFormat_Dicom
Definition OrthancCPlugin.h:822
@ OrthancPluginCompressionType_Gzip
Definition OrthancCPlugin.h:806
@ OrthancPluginCompressionType_ZlibWithSize
Definition OrthancCPlugin.h:805
@ OrthancPluginCompressionType_None
Definition OrthancCPlugin.h:808
@ OrthancPluginCompressionType_Zlib
Definition OrthancCPlugin.h:804
@ OrthancPluginCompressionType_GzipWithSize
Definition OrthancCPlugin.h:807
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:2649
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:2684
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:2797
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition OrthancCPlugin.h:2933
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition OrthancCPlugin.h:2968
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition OrthancCPlugin.h:3831
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:2761
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition OrthancCPlugin.h:3792
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition OrthancCPlugin.h:2898
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition OrthancCPlugin.h:2582
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition OrthancCPlugin.h:3003
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:2612
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition OrthancCPlugin.h:2863
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition OrthancCPlugin.h:2713
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition OrthancCPlugin.h:2736
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:9165
char * OrthancPluginGenerateRestApiAuthorizationToken(OrthancPluginContext *context)
Generate a token to grant full access to the REST API of Orthanc.
Definition OrthancCPlugin.h:8966
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:5473
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition OrthancCPlugin.h:2549
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:2508
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition OrthancCPlugin.h:3071
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition OrthancCPlugin.h:7323
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition OrthancCPlugin.h:3094
OrthancPluginErrorCode OrthancPluginSendStreamChunk(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize)
Send a chunk as a part of an HTTP stream answer.
Definition OrthancCPlugin.h:9786
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition OrthancCPlugin.h:2451
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition OrthancCPlugin.h:3048
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition OrthancCPlugin.h:3149
OrthancPluginErrorCode OrthancPluginStartStreamAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *contentType)
Start an HTTP stream answer.
Definition OrthancCPlugin.h:9759
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition OrthancCPlugin.h:3124
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition OrthancCPlugin.h:2831
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:4618
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:4031
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:6070
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:4225
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition OrthancCPlugin.h:4002
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition OrthancCPlugin.h:1910
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderExecute)(OrthancPluginServerChunkedRequestReader *reader, OrthancPluginRestOutput *output)
Callback invoked whenever the request body is entirely received.
Definition OrthancCPlugin.h:7938
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:6183
struct _OrthancPluginJob_t OrthancPluginJob
Opaque structure to a job to be executed by Orthanc.
Definition OrthancCPlugin.h:1303
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:9097
void OrthancPluginLogMessage(OrthancPluginContext *context, const char *message, const char *plugin, const char *file, uint32_t line, OrthancPluginLogCategory category, OrthancPluginLogLevel level)
Log a message.
Definition OrthancCPlugin.h:9721
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition OrthancCPlugin.h:2305
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderFactory)(OrthancPluginServerChunkedRequestReader **reader, const char *url, const OrthancPluginHttpRequest *request)
Callback to create a reader to handle incoming chunked HTTP transfers.
Definition OrthancCPlugin.h:7899
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition OrthancCPlugin.h:6600
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition OrthancCPlugin.h:6737
OrthancPluginLogLevel
Definition OrthancCPlugin.h:1117
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:5278
OrthancPluginIdentifierConstraint
Definition OrthancCPlugin.h:923
void OrthancPluginExtendOrthancExplorer2(OrthancPluginContext *context, const char *plugin, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition OrthancCPlugin.h:3757
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:5225
OrthancPluginResourceType
Definition OrthancCPlugin.h:755
void OrthancPluginSetRootUri2(OrthancPluginContext *context, const char *plugin, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition OrthancCPlugin.h:3657
void OrthancPluginSetMetricsIntegerValue(OrthancPluginContext *context, const char *name, int64_t value, OrthancPluginMetricsType type)
Set the value of an integer metrics.
Definition OrthancCPlugin.h:9661
OrthancPluginLogCategory
Definition OrthancCPlugin.h:1134
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition OrthancCPlugin.h:4141
const char * OrthancPluginKeysValuesIteratorGetKey(OrthancPluginContext *context, OrthancPluginKeysValuesIterator *iterator)
Get the current key of an iterator over a key-value store.
Definition OrthancCPlugin.h:10148
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition OrthancCPlugin.h:3862
OrthancPluginErrorCode OrthancPluginKeysValuesIteratorNext(OrthancPluginContext *context, uint8_t *done, OrthancPluginKeysValuesIterator *iterator)
Read the next element of an iterator over a key-value store.
Definition OrthancCPlugin.h:10119
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition OrthancCPlugin.h:5945
OrthancPluginErrorCode
Definition OrthancCPlugin.h:216
struct _OrthancPluginPeers_t OrthancPluginPeers
Opaque structure to the set of remote Orthanc Peers that are known to the local Orthanc server.
Definition OrthancCPlugin.h:1295
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:4709
uint32_t(* OrthancPluginChunkedClientRequestGetChunkSize)(void *request)
Callback to read the size of the current request chunk during a chunked transfer.
Definition OrthancCPlugin.h:7740
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition OrthancCPlugin.h:5169
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, uint32_t size)
Create a 32-bit memory buffer.
Definition OrthancCPlugin.h:8928
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:7155
OrthancPluginDicomWebBinaryMode
Definition OrthancCPlugin.h:1012
OrthancPluginErrorCode(* OrthancPluginJobGetContent2)(OrthancPluginMemoryBuffer *target, void *job)
Callback to retrieve the content of one custom job.
Definition OrthancCPlugin.h:1830
OrthancPluginErrorCode(* OrthancPluginChunkedClientRequestNext)(void *request)
Callback to advance in the request body during a chunked transfer.
Definition OrthancCPlugin.h:7708
struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode
Opaque structure that represents a node in a JSON or XML document used in DICOMweb.
Definition OrthancCPlugin.h:1312
OrthancPluginErrorCode OrthancPluginGetKeyValue(OrthancPluginContext *context, uint8_t *found, OrthancPluginMemoryBuffer *target, const char *storeId, const char *key)
Get the value associated with a key in the Orthanc key-value store.
Definition OrthancCPlugin.h:10017
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition OrthancCPlugin.h:1796
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition OrthancCPlugin.h:7468
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition OrthancCPlugin.h:6562
OrthancPluginDicomToJsonFlags
Definition OrthancCPlugin.h:887
OrthancPluginJobStepStatus
Definition OrthancCPlugin.h:969
OrthancPluginCreateDicomFlags
Definition OrthancCPlugin.h:908
void(* OrthancPluginServerChunkedRequestReaderFinalize)(OrthancPluginServerChunkedRequestReader *reader)
Callback invoked to release the resources associated with an incoming HTTP chunked transfer.
Definition OrthancCPlugin.h:7956
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:6633
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition OrthancCPlugin.h:3734
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition OrthancCPlugin.h:2289
OrthancPluginQueueOrigin
Definition OrthancCPlugin.h:1165
OrthancPluginErrorCode OrthancPluginDequeueValue(OrthancPluginContext *context, uint8_t *found, OrthancPluginMemoryBuffer *target, const char *queueId, OrthancPluginQueueOrigin origin)
Dequeue a value from a queue.
Definition OrthancCPlugin.h:10250
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition OrthancCPlugin.h:6815
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition OrthancCPlugin.h:6703
OrthancPluginConstraintType
Definition OrthancCPlugin.h:938
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition OrthancCPlugin.h:3516
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition OrthancCPlugin.h:4110
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition OrthancCPlugin.h:1886
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition OrthancCPlugin.h:5981
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition OrthancCPlugin.h:3896
void OrthancPluginSetMetricsValue(OrthancPluginContext *context, const char *name, float value, OrthancPluginMetricsType type)
Set the value of a floating-point metrics.
Definition OrthancCPlugin.h:7401
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:7918
OrthancPluginReceivedInstanceAction
Definition OrthancCPlugin.h:1073
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:7819
int32_t(* OrthancPluginJobGetSerialized2)(OrthancPluginMemoryBuffer *target, void *job)
Callback to serialize one custom job.
Definition OrthancCPlugin.h:1870
void OrthancPluginFreeMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *buffer)
Free a memory buffer.
Definition OrthancCPlugin.h:2257
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:4751
OrthancPluginErrorCode OrthancPluginStoreKeyValue(OrthancPluginContext *context, const char *storeId, const char *key, const void *value, uint32_t valueSize)
Store a key-value pair in the Orthanc database.
Definition OrthancCPlugin.h:9956
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:5366
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:5736
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:5415
void OrthancPluginFreeKeysValuesIterator(OrthancPluginContext *context, OrthancPluginKeysValuesIterator *iterator)
Free an iterator over a key-value store.
Definition OrthancCPlugin.h:10092
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition OrthancCPlugin.h:7210
const char * OrthancPluginGetDatabaseServerIdentifier(OrthancPluginContext *context)
Gets the DatabaseServerIdentifier.
Definition OrthancCPlugin.h:9479
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition OrthancCPlugin.h:6238
OrthancPluginStorageCommitmentFailureReason
Definition OrthancCPlugin.h:1025
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:7671
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:6902
OrthancPluginMetricsType
Definition OrthancCPlugin.h:995
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition OrthancCPlugin.h:7355
OrthancPluginErrorCode OrthancPluginSetAttachmentCustomData(OrthancPluginContext *context, const char *attachmentUuid, const void *customData, uint32_t customDataSize)
Update the custom data associated with an attachment in the Orthanc database.
Definition OrthancCPlugin.h:9923
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition OrthancCPlugin.h:4789
uint8_t(* OrthancPluginChunkedClientRequestIsDone)(void *request)
Callback to know whether the request body is entirely read during a chunked transfer.
Definition OrthancCPlugin.h:7691
const void *(* OrthancPluginChunkedClientRequestGetChunkData)(void *request)
Callback to read the current chunk of the request body during a chunked transfer.
Definition OrthancCPlugin.h:7724
OrthancPluginErrorCode OrthancPluginAdoptDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *instanceId, OrthancPluginMemoryBuffer *attachmentUuid, OrthancPluginStoreStatus *storeStatus, const void *dicom, uint64_t dicomSize, const void *customData, uint32_t customDataSize)
Adopt a DICOM instance read from the filesystem.
Definition OrthancCPlugin.h:9850
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:7069
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition OrthancCPlugin.h:2241
OrthancPluginErrorCode OrthancPluginEnqueueValue(OrthancPluginContext *context, const char *queueId, const void *value, uint32_t valueSize)
Append a value to the back of a queue.
Definition OrthancCPlugin.h:10217
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition OrthancCPlugin.h:7510
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition OrthancCPlugin.h:1850
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition OrthancCPlugin.h:3961
OrthancPluginKeysValuesIterator * OrthancPluginCreateKeysValuesIterator(OrthancPluginContext *context, const char *storeId)
Create an iterator over the key-value pairs of a key-value store in the Orthanc database.
Definition OrthancCPlugin.h:10060
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *target, uint64_t size)
Create a 64-bit memory buffer.
Definition OrthancCPlugin.h:9012
OrthancPluginLoadDicomInstanceMode
Definition OrthancCPlugin.h:1087
OrthancPluginStoreStatus
Definition OrthancCPlugin.h:1151
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:7650
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition OrthancCPlugin.h:6767
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition OrthancCPlugin.h:1812
OrthancPluginValueRepresentation
Definition OrthancCPlugin.h:833
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int32_t priority)
Submit a new job to the jobs engine of Orthanc.
Definition OrthancCPlugin.h:7242
OrthancPluginErrorCode OrthancPluginKeysValuesIteratorGetValue(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginKeysValuesIterator *iterator)
Get the current value of an iterator over a key-value store.
Definition OrthancCPlugin.h:10187
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition OrthancCPlugin.h:4671
OrthancPluginJobStopReason
Definition OrthancCPlugin.h:983
OrthancPluginErrorCode OrthancPluginDeleteKeyValue(OrthancPluginContext *context, const char *storeId, const char *key)
Delete a key-value pair from the Orthanc database.
Definition OrthancCPlugin.h:9986
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition OrthancCPlugin.h:3486
OrthancPluginDicomToJsonFormat
Definition OrthancCPlugin.h:872
void OrthancPluginSetDescription2(OrthancPluginContext *context, const char *plugin, const char *description)
Set a description for this plugin.
Definition OrthancCPlugin.h:3707
OrthancPluginErrorCode OrthancPluginGetAttachmentCustomData(OrthancPluginContext *context, OrthancPluginMemoryBuffer *customData, const char *attachmentUuid)
Retrieve the custom data associated with an attachment in the Orthanc database.
Definition OrthancCPlugin.h:9891
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition OrthancCPlugin.h:2273
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition OrthancCPlugin.h:3551
OrthancPluginHttpMethod
Definition OrthancCPlugin.h:345
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition OrthancCPlugin.h:3632
char * OrthancPluginEncodeDicomWebXml2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition OrthancCPlugin.h:7606
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:6983
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:1287
char * OrthancPluginEncodeDicomWebJson2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition OrthancCPlugin.h:7562
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition OrthancCPlugin.h:6027
OrthancPluginErrorCode OrthancPluginGetQueueSize(OrthancPluginContext *context, const char *queueId, uint64_t *size)
Get the number of elements in a queue.
Definition OrthancCPlugin.h:10280
OrthancPluginInstanceOrigin
Definition OrthancCPlugin.h:953
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition OrthancCPlugin.h:1783
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition OrthancCPlugin.h:2079
OrthancPluginErrorCode OrthancPluginSetCurrentThreadName(OrthancPluginContext *context, const char *threadName)
Set the name of the current thread.
Definition OrthancCPlugin.h:9688
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition OrthancCPlugin.h:1927
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition OrthancCPlugin.h:4172
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginContentType
Definition OrthancCPlugin.h:740
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition OrthancCPlugin.h:6856
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition OrthancCPlugin.h:3684
char * OrthancPluginGetTagName(OrthancPluginContext *context, uint16_t group, uint16_t element, const char *privateCreator)
Returns the symbolic name of a DICOM tag.
Definition OrthancCPlugin.h:8052
@ OrthancPluginLogLevel_Warning
Definition OrthancCPlugin.h:1119
@ OrthancPluginLogLevel_Trace
Definition OrthancCPlugin.h:1121
@ OrthancPluginLogLevel_Error
Definition OrthancCPlugin.h:1118
@ OrthancPluginLogLevel_Info
Definition OrthancCPlugin.h:1120
@ OrthancPluginIdentifierConstraint_Wildcard
Definition OrthancCPlugin.h:927
@ OrthancPluginIdentifierConstraint_Equal
Definition OrthancCPlugin.h:924
@ OrthancPluginIdentifierConstraint_SmallerOrEqual
Definition OrthancCPlugin.h:925
@ OrthancPluginIdentifierConstraint_GreaterOrEqual
Definition OrthancCPlugin.h:926
@ OrthancPluginResourceType_Instance
Definition OrthancCPlugin.h:759
@ OrthancPluginResourceType_None
Definition OrthancCPlugin.h:760
@ OrthancPluginResourceType_Series
Definition OrthancCPlugin.h:758
@ OrthancPluginResourceType_Study
Definition OrthancCPlugin.h:757
@ OrthancPluginResourceType_Patient
Definition OrthancCPlugin.h:756
@ OrthancPluginLogCategory_Dicom
Definition OrthancCPlugin.h:1139
@ OrthancPluginLogCategory_Jobs
Definition OrthancCPlugin.h:1140
@ OrthancPluginLogCategory_Sqlite
Definition OrthancCPlugin.h:1138
@ OrthancPluginLogCategory_Plugins
Definition OrthancCPlugin.h:1136
@ OrthancPluginLogCategory_Generic
Definition OrthancCPlugin.h:1135
@ OrthancPluginLogCategory_Lua
Definition OrthancCPlugin.h:1141
@ OrthancPluginLogCategory_Http
Definition OrthancCPlugin.h:1137
@ OrthancPluginErrorCode_CreateDicomBadParent
Definition OrthancCPlugin.h:306
@ OrthancPluginErrorCode_MainDicomTagsMultiplyDefined
Definition OrthancCPlugin.h:262
@ OrthancPluginErrorCode_SQLiteFlush
Definition OrthancCPlugin.h:274
@ OrthancPluginErrorCode_IncompatibleDatabaseVersion
Definition OrthancCPlugin.h:236
@ OrthancPluginErrorCode_BadSequenceOfCalls
Definition OrthancCPlugin.h:224
@ OrthancPluginErrorCode_SharedLibrary
Definition OrthancCPlugin.h:243
@ OrthancPluginErrorCode_NullPointer
Definition OrthancCPlugin.h:253
@ OrthancPluginErrorCode_NotLuaPredicate
Definition OrthancCPlugin.h:316
@ OrthancPluginErrorCode_LuaAlreadyExecuted
Definition OrthancCPlugin.h:314
@ OrthancPluginErrorCode_NotAcceptable
Definition OrthancCPlugin.h:252
@ OrthancPluginErrorCode_FullStorage
Definition OrthancCPlugin.h:237
@ OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered
Definition OrthancCPlugin.h:319
@ OrthancPluginErrorCode_InexistentFile
Definition OrthancCPlugin.h:231
@ OrthancPluginErrorCode_CreateDicomParentEncoding
Definition OrthancCPlugin.h:308
@ OrthancPluginErrorCode_CannotOrderSlices
Definition OrthancCPlugin.h:322
@ OrthancPluginErrorCode_InternalError
Definition OrthancCPlugin.h:217
@ OrthancPluginErrorCode_DiscontinuedAbi
Definition OrthancCPlugin.h:258
@ OrthancPluginErrorCode_NoCFindHandler
Definition OrthancCPlugin.h:292
@ OrthancPluginErrorCode_SQLiteCommitWithoutTransaction
Definition OrthancCPlugin.h:272
@ OrthancPluginErrorCode_DatabasePlugin
Definition OrthancCPlugin.h:249
@ OrthancPluginErrorCode_SQLiteStatementAlreadyUsed
Definition OrthancCPlugin.h:269
@ OrthancPluginErrorCode_SQLiteCannotRun
Definition OrthancCPlugin.h:275
@ OrthancPluginErrorCode_UnknownPluginService
Definition OrthancCPlugin.h:244
@ OrthancPluginErrorCode_JsonToLuaTable
Definition OrthancCPlugin.h:311
@ OrthancPluginErrorCode_CreateDicomOverrideTag
Definition OrthancCPlugin.h:302
@ OrthancPluginErrorCode_SQLiteBindOutOfRange
Definition OrthancCPlugin.h:277
@ OrthancPluginErrorCode_ParameterOutOfRange
Definition OrthancCPlugin.h:221
@ OrthancPluginErrorCode_SQLiteRegisterFunction
Definition OrthancCPlugin.h:273
@ OrthancPluginErrorCode_SQLiteTransactionBegin
Definition OrthancCPlugin.h:281
@ OrthancPluginErrorCode_CreateDicomNoPayload
Definition OrthancCPlugin.h:304
@ OrthancPluginErrorCode_Unauthorized
Definition OrthancCPlugin.h:247
@ OrthancPluginErrorCode_RegularFileExpected
Definition OrthancCPlugin.h:288
@ OrthancPluginErrorCode_DicomPortInUse
Definition OrthancCPlugin.h:286
@ OrthancPluginErrorCode_BadApplicationEntityTitle
Definition OrthancCPlugin.h:291
@ OrthancPluginErrorCode_NoCStoreHandler
Definition OrthancCPlugin.h:294
@ OrthancPluginErrorCode_PathToExecutable
Definition OrthancCPlugin.h:289
@ OrthancPluginErrorCode_NoSopClassOrInstance
Definition OrthancCPlugin.h:296
@ OrthancPluginErrorCode_BadFont
Definition OrthancCPlugin.h:248
@ OrthancPluginErrorCode_DicomGetUnavailable
Definition OrthancCPlugin.h:327
@ OrthancPluginErrorCode_DatabaseUnavailable
Definition OrthancCPlugin.h:254
@ OrthancPluginErrorCode_CannotCreateLua
Definition OrthancCPlugin.h:312
@ OrthancPluginErrorCode_SQLiteExecute
Definition OrthancCPlugin.h:270
@ OrthancPluginErrorCode_UriSyntax
Definition OrthancCPlugin.h:230
@ OrthancPluginErrorCode_DirectoryOverFile
Definition OrthancCPlugin.h:282
@ OrthancPluginErrorCode_Revision
Definition OrthancCPlugin.h:261
@ OrthancPluginErrorCode_InexistentTag
Definition OrthancCPlugin.h:239
@ OrthancPluginErrorCode_IncompatibleImageFormat
Definition OrthancCPlugin.h:241
@ OrthancPluginErrorCode_UnsupportedMediaType
Definition OrthancCPlugin.h:328
@ OrthancPluginErrorCode_DicomFindUnavailable
Definition OrthancCPlugin.h:298
@ OrthancPluginErrorCode_SQLiteCannotStep
Definition OrthancCPlugin.h:276
@ OrthancPluginErrorCode_CreateDicomParentIsInstance
Definition OrthancCPlugin.h:307
@ OrthancPluginErrorCode_DuplicateResource
Definition OrthancCPlugin.h:264
@ OrthancPluginErrorCode_StorageAreaAlreadyRegistered
Definition OrthancCPlugin.h:318
@ OrthancPluginErrorCode_LuaReturnsNoString
Definition OrthancCPlugin.h:317
@ OrthancPluginErrorCode_UnknownResource
Definition OrthancCPlugin.h:235
@ OrthancPluginErrorCode_CreateDicomNotString
Definition OrthancCPlugin.h:301
@ OrthancPluginErrorCode_HttpPortInUse
Definition OrthancCPlugin.h:285
@ OrthancPluginErrorCode_SslDisabled
Definition OrthancCPlugin.h:321
@ OrthancPluginErrorCode_UnknownModality
Definition OrthancCPlugin.h:309
@ OrthancPluginErrorCode_BadHttpStatusInRest
Definition OrthancCPlugin.h:287
@ OrthancPluginErrorCode_BadGeometry
Definition OrthancCPlugin.h:256
@ OrthancPluginErrorCode_AlreadyExistingTag
Definition OrthancCPlugin.h:324
@ OrthancPluginErrorCode_FileStorageCannotWrite
Definition OrthancCPlugin.h:283
@ OrthancPluginErrorCode_CreateDicomUseDataUriScheme
Definition OrthancCPlugin.h:305
@ OrthancPluginErrorCode_DirectoryExpected
Definition OrthancCPlugin.h:284
@ OrthancPluginErrorCode_NoCMoveHandler
Definition OrthancCPlugin.h:293
@ OrthancPluginErrorCode_SQLitePrepareStatement
Definition OrthancCPlugin.h:278
@ OrthancPluginErrorCode_CorruptedFile
Definition OrthancCPlugin.h:238
@ OrthancPluginErrorCode_StorageAreaPlugin
Definition OrthancCPlugin.h:250
@ OrthancPluginErrorCode_BadJobOrdering
Definition OrthancCPlugin.h:310
@ OrthancPluginErrorCode_IncompatibleConfigurations
Definition OrthancCPlugin.h:265
@ OrthancPluginErrorCode_DatabaseCannotSerialize
Definition OrthancCPlugin.h:260
@ OrthancPluginErrorCode_CanceledJob
Definition OrthancCPlugin.h:255
@ OrthancPluginErrorCode_BadRange
Definition OrthancCPlugin.h:259
@ OrthancPluginErrorCode_NotImplemented
Definition OrthancCPlugin.h:220
@ OrthancPluginErrorCode_SslInitialization
Definition OrthancCPlugin.h:257
@ OrthancPluginErrorCode_IncompatibleImageSize
Definition OrthancCPlugin.h:242
@ OrthancPluginErrorCode_BadFileFormat
Definition OrthancCPlugin.h:233
@ OrthancPluginErrorCode_BadRequest
Definition OrthancCPlugin.h:226
@ OrthancPluginErrorCode_SystemCommand
Definition OrthancCPlugin.h:228
@ OrthancPluginErrorCode_NoStorageCommitmentHandler
Definition OrthancCPlugin.h:325
@ OrthancPluginErrorCode_SQLiteAlreadyOpened
Definition OrthancCPlugin.h:267
@ OrthancPluginErrorCode_Plugin
Definition OrthancCPlugin.h:219
@ OrthancPluginErrorCode_CannotExecuteLua
Definition OrthancCPlugin.h:313
@ OrthancPluginErrorCode_SQLiteRollbackWithoutTransaction
Definition OrthancCPlugin.h:271
@ OrthancPluginErrorCode_UnknownDicomTag
Definition OrthancCPlugin.h:245
@ OrthancPluginErrorCode_ForbiddenAccess
Definition OrthancCPlugin.h:263
@ OrthancPluginErrorCode_NoPresentationContext
Definition OrthancCPlugin.h:297
@ OrthancPluginErrorCode_EmptyRequest
Definition OrthancCPlugin.h:251
@ OrthancPluginErrorCode_DatabaseNotInitialized
Definition OrthancCPlugin.h:320
@ OrthancPluginErrorCode_DicomMoveUnavailable
Definition OrthancCPlugin.h:299
@ OrthancPluginErrorCode_SQLiteTransactionCommit
Definition OrthancCPlugin.h:280
@ OrthancPluginErrorCode_BadJson
Definition OrthancCPlugin.h:246
@ OrthancPluginErrorCode_Success
Definition OrthancCPlugin.h:218
@ OrthancPluginErrorCode_NetworkProtocol
Definition OrthancCPlugin.h:227
@ OrthancPluginErrorCode_NoApplicationEntityFilter
Definition OrthancCPlugin.h:295
@ OrthancPluginErrorCode_InexistentItem
Definition OrthancCPlugin.h:225
@ OrthancPluginErrorCode_Timeout
Definition OrthancCPlugin.h:234
@ OrthancPluginErrorCode_LuaBadOutput
Definition OrthancCPlugin.h:315
@ OrthancPluginErrorCode_SQLiteTransactionAlreadyStarted
Definition OrthancCPlugin.h:279
@ OrthancPluginErrorCode_NoCGetHandler
Definition OrthancCPlugin.h:326
@ OrthancPluginErrorCode_SQLiteNotOpened
Definition OrthancCPlugin.h:266
@ OrthancPluginErrorCode_ReadOnly
Definition OrthancCPlugin.h:240
@ OrthancPluginErrorCode_CannotStoreInstance
Definition OrthancCPlugin.h:300
@ OrthancPluginErrorCode_CannotWriteFile
Definition OrthancCPlugin.h:232
@ OrthancPluginErrorCode_BadParameterType
Definition OrthancCPlugin.h:223
@ OrthancPluginErrorCode_NotEnoughMemory
Definition OrthancCPlugin.h:222
@ OrthancPluginErrorCode_CreateDicomUseContent
Definition OrthancCPlugin.h:303
@ OrthancPluginErrorCode_Database
Definition OrthancCPlugin.h:229
@ OrthancPluginErrorCode_SQLiteCannotOpen
Definition OrthancCPlugin.h:268
@ OrthancPluginErrorCode_MakeDirectory
Definition OrthancCPlugin.h:290
@ OrthancPluginErrorCode_NoWorklistHandler
Definition OrthancCPlugin.h:323
@ OrthancPluginDicomWebBinaryMode_InlineBinary
Definition OrthancCPlugin.h:1014
@ OrthancPluginDicomWebBinaryMode_BulkDataUri
Definition OrthancCPlugin.h:1015
@ OrthancPluginDicomWebBinaryMode_Ignore
Definition OrthancCPlugin.h:1013
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii
Definition OrthancCPlugin.h:893
@ OrthancPluginDicomToJsonFlags_IncludeBinary
Definition OrthancCPlugin.h:889
@ OrthancPluginDicomToJsonFlags_IncludePixelData
Definition OrthancCPlugin.h:892
@ OrthancPluginDicomToJsonFlags_IncludeUnknownTags
Definition OrthancCPlugin.h:891
@ OrthancPluginDicomToJsonFlags_SkipGroupLengths
Definition OrthancCPlugin.h:896
@ OrthancPluginDicomToJsonFlags_None
Definition OrthancCPlugin.h:888
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
Definition OrthancCPlugin.h:894
@ OrthancPluginDicomToJsonFlags_StopAfterPixelData
Definition OrthancCPlugin.h:895
@ OrthancPluginDicomToJsonFlags_IncludePrivateTags
Definition OrthancCPlugin.h:890
@ OrthancPluginJobStepStatus_Continue
Definition OrthancCPlugin.h:972
@ OrthancPluginJobStepStatus_Success
Definition OrthancCPlugin.h:970
@ OrthancPluginJobStepStatus_Failure
Definition OrthancCPlugin.h:971
@ OrthancPluginCreateDicomFlags_DecodeDataUriScheme
Definition OrthancCPlugin.h:910
@ OrthancPluginCreateDicomFlags_None
Definition OrthancCPlugin.h:909
@ OrthancPluginCreateDicomFlags_GenerateIdentifiers
Definition OrthancCPlugin.h:911
@ OrthancPluginQueueOrigin_Front
Definition OrthancCPlugin.h:1166
@ OrthancPluginQueueOrigin_Back
Definition OrthancCPlugin.h:1167
@ OrthancPluginConstraintType_SmallerOrEqual
Definition OrthancCPlugin.h:940
@ OrthancPluginConstraintType_List
Definition OrthancCPlugin.h:943
@ OrthancPluginConstraintType_GreaterOrEqual
Definition OrthancCPlugin.h:941
@ OrthancPluginConstraintType_Equal
Definition OrthancCPlugin.h:939
@ OrthancPluginConstraintType_Wildcard
Definition OrthancCPlugin.h:942
@ OrthancPluginReceivedInstanceAction_KeepAsIs
Definition OrthancCPlugin.h:1074
@ OrthancPluginReceivedInstanceAction_Discard
Definition OrthancCPlugin.h:1076
@ OrthancPluginReceivedInstanceAction_Modify
Definition OrthancCPlugin.h:1075
@ OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
Definition OrthancCPlugin.h:1052
@ OrthancPluginStorageCommitmentFailureReason_Success
Definition OrthancCPlugin.h:1029
@ OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
Definition OrthancCPlugin.h:1065
@ OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
Definition OrthancCPlugin.h:1059
@ OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
Definition OrthancCPlugin.h:1046
@ OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
Definition OrthancCPlugin.h:1040
@ OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
Definition OrthancCPlugin.h:1034
@ OrthancPluginMetricsType_Default
Definition OrthancCPlugin.h:996
@ OrthancPluginMetricsType_Timer
Definition OrthancCPlugin.h:1003
@ OrthancPluginLoadDicomInstanceMode_UntilPixelData
Definition OrthancCPlugin.h:1097
@ OrthancPluginLoadDicomInstanceMode_WholeDicom
Definition OrthancCPlugin.h:1091
@ OrthancPluginLoadDicomInstanceMode_EmptyPixelData
Definition OrthancCPlugin.h:1104
@ OrthancPluginStoreStatus_Success
Definition OrthancCPlugin.h:1152
@ OrthancPluginStoreStatus_FilteredOut
Definition OrthancCPlugin.h:1155
@ OrthancPluginStoreStatus_StorageFull
Definition OrthancCPlugin.h:1156
@ OrthancPluginStoreStatus_Failure
Definition OrthancCPlugin.h:1154
@ OrthancPluginStoreStatus_AlreadyStored
Definition OrthancCPlugin.h:1153
@ OrthancPluginValueRepresentation_PN
Definition OrthancCPlugin.h:849
@ OrthancPluginValueRepresentation_UL
Definition OrthancCPlugin.h:857
@ OrthancPluginValueRepresentation_UN
Definition OrthancCPlugin.h:858
@ OrthancPluginValueRepresentation_DA
Definition OrthancCPlugin.h:838
@ OrthancPluginValueRepresentation_OF
Definition OrthancCPlugin.h:847
@ OrthancPluginValueRepresentation_OW
Definition OrthancCPlugin.h:848
@ OrthancPluginValueRepresentation_CS
Definition OrthancCPlugin.h:837
@ OrthancPluginValueRepresentation_US
Definition OrthancCPlugin.h:859
@ OrthancPluginValueRepresentation_SH
Definition OrthancCPlugin.h:850
@ OrthancPluginValueRepresentation_FL
Definition OrthancCPlugin.h:842
@ OrthancPluginValueRepresentation_DT
Definition OrthancCPlugin.h:840
@ OrthancPluginValueRepresentation_TM
Definition OrthancCPlugin.h:855
@ OrthancPluginValueRepresentation_SQ
Definition OrthancCPlugin.h:852
@ OrthancPluginValueRepresentation_DS
Definition OrthancCPlugin.h:839
@ OrthancPluginValueRepresentation_OB
Definition OrthancCPlugin.h:846
@ OrthancPluginValueRepresentation_SL
Definition OrthancCPlugin.h:851
@ OrthancPluginValueRepresentation_ST
Definition OrthancCPlugin.h:854
@ OrthancPluginValueRepresentation_IS
Definition OrthancCPlugin.h:843
@ OrthancPluginValueRepresentation_LT
Definition OrthancCPlugin.h:845
@ OrthancPluginValueRepresentation_SS
Definition OrthancCPlugin.h:853
@ OrthancPluginValueRepresentation_UT
Definition OrthancCPlugin.h:860
@ OrthancPluginValueRepresentation_LO
Definition OrthancCPlugin.h:844
@ OrthancPluginValueRepresentation_AE
Definition OrthancCPlugin.h:834
@ OrthancPluginValueRepresentation_FD
Definition OrthancCPlugin.h:841
@ OrthancPluginValueRepresentation_UI
Definition OrthancCPlugin.h:856
@ OrthancPluginValueRepresentation_AS
Definition OrthancCPlugin.h:835
@ OrthancPluginValueRepresentation_AT
Definition OrthancCPlugin.h:836
@ OrthancPluginJobStopReason_Failure
Definition OrthancCPlugin.h:986
@ OrthancPluginJobStopReason_Success
Definition OrthancCPlugin.h:984
@ OrthancPluginJobStopReason_Canceled
Definition OrthancCPlugin.h:987
@ OrthancPluginJobStopReason_Paused
Definition OrthancCPlugin.h:985
@ OrthancPluginDicomToJsonFormat_Full
Definition OrthancCPlugin.h:873
@ OrthancPluginDicomToJsonFormat_Human
Definition OrthancCPlugin.h:875
@ OrthancPluginDicomToJsonFormat_Short
Definition OrthancCPlugin.h:874
@ OrthancPluginHttpMethod_Delete
Definition OrthancCPlugin.h:349
@ OrthancPluginHttpMethod_Post
Definition OrthancCPlugin.h:347
@ OrthancPluginHttpMethod_Put
Definition OrthancCPlugin.h:348
@ OrthancPluginHttpMethod_Get
Definition OrthancCPlugin.h:346
@ OrthancPluginInstanceOrigin_Unknown
Definition OrthancCPlugin.h:954
@ OrthancPluginInstanceOrigin_RestApi
Definition OrthancCPlugin.h:956
@ OrthancPluginInstanceOrigin_Lua
Definition OrthancCPlugin.h:958
@ OrthancPluginInstanceOrigin_WebDav
Definition OrthancCPlugin.h:959
@ OrthancPluginInstanceOrigin_DicomProtocol
Definition OrthancCPlugin.h:955
@ OrthancPluginInstanceOrigin_Plugin
Definition OrthancCPlugin.h:957
@ OrthancPluginContentType_Dicom
Definition OrthancCPlugin.h:742
@ OrthancPluginContentType_DicomAsJson
Definition OrthancCPlugin.h:743
@ OrthancPluginContentType_Unknown
Definition OrthancCPlugin.h:741
@ OrthancPluginContentType_DicomUntilPixelData
Definition OrthancCPlugin.h:744
An entry in the dictionary of DICOM tags.
Definition OrthancCPlugin.h:2061
uint32_t minMultiplicity
Definition OrthancCPlugin.h:2065
uint32_t maxMultiplicity
Definition OrthancCPlugin.h:2066
OrthancPluginValueRepresentation vr
Definition OrthancCPlugin.h:2064
uint16_t element
Definition OrthancCPlugin.h:2063
uint16_t group
Definition OrthancCPlugin.h:2062
The parameters of a REST request.
Definition OrthancCPlugin.h:360
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition OrthancCPlugin.h:389
const char *const * groups
The matched values for the groups of the regular expression.
Definition OrthancCPlugin.h:374
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition OrthancCPlugin.h:399
uint32_t groupsCount
The number of groups of the regular expression.
Definition OrthancCPlugin.h:369
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition OrthancCPlugin.h:414
const void * body
For a PUT or POST request, the content of the body.
Definition OrthancCPlugin.h:394
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition OrthancCPlugin.h:384
uint32_t headersCount
The number of HTTP headers.
Definition OrthancCPlugin.h:409
OrthancPluginHttpMethod method
The HTTP method.
Definition OrthancCPlugin.h:364
uint32_t getCount
For a GET request, the number of GET parameters.
Definition OrthancCPlugin.h:379
const char *const * headersValues
The values of the HTTP headers.
Definition OrthancCPlugin.h:419
A 64-bit memory buffer allocated by the core system of Orthanc.
Definition OrthancCPlugin.h:1204
uint64_t size
The number of bytes in the buffer.
Definition OrthancCPlugin.h:1213
void * data
The content of the buffer.
Definition OrthancCPlugin.h:1208
A 32-bit memory buffer allocated by the core system of Orthanc.
Definition OrthancCPlugin.h:1182
uint32_t size
The number of bytes in the buffer.
Definition OrthancCPlugin.h:1191
void * data
The content of the buffer.
Definition OrthancCPlugin.h:1186