Orthanc Plugin SDK 1.12.4
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1
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 4
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
207#ifdef __cplusplus
208extern "C"
209{
210#endif
211
215 typedef enum
216 {
327
328 _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
330
331
336 ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
337
338
351
352
357 typedef struct
358 {
363
367 uint32_t groupsCount;
368
372 const char* const* groups;
373
377 uint32_t getCount;
378
382 const char* const* getKeys;
383
387 const char* const* getValues;
388
392 const void* body;
393
397 uint32_t bodySize;
398
399
400 /* --------------------------------------------------
401 New in version 0.8.1
402 -------------------------------------------------- */
403
407 uint32_t headersCount;
408
412 const char* const* headersKeys;
413
417 const char* const* headersValues;
418
420
421
422 typedef enum
423 {
424 /* Generic services */
425 _OrthancPluginService_LogInfo = 1,
426 _OrthancPluginService_LogWarning = 2,
427 _OrthancPluginService_LogError = 3,
428 _OrthancPluginService_GetOrthancPath = 4,
429 _OrthancPluginService_GetOrthancDirectory = 5,
430 _OrthancPluginService_GetConfigurationPath = 6,
431 _OrthancPluginService_SetPluginProperty = 7,
432 _OrthancPluginService_GetGlobalProperty = 8,
433 _OrthancPluginService_SetGlobalProperty = 9,
434 _OrthancPluginService_GetCommandLineArgumentsCount = 10,
435 _OrthancPluginService_GetCommandLineArgument = 11,
436 _OrthancPluginService_GetExpectedDatabaseVersion = 12,
437 _OrthancPluginService_GetConfiguration = 13,
438 _OrthancPluginService_BufferCompression = 14,
439 _OrthancPluginService_ReadFile = 15,
440 _OrthancPluginService_WriteFile = 16,
441 _OrthancPluginService_GetErrorDescription = 17,
442 _OrthancPluginService_CallHttpClient = 18,
443 _OrthancPluginService_RegisterErrorCode = 19,
444 _OrthancPluginService_RegisterDictionaryTag = 20,
445 _OrthancPluginService_DicomBufferToJson = 21,
446 _OrthancPluginService_DicomInstanceToJson = 22,
447 _OrthancPluginService_CreateDicom = 23,
448 _OrthancPluginService_ComputeMd5 = 24,
449 _OrthancPluginService_ComputeSha1 = 25,
450 _OrthancPluginService_LookupDictionary = 26,
451 _OrthancPluginService_CallHttpClient2 = 27,
452 _OrthancPluginService_GenerateUuid = 28,
453 _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
454 _OrthancPluginService_AutodetectMimeType = 30,
455 _OrthancPluginService_SetMetricsValue = 31,
456 _OrthancPluginService_EncodeDicomWebJson = 32,
457 _OrthancPluginService_EncodeDicomWebXml = 33,
458 _OrthancPluginService_ChunkedHttpClient = 34, /* New in Orthanc 1.5.7 */
459 _OrthancPluginService_GetTagName = 35, /* New in Orthanc 1.5.7 */
460 _OrthancPluginService_EncodeDicomWebJson2 = 36, /* New in Orthanc 1.7.0 */
461 _OrthancPluginService_EncodeDicomWebXml2 = 37, /* New in Orthanc 1.7.0 */
462 _OrthancPluginService_CreateMemoryBuffer = 38, /* New in Orthanc 1.7.0 */
463 _OrthancPluginService_GenerateRestApiAuthorizationToken = 39, /* New in Orthanc 1.8.1 */
464 _OrthancPluginService_CreateMemoryBuffer64 = 40, /* New in Orthanc 1.9.0 */
465 _OrthancPluginService_CreateDicom2 = 41, /* New in Orthanc 1.9.0 */
466 _OrthancPluginService_GetDatabaseServerIdentifier = 42, /* New in Orthanc 1.11.1 */
467 _OrthancPluginService_SetMetricsIntegerValue = 43, /* New in Orthanc 1.12.1 */
468 _OrthancPluginService_SetCurrentThreadName = 44, /* New in Orthanc 1.12.2 */
469 _OrthancPluginService_LogMessage = 45, /* New in Orthanc 1.12.4 */
470
471
472 /* Registration of callbacks */
473 _OrthancPluginService_RegisterRestCallback = 1000,
474 _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
475 _OrthancPluginService_RegisterStorageArea = 1002,
476 _OrthancPluginService_RegisterOnChangeCallback = 1003,
477 _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
478 _OrthancPluginService_RegisterWorklistCallback = 1005,
479 _OrthancPluginService_RegisterDecodeImageCallback = 1006,
480 _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
481 _OrthancPluginService_RegisterFindCallback = 1008,
482 _OrthancPluginService_RegisterMoveCallback = 1009,
483 _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
484 _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
485 _OrthancPluginService_RegisterChunkedRestCallback = 1012, /* New in Orthanc 1.5.7 */
486 _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
487 _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
488 _OrthancPluginService_RegisterTranscoderCallback = 1015, /* New in Orthanc 1.7.0 */
489 _OrthancPluginService_RegisterStorageArea2 = 1016, /* New in Orthanc 1.9.0 */
490 _OrthancPluginService_RegisterIncomingCStoreInstanceFilter = 1017, /* New in Orthanc 1.10.0 */
491 _OrthancPluginService_RegisterReceivedInstanceCallback = 1018, /* New in Orthanc 1.10.0 */
492 _OrthancPluginService_RegisterWebDavCollection = 1019, /* New in Orthanc 1.10.1 */
493
494 /* Sending answers to REST calls */
495 _OrthancPluginService_AnswerBuffer = 2000,
496 _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
497 _OrthancPluginService_Redirect = 2002,
498 _OrthancPluginService_SendHttpStatusCode = 2003,
499 _OrthancPluginService_SendUnauthorized = 2004,
500 _OrthancPluginService_SendMethodNotAllowed = 2005,
501 _OrthancPluginService_SetCookie = 2006,
502 _OrthancPluginService_SetHttpHeader = 2007,
503 _OrthancPluginService_StartMultipartAnswer = 2008,
504 _OrthancPluginService_SendMultipartItem = 2009,
505 _OrthancPluginService_SendHttpStatus = 2010,
506 _OrthancPluginService_CompressAndAnswerImage = 2011,
507 _OrthancPluginService_SendMultipartItem2 = 2012,
508 _OrthancPluginService_SetHttpErrorDetails = 2013,
509
510 /* Access to the Orthanc database and API */
511 _OrthancPluginService_GetDicomForInstance = 3000,
512 _OrthancPluginService_RestApiGet = 3001,
513 _OrthancPluginService_RestApiPost = 3002,
514 _OrthancPluginService_RestApiDelete = 3003,
515 _OrthancPluginService_RestApiPut = 3004,
516 _OrthancPluginService_LookupPatient = 3005,
517 _OrthancPluginService_LookupStudy = 3006,
518 _OrthancPluginService_LookupSeries = 3007,
519 _OrthancPluginService_LookupInstance = 3008,
520 _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
521 _OrthancPluginService_RestApiGetAfterPlugins = 3010,
522 _OrthancPluginService_RestApiPostAfterPlugins = 3011,
523 _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
524 _OrthancPluginService_RestApiPutAfterPlugins = 3013,
525 _OrthancPluginService_ReconstructMainDicomTags = 3014,
526 _OrthancPluginService_RestApiGet2 = 3015,
527 _OrthancPluginService_CallRestApi = 3016, /* New in Orthanc 1.9.2 */
528
529 /* Access to DICOM instances */
530 _OrthancPluginService_GetInstanceRemoteAet = 4000,
531 _OrthancPluginService_GetInstanceSize = 4001,
532 _OrthancPluginService_GetInstanceData = 4002,
533 _OrthancPluginService_GetInstanceJson = 4003,
534 _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
535 _OrthancPluginService_HasInstanceMetadata = 4005,
536 _OrthancPluginService_GetInstanceMetadata = 4006,
537 _OrthancPluginService_GetInstanceOrigin = 4007,
538 _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
539 _OrthancPluginService_HasInstancePixelData = 4009,
540 _OrthancPluginService_CreateDicomInstance = 4010, /* New in Orthanc 1.7.0 */
541 _OrthancPluginService_FreeDicomInstance = 4011, /* New in Orthanc 1.7.0 */
542 _OrthancPluginService_GetInstanceFramesCount = 4012, /* New in Orthanc 1.7.0 */
543 _OrthancPluginService_GetInstanceRawFrame = 4013, /* New in Orthanc 1.7.0 */
544 _OrthancPluginService_GetInstanceDecodedFrame = 4014, /* New in Orthanc 1.7.0 */
545 _OrthancPluginService_TranscodeDicomInstance = 4015, /* New in Orthanc 1.7.0 */
546 _OrthancPluginService_SerializeDicomInstance = 4016, /* New in Orthanc 1.7.0 */
547 _OrthancPluginService_GetInstanceAdvancedJson = 4017, /* New in Orthanc 1.7.0 */
548 _OrthancPluginService_GetInstanceDicomWebJson = 4018, /* New in Orthanc 1.7.0 */
549 _OrthancPluginService_GetInstanceDicomWebXml = 4019, /* New in Orthanc 1.7.0 */
550 _OrthancPluginService_LoadDicomInstance = 4020, /* New in Orthanc 1.12.1 */
551
552 /* Services for plugins implementing a database back-end */
553 _OrthancPluginService_RegisterDatabaseBackend = 5000, /* New in Orthanc 0.8.6 */
554 _OrthancPluginService_DatabaseAnswer = 5001,
555 _OrthancPluginService_RegisterDatabaseBackendV2 = 5002, /* New in Orthanc 0.9.4 */
556 _OrthancPluginService_StorageAreaCreate = 5003,
557 _OrthancPluginService_StorageAreaRead = 5004,
558 _OrthancPluginService_StorageAreaRemove = 5005,
559 _OrthancPluginService_RegisterDatabaseBackendV3 = 5006, /* New in Orthanc 1.9.2 */
560 _OrthancPluginService_RegisterDatabaseBackendV4 = 5007, /* New in Orthanc 1.12.0 */
561
562 /* Primitives for handling images */
563 _OrthancPluginService_GetImagePixelFormat = 6000,
564 _OrthancPluginService_GetImageWidth = 6001,
565 _OrthancPluginService_GetImageHeight = 6002,
566 _OrthancPluginService_GetImagePitch = 6003,
567 _OrthancPluginService_GetImageBuffer = 6004,
568 _OrthancPluginService_UncompressImage = 6005,
569 _OrthancPluginService_FreeImage = 6006,
570 _OrthancPluginService_CompressImage = 6007,
571 _OrthancPluginService_ConvertPixelFormat = 6008,
572 _OrthancPluginService_GetFontsCount = 6009,
573 _OrthancPluginService_GetFontInfo = 6010,
574 _OrthancPluginService_DrawText = 6011,
575 _OrthancPluginService_CreateImage = 6012,
576 _OrthancPluginService_CreateImageAccessor = 6013,
577 _OrthancPluginService_DecodeDicomImage = 6014,
578
579 /* Primitives for handling C-Find, C-Move and worklists */
580 _OrthancPluginService_WorklistAddAnswer = 7000,
581 _OrthancPluginService_WorklistMarkIncomplete = 7001,
582 _OrthancPluginService_WorklistIsMatch = 7002,
583 _OrthancPluginService_WorklistGetDicomQuery = 7003,
584 _OrthancPluginService_FindAddAnswer = 7004,
585 _OrthancPluginService_FindMarkIncomplete = 7005,
586 _OrthancPluginService_GetFindQuerySize = 7006,
587 _OrthancPluginService_GetFindQueryTag = 7007,
588 _OrthancPluginService_GetFindQueryTagName = 7008,
589 _OrthancPluginService_GetFindQueryValue = 7009,
590 _OrthancPluginService_CreateFindMatcher = 7010,
591 _OrthancPluginService_FreeFindMatcher = 7011,
592 _OrthancPluginService_FindMatcherIsMatch = 7012,
593
594 /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
595 _OrthancPluginService_GetPeers = 8000,
596 _OrthancPluginService_FreePeers = 8001,
597 _OrthancPluginService_GetPeersCount = 8003,
598 _OrthancPluginService_GetPeerName = 8004,
599 _OrthancPluginService_GetPeerUrl = 8005,
600 _OrthancPluginService_CallPeerApi = 8006,
601 _OrthancPluginService_GetPeerUserProperty = 8007,
602
603 /* Primitives for handling jobs (new in 1.4.2) */
604 _OrthancPluginService_CreateJob = 9000, /* Deprecated since SDK 1.11.3 */
605 _OrthancPluginService_FreeJob = 9001,
606 _OrthancPluginService_SubmitJob = 9002,
607 _OrthancPluginService_RegisterJobsUnserializer = 9003,
608 _OrthancPluginService_CreateJob2 = 9004, /* New in SDK 1.11.3 */
609
610 _OrthancPluginService_INTERNAL = 0x7fffffff
611 } _OrthancPluginService;
612
613
614 typedef enum
615 {
616 _OrthancPluginProperty_Description = 1,
617 _OrthancPluginProperty_RootUri = 2,
618 _OrthancPluginProperty_OrthancExplorer = 3,
619
620 _OrthancPluginProperty_INTERNAL = 0x7fffffff
621 } _OrthancPluginProperty;
622
623
624
715
716
717
730
731
732
746
747
748
777
778
792
793
798 typedef enum
799 {
804 _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
806
807
844
845
851 typedef enum
852 {
857 _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
859
860
880
881
895
896
911
912
927
928
943
944
954
955
969
970
985
986
997
998
1047
1048
1060
1061
1088
1089
1096 typedef enum
1097 {
1103 _OrthancPluginLogLevel_INTERNAL = 0x7fffffff
1105
1106
1125
1126
1134 typedef struct
1135 {
1139 void* data;
1140
1144 uint32_t size;
1146
1147
1148
1156 typedef struct
1157 {
1161 void* data;
1162
1166 uint64_t size;
1168
1169
1170
1171
1176 typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
1177
1178
1179
1184 typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
1185
1186
1187
1192 typedef struct _OrthancPluginImage_t OrthancPluginImage;
1193
1194
1195
1200 typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
1201
1202
1203
1208 typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
1209
1210
1211
1216 typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
1217
1218
1219
1224 typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1225
1226
1227
1232 typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1233
1234
1235
1240 typedef struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher;
1241
1242
1243
1248 typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1249
1250
1251
1256 typedef struct _OrthancPluginJob_t OrthancPluginJob;
1257
1258
1259
1265 typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1266
1267
1268
1275 const char* url,
1276 const OrthancPluginHttpRequest* request);
1277
1278
1279
1285 const OrthancPluginDicomInstance* instance,
1286 const char* instanceId);
1287
1288
1289
1295 OrthancPluginChangeType changeType,
1296 OrthancPluginResourceType resourceType,
1297 const char* resourceId);
1298
1299
1300
1306 OrthancPluginImage** target,
1307 const void* dicom,
1308 const uint32_t size,
1309 uint32_t frameIndex);
1310
1311
1312
1317 typedef void (*OrthancPluginFree) (void* buffer);
1318
1319
1320
1330 const char* bulkDataUri);
1331
1332
1333
1347 const char* uuid,
1348 const void* content,
1349 int64_t size,
1351
1352
1353
1374 void** content,
1375 int64_t* size,
1376 const char* uuid,
1378
1379
1380
1395 const char* uuid,
1397
1398
1399
1418 const char* uuid,
1420 uint64_t rangeStart);
1421
1422
1423
1435 const char* uuid,
1437
1438
1439
1455 const OrthancPluginWorklistQuery* query,
1456 const char* issuerAet,
1457 const char* calledAet);
1458
1459
1460
1486 const char* uri,
1487 const char* ip,
1488 uint32_t headersCount,
1489 const char* const* headersKeys,
1490 const char* const* headersValues);
1491
1492
1493
1521 const char* uri,
1522 const char* ip,
1523 uint32_t headersCount,
1524 const char* const* headersKeys,
1525 const char* const* headersValues,
1526 uint32_t getArgumentsCount,
1527 const char* const* getArgumentsKeys,
1528 const char* const* getArgumentsValues);
1529
1530
1531
1547 OrthancPluginFindAnswers* answers,
1548 const OrthancPluginFindQuery* query,
1549 const char* issuerAet,
1550 const char* calledAet);
1551
1552
1553
1589 typedef void* (*OrthancPluginMoveCallback) (
1590 OrthancPluginResourceType resourceType,
1591 const char* patientId,
1592 const char* accessionNumber,
1593 const char* studyInstanceUid,
1594 const char* seriesInstanceUid,
1595 const char* sopInstanceUid,
1596 const char* originatorAet,
1597 const char* sourceAet,
1598 const char* targetAet,
1599 uint16_t originatorId);
1600
1601
1614 typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1615
1616
1629 typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1630
1631
1643 typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1644
1645
1656 typedef void (*OrthancPluginJobFinalize) (void* job);
1657
1658
1669 typedef float (*OrthancPluginJobGetProgress) (void* job);
1670
1671
1685 typedef const char* (*OrthancPluginJobGetContent) (void* job);
1686
1687
1704 void* job);
1705
1706
1723 typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1724
1725
1744 void* job);
1745
1746
1760
1761
1785
1786
1801
1802
1816 typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1817 const char* serialized);
1818
1819
1820
1836
1837
1838
1866 uint32_t levelDepth,
1867 const uint16_t* levelTagGroup,
1868 const uint16_t* levelTagElement,
1869 const uint32_t* levelIndex,
1870 uint16_t tagGroup,
1871 uint16_t tagElement,
1873
1874
1875
1904 uint32_t levelDepth,
1905 const uint16_t* levelTagGroup,
1906 const uint16_t* levelTagElement,
1907 const uint32_t* levelIndex,
1908 uint16_t tagGroup,
1909 uint16_t tagElement,
1911 void* payload);
1912
1913
1914
1918 typedef struct _OrthancPluginContext_t
1919 {
1920 void* pluginsManager;
1921 const char* orthancVersion;
1922 OrthancPluginFree Free;
1923 OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1924 _OrthancPluginService service,
1925 const void* params);
1927
1928
1929
1941
1942
1943
1952 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1953 OrthancPluginContext* context,
1954 char* str)
1955 {
1956 if (str != NULL)
1957 {
1958 context->Free(str);
1959 }
1960 }
1961
1962
1982 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginCheckVersionAdvanced(
1983 OrthancPluginContext* context,
1984 int32_t expectedMajor,
1985 int32_t expectedMinor,
1986 int32_t expectedRevision)
1987 {
1988 int32_t major, minor, revision;
1989
1990 if (sizeof(int) != sizeof(int32_t) || /* Ensure binary compatibility with Orthanc SDK <= 1.12.1 */
1991 sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1992 sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1993 sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1994 sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1995 sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1996 sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1997 sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1998 sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1999 sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
2000 sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
2001 sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
2002 sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
2003 sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
2004 sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
2005 sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
2006 sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
2007 sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
2008 sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
2009 sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
2010 sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
2011 sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason) ||
2012 sizeof(int32_t) != sizeof(OrthancPluginLoadDicomInstanceMode) ||
2013 sizeof(int32_t) != sizeof(OrthancPluginLogLevel) ||
2014 sizeof(int32_t) != sizeof(OrthancPluginLogCategory))
2015 {
2016 /* Mismatch in the size of the enumerations */
2017 return 0;
2018 }
2019
2020 /* Assume compatibility with the mainline */
2021 if (!strcmp(context->orthancVersion, "mainline"))
2022 {
2023 return 1;
2024 }
2025
2026 /* Parse the version of the Orthanc core */
2027 if (
2028#ifdef _MSC_VER
2029 sscanf_s
2030#else
2031 sscanf
2032#endif
2033 (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
2034 {
2035 return 0;
2036 }
2037
2038 /* Check the major number of the version */
2039
2040 if (major > expectedMajor)
2041 {
2042 return 1;
2043 }
2044
2045 if (major < expectedMajor)
2046 {
2047 return 0;
2048 }
2049
2050 /* Check the minor number of the version */
2051
2052 if (minor > expectedMinor)
2053 {
2054 return 1;
2055 }
2056
2057 if (minor < expectedMinor)
2058 {
2059 return 0;
2060 }
2061
2062 /* Check the revision number of the version */
2063
2064 if (revision >= expectedRevision)
2065 {
2066 return 1;
2067 }
2068 else
2069 {
2070 return 0;
2071 }
2072 }
2073
2074
2091 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginCheckVersion(
2092 OrthancPluginContext* context)
2093 {
2095 context,
2096 ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
2097 ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
2098 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
2099 }
2100
2101
2110 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
2111 OrthancPluginContext* context,
2113 {
2114 context->Free(buffer->data);
2115 }
2116
2117
2126 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer64(
2127 OrthancPluginContext* context,
2129 {
2130 context->Free(buffer->data);
2131 }
2132
2133
2142 ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
2143 OrthancPluginContext* context,
2144 const char* message)
2145 {
2146 context->InvokeService(context, _OrthancPluginService_LogError, message);
2147 }
2148
2149
2158 ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
2159 OrthancPluginContext* context,
2160 const char* message)
2161 {
2162 context->InvokeService(context, _OrthancPluginService_LogWarning, message);
2163 }
2164
2165
2174 ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
2175 OrthancPluginContext* context,
2176 const char* message)
2177 {
2178 context->InvokeService(context, _OrthancPluginService_LogInfo, message);
2179 }
2180
2181
2182
2183 typedef struct
2184 {
2185 const char* pathRegularExpression;
2187 } _OrthancPluginRestCallback;
2188
2210 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
2211 OrthancPluginContext* context,
2212 const char* pathRegularExpression,
2214 {
2215 _OrthancPluginRestCallback params;
2216 params.pathRegularExpression = pathRegularExpression;
2217 params.callback = callback;
2218 context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
2219 }
2220
2221
2222
2251 OrthancPluginContext* context,
2252 const char* pathRegularExpression,
2254 {
2255 _OrthancPluginRestCallback params;
2256 params.pathRegularExpression = pathRegularExpression;
2257 params.callback = callback;
2258 context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
2259 }
2260
2261
2262
2263 typedef struct
2264 {
2266 } _OrthancPluginOnStoredInstanceCallback;
2267
2289 OrthancPluginContext* context,
2291 {
2292 _OrthancPluginOnStoredInstanceCallback params;
2293 params.callback = callback;
2294
2295 context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
2296 }
2297
2298
2299
2300 typedef struct
2301 {
2303 const void* answer;
2304 uint32_t answerSize;
2305 const char* mimeType;
2306 } _OrthancPluginAnswerBuffer;
2307
2320 ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
2321 OrthancPluginContext* context,
2323 const void* answer,
2324 uint32_t answerSize,
2325 const char* mimeType)
2326 {
2327 _OrthancPluginAnswerBuffer params;
2328 params.output = output;
2329 params.answer = answer;
2330 params.answerSize = answerSize;
2331 params.mimeType = mimeType;
2332 context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
2333 }
2334
2335
2336 typedef struct
2337 {
2340 uint32_t width;
2341 uint32_t height;
2342 uint32_t pitch;
2343 const void* buffer;
2344 } _OrthancPluginCompressAndAnswerPngImage;
2345
2346 typedef struct
2347 {
2349 OrthancPluginImageFormat imageFormat;
2350 OrthancPluginPixelFormat pixelFormat;
2351 uint32_t width;
2352 uint32_t height;
2353 uint32_t pitch;
2354 const void* buffer;
2355 uint8_t quality;
2356 } _OrthancPluginCompressAndAnswerImage;
2357
2358
2377 ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2378 OrthancPluginContext* context,
2381 uint32_t width,
2382 uint32_t height,
2383 uint32_t pitch,
2384 const void* buffer)
2385 {
2386 _OrthancPluginCompressAndAnswerImage params;
2387 params.output = output;
2388 params.imageFormat = OrthancPluginImageFormat_Png;
2389 params.pixelFormat = format;
2390 params.width = width;
2391 params.height = height;
2392 params.pitch = pitch;
2393 params.buffer = buffer;
2394 params.quality = 0; /* No quality for PNG */
2395 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2396 }
2397
2398
2399
2400 typedef struct
2401 {
2403 const char* instanceId;
2404 } _OrthancPluginGetDicomForInstance;
2405
2419 OrthancPluginContext* context,
2421 const char* instanceId)
2422 {
2423 _OrthancPluginGetDicomForInstance params;
2424 params.target = target;
2425 params.instanceId = instanceId;
2426 return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2427 }
2428
2429
2430
2431 typedef struct
2432 {
2434 const char* uri;
2435 } _OrthancPluginRestApiGet;
2436
2452 OrthancPluginContext* context,
2454 const char* uri)
2455 {
2456 _OrthancPluginRestApiGet params;
2457 params.target = target;
2458 params.uri = uri;
2459 return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2460 }
2461
2462
2463
2482 OrthancPluginContext* context,
2484 const char* uri)
2485 {
2486 _OrthancPluginRestApiGet params;
2487 params.target = target;
2488 params.uri = uri;
2489 return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2490 }
2491
2492
2493
2494 typedef struct
2495 {
2497 const char* uri;
2498 const void* body;
2499 uint32_t bodySize;
2500 } _OrthancPluginRestApiPostPut;
2501
2519 OrthancPluginContext* context,
2521 const char* uri,
2522 const void* body,
2523 uint32_t bodySize)
2524 {
2525 _OrthancPluginRestApiPostPut params;
2526 params.target = target;
2527 params.uri = uri;
2528 params.body = body;
2529 params.bodySize = bodySize;
2530 return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2531 }
2532
2533
2554 OrthancPluginContext* context,
2556 const char* uri,
2557 const void* body,
2558 uint32_t bodySize)
2559 {
2560 _OrthancPluginRestApiPostPut params;
2561 params.target = target;
2562 params.uri = uri;
2563 params.body = body;
2564 params.bodySize = bodySize;
2565 return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2566 }
2567
2568
2569
2583 OrthancPluginContext* context,
2584 const char* uri)
2585 {
2586 return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2587 }
2588
2589
2606 OrthancPluginContext* context,
2607 const char* uri)
2608 {
2609 return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2610 }
2611
2612
2613
2631 OrthancPluginContext* context,
2633 const char* uri,
2634 const void* body,
2635 uint32_t bodySize)
2636 {
2637 _OrthancPluginRestApiPostPut params;
2638 params.target = target;
2639 params.uri = uri;
2640 params.body = body;
2641 params.bodySize = bodySize;
2642 return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2643 }
2644
2645
2646
2667 OrthancPluginContext* context,
2669 const char* uri,
2670 const void* body,
2671 uint32_t bodySize)
2672 {
2673 _OrthancPluginRestApiPostPut params;
2674 params.target = target;
2675 params.uri = uri;
2676 params.body = body;
2677 params.bodySize = bodySize;
2678 return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2679 }
2680
2681
2682
2683 typedef struct
2684 {
2686 const char* argument;
2687 } _OrthancPluginOutputPlusArgument;
2688
2700 ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2701 OrthancPluginContext* context,
2703 const char* redirection)
2704 {
2705 _OrthancPluginOutputPlusArgument params;
2706 params.output = output;
2707 params.argument = redirection;
2708 context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2709 }
2710
2711
2712
2713 typedef struct
2714 {
2715 char** result;
2716 const char* argument;
2717 } _OrthancPluginRetrieveDynamicString;
2718
2732 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2733 OrthancPluginContext* context,
2734 const char* patientID)
2735 {
2736 char* result;
2737
2738 _OrthancPluginRetrieveDynamicString params;
2739 params.result = &result;
2740 params.argument = patientID;
2741
2742 if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2743 {
2744 /* Error */
2745 return NULL;
2746 }
2747 else
2748 {
2749 return result;
2750 }
2751 }
2752
2753
2767 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2768 OrthancPluginContext* context,
2769 const char* studyUID)
2770 {
2771 char* result;
2772
2773 _OrthancPluginRetrieveDynamicString params;
2774 params.result = &result;
2775 params.argument = studyUID;
2776
2777 if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2778 {
2779 /* Error */
2780 return NULL;
2781 }
2782 else
2783 {
2784 return result;
2785 }
2786 }
2787
2788
2803 OrthancPluginContext* context,
2804 const char* accessionNumber)
2805 {
2806 char* result;
2807
2808 _OrthancPluginRetrieveDynamicString params;
2809 params.result = &result;
2810 params.argument = accessionNumber;
2811
2812 if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2813 {
2814 /* Error */
2815 return NULL;
2816 }
2817 else
2818 {
2819 return result;
2820 }
2821 }
2822
2823
2837 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2838 OrthancPluginContext* context,
2839 const char* seriesUID)
2840 {
2841 char* result;
2842
2843 _OrthancPluginRetrieveDynamicString params;
2844 params.result = &result;
2845 params.argument = seriesUID;
2846
2847 if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2848 {
2849 /* Error */
2850 return NULL;
2851 }
2852 else
2853 {
2854 return result;
2855 }
2856 }
2857
2858
2872 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2873 OrthancPluginContext* context,
2874 const char* sopInstanceUID)
2875 {
2876 char* result;
2877
2878 _OrthancPluginRetrieveDynamicString params;
2879 params.result = &result;
2880 params.argument = sopInstanceUID;
2881
2882 if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2883 {
2884 /* Error */
2885 return NULL;
2886 }
2887 else
2888 {
2889 return result;
2890 }
2891 }
2892
2893
2894
2895 typedef struct
2896 {
2898 uint16_t status;
2899 } _OrthancPluginSendHttpStatusCode;
2900
2917 ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2918 OrthancPluginContext* context,
2920 uint16_t status)
2921 {
2922 _OrthancPluginSendHttpStatusCode params;
2923 params.output = output;
2924 params.status = status;
2925 context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2926 }
2927
2928
2940 ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2941 OrthancPluginContext* context,
2943 const char* realm)
2944 {
2945 _OrthancPluginOutputPlusArgument params;
2946 params.output = output;
2947 params.argument = realm;
2948 context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2949 }
2950
2951
2963 ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2964 OrthancPluginContext* context,
2966 const char* allowedMethods)
2967 {
2968 _OrthancPluginOutputPlusArgument params;
2969 params.output = output;
2970 params.argument = allowedMethods;
2971 context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2972 }
2973
2974
2975 typedef struct
2976 {
2978 const char* key;
2979 const char* value;
2980 } _OrthancPluginSetHttpHeader;
2981
2993 ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2994 OrthancPluginContext* context,
2996 const char* cookie,
2997 const char* value)
2998 {
2999 _OrthancPluginSetHttpHeader params;
3000 params.output = output;
3001 params.key = cookie;
3002 params.value = value;
3003 context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
3004 }
3005
3006
3018 ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
3019 OrthancPluginContext* context,
3021 const char* key,
3022 const char* value)
3023 {
3024 _OrthancPluginSetHttpHeader params;
3025 params.output = output;
3026 params.key = key;
3027 params.value = value;
3028 context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
3029 }
3030
3031
3032 typedef struct
3033 {
3034 char** resultStringToFree;
3035 const char** resultString;
3036 int64_t* resultInt64;
3037 const char* key;
3038 const OrthancPluginDicomInstance* instance;
3039 OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
3040 } _OrthancPluginAccessDicomInstance;
3041
3042
3054 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
3055 OrthancPluginContext* context,
3056 const OrthancPluginDicomInstance* instance)
3057 {
3058 const char* result;
3059
3060 _OrthancPluginAccessDicomInstance params;
3061 memset(&params, 0, sizeof(params));
3062 params.resultString = &result;
3063 params.instance = instance;
3064
3065 if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
3066 {
3067 /* Error */
3068 return NULL;
3069 }
3070 else
3071 {
3072 return result;
3073 }
3074 }
3075
3076
3087 ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
3088 OrthancPluginContext* context,
3089 const OrthancPluginDicomInstance* instance)
3090 {
3091 int64_t size;
3092
3093 _OrthancPluginAccessDicomInstance params;
3094 memset(&params, 0, sizeof(params));
3095 params.resultInt64 = &size;
3096 params.instance = instance;
3097
3098 if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
3099 {
3100 /* Error */
3101 return -1;
3102 }
3103 else
3104 {
3105 return size;
3106 }
3107 }
3108
3109
3120 ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData(
3121 OrthancPluginContext* context,
3122 const OrthancPluginDicomInstance* instance)
3123 {
3124 const char* result;
3125
3126 _OrthancPluginAccessDicomInstance params;
3127 memset(&params, 0, sizeof(params));
3128 params.resultString = &result;
3129 params.instance = instance;
3130
3131 if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
3132 {
3133 /* Error */
3134 return NULL;
3135 }
3136 else
3137 {
3138 return result;
3139 }
3140 }
3141
3142
3156 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
3157 OrthancPluginContext* context,
3158 const OrthancPluginDicomInstance* instance)
3159 {
3160 char* result;
3161
3162 _OrthancPluginAccessDicomInstance params;
3163 memset(&params, 0, sizeof(params));
3164 params.resultStringToFree = &result;
3165 params.instance = instance;
3166
3167 if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
3168 {
3169 /* Error */
3170 return NULL;
3171 }
3172 else
3173 {
3174 return result;
3175 }
3176 }
3177
3178
3194 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
3195 OrthancPluginContext* context,
3196 const OrthancPluginDicomInstance* instance)
3197 {
3198 char* result;
3199
3200 _OrthancPluginAccessDicomInstance params;
3201 memset(&params, 0, sizeof(params));
3202 params.resultStringToFree = &result;
3203 params.instance = instance;
3204
3205 if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
3206 {
3207 /* Error */
3208 return NULL;
3209 }
3210 else
3211 {
3212 return result;
3213 }
3214 }
3215
3216
3233 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstanceMetadata(
3234 OrthancPluginContext* context,
3235 const OrthancPluginDicomInstance* instance,
3236 const char* metadata)
3237 {
3238 int64_t result;
3239
3240 _OrthancPluginAccessDicomInstance params;
3241 memset(&params, 0, sizeof(params));
3242 params.resultInt64 = &result;
3243 params.instance = instance;
3244 params.key = metadata;
3245
3246 if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3247 {
3248 /* Error */
3249 return -1;
3250 }
3251 else
3252 {
3253 return (result != 0);
3254 }
3255 }
3256
3257
3274 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
3275 OrthancPluginContext* context,
3276 const OrthancPluginDicomInstance* instance,
3277 const char* metadata)
3278 {
3279 const char* result;
3280
3281 _OrthancPluginAccessDicomInstance params;
3282 memset(&params, 0, sizeof(params));
3283 params.resultString = &result;
3284 params.instance = instance;
3285 params.key = metadata;
3286
3287 if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3288 {
3289 /* Error */
3290 return NULL;
3291 }
3292 else
3293 {
3294 return result;
3295 }
3296 }
3297
3298
3299
3300 typedef struct
3301 {
3305 OrthancPluginFree free;
3306 } _OrthancPluginRegisterStorageArea;
3307
3323 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
3324 OrthancPluginContext* context,
3328 {
3329 _OrthancPluginRegisterStorageArea params;
3330 params.create = create;
3331 params.read = read;
3332 params.remove = remove;
3333
3334#ifdef __cplusplus
3335 params.free = ::free;
3336#else
3337 params.free = free;
3338#endif
3339
3340 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3341 }
3342
3343
3344
3355 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3356 {
3357 char* result;
3358
3359 _OrthancPluginRetrieveDynamicString params;
3360 params.result = &result;
3361 params.argument = NULL;
3362
3363 if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3364 {
3365 /* Error */
3366 return NULL;
3367 }
3368 else
3369 {
3370 return result;
3371 }
3372 }
3373
3374
3385 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3386 {
3387 char* result;
3388
3389 _OrthancPluginRetrieveDynamicString params;
3390 params.result = &result;
3391 params.argument = NULL;
3392
3393 if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3394 {
3395 /* Error */
3396 return NULL;
3397 }
3398 else
3399 {
3400 return result;
3401 }
3402 }
3403
3404
3420 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3421 {
3422 char* result;
3423
3424 _OrthancPluginRetrieveDynamicString params;
3425 params.result = &result;
3426 params.argument = NULL;
3427
3428 if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3429 {
3430 /* Error */
3431 return NULL;
3432 }
3433 else
3434 {
3435 return result;
3436 }
3437 }
3438
3439
3440
3441 typedef struct
3442 {
3444 } _OrthancPluginOnChangeCallback;
3445
3466 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3467 OrthancPluginContext* context,
3469 {
3470 _OrthancPluginOnChangeCallback params;
3471 params.callback = callback;
3472
3473 context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3474 }
3475
3476
3477
3478 typedef struct
3479 {
3480 const char* plugin;
3481 _OrthancPluginProperty property;
3482 const char* value;
3483 } _OrthancPluginSetPluginProperty;
3484
3485
3501 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3502 OrthancPluginContext* context,
3503 const char* uri)
3504 {
3505 _OrthancPluginSetPluginProperty params;
3506 params.plugin = OrthancPluginGetName();
3507 params.property = _OrthancPluginProperty_RootUri;
3508 params.value = uri;
3509
3510 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3511 }
3512
3513
3526 ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri2(
3527 OrthancPluginContext* context,
3528 const char* plugin,
3529 const char* uri)
3530 {
3531 _OrthancPluginSetPluginProperty params;
3532 params.plugin = plugin;
3533 params.property = _OrthancPluginProperty_RootUri;
3534 params.value = uri;
3535
3536 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3537 }
3538
3539
3553 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3554 OrthancPluginContext* context,
3555 const char* description)
3556 {
3557 _OrthancPluginSetPluginProperty params;
3558 params.plugin = OrthancPluginGetName();
3559 params.property = _OrthancPluginProperty_Description;
3560 params.value = description;
3561
3562 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3563 }
3564
3565
3576 ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription2(
3577 OrthancPluginContext* context,
3578 const char* plugin,
3579 const char* description)
3580 {
3581 _OrthancPluginSetPluginProperty params;
3582 params.plugin = plugin;
3583 params.property = _OrthancPluginProperty_Description;
3584 params.value = description;
3585
3586 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3587 }
3588
3589
3603 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3604 OrthancPluginContext* context,
3605 const char* javascript)
3606 {
3607 _OrthancPluginSetPluginProperty params;
3608 params.plugin = OrthancPluginGetName();
3609 params.property = _OrthancPluginProperty_OrthancExplorer;
3610 params.value = javascript;
3611
3612 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3613 }
3614
3615
3626 ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer2(
3627 OrthancPluginContext* context,
3628 const char* plugin,
3629 const char* javascript)
3630 {
3631 _OrthancPluginSetPluginProperty params;
3632 params.plugin = plugin;
3633 params.property = _OrthancPluginProperty_OrthancExplorer;
3634 params.value = javascript;
3635
3636 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3637 }
3638
3639
3640 typedef struct
3641 {
3642 char** result;
3643 int32_t property;
3644 const char* value;
3645 } _OrthancPluginGlobalProperty;
3646
3647
3661 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3662 OrthancPluginContext* context,
3663 int32_t property,
3664 const char* defaultValue)
3665 {
3666 char* result;
3667
3668 _OrthancPluginGlobalProperty params;
3669 params.result = &result;
3670 params.property = property;
3671 params.value = defaultValue;
3672
3673 if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3674 {
3675 /* Error */
3676 return NULL;
3677 }
3678 else
3679 {
3680 return result;
3681 }
3682 }
3683
3684
3701 OrthancPluginContext* context,
3702 int32_t property,
3703 const char* value)
3704 {
3705 _OrthancPluginGlobalProperty params;
3706 params.result = NULL;
3707 params.property = property;
3708 params.value = value;
3709
3710 return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3711 }
3712
3713
3714
3715 typedef struct
3716 {
3717 int32_t *resultInt32;
3718 uint32_t *resultUint32;
3719 int64_t *resultInt64;
3720 uint64_t *resultUint64;
3721 } _OrthancPluginReturnSingleValue;
3722
3731 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3732 OrthancPluginContext* context)
3733 {
3734 uint32_t count = 0;
3735
3736 _OrthancPluginReturnSingleValue params;
3737 memset(&params, 0, sizeof(params));
3738 params.resultUint32 = &count;
3739
3740 if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3741 {
3742 /* Error */
3743 return 0;
3744 }
3745 else
3746 {
3747 return count;
3748 }
3749 }
3750
3751
3752
3765 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3766 OrthancPluginContext* context,
3767 uint32_t argument)
3768 {
3769 char* result;
3770
3771 _OrthancPluginGlobalProperty params;
3772 params.result = &result;
3773 params.property = (int32_t) argument;
3774 params.value = NULL;
3775
3776 if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3777 {
3778 /* Error */
3779 return NULL;
3780 }
3781 else
3782 {
3783 return result;
3784 }
3785 }
3786
3787
3797 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3798 OrthancPluginContext* context)
3799 {
3800 uint32_t count = 0;
3801
3802 _OrthancPluginReturnSingleValue params;
3803 memset(&params, 0, sizeof(params));
3804 params.resultUint32 = &count;
3805
3806 if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3807 {
3808 /* Error */
3809 return 0;
3810 }
3811 else
3812 {
3813 return count;
3814 }
3815 }
3816
3817
3818
3830 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3831 {
3832 char* result;
3833
3834 _OrthancPluginRetrieveDynamicString params;
3835 params.result = &result;
3836 params.argument = NULL;
3837
3838 if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3839 {
3840 /* Error */
3841 return NULL;
3842 }
3843 else
3844 {
3845 return result;
3846 }
3847 }
3848
3849
3850
3851 typedef struct
3852 {
3854 const char* subType;
3855 const char* contentType;
3856 } _OrthancPluginStartMultipartAnswer;
3857
3872 OrthancPluginContext* context,
3874 const char* subType,
3875 const char* contentType)
3876 {
3877 _OrthancPluginStartMultipartAnswer params;
3878 params.output = output;
3879 params.subType = subType;
3880 params.contentType = contentType;
3881 return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3882 }
3883
3884
3901 OrthancPluginContext* context,
3903 const void* answer,
3904 uint32_t answerSize)
3905 {
3906 _OrthancPluginAnswerBuffer params;
3907 params.output = output;
3908 params.answer = answer;
3909 params.answerSize = answerSize;
3910 params.mimeType = NULL;
3911 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3912 }
3913
3914
3915
3916 typedef struct
3917 {
3919 const void* source;
3920 uint32_t size;
3921 OrthancPluginCompressionType compression;
3922 uint8_t uncompress;
3923 } _OrthancPluginBufferCompression;
3924
3925
3943 OrthancPluginContext* context,
3945 const void* source,
3946 uint32_t size,
3947 OrthancPluginCompressionType compression,
3948 uint8_t uncompress)
3949 {
3950 _OrthancPluginBufferCompression params;
3951 params.target = target;
3952 params.source = source;
3953 params.size = size;
3954 params.compression = compression;
3955 params.uncompress = uncompress;
3956
3957 return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3958 }
3959
3960
3961
3962 typedef struct
3963 {
3965 const char* path;
3966 } _OrthancPluginReadFile;
3967
3980 OrthancPluginContext* context,
3982 const char* path)
3983 {
3984 _OrthancPluginReadFile params;
3985 params.target = target;
3986 params.path = path;
3987 return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3988 }
3989
3990
3991
3992 typedef struct
3993 {
3994 const char* path;
3995 const void* data;
3996 uint32_t size;
3997 } _OrthancPluginWriteFile;
3998
4011 OrthancPluginContext* context,
4012 const char* path,
4013 const void* data,
4014 uint32_t size)
4015 {
4016 _OrthancPluginWriteFile params;
4017 params.path = path;
4018 params.data = data;
4019 params.size = size;
4020 return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
4021 }
4022
4023
4024
4025 typedef struct
4026 {
4027 const char** target;
4029 } _OrthancPluginGetErrorDescription;
4030
4041 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
4042 OrthancPluginContext* context,
4044 {
4045 const char* result = NULL;
4046
4047 _OrthancPluginGetErrorDescription params;
4048 params.target = &result;
4049 params.error = error;
4050
4051 if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
4052 result == NULL)
4053 {
4054 return "Unknown error code";
4055 }
4056 else
4057 {
4058 return result;
4059 }
4060 }
4061
4062
4063
4064 typedef struct
4065 {
4067 uint16_t status;
4068 const void* body;
4069 uint32_t bodySize;
4070 } _OrthancPluginSendHttpStatus;
4071
4094 ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
4095 OrthancPluginContext* context,
4097 uint16_t status,
4098 const void* body,
4099 uint32_t bodySize)
4100 {
4101 _OrthancPluginSendHttpStatus params;
4102 params.output = output;
4103 params.status = status;
4104 params.body = body;
4105 params.bodySize = bodySize;
4106 context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
4107 }
4108
4109
4110
4111 typedef struct
4112 {
4113 const OrthancPluginImage* image;
4114 uint32_t* resultUint32;
4115 OrthancPluginPixelFormat* resultPixelFormat;
4116 void** resultBuffer;
4117 } _OrthancPluginGetImageInfo;
4118
4119
4131 OrthancPluginContext* context,
4132 const OrthancPluginImage* image)
4133 {
4135
4136 _OrthancPluginGetImageInfo params;
4137 memset(&params, 0, sizeof(params));
4138 params.image = image;
4139 params.resultPixelFormat = &target;
4140
4141 if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
4142 {
4144 }
4145 else
4146 {
4147 return (OrthancPluginPixelFormat) target;
4148 }
4149 }
4150
4151
4152
4163 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
4164 OrthancPluginContext* context,
4165 const OrthancPluginImage* image)
4166 {
4167 uint32_t width;
4168
4169 _OrthancPluginGetImageInfo params;
4170 memset(&params, 0, sizeof(params));
4171 params.image = image;
4172 params.resultUint32 = &width;
4173
4174 if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
4175 {
4176 return 0;
4177 }
4178 else
4179 {
4180 return width;
4181 }
4182 }
4183
4184
4185
4196 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
4197 OrthancPluginContext* context,
4198 const OrthancPluginImage* image)
4199 {
4200 uint32_t height;
4201
4202 _OrthancPluginGetImageInfo params;
4203 memset(&params, 0, sizeof(params));
4204 params.image = image;
4205 params.resultUint32 = &height;
4206
4207 if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
4208 {
4209 return 0;
4210 }
4211 else
4212 {
4213 return height;
4214 }
4215 }
4216
4217
4218
4231 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
4232 OrthancPluginContext* context,
4233 const OrthancPluginImage* image)
4234 {
4235 uint32_t pitch;
4236
4237 _OrthancPluginGetImageInfo params;
4238 memset(&params, 0, sizeof(params));
4239 params.image = image;
4240 params.resultUint32 = &pitch;
4241
4242 if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
4243 {
4244 return 0;
4245 }
4246 else
4247 {
4248 return pitch;
4249 }
4250 }
4251
4252
4253
4265 ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
4266 OrthancPluginContext* context,
4267 const OrthancPluginImage* image)
4268 {
4269 void* target = NULL;
4270
4271 _OrthancPluginGetImageInfo params;
4272 memset(&params, 0, sizeof(params));
4273 params.resultBuffer = &target;
4274 params.image = image;
4275
4276 if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
4277 {
4278 return NULL;
4279 }
4280 else
4281 {
4282 return target;
4283 }
4284 }
4285
4286
4287 typedef struct
4288 {
4289 OrthancPluginImage** target;
4290 const void* data;
4291 uint32_t size;
4293 } _OrthancPluginUncompressImage;
4294
4295
4309 OrthancPluginContext* context,
4310 const void* data,
4311 uint32_t size,
4313 {
4314 OrthancPluginImage* target = NULL;
4315
4316 _OrthancPluginUncompressImage params;
4317 memset(&params, 0, sizeof(params));
4318 params.target = &target;
4319 params.data = data;
4320 params.size = size;
4321 params.format = format;
4322
4323 if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
4324 {
4325 return NULL;
4326 }
4327 else
4328 {
4329 return target;
4330 }
4331 }
4332
4333
4334
4335
4336 typedef struct
4337 {
4338 OrthancPluginImage* image;
4339 } _OrthancPluginFreeImage;
4340
4350 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
4351 OrthancPluginContext* context,
4352 OrthancPluginImage* image)
4353 {
4354 _OrthancPluginFreeImage params;
4355 params.image = image;
4356
4357 context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
4358 }
4359
4360
4361
4362
4363 typedef struct
4364 {
4366 OrthancPluginImageFormat imageFormat;
4367 OrthancPluginPixelFormat pixelFormat;
4368 uint32_t width;
4369 uint32_t height;
4370 uint32_t pitch;
4371 const void* buffer;
4372 uint8_t quality;
4373 } _OrthancPluginCompressImage;
4374
4375
4396 OrthancPluginContext* context,
4399 uint32_t width,
4400 uint32_t height,
4401 uint32_t pitch,
4402 const void* buffer)
4403 {
4404 _OrthancPluginCompressImage params;
4405 memset(&params, 0, sizeof(params));
4406 params.target = target;
4407 params.imageFormat = OrthancPluginImageFormat_Png;
4408 params.pixelFormat = format;
4409 params.width = width;
4410 params.height = height;
4411 params.pitch = pitch;
4412 params.buffer = buffer;
4413 params.quality = 0; /* Unused for PNG */
4414
4415 return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4416 }
4417
4418
4441 OrthancPluginContext* context,
4444 uint32_t width,
4445 uint32_t height,
4446 uint32_t pitch,
4447 const void* buffer,
4448 uint8_t quality)
4449 {
4450 _OrthancPluginCompressImage params;
4451 memset(&params, 0, sizeof(params));
4452 params.target = target;
4453 params.imageFormat = OrthancPluginImageFormat_Jpeg;
4454 params.pixelFormat = format;
4455 params.width = width;
4456 params.height = height;
4457 params.pitch = pitch;
4458 params.buffer = buffer;
4459 params.quality = quality;
4460
4461 return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4462 }
4463
4464
4465
4488 OrthancPluginContext* context,
4491 uint32_t width,
4492 uint32_t height,
4493 uint32_t pitch,
4494 const void* buffer,
4495 uint8_t quality)
4496 {
4497 _OrthancPluginCompressAndAnswerImage params;
4498 params.output = output;
4499 params.imageFormat = OrthancPluginImageFormat_Jpeg;
4500 params.pixelFormat = format;
4501 params.width = width;
4502 params.height = height;
4503 params.pitch = pitch;
4504 params.buffer = buffer;
4505 params.quality = quality;
4506 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4507 }
4508
4509
4510
4511
4512 typedef struct
4513 {
4516 const char* url;
4517 const char* username;
4518 const char* password;
4519 const void* body;
4520 uint32_t bodySize;
4521 } _OrthancPluginCallHttpClient;
4522
4523
4541 OrthancPluginContext* context,
4543 const char* url,
4544 const char* username,
4545 const char* password)
4546 {
4547 _OrthancPluginCallHttpClient params;
4548 memset(&params, 0, sizeof(params));
4549
4550 params.target = target;
4551 params.method = OrthancPluginHttpMethod_Get;
4552 params.url = url;
4553 params.username = username;
4554 params.password = password;
4555
4556 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4557 }
4558
4559
4579 OrthancPluginContext* context,
4581 const char* url,
4582 const void* body,
4583 uint32_t bodySize,
4584 const char* username,
4585 const char* password)
4586 {
4587 _OrthancPluginCallHttpClient params;
4588 memset(&params, 0, sizeof(params));
4589
4590 params.target = target;
4591 params.method = OrthancPluginHttpMethod_Post;
4592 params.url = url;
4593 params.body = body;
4594 params.bodySize = bodySize;
4595 params.username = username;
4596 params.password = password;
4597
4598 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4599 }
4600
4601
4621 OrthancPluginContext* context,
4623 const char* url,
4624 const void* body,
4625 uint32_t bodySize,
4626 const char* username,
4627 const char* password)
4628 {
4629 _OrthancPluginCallHttpClient params;
4630 memset(&params, 0, sizeof(params));
4631
4632 params.target = target;
4633 params.method = OrthancPluginHttpMethod_Put;
4634 params.url = url;
4635 params.body = body;
4636 params.bodySize = bodySize;
4637 params.username = username;
4638 params.password = password;
4639
4640 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4641 }
4642
4643
4659 OrthancPluginContext* context,
4660 const char* url,
4661 const char* username,
4662 const char* password)
4663 {
4664 _OrthancPluginCallHttpClient params;
4665 memset(&params, 0, sizeof(params));
4666
4667 params.method = OrthancPluginHttpMethod_Delete;
4668 params.url = url;
4669 params.username = username;
4670 params.password = password;
4671
4672 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4673 }
4674
4675
4676
4677 typedef struct
4678 {
4679 OrthancPluginImage** target;
4680 const OrthancPluginImage* source;
4681 OrthancPluginPixelFormat targetFormat;
4682 } _OrthancPluginConvertPixelFormat;
4683
4684
4697 OrthancPluginContext* context,
4698 const OrthancPluginImage* source,
4699 OrthancPluginPixelFormat targetFormat)
4700 {
4701 OrthancPluginImage* target = NULL;
4702
4703 _OrthancPluginConvertPixelFormat params;
4704 params.target = &target;
4705 params.source = source;
4706 params.targetFormat = targetFormat;
4707
4708 if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4709 {
4710 return NULL;
4711 }
4712 else
4713 {
4714 return target;
4715 }
4716 }
4717
4718
4719
4731 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4732 OrthancPluginContext* context)
4733 {
4734 uint32_t count = 0;
4735
4736 _OrthancPluginReturnSingleValue params;
4737 memset(&params, 0, sizeof(params));
4738 params.resultUint32 = &count;
4739
4740 if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4741 {
4742 /* Error */
4743 return 0;
4744 }
4745 else
4746 {
4747 return count;
4748 }
4749 }
4750
4751
4752
4753
4754 typedef struct
4755 {
4756 uint32_t fontIndex; /* in */
4757 const char** name; /* out */
4758 uint32_t* size; /* out */
4759 } _OrthancPluginGetFontInfo;
4760
4771 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4772 OrthancPluginContext* context,
4773 uint32_t fontIndex)
4774 {
4775 const char* result = NULL;
4776
4777 _OrthancPluginGetFontInfo params;
4778 memset(&params, 0, sizeof(params));
4779 params.name = &result;
4780 params.fontIndex = fontIndex;
4781
4782 if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4783 {
4784 return NULL;
4785 }
4786 else
4787 {
4788 return result;
4789 }
4790 }
4791
4792
4803 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4804 OrthancPluginContext* context,
4805 uint32_t fontIndex)
4806 {
4807 uint32_t result;
4808
4809 _OrthancPluginGetFontInfo params;
4810 memset(&params, 0, sizeof(params));
4811 params.size = &result;
4812 params.fontIndex = fontIndex;
4813
4814 if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4815 {
4816 return 0;
4817 }
4818 else
4819 {
4820 return result;
4821 }
4822 }
4823
4824
4825
4826 typedef struct
4827 {
4828 OrthancPluginImage* image;
4829 uint32_t fontIndex;
4830 const char* utf8Text;
4831 int32_t x;
4832 int32_t y;
4833 uint8_t r;
4834 uint8_t g;
4835 uint8_t b;
4836 } _OrthancPluginDrawText;
4837
4838
4857 OrthancPluginContext* context,
4858 OrthancPluginImage* image,
4859 uint32_t fontIndex,
4860 const char* utf8Text,
4861 int32_t x,
4862 int32_t y,
4863 uint8_t r,
4864 uint8_t g,
4865 uint8_t b)
4866 {
4867 _OrthancPluginDrawText params;
4868 memset(&params, 0, sizeof(params));
4869 params.image = image;
4870 params.fontIndex = fontIndex;
4871 params.utf8Text = utf8Text;
4872 params.x = x;
4873 params.y = y;
4874 params.r = r;
4875 params.g = g;
4876 params.b = b;
4877
4878 return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4879 }
4880
4881
4882
4883 typedef struct
4884 {
4885 OrthancPluginStorageArea* storageArea;
4886 const char* uuid;
4887 const void* content;
4888 uint64_t size;
4890 } _OrthancPluginStorageAreaCreate;
4891
4892
4910 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginStorageAreaCreate(
4911 OrthancPluginContext* context,
4912 OrthancPluginStorageArea* storageArea,
4913 const char* uuid,
4914 const void* content,
4915 uint64_t size,
4917 {
4918 _OrthancPluginStorageAreaCreate params;
4919 params.storageArea = storageArea;
4920 params.uuid = uuid;
4921 params.content = content;
4922 params.size = size;
4923 params.type = type;
4924
4925 return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4926 }
4927
4928
4929 typedef struct
4930 {
4932 OrthancPluginStorageArea* storageArea;
4933 const char* uuid;
4935 } _OrthancPluginStorageAreaRead;
4936
4937
4954 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginStorageAreaRead(
4955 OrthancPluginContext* context,
4957 OrthancPluginStorageArea* storageArea,
4958 const char* uuid,
4960 {
4961 _OrthancPluginStorageAreaRead params;
4962 params.target = target;
4963 params.storageArea = storageArea;
4964 params.uuid = uuid;
4965 params.type = type;
4966
4967 return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4968 }
4969
4970
4971 typedef struct
4972 {
4973 OrthancPluginStorageArea* storageArea;
4974 const char* uuid;
4976 } _OrthancPluginStorageAreaRemove;
4977
4993 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginStorageAreaRemove(
4994 OrthancPluginContext* context,
4995 OrthancPluginStorageArea* storageArea,
4996 const char* uuid,
4998 {
4999 _OrthancPluginStorageAreaRemove params;
5000 params.storageArea = storageArea;
5001 params.uuid = uuid;
5002 params.type = type;
5003
5004 return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
5005 }
5006
5007
5008
5009 typedef struct
5010 {
5011 OrthancPluginErrorCode* target;
5012 int32_t code;
5013 uint16_t httpStatus;
5014 const char* message;
5015 } _OrthancPluginRegisterErrorCode;
5016
5033 OrthancPluginContext* context,
5034 int32_t code,
5035 uint16_t httpStatus,
5036 const char* message)
5037 {
5039
5040 _OrthancPluginRegisterErrorCode params;
5041 params.target = &target;
5042 params.code = code;
5043 params.httpStatus = httpStatus;
5044 params.message = message;
5045
5046 if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
5047 {
5048 return target;
5049 }
5050 else
5051 {
5052 /* There was an error while assigned the error. Use a generic code. */
5054 }
5055 }
5056
5057
5058
5059 typedef struct
5060 {
5061 uint16_t group;
5062 uint16_t element;
5064 const char* name;
5065 uint32_t minMultiplicity;
5066 uint32_t maxMultiplicity;
5067 } _OrthancPluginRegisterDictionaryTag;
5068
5089 OrthancPluginContext* context,
5090 uint16_t group,
5091 uint16_t element,
5093 const char* name,
5094 uint32_t minMultiplicity,
5095 uint32_t maxMultiplicity)
5096 {
5097 _OrthancPluginRegisterDictionaryTag params;
5098 params.group = group;
5099 params.element = element;
5100 params.vr = vr;
5101 params.name = name;
5102 params.minMultiplicity = minMultiplicity;
5103 params.maxMultiplicity = maxMultiplicity;
5104
5105 return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
5106 }
5107
5108
5109
5110 typedef struct
5111 {
5112 uint16_t group;
5113 uint16_t element;
5115 const char* name;
5116 uint32_t minMultiplicity;
5117 uint32_t maxMultiplicity;
5118 const char* privateCreator;
5119 } _OrthancPluginRegisterPrivateDictionaryTag;
5120
5142 OrthancPluginContext* context,
5143 uint16_t group,
5144 uint16_t element,
5146 const char* name,
5147 uint32_t minMultiplicity,
5148 uint32_t maxMultiplicity,
5149 const char* privateCreator)
5150 {
5151 _OrthancPluginRegisterPrivateDictionaryTag params;
5152 params.group = group;
5153 params.element = element;
5154 params.vr = vr;
5155 params.name = name;
5156 params.minMultiplicity = minMultiplicity;
5157 params.maxMultiplicity = maxMultiplicity;
5158 params.privateCreator = privateCreator;
5159
5160 return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
5161 }
5162
5163
5164
5165 typedef struct
5166 {
5167 OrthancPluginStorageArea* storageArea;
5169 } _OrthancPluginReconstructMainDicomTags;
5170
5186 OrthancPluginContext* context,
5187 OrthancPluginStorageArea* storageArea,
5189 {
5190 _OrthancPluginReconstructMainDicomTags params;
5191 params.level = level;
5192 params.storageArea = storageArea;
5193
5194 return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
5195 }
5196
5197
5198 typedef struct
5199 {
5200 char** result;
5201 const char* instanceId;
5202 const void* buffer;
5203 uint32_t size;
5206 uint32_t maxStringLength;
5207 } _OrthancPluginDicomToJson;
5208
5209
5229 ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
5230 OrthancPluginContext* context,
5231 const void* buffer,
5232 uint32_t size,
5235 uint32_t maxStringLength)
5236 {
5237 char* result;
5238
5239 _OrthancPluginDicomToJson params;
5240 memset(&params, 0, sizeof(params));
5241 params.result = &result;
5242 params.buffer = buffer;
5243 params.size = size;
5244 params.format = format;
5245 params.flags = flags;
5246 params.maxStringLength = maxStringLength;
5247
5248 if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
5249 {
5250 /* Error */
5251 return NULL;
5252 }
5253 else
5254 {
5255 return result;
5256 }
5257 }
5258
5259
5278 ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
5279 OrthancPluginContext* context,
5280 const char* instanceId,
5283 uint32_t maxStringLength)
5284 {
5285 char* result;
5286
5287 _OrthancPluginDicomToJson params;
5288 memset(&params, 0, sizeof(params));
5289 params.result = &result;
5290 params.instanceId = instanceId;
5291 params.format = format;
5292 params.flags = flags;
5293 params.maxStringLength = maxStringLength;
5294
5295 if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
5296 {
5297 /* Error */
5298 return NULL;
5299 }
5300 else
5301 {
5302 return result;
5303 }
5304 }
5305
5306
5307 typedef struct
5308 {
5310 const char* uri;
5311 uint32_t headersCount;
5312 const char* const* headersKeys;
5313 const char* const* headersValues;
5314 int32_t afterPlugins;
5315 } _OrthancPluginRestApiGet2;
5316
5337 OrthancPluginContext* context,
5339 const char* uri,
5340 uint32_t headersCount,
5341 const char* const* headersKeys,
5342 const char* const* headersValues,
5343 int32_t afterPlugins)
5344 {
5345 _OrthancPluginRestApiGet2 params;
5346 params.target = target;
5347 params.uri = uri;
5348 params.headersCount = headersCount;
5349 params.headersKeys = headersKeys;
5350 params.headersValues = headersValues;
5351 params.afterPlugins = afterPlugins;
5352
5353 return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
5354 }
5355
5356
5357
5358 typedef struct
5359 {
5361 } _OrthancPluginWorklistCallback;
5362
5375 OrthancPluginContext* context,
5377 {
5378 _OrthancPluginWorklistCallback params;
5379 params.callback = callback;
5380
5381 return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
5382 }
5383
5384
5385
5386 typedef struct
5387 {
5389 const OrthancPluginWorklistQuery* query;
5390 const void* dicom;
5391 uint32_t size;
5392 } _OrthancPluginWorklistAnswersOperation;
5393
5411 OrthancPluginContext* context,
5413 const OrthancPluginWorklistQuery* query,
5414 const void* dicom,
5415 uint32_t size)
5416 {
5417 _OrthancPluginWorklistAnswersOperation params;
5418 params.answers = answers;
5419 params.query = query;
5420 params.dicom = dicom;
5421 params.size = size;
5422
5423 return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
5424 }
5425
5426
5441 OrthancPluginContext* context,
5443 {
5444 _OrthancPluginWorklistAnswersOperation params;
5445 params.answers = answers;
5446 params.query = NULL;
5447 params.dicom = NULL;
5448 params.size = 0;
5449
5450 return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5451 }
5452
5453
5454 typedef struct
5455 {
5456 const OrthancPluginWorklistQuery* query;
5457 const void* dicom;
5458 uint32_t size;
5459 int32_t* isMatch;
5461 } _OrthancPluginWorklistQueryOperation;
5462
5478 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5479 OrthancPluginContext* context,
5480 const OrthancPluginWorklistQuery* query,
5481 const void* dicom,
5482 uint32_t size)
5483 {
5484 int32_t isMatch = 0;
5485
5486 _OrthancPluginWorklistQueryOperation params;
5487 params.query = query;
5488 params.dicom = dicom;
5489 params.size = size;
5490 params.isMatch = &isMatch;
5491 params.target = NULL;
5492
5493 if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5494 {
5495 return isMatch;
5496 }
5497 else
5498 {
5499 /* Error: Assume non-match */
5500 return 0;
5501 }
5502 }
5503
5504
5518 OrthancPluginContext* context,
5520 const OrthancPluginWorklistQuery* query)
5521 {
5522 _OrthancPluginWorklistQueryOperation params;
5523 params.query = query;
5524 params.dicom = NULL;
5525 params.size = 0;
5526 params.isMatch = NULL;
5527 params.target = target;
5528
5529 return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5530 }
5531
5532
5544 OrthancPluginContext* context,
5545 const OrthancPluginDicomInstance* instance)
5546 {
5548
5549 _OrthancPluginAccessDicomInstance params;
5550 memset(&params, 0, sizeof(params));
5551 params.resultOrigin = &origin;
5552 params.instance = instance;
5553
5554 if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5555 {
5556 /* Error */
5558 }
5559 else
5560 {
5561 return origin;
5562 }
5563 }
5564
5565
5566 typedef struct
5567 {
5569 const char* json;
5570 const OrthancPluginImage* pixelData;
5572 } _OrthancPluginCreateDicom;
5573
5600 OrthancPluginContext* context,
5602 const char* json,
5603 const OrthancPluginImage* pixelData,
5605 {
5606 _OrthancPluginCreateDicom params;
5607 params.target = target;
5608 params.json = json;
5609 params.pixelData = pixelData;
5610 params.flags = flags;
5611
5612 return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5613 }
5614
5615
5616 typedef struct
5617 {
5619 } _OrthancPluginDecodeImageCallback;
5620
5636 OrthancPluginContext* context,
5638 {
5639 _OrthancPluginDecodeImageCallback params;
5640 params.callback = callback;
5641
5642 return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5643 }
5644
5645
5646
5647 typedef struct
5648 {
5649 OrthancPluginImage** target;
5651 uint32_t width;
5652 uint32_t height;
5653 uint32_t pitch;
5654 void* buffer;
5655 const void* constBuffer;
5656 uint32_t bufferSize;
5657 uint32_t frameIndex;
5658 } _OrthancPluginCreateImage;
5659
5660
5674 OrthancPluginContext* context,
5676 uint32_t width,
5677 uint32_t height)
5678 {
5679 OrthancPluginImage* target = NULL;
5680
5681 _OrthancPluginCreateImage params;
5682 memset(&params, 0, sizeof(params));
5683 params.target = &target;
5684 params.format = format;
5685 params.width = width;
5686 params.height = height;
5687
5688 if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5689 {
5690 return NULL;
5691 }
5692 else
5693 {
5694 return target;
5695 }
5696 }
5697
5698
5717 OrthancPluginContext* context,
5719 uint32_t width,
5720 uint32_t height,
5721 uint32_t pitch,
5722 void* buffer)
5723 {
5724 OrthancPluginImage* target = NULL;
5725
5726 _OrthancPluginCreateImage params;
5727 memset(&params, 0, sizeof(params));
5728 params.target = &target;
5729 params.format = format;
5730 params.width = width;
5731 params.height = height;
5732 params.pitch = pitch;
5733 params.buffer = buffer;
5734
5735 if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5736 {
5737 return NULL;
5738 }
5739 else
5740 {
5741 return target;
5742 }
5743 }
5744
5745
5746
5763 OrthancPluginContext* context,
5764 const void* buffer,
5765 uint32_t bufferSize,
5766 uint32_t frameIndex)
5767 {
5768 OrthancPluginImage* target = NULL;
5769
5770 _OrthancPluginCreateImage params;
5771 memset(&params, 0, sizeof(params));
5772 params.target = &target;
5773 params.constBuffer = buffer;
5774 params.bufferSize = bufferSize;
5775 params.frameIndex = frameIndex;
5776
5777 if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5778 {
5779 return NULL;
5780 }
5781 else
5782 {
5783 return target;
5784 }
5785 }
5786
5787
5788
5789 typedef struct
5790 {
5791 char** result;
5792 const void* buffer;
5793 uint32_t size;
5794 } _OrthancPluginComputeHash;
5795
5808 ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5809 OrthancPluginContext* context,
5810 const void* buffer,
5811 uint32_t size)
5812 {
5813 char* result;
5814
5815 _OrthancPluginComputeHash params;
5816 params.result = &result;
5817 params.buffer = buffer;
5818 params.size = size;
5819
5820 if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5821 {
5822 /* Error */
5823 return NULL;
5824 }
5825 else
5826 {
5827 return result;
5828 }
5829 }
5830
5831
5844 ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5845 OrthancPluginContext* context,
5846 const void* buffer,
5847 uint32_t size)
5848 {
5849 char* result;
5850
5851 _OrthancPluginComputeHash params;
5852 params.result = &result;
5853 params.buffer = buffer;
5854 params.size = size;
5855
5856 if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5857 {
5858 /* Error */
5859 return NULL;
5860 }
5861 else
5862 {
5863 return result;
5864 }
5865 }
5866
5867
5868
5869 typedef struct
5870 {
5872 const char* name;
5873 } _OrthancPluginLookupDictionary;
5874
5891 OrthancPluginContext* context,
5893 const char* name)
5894 {
5895 _OrthancPluginLookupDictionary params;
5896 params.target = target;
5897 params.name = name;
5898 return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5899 }
5900
5901
5902
5903 typedef struct
5904 {
5906 const void* answer;
5907 uint32_t answerSize;
5908 uint32_t headersCount;
5909 const char* const* headersKeys;
5910 const char* const* headersValues;
5911 } _OrthancPluginSendMultipartItem2;
5912
5934 OrthancPluginContext* context,
5936 const void* answer,
5937 uint32_t answerSize,
5938 uint32_t headersCount,
5939 const char* const* headersKeys,
5940 const char* const* headersValues)
5941 {
5942 _OrthancPluginSendMultipartItem2 params;
5943 params.output = output;
5944 params.answer = answer;
5945 params.answerSize = answerSize;
5946 params.headersCount = headersCount;
5947 params.headersKeys = headersKeys;
5948 params.headersValues = headersValues;
5949
5950 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5951 }
5952
5953
5954 typedef struct
5955 {
5957 } _OrthancPluginIncomingHttpRequestFilter;
5958
5971 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(
5972 OrthancPluginContext* context,
5974 {
5975 _OrthancPluginIncomingHttpRequestFilter params;
5976 params.callback = callback;
5977
5978 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5979 }
5980
5981
5982
5983 typedef struct
5984 {
5985 OrthancPluginMemoryBuffer* answerBody;
5986 OrthancPluginMemoryBuffer* answerHeaders;
5987 uint16_t* httpStatus;
5989 const char* url;
5990 uint32_t headersCount;
5991 const char* const* headersKeys;
5992 const char* const* headersValues;
5993 const void* body;
5994 uint32_t bodySize;
5995 const char* username;
5996 const char* password;
5997 uint32_t timeout;
5998 const char* certificateFile;
5999 const char* certificateKeyFile;
6000 const char* certificateKeyPassword;
6001 uint8_t pkcs11;
6002 } _OrthancPluginCallHttpClient2;
6003
6004
6005
6047 OrthancPluginContext* context,
6048 OrthancPluginMemoryBuffer* answerBody,
6049 OrthancPluginMemoryBuffer* answerHeaders,
6050 uint16_t* httpStatus,
6052 const char* url,
6053 uint32_t headersCount,
6054 const char* const* headersKeys,
6055 const char* const* headersValues,
6056 const void* body,
6057 uint32_t bodySize,
6058 const char* username,
6059 const char* password,
6060 uint32_t timeout,
6061 const char* certificateFile,
6062 const char* certificateKeyFile,
6063 const char* certificateKeyPassword,
6064 uint8_t pkcs11)
6065 {
6066 _OrthancPluginCallHttpClient2 params;
6067 memset(&params, 0, sizeof(params));
6068
6069 params.answerBody = answerBody;
6070 params.answerHeaders = answerHeaders;
6071 params.httpStatus = httpStatus;
6072 params.method = method;
6073 params.url = url;
6074 params.headersCount = headersCount;
6075 params.headersKeys = headersKeys;
6076 params.headersValues = headersValues;
6077 params.body = body;
6078 params.bodySize = bodySize;
6079 params.username = username;
6080 params.password = password;
6081 params.timeout = timeout;
6082 params.certificateFile = certificateFile;
6083 params.certificateKeyFile = certificateKeyFile;
6084 params.certificateKeyPassword = certificateKeyPassword;
6085 params.pkcs11 = pkcs11;
6086
6087 return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
6088 }
6089
6090
6101 ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
6102 OrthancPluginContext* context)
6103 {
6104 char* result;
6105
6106 _OrthancPluginRetrieveDynamicString params;
6107 params.result = &result;
6108 params.argument = NULL;
6109
6110 if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
6111 {
6112 /* Error */
6113 return NULL;
6114 }
6115 else
6116 {
6117 return result;
6118 }
6119 }
6120
6121
6122
6123
6124 typedef struct
6125 {
6127 } _OrthancPluginFindCallback;
6128
6141 OrthancPluginContext* context,
6143 {
6144 _OrthancPluginFindCallback params;
6145 params.callback = callback;
6146
6147 return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
6148 }
6149
6150
6151 typedef struct
6152 {
6153 OrthancPluginFindAnswers *answers;
6154 const OrthancPluginFindQuery *query;
6155 const void *dicom;
6156 uint32_t size;
6157 uint32_t index;
6158 uint32_t *resultUint32;
6159 uint16_t *resultGroup;
6160 uint16_t *resultElement;
6161 char **resultString;
6162 } _OrthancPluginFindOperation;
6163
6180 OrthancPluginContext* context,
6181 OrthancPluginFindAnswers* answers,
6182 const void* dicom,
6183 uint32_t size)
6184 {
6185 _OrthancPluginFindOperation params;
6186 memset(&params, 0, sizeof(params));
6187 params.answers = answers;
6188 params.dicom = dicom;
6189 params.size = size;
6190
6191 return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
6192 }
6193
6194
6209 OrthancPluginContext* context,
6210 OrthancPluginFindAnswers* answers)
6211 {
6212 _OrthancPluginFindOperation params;
6213 memset(&params, 0, sizeof(params));
6214 params.answers = answers;
6215
6216 return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
6217 }
6218
6219
6220
6232 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
6233 OrthancPluginContext* context,
6234 const OrthancPluginFindQuery* query)
6235 {
6236 uint32_t count = 0;
6237
6238 _OrthancPluginFindOperation params;
6239 memset(&params, 0, sizeof(params));
6240 params.query = query;
6241 params.resultUint32 = &count;
6242
6243 if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
6244 {
6245 /* Error */
6246 return 0;
6247 }
6248 else
6249 {
6250 return count;
6251 }
6252 }
6253
6254
6270 OrthancPluginContext* context,
6271 uint16_t* group,
6272 uint16_t* element,
6273 const OrthancPluginFindQuery* query,
6274 uint32_t index)
6275 {
6276 _OrthancPluginFindOperation params;
6277 memset(&params, 0, sizeof(params));
6278 params.query = query;
6279 params.index = index;
6280 params.resultGroup = group;
6281 params.resultElement = element;
6282
6283 return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
6284 }
6285
6286
6300 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
6301 OrthancPluginContext* context,
6302 const OrthancPluginFindQuery* query,
6303 uint32_t index)
6304 {
6305 char* result;
6306
6307 _OrthancPluginFindOperation params;
6308 memset(&params, 0, sizeof(params));
6309 params.query = query;
6310 params.index = index;
6311 params.resultString = &result;
6312
6313 if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
6314 {
6315 /* Error */
6316 return NULL;
6317 }
6318 else
6319 {
6320 return result;
6321 }
6322 }
6323
6324
6338 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
6339 OrthancPluginContext* context,
6340 const OrthancPluginFindQuery* query,
6341 uint32_t index)
6342 {
6343 char* result;
6344
6345 _OrthancPluginFindOperation params;
6346 memset(&params, 0, sizeof(params));
6347 params.query = query;
6348 params.index = index;
6349 params.resultString = &result;
6350
6351 if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
6352 {
6353 /* Error */
6354 return NULL;
6355 }
6356 else
6357 {
6358 return result;
6359 }
6360 }
6361
6362
6363
6364
6365 typedef struct
6366 {
6368 OrthancPluginGetMoveSize getMoveSize;
6369 OrthancPluginApplyMove applyMove;
6370 OrthancPluginFreeMove freeMove;
6371 } _OrthancPluginMoveCallback;
6372
6387 OrthancPluginContext* context,
6389 OrthancPluginGetMoveSize getMoveSize,
6390 OrthancPluginApplyMove applyMove,
6391 OrthancPluginFreeMove freeMove)
6392 {
6393 _OrthancPluginMoveCallback params;
6394 params.callback = callback;
6395 params.getMoveSize = getMoveSize;
6396 params.applyMove = applyMove;
6397 params.freeMove = freeMove;
6398
6399 return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
6400 }
6401
6402
6403
6404 typedef struct
6405 {
6406 OrthancPluginFindMatcher** target;
6407 const void* query;
6408 uint32_t size;
6409 } _OrthancPluginCreateFindMatcher;
6410
6411
6426 OrthancPluginContext* context,
6427 const void* query,
6428 uint32_t size)
6429 {
6430 OrthancPluginFindMatcher* target = NULL;
6431
6432 _OrthancPluginCreateFindMatcher params;
6433 memset(&params, 0, sizeof(params));
6434 params.target = &target;
6435 params.query = query;
6436 params.size = size;
6437
6438 if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
6439 {
6440 return NULL;
6441 }
6442 else
6443 {
6444 return target;
6445 }
6446 }
6447
6448
6449 typedef struct
6450 {
6451 OrthancPluginFindMatcher* matcher;
6452 } _OrthancPluginFreeFindMatcher;
6453
6463 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6464 OrthancPluginContext* context,
6465 OrthancPluginFindMatcher* matcher)
6466 {
6467 _OrthancPluginFreeFindMatcher params;
6468 params.matcher = matcher;
6469
6470 context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6471 }
6472
6473
6474 typedef struct
6475 {
6476 const OrthancPluginFindMatcher* matcher;
6477 const void* dicom;
6478 uint32_t size;
6479 int32_t* isMatch;
6480 } _OrthancPluginFindMatcherIsMatch;
6481
6496 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6497 OrthancPluginContext* context,
6498 const OrthancPluginFindMatcher* matcher,
6499 const void* dicom,
6500 uint32_t size)
6501 {
6502 int32_t isMatch = 0;
6503
6504 _OrthancPluginFindMatcherIsMatch params;
6505 params.matcher = matcher;
6506 params.dicom = dicom;
6507 params.size = size;
6508 params.isMatch = &isMatch;
6509
6510 if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6511 {
6512 return isMatch;
6513 }
6514 else
6515 {
6516 /* Error: Assume non-match */
6517 return 0;
6518 }
6519 }
6520
6521
6522 typedef struct
6523 {
6525 } _OrthancPluginIncomingHttpRequestFilter2;
6526
6539 OrthancPluginContext* context,
6541 {
6542 _OrthancPluginIncomingHttpRequestFilter2 params;
6543 params.callback = callback;
6544
6545 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6546 }
6547
6548
6549
6550 typedef struct
6551 {
6552 OrthancPluginPeers** peers;
6553 } _OrthancPluginGetPeers;
6554
6567 OrthancPluginContext* context)
6568 {
6569 OrthancPluginPeers* peers = NULL;
6570
6571 _OrthancPluginGetPeers params;
6572 memset(&params, 0, sizeof(params));
6573 params.peers = &peers;
6574
6575 if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6576 {
6577 return NULL;
6578 }
6579 else
6580 {
6581 return peers;
6582 }
6583 }
6584
6585
6586 typedef struct
6587 {
6588 OrthancPluginPeers* peers;
6589 } _OrthancPluginFreePeers;
6590
6600 ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6601 OrthancPluginContext* context,
6602 OrthancPluginPeers* peers)
6603 {
6604 _OrthancPluginFreePeers params;
6605 params.peers = peers;
6606
6607 context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6608 }
6609
6610
6611 typedef struct
6612 {
6613 uint32_t* target;
6614 const OrthancPluginPeers* peers;
6615 } _OrthancPluginGetPeersCount;
6616
6630 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6631 OrthancPluginContext* context,
6632 const OrthancPluginPeers* peers)
6633 {
6634 uint32_t target = 0;
6635
6636 _OrthancPluginGetPeersCount params;
6637 memset(&params, 0, sizeof(params));
6638 params.target = &target;
6639 params.peers = peers;
6640
6641 if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6642 {
6643 /* Error */
6644 return 0;
6645 }
6646 else
6647 {
6648 return target;
6649 }
6650 }
6651
6652
6653 typedef struct
6654 {
6655 const char** target;
6656 const OrthancPluginPeers* peers;
6657 uint32_t peerIndex;
6658 const char* userProperty;
6659 } _OrthancPluginGetPeerProperty;
6660
6678 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6679 OrthancPluginContext* context,
6680 const OrthancPluginPeers* peers,
6681 uint32_t peerIndex)
6682 {
6683 const char* target = NULL;
6684
6685 _OrthancPluginGetPeerProperty params;
6686 memset(&params, 0, sizeof(params));
6687 params.target = &target;
6688 params.peers = peers;
6689 params.peerIndex = peerIndex;
6690 params.userProperty = NULL;
6691
6692 if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6693 {
6694 /* Error */
6695 return NULL;
6696 }
6697 else
6698 {
6699 return target;
6700 }
6701 }
6702
6703
6719 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6720 OrthancPluginContext* context,
6721 const OrthancPluginPeers* peers,
6722 uint32_t peerIndex)
6723 {
6724 const char* target = NULL;
6725
6726 _OrthancPluginGetPeerProperty params;
6727 memset(&params, 0, sizeof(params));
6728 params.target = &target;
6729 params.peers = peers;
6730 params.peerIndex = peerIndex;
6731 params.userProperty = NULL;
6732
6733 if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6734 {
6735 /* Error */
6736 return NULL;
6737 }
6738 else
6739 {
6740 return target;
6741 }
6742 }
6743
6744
6745
6765 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6766 OrthancPluginContext* context,
6767 const OrthancPluginPeers* peers,
6768 uint32_t peerIndex,
6769 const char* userProperty)
6770 {
6771 const char* target = NULL;
6772
6773 _OrthancPluginGetPeerProperty params;
6774 memset(&params, 0, sizeof(params));
6775 params.target = &target;
6776 params.peers = peers;
6777 params.peerIndex = peerIndex;
6778 params.userProperty = userProperty;
6779
6780 if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6781 {
6782 /* No such user property */
6783 return NULL;
6784 }
6785 else
6786 {
6787 return target;
6788 }
6789 }
6790
6791
6792
6793 typedef struct
6794 {
6795 OrthancPluginMemoryBuffer* answerBody;
6796 OrthancPluginMemoryBuffer* answerHeaders;
6797 uint16_t* httpStatus;
6798 const OrthancPluginPeers* peers;
6799 uint32_t peerIndex;
6801 const char* uri;
6802 uint32_t additionalHeadersCount;
6803 const char* const* additionalHeadersKeys;
6804 const char* const* additionalHeadersValues;
6805 const void* body;
6806 uint32_t bodySize;
6807 uint32_t timeout;
6808 } _OrthancPluginCallPeerApi;
6809
6847 OrthancPluginContext* context,
6848 OrthancPluginMemoryBuffer* answerBody,
6849 OrthancPluginMemoryBuffer* answerHeaders,
6850 uint16_t* httpStatus,
6851 const OrthancPluginPeers* peers,
6852 uint32_t peerIndex,
6854 const char* uri,
6855 uint32_t additionalHeadersCount,
6856 const char* const* additionalHeadersKeys,
6857 const char* const* additionalHeadersValues,
6858 const void* body,
6859 uint32_t bodySize,
6860 uint32_t timeout)
6861 {
6862 _OrthancPluginCallPeerApi params;
6863 memset(&params, 0, sizeof(params));
6864
6865 params.answerBody = answerBody;
6866 params.answerHeaders = answerHeaders;
6867 params.httpStatus = httpStatus;
6868 params.peers = peers;
6869 params.peerIndex = peerIndex;
6870 params.method = method;
6871 params.uri = uri;
6872 params.additionalHeadersCount = additionalHeadersCount;
6873 params.additionalHeadersKeys = additionalHeadersKeys;
6874 params.additionalHeadersValues = additionalHeadersValues;
6875 params.body = body;
6876 params.bodySize = bodySize;
6877 params.timeout = timeout;
6878
6879 return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6880 }
6881
6882
6883
6884
6885
6886 typedef struct
6887 {
6888 OrthancPluginJob** target;
6889 void *job;
6890 OrthancPluginJobFinalize finalize;
6891 const char *type;
6892 OrthancPluginJobGetProgress getProgress;
6893 OrthancPluginJobGetContent getContent;
6894 OrthancPluginJobGetSerialized getSerialized;
6898 } _OrthancPluginCreateJob;
6899
6932 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE OrthancPluginJob *OrthancPluginCreateJob(
6933 OrthancPluginContext *context,
6934 void *job,
6935 OrthancPluginJobFinalize finalize,
6936 const char *type,
6937 OrthancPluginJobGetProgress getProgress,
6938 OrthancPluginJobGetContent getContent,
6939 OrthancPluginJobGetSerialized getSerialized,
6943 {
6944 OrthancPluginJob* target = NULL;
6945
6946 _OrthancPluginCreateJob params;
6947 memset(&params, 0, sizeof(params));
6948
6949 params.target = &target;
6950 params.job = job;
6951 params.finalize = finalize;
6952 params.type = type;
6953 params.getProgress = getProgress;
6954 params.getContent = getContent;
6955 params.getSerialized = getSerialized;
6956 params.step = step;
6957 params.stop = stop;
6958 params.reset = reset;
6959
6960 if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6961 target == NULL)
6962 {
6963 /* Error */
6964 return NULL;
6965 }
6966 else
6967 {
6968 return target;
6969 }
6970 }
6971
6972
6973 typedef struct
6974 {
6975 OrthancPluginJob** target;
6976 void *job;
6977 OrthancPluginJobFinalize finalize;
6978 const char *type;
6979 OrthancPluginJobGetProgress getProgress;
6980 OrthancPluginJobGetContent2 getContent;
6981 OrthancPluginJobGetSerialized2 getSerialized;
6985 } _OrthancPluginCreateJob2;
6986
7019 OrthancPluginContext *context,
7020 void *job,
7021 OrthancPluginJobFinalize finalize,
7022 const char *type,
7023 OrthancPluginJobGetProgress getProgress,
7024 OrthancPluginJobGetContent2 getContent,
7025 OrthancPluginJobGetSerialized2 getSerialized,
7029 {
7030 OrthancPluginJob* target = NULL;
7031
7032 _OrthancPluginCreateJob2 params;
7033 memset(&params, 0, sizeof(params));
7034
7035 params.target = &target;
7036 params.job = job;
7037 params.finalize = finalize;
7038 params.type = type;
7039 params.getProgress = getProgress;
7040 params.getContent = getContent;
7041 params.getSerialized = getSerialized;
7042 params.step = step;
7043 params.stop = stop;
7044 params.reset = reset;
7045
7046 if (context->InvokeService(context, _OrthancPluginService_CreateJob2, &params) != OrthancPluginErrorCode_Success ||
7047 target == NULL)
7048 {
7049 /* Error */
7050 return NULL;
7051 }
7052 else
7053 {
7054 return target;
7055 }
7056 }
7057
7058
7059 typedef struct
7060 {
7061 OrthancPluginJob* job;
7062 } _OrthancPluginFreeJob;
7063
7073 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
7074 OrthancPluginContext* context,
7075 OrthancPluginJob* job)
7076 {
7077 _OrthancPluginFreeJob params;
7078 params.job = job;
7079
7080 context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
7081 }
7082
7083
7084
7085 typedef struct
7086 {
7087 char** resultId;
7088 OrthancPluginJob *job;
7089 int32_t priority;
7090 } _OrthancPluginSubmitJob;
7091
7105 ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
7106 OrthancPluginContext *context,
7107 OrthancPluginJob *job,
7108 int32_t priority)
7109 {
7110 char* resultId = NULL;
7111
7112 _OrthancPluginSubmitJob params;
7113 memset(&params, 0, sizeof(params));
7114
7115 params.resultId = &resultId;
7116 params.job = job;
7117 params.priority = priority;
7118
7119 if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
7120 resultId == NULL)
7121 {
7122 /* Error */
7123 return NULL;
7124 }
7125 else
7126 {
7127 return resultId;
7128 }
7129 }
7130
7131
7132
7133 typedef struct
7134 {
7135 OrthancPluginJobsUnserializer unserializer;
7136 } _OrthancPluginJobsUnserializer;
7137
7150 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
7151 OrthancPluginContext* context,
7152 OrthancPluginJobsUnserializer unserializer)
7153 {
7154 _OrthancPluginJobsUnserializer params;
7155 params.unserializer = unserializer;
7156
7157 context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
7158 }
7159
7160
7161
7162 typedef struct
7163 {
7165 const char* details;
7166 uint8_t log;
7167 } _OrthancPluginSetHttpErrorDetails;
7168
7186 ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
7187 OrthancPluginContext* context,
7189 const char* details,
7190 uint8_t log)
7191 {
7192 _OrthancPluginSetHttpErrorDetails params;
7193 params.output = output;
7194 params.details = details;
7195 params.log = log;
7196 context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
7197 }
7198
7199
7200
7201 typedef struct
7202 {
7203 const char** result;
7204 const char* argument;
7205 } _OrthancPluginRetrieveStaticString;
7206
7218 ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
7219 OrthancPluginContext* context,
7220 const char* path)
7221 {
7222 const char* result = NULL;
7223
7224 _OrthancPluginRetrieveStaticString params;
7225 params.result = &result;
7226 params.argument = path;
7227
7228 if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
7229 {
7230 /* Error */
7231 return NULL;
7232 }
7233 else
7234 {
7235 return result;
7236 }
7237 }
7238
7239
7240
7241 typedef struct
7242 {
7243 const char* name;
7244 float value;
7246 } _OrthancPluginSetMetricsValue;
7247
7264 ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
7265 OrthancPluginContext* context,
7266 const char* name,
7267 float value,
7269 {
7270 _OrthancPluginSetMetricsValue params;
7271 params.name = name;
7272 params.value = value;
7273 params.type = type;
7274 context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
7275 }
7276
7277
7278
7279 typedef struct
7280 {
7282 } _OrthancPluginRegisterRefreshMetricsCallback;
7283
7296 OrthancPluginContext* context,
7298 {
7299 _OrthancPluginRegisterRefreshMetricsCallback params;
7300 params.callback = callback;
7301 context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
7302 }
7303
7304
7305
7306
7307 typedef struct
7308 {
7309 char** target;
7310 const void* dicom;
7311 uint32_t dicomSize;
7313 } _OrthancPluginEncodeDicomWeb;
7314
7331 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
7332 OrthancPluginContext* context,
7333 const void* dicom,
7334 uint32_t dicomSize,
7336 {
7337 char* target = NULL;
7338
7339 _OrthancPluginEncodeDicomWeb params;
7340 params.target = &target;
7341 params.dicom = dicom;
7342 params.dicomSize = dicomSize;
7343 params.callback = callback;
7344
7345 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
7346 {
7347 /* Error */
7348 return NULL;
7349 }
7350 else
7351 {
7352 return target;
7353 }
7354 }
7355
7356
7373 ORTHANC_PLUGIN_DEPRECATED ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
7374 OrthancPluginContext* context,
7375 const void* dicom,
7376 uint32_t dicomSize,
7378 {
7379 char* target = NULL;
7380
7381 _OrthancPluginEncodeDicomWeb params;
7382 params.target = &target;
7383 params.dicom = dicom;
7384 params.dicomSize = dicomSize;
7385 params.callback = callback;
7386
7387 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
7388 {
7389 /* Error */
7390 return NULL;
7391 }
7392 else
7393 {
7394 return target;
7395 }
7396 }
7397
7398
7399
7400 typedef struct
7401 {
7402 char** target;
7403 const void* dicom;
7404 uint32_t dicomSize;
7406 void* payload;
7407 } _OrthancPluginEncodeDicomWeb2;
7408
7425 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson2(
7426 OrthancPluginContext* context,
7427 const void* dicom,
7428 uint32_t dicomSize,
7430 void* payload)
7431 {
7432 char* target = NULL;
7433
7434 _OrthancPluginEncodeDicomWeb2 params;
7435 params.target = &target;
7436 params.dicom = dicom;
7437 params.dicomSize = dicomSize;
7438 params.callback = callback;
7439 params.payload = payload;
7440
7441 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson2, &params) != OrthancPluginErrorCode_Success)
7442 {
7443 /* Error */
7444 return NULL;
7445 }
7446 else
7447 {
7448 return target;
7449 }
7450 }
7451
7452
7469 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml2(
7470 OrthancPluginContext* context,
7471 const void* dicom,
7472 uint32_t dicomSize,
7474 void* payload)
7475 {
7476 char* target = NULL;
7477
7478 _OrthancPluginEncodeDicomWeb2 params;
7479 params.target = &target;
7480 params.dicom = dicom;
7481 params.dicomSize = dicomSize;
7482 params.callback = callback;
7483 params.payload = payload;
7484
7485 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml2, &params) != OrthancPluginErrorCode_Success)
7486 {
7487 /* Error */
7488 return NULL;
7489 }
7490 else
7491 {
7492 return target;
7493 }
7494 }
7495
7496
7497
7514 void* answer,
7515 const char* key,
7516 const char* value);
7517
7518
7535 void* answer,
7536 const void* data,
7537 uint32_t size);
7538
7539
7554 typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
7555
7556
7572
7573
7587 typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
7588
7589
7603 typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
7604
7605
7606 typedef struct
7607 {
7608 void* answer;
7611 uint16_t* httpStatus;
7613 const char* url;
7614 uint32_t headersCount;
7615 const char* const* headersKeys;
7616 const char* const* headersValues;
7617 void* request;
7622 const char* username;
7623 const char* password;
7624 uint32_t timeout;
7625 const char* certificateFile;
7626 const char* certificateKeyFile;
7627 const char* certificateKeyPassword;
7628 uint8_t pkcs11;
7629 } _OrthancPluginChunkedHttpClient;
7630
7631
7683 OrthancPluginContext* context,
7684 void* answer,
7687 uint16_t* httpStatus,
7689 const char* url,
7690 uint32_t headersCount,
7691 const char* const* headersKeys,
7692 const char* const* headersValues,
7693 void* request,
7698 const char* username,
7699 const char* password,
7700 uint32_t timeout,
7701 const char* certificateFile,
7702 const char* certificateKeyFile,
7703 const char* certificateKeyPassword,
7704 uint8_t pkcs11)
7705 {
7706 _OrthancPluginChunkedHttpClient params;
7707 memset(&params, 0, sizeof(params));
7708
7709 /* In common with OrthancPluginHttpClient() */
7710 params.httpStatus = httpStatus;
7711 params.method = method;
7712 params.url = url;
7713 params.headersCount = headersCount;
7714 params.headersKeys = headersKeys;
7715 params.headersValues = headersValues;
7716 params.username = username;
7717 params.password = password;
7718 params.timeout = timeout;
7719 params.certificateFile = certificateFile;
7720 params.certificateKeyFile = certificateKeyFile;
7721 params.certificateKeyPassword = certificateKeyPassword;
7722 params.pkcs11 = pkcs11;
7723
7724 /* For chunked body/answer */
7725 params.answer = answer;
7726 params.answerAddChunk = answerAddChunk;
7727 params.answerAddHeader = answerAddHeader;
7728 params.request = request;
7729 params.requestIsDone = requestIsDone;
7730 params.requestChunkData = requestChunkData;
7731 params.requestChunkSize = requestChunkSize;
7732 params.requestNext = requestNext;
7733
7734 return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7735 }
7736
7737
7738
7743 typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7744
7745
7746
7764 const char* url,
7765 const OrthancPluginHttpRequest* request);
7766
7767
7783 const void* data,
7784 uint32_t size);
7785
7786
7803 OrthancPluginRestOutput* output);
7804
7805
7821
7822 typedef struct
7823 {
7824 const char* pathRegularExpression;
7825 OrthancPluginRestCallback getHandler;
7827 OrthancPluginRestCallback deleteHandler;
7832 } _OrthancPluginChunkedRestCallback;
7833
7834
7865 OrthancPluginContext* context,
7866 const char* pathRegularExpression,
7867 OrthancPluginRestCallback getHandler,
7869 OrthancPluginRestCallback deleteHandler,
7874 {
7875 _OrthancPluginChunkedRestCallback params;
7876 params.pathRegularExpression = pathRegularExpression;
7877 params.getHandler = getHandler;
7878 params.postHandler = postHandler;
7879 params.deleteHandler = deleteHandler;
7880 params.putHandler = putHandler;
7881 params.addChunk = addChunk;
7882 params.execute = execute;
7883 params.finalize = finalize;
7884
7885 context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
7886 }
7887
7888
7889
7890
7891
7892 typedef struct
7893 {
7894 char** result;
7895 uint16_t group;
7896 uint16_t element;
7897 const char* privateCreator;
7898 } _OrthancPluginGetTagName;
7899
7915 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
7916 OrthancPluginContext* context,
7917 uint16_t group,
7918 uint16_t element,
7919 const char* privateCreator)
7920 {
7921 char* result;
7922
7923 _OrthancPluginGetTagName params;
7924 params.result = &result;
7925 params.group = group;
7926 params.element = element;
7927 params.privateCreator = privateCreator;
7928
7929 if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
7930 {
7931 /* Error */
7932 return NULL;
7933 }
7934 else
7935 {
7936 return result;
7937 }
7938 }
7939
7940
7941
7971 void** handler /* out */,
7972 const char* jobId,
7973 const char* transactionUid,
7974 const char* const* sopClassUids,
7975 const char* const* sopInstanceUids,
7976 uint32_t countInstances,
7977 const char* remoteAet,
7978 const char* calledAet);
7979
7980
7992 typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
7993
7994
8015 void* handler,
8016 const char* sopClassUid,
8017 const char* sopInstanceUid);
8018
8019
8020 typedef struct
8021 {
8025 } _OrthancPluginRegisterStorageCommitmentScpCallback;
8026
8041 OrthancPluginContext* context,
8045 {
8046 _OrthancPluginRegisterStorageCommitmentScpCallback params;
8047 params.factory = factory;
8048 params.destructor = destructor;
8049 params.lookup = lookup;
8050 return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
8051 }
8052
8053
8054
8081 const OrthancPluginDicomInstance* instance);
8082
8083
8084 typedef struct
8085 {
8087 } _OrthancPluginIncomingDicomInstanceFilter;
8088
8102 OrthancPluginContext* context,
8104 {
8105 _OrthancPluginIncomingDicomInstanceFilter params;
8106 params.callback = callback;
8107
8108 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, &params);
8109 }
8110
8111
8143 uint16_t* dimseStatus /* out */,
8144 const OrthancPluginDicomInstance* instance);
8145
8146
8147 typedef struct
8148 {
8150 } _OrthancPluginIncomingCStoreInstanceFilter;
8151
8165 OrthancPluginContext* context,
8167 {
8168 _OrthancPluginIncomingCStoreInstanceFilter params;
8169 params.callback = callback;
8170
8171 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingCStoreInstanceFilter, &params);
8172 }
8173
8210 OrthancPluginMemoryBuffer64* modifiedDicomBuffer,
8211 const void* receivedDicomBuffer,
8212 uint64_t receivedDicomBufferSize,
8214
8215
8216 typedef struct
8217 {
8219 } _OrthancPluginReceivedInstanceCallback;
8220
8242 OrthancPluginContext* context,
8244 {
8245 _OrthancPluginReceivedInstanceCallback params;
8246 params.callback = callback;
8247
8248 return context->InvokeService(context, _OrthancPluginService_RegisterReceivedInstanceCallback, &params);
8249 }
8250
8265 OrthancPluginContext* context,
8266 const OrthancPluginDicomInstance* instance)
8267 {
8268 char* result;
8269
8270 _OrthancPluginAccessDicomInstance params;
8271 memset(&params, 0, sizeof(params));
8272 params.resultStringToFree = &result;
8273 params.instance = instance;
8274
8275 if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, &params) != OrthancPluginErrorCode_Success)
8276 {
8277 /* Error */
8278 return NULL;
8279 }
8280 else
8281 {
8282 return result;
8283 }
8284 }
8285
8286
8299 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData(
8300 OrthancPluginContext* context,
8301 const OrthancPluginDicomInstance* instance)
8302 {
8303 int64_t hasPixelData;
8304
8305 _OrthancPluginAccessDicomInstance params;
8306 memset(&params, 0, sizeof(params));
8307 params.resultInt64 = &hasPixelData;
8308 params.instance = instance;
8309
8310 if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, &params) != OrthancPluginErrorCode_Success ||
8311 hasPixelData < 0 ||
8312 hasPixelData > 1)
8313 {
8314 /* Error */
8315 return -1;
8316 }
8317 else
8318 {
8319 return (hasPixelData != 0);
8320 }
8321 }
8322
8323
8324
8325
8326
8327
8328 typedef struct
8329 {
8331 const void* buffer;
8332 uint32_t size;
8333 const char* transferSyntax;
8334 } _OrthancPluginCreateDicomInstance;
8335
8350 OrthancPluginContext* context,
8351 const void* buffer,
8352 uint32_t size)
8353 {
8354 OrthancPluginDicomInstance* target = NULL;
8355
8356 _OrthancPluginCreateDicomInstance params;
8357 params.target = &target;
8358 params.buffer = buffer;
8359 params.size = size;
8360
8361 if (context->InvokeService(context, _OrthancPluginService_CreateDicomInstance, &params) != OrthancPluginErrorCode_Success)
8362 {
8363 /* Error */
8364 return NULL;
8365 }
8366 else
8367 {
8368 return target;
8369 }
8370 }
8371
8372 typedef struct
8373 {
8375 } _OrthancPluginFreeDicomInstance;
8376
8387 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeDicomInstance(
8388 OrthancPluginContext* context,
8390 {
8391 _OrthancPluginFreeDicomInstance params;
8392 params.dicom = dicom;
8393
8394 context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, &params);
8395 }
8396
8397
8398 typedef struct
8399 {
8400 uint32_t* targetUint32;
8401 OrthancPluginMemoryBuffer* targetBuffer;
8402 OrthancPluginImage** targetImage;
8403 char** targetStringToFree;
8404 const OrthancPluginDicomInstance* instance;
8405 uint32_t frameIndex;
8408 uint32_t maxStringLength;
8409 OrthancPluginDicomWebBinaryCallback2 dicomWebCallback;
8410 void* dicomWebPayload;
8411 } _OrthancPluginAccessDicomInstance2;
8412
8424 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetInstanceFramesCount(
8425 OrthancPluginContext* context,
8426 const OrthancPluginDicomInstance* instance)
8427 {
8428 uint32_t count;
8429
8430 _OrthancPluginAccessDicomInstance2 params;
8431 memset(&params, 0, sizeof(params));
8432 params.targetUint32 = &count;
8433 params.instance = instance;
8434
8435 if (context->InvokeService(context, _OrthancPluginService_GetInstanceFramesCount, &params) != OrthancPluginErrorCode_Success)
8436 {
8437 /* Error */
8438 return 0;
8439 }
8440 else
8441 {
8442 return count;
8443 }
8444 }
8445
8446
8465 OrthancPluginContext* context,
8467 const OrthancPluginDicomInstance* instance,
8468 uint32_t frameIndex)
8469 {
8470 _OrthancPluginAccessDicomInstance2 params;
8471 memset(&params, 0, sizeof(params));
8472 params.targetBuffer = target;
8473 params.instance = instance;
8474 params.frameIndex = frameIndex;
8475
8476 return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, &params);
8477 }
8478
8479
8493 OrthancPluginContext* context,
8494 const OrthancPluginDicomInstance* instance,
8495 uint32_t frameIndex)
8496 {
8497 OrthancPluginImage* target = NULL;
8498
8499 _OrthancPluginAccessDicomInstance2 params;
8500 memset(&params, 0, sizeof(params));
8501 params.targetImage = &target;
8502 params.instance = instance;
8503 params.frameIndex = frameIndex;
8504
8505 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDecodedFrame, &params) != OrthancPluginErrorCode_Success)
8506 {
8507 return NULL;
8508 }
8509 else
8510 {
8511 return target;
8512 }
8513 }
8514
8515
8532 OrthancPluginContext* context,
8533 const void* buffer,
8534 uint32_t size,
8535 const char* transferSyntax)
8536 {
8537 OrthancPluginDicomInstance* target = NULL;
8538
8539 _OrthancPluginCreateDicomInstance params;
8540 params.target = &target;
8541 params.buffer = buffer;
8542 params.size = size;
8543 params.transferSyntax = transferSyntax;
8544
8545 if (context->InvokeService(context, _OrthancPluginService_TranscodeDicomInstance, &params) != OrthancPluginErrorCode_Success)
8546 {
8547 /* Error */
8548 return NULL;
8549 }
8550 else
8551 {
8552 return target;
8553 }
8554 }
8555
8570 OrthancPluginContext* context,
8572 const OrthancPluginDicomInstance* instance)
8573 {
8574 _OrthancPluginAccessDicomInstance2 params;
8575 memset(&params, 0, sizeof(params));
8576 params.targetBuffer = target;
8577 params.instance = instance;
8578
8579 return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, &params);
8580 }
8581
8582
8601 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceAdvancedJson(
8602 OrthancPluginContext* context,
8603 const OrthancPluginDicomInstance* instance,
8606 uint32_t maxStringLength)
8607 {
8608 char* result = NULL;
8609
8610 _OrthancPluginAccessDicomInstance2 params;
8611 memset(&params, 0, sizeof(params));
8612 params.targetStringToFree = &result;
8613 params.instance = instance;
8614 params.format = format;
8615 params.flags = flags;
8616 params.maxStringLength = maxStringLength;
8617
8618 if (context->InvokeService(context, _OrthancPluginService_GetInstanceAdvancedJson, &params) != OrthancPluginErrorCode_Success)
8619 {
8620 /* Error */
8621 return NULL;
8622 }
8623 else
8624 {
8625 return result;
8626 }
8627 }
8628
8629
8644 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebJson(
8645 OrthancPluginContext* context,
8646 const OrthancPluginDicomInstance* instance,
8648 void* payload)
8649 {
8650 char* target = NULL;
8651
8652 _OrthancPluginAccessDicomInstance2 params;
8653 params.targetStringToFree = &target;
8654 params.instance = instance;
8655 params.dicomWebCallback = callback;
8656 params.dicomWebPayload = payload;
8657
8658 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebJson, &params) != OrthancPluginErrorCode_Success)
8659 {
8660 /* Error */
8661 return NULL;
8662 }
8663 else
8664 {
8665 return target;
8666 }
8667 }
8668
8669
8684 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebXml(
8685 OrthancPluginContext* context,
8686 const OrthancPluginDicomInstance* instance,
8688 void* payload)
8689 {
8690 char* target = NULL;
8691
8692 _OrthancPluginAccessDicomInstance2 params;
8693 params.targetStringToFree = &target;
8694 params.instance = instance;
8695 params.dicomWebCallback = callback;
8696 params.dicomWebPayload = payload;
8697
8698 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebXml, &params) != OrthancPluginErrorCode_Success)
8699 {
8700 /* Error */
8701 return NULL;
8702 }
8703 else
8704 {
8705 return target;
8706 }
8707 }
8708
8709
8710
8730 OrthancPluginMemoryBuffer* transcoded /* out */,
8731 const void* buffer,
8732 uint64_t size,
8733 const char* const* allowedSyntaxes,
8734 uint32_t countSyntaxes,
8735 uint8_t allowNewSopInstanceUid);
8736
8737
8738 typedef struct
8739 {
8741 } _OrthancPluginTranscoderCallback;
8742
8757 OrthancPluginContext* context,
8759 {
8760 _OrthancPluginTranscoderCallback params;
8761 params.callback = callback;
8762
8763 return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, &params);
8764 }
8765
8766
8767
8768 typedef struct
8769 {
8771 uint32_t size;
8772 } _OrthancPluginCreateMemoryBuffer;
8773
8792 OrthancPluginContext* context,
8794 uint32_t size)
8795 {
8796 _OrthancPluginCreateMemoryBuffer params;
8797 params.target = target;
8798 params.size = size;
8799
8800 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, &params);
8801 }
8802
8803
8830 OrthancPluginContext* context)
8831 {
8832 char* result;
8833
8834 _OrthancPluginRetrieveDynamicString params;
8835 params.result = &result;
8836 params.argument = NULL;
8837
8838 if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
8840 {
8841 /* Error */
8842 return NULL;
8843 }
8844 else
8845 {
8846 return result;
8847 }
8848 }
8849
8850
8851
8852 typedef struct
8853 {
8855 uint64_t size;
8856 } _OrthancPluginCreateMemoryBuffer64;
8857
8876 OrthancPluginContext* context,
8878 uint64_t size)
8879 {
8880 _OrthancPluginCreateMemoryBuffer64 params;
8881 params.target = target;
8882 params.size = size;
8883
8884 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer64, &params);
8885 }
8886
8887
8888 typedef struct
8889 {
8894 } _OrthancPluginRegisterStorageArea2;
8895
8912 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea2(
8913 OrthancPluginContext* context,
8918 {
8919 _OrthancPluginRegisterStorageArea2 params;
8920 params.create = create;
8921 params.readWhole = readWhole;
8922 params.readRange = readRange;
8923 params.remove = remove;
8924 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea2, &params);
8925 }
8926
8927
8928
8929 typedef struct
8930 {
8931 _OrthancPluginCreateDicom createDicom;
8932 const char* privateCreator;
8933 } _OrthancPluginCreateDicom2;
8934
8960 OrthancPluginContext* context,
8962 const char* json,
8963 const OrthancPluginImage* pixelData,
8965 const char* privateCreator)
8966 {
8967 _OrthancPluginCreateDicom2 params;
8968 params.createDicom.target = target;
8969 params.createDicom.json = json;
8970 params.createDicom.pixelData = pixelData;
8971 params.createDicom.flags = flags;
8972 params.privateCreator = privateCreator;
8973
8974 return context->InvokeService(context, _OrthancPluginService_CreateDicom2, &params);
8975 }
8976
8977
8978
8979
8980
8981
8982 typedef struct
8983 {
8984 OrthancPluginMemoryBuffer* answerBody;
8985 OrthancPluginMemoryBuffer* answerHeaders;
8986 uint16_t* httpStatus;
8988 const char* uri;
8989 uint32_t headersCount;
8990 const char* const* headersKeys;
8991 const char* const* headersValues;
8992 const void* body;
8993 uint32_t bodySize;
8994 uint8_t afterPlugins;
8995 } _OrthancPluginCallRestApi;
8996
9028 OrthancPluginContext* context,
9029 OrthancPluginMemoryBuffer* answerBody,
9030 OrthancPluginMemoryBuffer* answerHeaders,
9031 uint16_t* httpStatus,
9033 const char* uri,
9034 uint32_t headersCount,
9035 const char* const* headersKeys,
9036 const char* const* headersValues,
9037 const void* body,
9038 uint32_t bodySize,
9039 uint8_t afterPlugins)
9040 {
9041 _OrthancPluginCallRestApi params;
9042 memset(&params, 0, sizeof(params));
9043
9044 params.answerBody = answerBody;
9045 params.answerHeaders = answerHeaders;
9046 params.httpStatus = httpStatus;
9047 params.method = method;
9048 params.uri = uri;
9049 params.headersCount = headersCount;
9050 params.headersKeys = headersKeys;
9051 params.headersValues = headersValues;
9052 params.body = body;
9053 params.bodySize = bodySize;
9054 params.afterPlugins = afterPlugins;
9055
9056 return context->InvokeService(context, _OrthancPluginService_CallRestApi, &params);
9057 }
9058
9059
9060
9065 typedef struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection;
9066
9067
9086 const char* name,
9087 uint64_t size,
9088 const char* mimeType,
9089 const char* dateTime);
9090
9091
9107 const char* name,
9108 const char* dateTime);
9109
9110
9134 const void* data,
9135 uint64_t size,
9136 const char* mimeType,
9137 const char* dateTime);
9138
9139
9154 uint8_t* isExisting, /* out */
9155 uint32_t pathSize,
9156 const char* const* pathItems,
9157 void* payload);
9158
9159
9179 uint8_t* isExisting, /* out */
9183 uint32_t pathSize,
9184 const char* const* pathItems,
9185 void* payload);
9186
9187
9207 uint32_t pathSize,
9208 const char* const* pathItems,
9209 void* payload);
9210
9211
9228 uint8_t* isReadOnly, /* out */
9229 uint32_t pathSize,
9230 const char* const* pathItems,
9231 const void* data,
9232 uint64_t size,
9233 void* payload);
9234
9235
9250 uint8_t* isReadOnly, /* out */
9251 uint32_t pathSize,
9252 const char* const* pathItems,
9253 void* payload);
9254
9255
9270 uint8_t* isReadOnly, /* out */
9271 uint32_t pathSize,
9272 const char* const* pathItems,
9273 void* payload);
9274
9275
9276 typedef struct
9277 {
9278 const char* uri;
9285 void* payload;
9286 } _OrthancPluginRegisterWebDavCollection;
9287
9309 OrthancPluginContext* context,
9310 const char* uri,
9317 void* payload)
9318 {
9319 _OrthancPluginRegisterWebDavCollection params;
9320 params.uri = uri;
9321 params.isExistingFolder = isExistingFolder;
9322 params.listFolder = listFolder;
9323 params.retrieveFile = retrieveFile;
9324 params.storeFile = storeFile;
9325 params.createFolder = createFolder;
9326 params.deleteItem = deleteItem;
9327 params.payload = payload;
9328
9329 return context->InvokeService(context, _OrthancPluginService_RegisterWebDavCollection, &params);
9330 }
9331
9332
9341 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetDatabaseServerIdentifier(
9342 OrthancPluginContext* context)
9343 {
9344 const char* result;
9345
9346 _OrthancPluginRetrieveStaticString params;
9347 params.result = &result;
9348 params.argument = NULL;
9349
9350 if (context->InvokeService(context, _OrthancPluginService_GetDatabaseServerIdentifier, &params) != OrthancPluginErrorCode_Success)
9351 {
9352 /* Error */
9353 return NULL;
9354 }
9355 else
9356 {
9357 return result;
9358 }
9359 }
9360
9361
9370 void* backend,
9371 const void* request,
9372 uint64_t requestSize);
9373
9379 typedef void (*OrthancPluginFinalizeDatabaseBackendV4) (void* backend);
9380
9381 typedef struct
9382 {
9383 void* backend;
9384 uint32_t maxDatabaseRetries;
9387 } _OrthancPluginRegisterDatabaseBackendV4;
9388
9407 OrthancPluginContext* context,
9408 void* backend,
9409 uint32_t maxDatabaseRetries,
9412 {
9413 _OrthancPluginRegisterDatabaseBackendV4 params;
9414 params.backend = backend;
9415 params.maxDatabaseRetries = maxDatabaseRetries;
9416 params.operations = operations;
9417 params.finalize = finalize;
9418
9419 return context->InvokeService(context, _OrthancPluginService_RegisterDatabaseBackendV4, &params);
9420 }
9421
9422
9423 typedef struct
9424 {
9426 const char* instanceId;
9428 } _OrthancPluginLoadDicomInstance;
9429
9444 OrthancPluginContext* context,
9445 const char* instanceId,
9447 {
9448 OrthancPluginDicomInstance* target = NULL;
9449
9450 _OrthancPluginLoadDicomInstance params;
9451 params.target = &target;
9452 params.instanceId = instanceId;
9453 params.mode = mode;
9454
9455 if (context->InvokeService(context, _OrthancPluginService_LoadDicomInstance, &params) != OrthancPluginErrorCode_Success)
9456 {
9457 /* Error */
9458 return NULL;
9459 }
9460 else
9461 {
9462 return target;
9463 }
9464 }
9465
9466
9467 typedef struct
9468 {
9469 const char* name;
9470 int64_t value;
9472 } _OrthancPluginSetMetricsIntegerValue;
9473
9489 ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsIntegerValue(
9490 OrthancPluginContext* context,
9491 const char* name,
9492 int64_t value,
9494 {
9495 _OrthancPluginSetMetricsIntegerValue params;
9496 params.name = name;
9497 params.value = value;
9498 params.type = type;
9499 context->InvokeService(context, _OrthancPluginService_SetMetricsIntegerValue, &params);
9500 }
9501
9502
9517 OrthancPluginContext* context,
9518 const char* threadName)
9519 {
9520 return context->InvokeService(context, _OrthancPluginService_SetCurrentThreadName, threadName);
9521 }
9522
9523
9524 typedef struct
9525 {
9526 /* Note: This structure is also defined in Logging.h and it must be binary compatible */
9527 const char* message;
9528 const char* plugin;
9529 const char* file;
9530 uint32_t line;
9531 OrthancPluginLogCategory category;
9533 } _OrthancPluginLogMessage;
9534
9535
9549 ORTHANC_PLUGIN_INLINE void OrthancPluginLogMessage(
9550 OrthancPluginContext* context,
9551 const char* message,
9552 const char* plugin,
9553 const char* file,
9554 uint32_t line,
9555 OrthancPluginLogCategory category,
9557 {
9558 _OrthancPluginLogMessage m;
9559 m.message = message;
9560 m.plugin = plugin;
9561 m.file = file;
9562 m.line = line;
9563 m.category = category;
9564 m.level = level;
9565 context->InvokeService(context, _OrthancPluginService_LogMessage, &m);
9566 }
9567
9568
9569#ifdef __cplusplus
9570}
9571#endif
9572
9573
OrthancPluginErrorCode OrthancPluginRegisterDatabaseBackendV4(OrthancPluginContext *context, void *backend, uint32_t maxDatabaseRetries, OrthancPluginCallDatabaseBackendV4 operations, OrthancPluginFinalizeDatabaseBackendV4 finalize)
Register a custom database back-end.
Definition OrthancCPlugin.h:9406
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:9368
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:8209
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:9084
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition OrthancCPlugin.h:3323
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition OrthancCPlugin.h:2288
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:1327
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition OrthancCPlugin.h:5635
OrthancPluginChangeType
Definition OrthancCPlugin.h:754
OrthancPluginErrorCode(* OrthancPluginStorageReadWhole)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type)
Callback for reading a whole file from the storage area.
Definition OrthancCPlugin.h:1393
OrthancPluginErrorCode OrthancPluginRegisterIncomingCStoreInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingCStoreInstanceFilter callback)
Register a callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition OrthancCPlugin.h:8164
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:1305
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition OrthancCPlugin.h:7295
OrthancPluginErrorCode(* OrthancPluginWebDavCreateFolderCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback to create a folder.
Definition OrthancCPlugin.h:9249
struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection
Opaque structure that represents a WebDAV collection.
Definition OrthancCPlugin.h:9065
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:1863
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:9204
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition OrthancCPlugin.h:8080
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition OrthancCPlugin.h:4993
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:8729
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition OrthancCPlugin.h:6538
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:9132
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition OrthancCPlugin.h:1373
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition OrthancCPlugin.h:2210
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition OrthancCPlugin.h:3797
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:8241
int32_t OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition OrthancCPlugin.h:2091
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:9178
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition OrthancCPlugin.h:1816
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition OrthancCPlugin.h:1176
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition OrthancCPlugin.h:3466
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:8912
OrthancPluginErrorCode(* OrthancPluginWebDavAddFolder)(OrthancPluginWebDavCollection *collection, const char *name, const char *dateTime)
Declare a subfolder while returning the content of a folder.
Definition OrthancCPlugin.h:9105
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:9308
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:1519
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition OrthancCPlugin.h:1273
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition OrthancCPlugin.h:1835
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition OrthancCPlugin.h:8756
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:1284
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:9227
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:9269
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition OrthancCPlugin.h:5185
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition OrthancCPlugin.h:1434
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition OrthancCPlugin.h:1346
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:1901
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:1294
void(* OrthancPluginFinalizeDatabaseBackendV4)(void *backend)
Signature of a callback function that is triggered when the database plugin must be finalized.
Definition OrthancCPlugin.h:9379
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition OrthancCPlugin.h:7743
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:9153
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:1484
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition OrthancCPlugin.h:7150
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition OrthancCPlugin.h:1317
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition OrthancCPlugin.h:2250
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition OrthancCPlugin.h:4954
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:1982
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:1416
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:7864
int32_t(* OrthancPluginIncomingCStoreInstanceFilter)(uint16_t *dimseStatus, const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition OrthancCPlugin.h:8142
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition OrthancCPlugin.h:8101
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition OrthancCPlugin.h:5971
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:4910
@ OrthancPluginChangeType_OrthancStopped
Definition OrthancCPlugin.h:766
@ OrthancPluginChangeType_OrthancStarted
Definition OrthancCPlugin.h:765
@ OrthancPluginChangeType_Deleted
Definition OrthancCPlugin.h:756
@ OrthancPluginChangeType_JobFailure
Definition OrthancCPlugin.h:773
@ OrthancPluginChangeType_NewInstance
Definition OrthancCPlugin.h:758
@ OrthancPluginChangeType_NewPatient
Definition OrthancCPlugin.h:759
@ OrthancPluginChangeType_JobSubmitted
Definition OrthancCPlugin.h:771
@ OrthancPluginChangeType_NewSeries
Definition OrthancCPlugin.h:760
@ OrthancPluginChangeType_StablePatient
Definition OrthancCPlugin.h:762
@ OrthancPluginChangeType_UpdatedPeers
Definition OrthancCPlugin.h:769
@ OrthancPluginChangeType_StableStudy
Definition OrthancCPlugin.h:764
@ OrthancPluginChangeType_CompletedSeries
Definition OrthancCPlugin.h:755
@ OrthancPluginChangeType_NewChildInstance
Definition OrthancCPlugin.h:757
@ OrthancPluginChangeType_UpdatedAttachment
Definition OrthancCPlugin.h:767
@ OrthancPluginChangeType_UpdatedMetadata
Definition OrthancCPlugin.h:768
@ OrthancPluginChangeType_StableSeries
Definition OrthancCPlugin.h:763
@ OrthancPluginChangeType_UpdatedModalities
Definition OrthancCPlugin.h:770
@ OrthancPluginChangeType_JobSuccess
Definition OrthancCPlugin.h:772
@ OrthancPluginChangeType_NewStudy
Definition OrthancCPlugin.h:761
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition OrthancCPlugin.h:6232
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition OrthancCPlugin.h:1224
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition OrthancCPlugin.h:1629
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition OrthancCPlugin.h:6208
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition OrthancCPlugin.h:7992
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:1453
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition OrthancCPlugin.h:6386
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:6338
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:7970
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition OrthancCPlugin.h:6140
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition OrthancCPlugin.h:5517
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:8013
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition OrthancCPlugin.h:5478
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition OrthancCPlugin.h:6179
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:8040
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition OrthancCPlugin.h:1232
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition OrthancCPlugin.h:1216
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition OrthancCPlugin.h:1546
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition OrthancCPlugin.h:1614
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition OrthancCPlugin.h:5374
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:6300
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition OrthancCPlugin.h:5440
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:6269
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition OrthancCPlugin.h:1643
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition OrthancCPlugin.h:1208
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:1589
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:5410
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition OrthancCPlugin.h:8299
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition OrthancCPlugin.h:8684
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition OrthancCPlugin.h:1184
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:8464
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition OrthancCPlugin.h:3054
OrthancPluginDicomInstance * OrthancPluginLoadDicomInstance(OrthancPluginContext *context, const char *instanceId, OrthancPluginLoadDicomInstanceMode mode)
Load a DICOM instance from the Orthanc server.
Definition OrthancCPlugin.h:9443
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition OrthancCPlugin.h:3156
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition OrthancCPlugin.h:8531
int32_t OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition OrthancCPlugin.h:3233
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition OrthancCPlugin.h:8349
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition OrthancCPlugin.h:8424
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition OrthancCPlugin.h:5543
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition OrthancCPlugin.h:3087
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition OrthancCPlugin.h:8644
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition OrthancCPlugin.h:8264
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition OrthancCPlugin.h:8387
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition OrthancCPlugin.h:8569
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:3274
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition OrthancCPlugin.h:3194
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition OrthancCPlugin.h:3120
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition OrthancCPlugin.h:8492
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:8601
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition OrthancCPlugin.h:4696
OrthancPluginPixelFormat
Definition OrthancCPlugin.h:630
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:4856
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:4440
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition OrthancCPlugin.h:4231
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition OrthancCPlugin.h:4130
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition OrthancCPlugin.h:5673
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition OrthancCPlugin.h:4731
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition OrthancCPlugin.h:4196
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition OrthancCPlugin.h:4265
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition OrthancCPlugin.h:4350
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:4395
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition OrthancCPlugin.h:5762
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition OrthancCPlugin.h:4308
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition OrthancCPlugin.h:4771
OrthancPluginImageFormat
Definition OrthancCPlugin.h:799
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition OrthancCPlugin.h:1200
OrthancPluginCompressionType
Definition OrthancCPlugin.h:784
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition OrthancCPlugin.h:4163
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:3942
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition OrthancCPlugin.h:4803
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:5716
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition OrthancCPlugin.h:1192
@ OrthancPluginPixelFormat_RGBA32
Color image in RGBA32 format.
Definition OrthancCPlugin.h:669
@ OrthancPluginPixelFormat_RGB48
Color image in RGB48 format.
Definition OrthancCPlugin.h:679
@ OrthancPluginPixelFormat_Grayscale8
Graylevel 8bpp image.
Definition OrthancCPlugin.h:637
@ OrthancPluginPixelFormat_SignedGrayscale16
Graylevel, signed 16bpp image.
Definition OrthancCPlugin.h:653
@ OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition OrthancCPlugin.h:695
@ OrthancPluginPixelFormat_RGB24
Color image in RGB24 format.
Definition OrthancCPlugin.h:661
@ OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition OrthancCPlugin.h:703
@ OrthancPluginPixelFormat_Unknown
Definition OrthancCPlugin.h:671
@ OrthancPluginPixelFormat_Grayscale64
Graylevel, unsigned 64bpp image.
Definition OrthancCPlugin.h:711
@ OrthancPluginPixelFormat_Grayscale32
Graylevel, unsigned 32bpp image.
Definition OrthancCPlugin.h:687
@ OrthancPluginPixelFormat_Grayscale16
Graylevel, unsigned 16bpp image.
Definition OrthancCPlugin.h:645
@ OrthancPluginImageFormat_Png
Definition OrthancCPlugin.h:800
@ OrthancPluginImageFormat_Jpeg
Definition OrthancCPlugin.h:801
@ OrthancPluginImageFormat_Dicom
Definition OrthancCPlugin.h:802
@ OrthancPluginCompressionType_Gzip
Definition OrthancCPlugin.h:787
@ OrthancPluginCompressionType_ZlibWithSize
Definition OrthancCPlugin.h:786
@ OrthancPluginCompressionType_Zlib
Definition OrthancCPlugin.h:785
@ OrthancPluginCompressionType_GzipWithSize
Definition OrthancCPlugin.h:788
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:2518
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:2553
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:2666
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition OrthancCPlugin.h:2802
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition OrthancCPlugin.h:2837
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition OrthancCPlugin.h:3700
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:2630
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition OrthancCPlugin.h:3661
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition OrthancCPlugin.h:2767
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition OrthancCPlugin.h:2451
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition OrthancCPlugin.h:2872
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:2481
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition OrthancCPlugin.h:2732
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition OrthancCPlugin.h:2582
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition OrthancCPlugin.h:2605
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:9027
char * OrthancPluginGenerateRestApiAuthorizationToken(OrthancPluginContext *context)
Generate a token to grant full access to the REST API of Orthanc.
Definition OrthancCPlugin.h:8829
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:5336
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition OrthancCPlugin.h:2418
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:2377
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition OrthancCPlugin.h:2940
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition OrthancCPlugin.h:7186
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition OrthancCPlugin.h:2963
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition OrthancCPlugin.h:2320
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition OrthancCPlugin.h:2917
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition OrthancCPlugin.h:3018
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition OrthancCPlugin.h:2993
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition OrthancCPlugin.h:2700
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:4487
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:3900
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:5933
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:4094
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition OrthancCPlugin.h:3871
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition OrthancCPlugin.h:1783
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderExecute)(OrthancPluginServerChunkedRequestReader *reader, OrthancPluginRestOutput *output)
Callback invoked whenever the request body is entirely received.
Definition OrthancCPlugin.h:7801
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:6046
struct _OrthancPluginJob_t OrthancPluginJob
Opaque structure to a job to be executed by Orthanc.
Definition OrthancCPlugin.h:1256
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:8959
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:9549
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition OrthancCPlugin.h:2174
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderFactory)(OrthancPluginServerChunkedRequestReader **reader, const char *url, const OrthancPluginHttpRequest *request)
Callback to create a reader to handle incoming chunked HTTP transfers.
Definition OrthancCPlugin.h:7762
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition OrthancCPlugin.h:6463
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition OrthancCPlugin.h:6600
OrthancPluginLogLevel
Definition OrthancCPlugin.h:1097
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:5141
OrthancPluginIdentifierConstraint
Definition OrthancCPlugin.h:903
void OrthancPluginExtendOrthancExplorer2(OrthancPluginContext *context, const char *plugin, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition OrthancCPlugin.h:3626
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:5088
OrthancPluginResourceType
Definition OrthancCPlugin.h:737
void OrthancPluginSetRootUri2(OrthancPluginContext *context, const char *plugin, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition OrthancCPlugin.h:3526
void OrthancPluginSetMetricsIntegerValue(OrthancPluginContext *context, const char *name, int64_t value, OrthancPluginMetricsType type)
Set the value of an integer metrics.
Definition OrthancCPlugin.h:9489
OrthancPluginLogCategory
Definition OrthancCPlugin.h:1114
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition OrthancCPlugin.h:4010
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition OrthancCPlugin.h:3731
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition OrthancCPlugin.h:5808
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:1248
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:4578
uint32_t(* OrthancPluginChunkedClientRequestGetChunkSize)(void *request)
Callback to read the size of the current request chunk during a chunked transfer.
Definition OrthancCPlugin.h:7603
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition OrthancCPlugin.h:5032
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, uint32_t size)
Create a 32-bit memory buffer.
Definition OrthancCPlugin.h:8791
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:7018
OrthancPluginDicomWebBinaryMode
Definition OrthancCPlugin.h:992
OrthancPluginErrorCode(* OrthancPluginJobGetContent2)(OrthancPluginMemoryBuffer *target, void *job)
Callback to retrieve the content of one custom job.
Definition OrthancCPlugin.h:1703
OrthancPluginErrorCode(* OrthancPluginChunkedClientRequestNext)(void *request)
Callback to advance in the request body during a chunked transfer.
Definition OrthancCPlugin.h:7571
struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode
Opaque structure that represents a node in a JSON or XML document used in DICOMweb.
Definition OrthancCPlugin.h:1265
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition OrthancCPlugin.h:1669
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition OrthancCPlugin.h:7331
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition OrthancCPlugin.h:6425
OrthancPluginDicomToJsonFlags
Definition OrthancCPlugin.h:867
OrthancPluginJobStepStatus
Definition OrthancCPlugin.h:949
OrthancPluginCreateDicomFlags
Definition OrthancCPlugin.h:888
void(* OrthancPluginServerChunkedRequestReaderFinalize)(OrthancPluginServerChunkedRequestReader *reader)
Callback invoked to release the resources associated with an incoming HTTP chunked transfer.
Definition OrthancCPlugin.h:7819
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:6496
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition OrthancCPlugin.h:3603
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition OrthancCPlugin.h:2158
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition OrthancCPlugin.h:6678
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition OrthancCPlugin.h:6566
OrthancPluginConstraintType
Definition OrthancCPlugin.h:918
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition OrthancCPlugin.h:3385
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition OrthancCPlugin.h:3979
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition OrthancCPlugin.h:1759
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition OrthancCPlugin.h:5844
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition OrthancCPlugin.h:3765
void OrthancPluginSetMetricsValue(OrthancPluginContext *context, const char *name, float value, OrthancPluginMetricsType type)
Set the value of a floating-point metrics.
Definition OrthancCPlugin.h:7264
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:7781
OrthancPluginReceivedInstanceAction
Definition OrthancCPlugin.h:1053
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:7682
int32_t(* OrthancPluginJobGetSerialized2)(OrthancPluginMemoryBuffer *target, void *job)
Callback to serialize one custom job.
Definition OrthancCPlugin.h:1743
void OrthancPluginFreeMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *buffer)
Free a memory buffer.
Definition OrthancCPlugin.h:2126
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:4620
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:5229
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:5599
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:5278
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition OrthancCPlugin.h:7073
const char * OrthancPluginGetDatabaseServerIdentifier(OrthancPluginContext *context)
Gets the DatabaseServerIdentifier.
Definition OrthancCPlugin.h:9341
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition OrthancCPlugin.h:6101
OrthancPluginStorageCommitmentFailureReason
Definition OrthancCPlugin.h:1005
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:7534
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:6765
OrthancPluginMetricsType
Definition OrthancCPlugin.h:975
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition OrthancCPlugin.h:7218
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition OrthancCPlugin.h:4658
uint8_t(* OrthancPluginChunkedClientRequestIsDone)(void *request)
Callback to know whether the request body is entirely read during a chunked transfer.
Definition OrthancCPlugin.h:7554
const void *(* OrthancPluginChunkedClientRequestGetChunkData)(void *request)
Callback to read the current chunk of the request body during a chunked transfer.
Definition OrthancCPlugin.h:7587
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:6932
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition OrthancCPlugin.h:2110
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition OrthancCPlugin.h:7373
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition OrthancCPlugin.h:1723
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition OrthancCPlugin.h:3830
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *target, uint64_t size)
Create a 64-bit memory buffer.
Definition OrthancCPlugin.h:8875
OrthancPluginLoadDicomInstanceMode
Definition OrthancCPlugin.h:1067
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:7513
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition OrthancCPlugin.h:6630
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition OrthancCPlugin.h:1685
OrthancPluginValueRepresentation
Definition OrthancCPlugin.h:813
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int32_t priority)
Submit a new job to the jobs engine of Orthanc.
Definition OrthancCPlugin.h:7105
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition OrthancCPlugin.h:4540
OrthancPluginJobStopReason
Definition OrthancCPlugin.h:963
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition OrthancCPlugin.h:3355
OrthancPluginDicomToJsonFormat
Definition OrthancCPlugin.h:852
void OrthancPluginSetDescription2(OrthancPluginContext *context, const char *plugin, const char *description)
Set a description for this plugin.
Definition OrthancCPlugin.h:3576
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition OrthancCPlugin.h:2142
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition OrthancCPlugin.h:3420
OrthancPluginHttpMethod
Definition OrthancCPlugin.h:343
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition OrthancCPlugin.h:3501
char * OrthancPluginEncodeDicomWebXml2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition OrthancCPlugin.h:7469
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:6846
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:1240
char * OrthancPluginEncodeDicomWebJson2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition OrthancCPlugin.h:7425
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition OrthancCPlugin.h:5890
OrthancPluginInstanceOrigin
Definition OrthancCPlugin.h:933
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition OrthancCPlugin.h:1656
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition OrthancCPlugin.h:1952
OrthancPluginErrorCode OrthancPluginSetCurrentThreadName(OrthancPluginContext *context, const char *threadName)
Set the name of the current thread.
Definition OrthancCPlugin.h:9516
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition OrthancCPlugin.h:1800
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition OrthancCPlugin.h:4041
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginContentType
Definition OrthancCPlugin.h:722
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition OrthancCPlugin.h:6719
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition OrthancCPlugin.h:3553
char * OrthancPluginGetTagName(OrthancPluginContext *context, uint16_t group, uint16_t element, const char *privateCreator)
Returns the symbolic name of a DICOM tag.
Definition OrthancCPlugin.h:7915
@ OrthancPluginLogLevel_Warning
Definition OrthancCPlugin.h:1099
@ OrthancPluginLogLevel_Trace
Definition OrthancCPlugin.h:1101
@ OrthancPluginLogLevel_Error
Definition OrthancCPlugin.h:1098
@ OrthancPluginLogLevel_Info
Definition OrthancCPlugin.h:1100
@ OrthancPluginIdentifierConstraint_Wildcard
Definition OrthancCPlugin.h:907
@ OrthancPluginIdentifierConstraint_Equal
Definition OrthancCPlugin.h:904
@ OrthancPluginIdentifierConstraint_SmallerOrEqual
Definition OrthancCPlugin.h:905
@ OrthancPluginIdentifierConstraint_GreaterOrEqual
Definition OrthancCPlugin.h:906
@ OrthancPluginResourceType_Instance
Definition OrthancCPlugin.h:741
@ OrthancPluginResourceType_None
Definition OrthancCPlugin.h:742
@ OrthancPluginResourceType_Series
Definition OrthancCPlugin.h:740
@ OrthancPluginResourceType_Study
Definition OrthancCPlugin.h:739
@ OrthancPluginResourceType_Patient
Definition OrthancCPlugin.h:738
@ OrthancPluginLogCategory_Dicom
Definition OrthancCPlugin.h:1119
@ OrthancPluginLogCategory_Jobs
Definition OrthancCPlugin.h:1120
@ OrthancPluginLogCategory_Sqlite
Definition OrthancCPlugin.h:1118
@ OrthancPluginLogCategory_Plugins
Definition OrthancCPlugin.h:1116
@ OrthancPluginLogCategory_Generic
Definition OrthancCPlugin.h:1115
@ OrthancPluginLogCategory_Lua
Definition OrthancCPlugin.h:1121
@ OrthancPluginLogCategory_Http
Definition OrthancCPlugin.h:1117
@ OrthancPluginErrorCode_CreateDicomBadParent
Definition OrthancCPlugin.h:305
@ OrthancPluginErrorCode_MainDicomTagsMultiplyDefined
Definition OrthancCPlugin.h:262
@ OrthancPluginErrorCode_SQLiteFlush
Definition OrthancCPlugin.h:273
@ 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:315
@ OrthancPluginErrorCode_LuaAlreadyExecuted
Definition OrthancCPlugin.h:313
@ OrthancPluginErrorCode_NotAcceptable
Definition OrthancCPlugin.h:252
@ OrthancPluginErrorCode_FullStorage
Definition OrthancCPlugin.h:237
@ OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered
Definition OrthancCPlugin.h:318
@ OrthancPluginErrorCode_InexistentFile
Definition OrthancCPlugin.h:231
@ OrthancPluginErrorCode_CreateDicomParentEncoding
Definition OrthancCPlugin.h:307
@ OrthancPluginErrorCode_CannotOrderSlices
Definition OrthancCPlugin.h:321
@ OrthancPluginErrorCode_InternalError
Definition OrthancCPlugin.h:217
@ OrthancPluginErrorCode_DiscontinuedAbi
Definition OrthancCPlugin.h:258
@ OrthancPluginErrorCode_NoCFindHandler
Definition OrthancCPlugin.h:291
@ OrthancPluginErrorCode_SQLiteCommitWithoutTransaction
Definition OrthancCPlugin.h:271
@ OrthancPluginErrorCode_DatabasePlugin
Definition OrthancCPlugin.h:249
@ OrthancPluginErrorCode_SQLiteStatementAlreadyUsed
Definition OrthancCPlugin.h:268
@ OrthancPluginErrorCode_SQLiteCannotRun
Definition OrthancCPlugin.h:274
@ OrthancPluginErrorCode_UnknownPluginService
Definition OrthancCPlugin.h:244
@ OrthancPluginErrorCode_JsonToLuaTable
Definition OrthancCPlugin.h:310
@ OrthancPluginErrorCode_CreateDicomOverrideTag
Definition OrthancCPlugin.h:301
@ OrthancPluginErrorCode_SQLiteBindOutOfRange
Definition OrthancCPlugin.h:276
@ OrthancPluginErrorCode_ParameterOutOfRange
Definition OrthancCPlugin.h:221
@ OrthancPluginErrorCode_SQLiteRegisterFunction
Definition OrthancCPlugin.h:272
@ OrthancPluginErrorCode_SQLiteTransactionBegin
Definition OrthancCPlugin.h:280
@ OrthancPluginErrorCode_CreateDicomNoPayload
Definition OrthancCPlugin.h:303
@ OrthancPluginErrorCode_Unauthorized
Definition OrthancCPlugin.h:247
@ OrthancPluginErrorCode_RegularFileExpected
Definition OrthancCPlugin.h:287
@ OrthancPluginErrorCode_DicomPortInUse
Definition OrthancCPlugin.h:285
@ OrthancPluginErrorCode_BadApplicationEntityTitle
Definition OrthancCPlugin.h:290
@ OrthancPluginErrorCode_NoCStoreHandler
Definition OrthancCPlugin.h:293
@ OrthancPluginErrorCode_PathToExecutable
Definition OrthancCPlugin.h:288
@ OrthancPluginErrorCode_NoSopClassOrInstance
Definition OrthancCPlugin.h:295
@ OrthancPluginErrorCode_BadFont
Definition OrthancCPlugin.h:248
@ OrthancPluginErrorCode_DatabaseUnavailable
Definition OrthancCPlugin.h:254
@ OrthancPluginErrorCode_CannotCreateLua
Definition OrthancCPlugin.h:311
@ OrthancPluginErrorCode_SQLiteExecute
Definition OrthancCPlugin.h:269
@ OrthancPluginErrorCode_UriSyntax
Definition OrthancCPlugin.h:230
@ OrthancPluginErrorCode_DirectoryOverFile
Definition OrthancCPlugin.h:281
@ OrthancPluginErrorCode_Revision
Definition OrthancCPlugin.h:261
@ OrthancPluginErrorCode_InexistentTag
Definition OrthancCPlugin.h:239
@ OrthancPluginErrorCode_IncompatibleImageFormat
Definition OrthancCPlugin.h:241
@ OrthancPluginErrorCode_UnsupportedMediaType
Definition OrthancCPlugin.h:326
@ OrthancPluginErrorCode_DicomFindUnavailable
Definition OrthancCPlugin.h:297
@ OrthancPluginErrorCode_SQLiteCannotStep
Definition OrthancCPlugin.h:275
@ OrthancPluginErrorCode_CreateDicomParentIsInstance
Definition OrthancCPlugin.h:306
@ OrthancPluginErrorCode_DuplicateResource
Definition OrthancCPlugin.h:264
@ OrthancPluginErrorCode_StorageAreaAlreadyRegistered
Definition OrthancCPlugin.h:317
@ OrthancPluginErrorCode_LuaReturnsNoString
Definition OrthancCPlugin.h:316
@ OrthancPluginErrorCode_UnknownResource
Definition OrthancCPlugin.h:235
@ OrthancPluginErrorCode_CreateDicomNotString
Definition OrthancCPlugin.h:300
@ OrthancPluginErrorCode_HttpPortInUse
Definition OrthancCPlugin.h:284
@ OrthancPluginErrorCode_SslDisabled
Definition OrthancCPlugin.h:320
@ OrthancPluginErrorCode_UnknownModality
Definition OrthancCPlugin.h:308
@ OrthancPluginErrorCode_BadHttpStatusInRest
Definition OrthancCPlugin.h:286
@ OrthancPluginErrorCode_BadGeometry
Definition OrthancCPlugin.h:256
@ OrthancPluginErrorCode_AlreadyExistingTag
Definition OrthancCPlugin.h:323
@ OrthancPluginErrorCode_FileStorageCannotWrite
Definition OrthancCPlugin.h:282
@ OrthancPluginErrorCode_CreateDicomUseDataUriScheme
Definition OrthancCPlugin.h:304
@ OrthancPluginErrorCode_DirectoryExpected
Definition OrthancCPlugin.h:283
@ OrthancPluginErrorCode_NoCMoveHandler
Definition OrthancCPlugin.h:292
@ OrthancPluginErrorCode_SQLitePrepareStatement
Definition OrthancCPlugin.h:277
@ OrthancPluginErrorCode_CorruptedFile
Definition OrthancCPlugin.h:238
@ OrthancPluginErrorCode_StorageAreaPlugin
Definition OrthancCPlugin.h:250
@ OrthancPluginErrorCode_BadJobOrdering
Definition OrthancCPlugin.h:309
@ 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:324
@ OrthancPluginErrorCode_SQLiteAlreadyOpened
Definition OrthancCPlugin.h:266
@ OrthancPluginErrorCode_Plugin
Definition OrthancCPlugin.h:219
@ OrthancPluginErrorCode_CannotExecuteLua
Definition OrthancCPlugin.h:312
@ OrthancPluginErrorCode_SQLiteRollbackWithoutTransaction
Definition OrthancCPlugin.h:270
@ OrthancPluginErrorCode_UnknownDicomTag
Definition OrthancCPlugin.h:245
@ OrthancPluginErrorCode_ForbiddenAccess
Definition OrthancCPlugin.h:263
@ OrthancPluginErrorCode_NoPresentationContext
Definition OrthancCPlugin.h:296
@ OrthancPluginErrorCode_EmptyRequest
Definition OrthancCPlugin.h:251
@ OrthancPluginErrorCode_DatabaseNotInitialized
Definition OrthancCPlugin.h:319
@ OrthancPluginErrorCode_DicomMoveUnavailable
Definition OrthancCPlugin.h:298
@ OrthancPluginErrorCode_SQLiteTransactionCommit
Definition OrthancCPlugin.h:279
@ OrthancPluginErrorCode_BadJson
Definition OrthancCPlugin.h:246
@ OrthancPluginErrorCode_Success
Definition OrthancCPlugin.h:218
@ OrthancPluginErrorCode_NetworkProtocol
Definition OrthancCPlugin.h:227
@ OrthancPluginErrorCode_NoApplicationEntityFilter
Definition OrthancCPlugin.h:294
@ OrthancPluginErrorCode_InexistentItem
Definition OrthancCPlugin.h:225
@ OrthancPluginErrorCode_Timeout
Definition OrthancCPlugin.h:234
@ OrthancPluginErrorCode_LuaBadOutput
Definition OrthancCPlugin.h:314
@ OrthancPluginErrorCode_SQLiteTransactionAlreadyStarted
Definition OrthancCPlugin.h:278
@ OrthancPluginErrorCode_NoCGetHandler
Definition OrthancCPlugin.h:325
@ OrthancPluginErrorCode_SQLiteNotOpened
Definition OrthancCPlugin.h:265
@ OrthancPluginErrorCode_ReadOnly
Definition OrthancCPlugin.h:240
@ OrthancPluginErrorCode_CannotStoreInstance
Definition OrthancCPlugin.h:299
@ OrthancPluginErrorCode_CannotWriteFile
Definition OrthancCPlugin.h:232
@ OrthancPluginErrorCode_BadParameterType
Definition OrthancCPlugin.h:223
@ OrthancPluginErrorCode_NotEnoughMemory
Definition OrthancCPlugin.h:222
@ OrthancPluginErrorCode_CreateDicomUseContent
Definition OrthancCPlugin.h:302
@ OrthancPluginErrorCode_Database
Definition OrthancCPlugin.h:229
@ OrthancPluginErrorCode_SQLiteCannotOpen
Definition OrthancCPlugin.h:267
@ OrthancPluginErrorCode_MakeDirectory
Definition OrthancCPlugin.h:289
@ OrthancPluginErrorCode_NoWorklistHandler
Definition OrthancCPlugin.h:322
@ OrthancPluginDicomWebBinaryMode_InlineBinary
Definition OrthancCPlugin.h:994
@ OrthancPluginDicomWebBinaryMode_BulkDataUri
Definition OrthancCPlugin.h:995
@ OrthancPluginDicomWebBinaryMode_Ignore
Definition OrthancCPlugin.h:993
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii
Definition OrthancCPlugin.h:873
@ OrthancPluginDicomToJsonFlags_IncludeBinary
Definition OrthancCPlugin.h:869
@ OrthancPluginDicomToJsonFlags_IncludePixelData
Definition OrthancCPlugin.h:872
@ OrthancPluginDicomToJsonFlags_IncludeUnknownTags
Definition OrthancCPlugin.h:871
@ OrthancPluginDicomToJsonFlags_SkipGroupLengths
Definition OrthancCPlugin.h:876
@ OrthancPluginDicomToJsonFlags_None
Definition OrthancCPlugin.h:868
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
Definition OrthancCPlugin.h:874
@ OrthancPluginDicomToJsonFlags_StopAfterPixelData
Definition OrthancCPlugin.h:875
@ OrthancPluginDicomToJsonFlags_IncludePrivateTags
Definition OrthancCPlugin.h:870
@ OrthancPluginJobStepStatus_Continue
Definition OrthancCPlugin.h:952
@ OrthancPluginJobStepStatus_Success
Definition OrthancCPlugin.h:950
@ OrthancPluginJobStepStatus_Failure
Definition OrthancCPlugin.h:951
@ OrthancPluginCreateDicomFlags_DecodeDataUriScheme
Definition OrthancCPlugin.h:890
@ OrthancPluginCreateDicomFlags_None
Definition OrthancCPlugin.h:889
@ OrthancPluginCreateDicomFlags_GenerateIdentifiers
Definition OrthancCPlugin.h:891
@ OrthancPluginConstraintType_SmallerOrEqual
Definition OrthancCPlugin.h:920
@ OrthancPluginConstraintType_List
Definition OrthancCPlugin.h:923
@ OrthancPluginConstraintType_GreaterOrEqual
Definition OrthancCPlugin.h:921
@ OrthancPluginConstraintType_Equal
Definition OrthancCPlugin.h:919
@ OrthancPluginConstraintType_Wildcard
Definition OrthancCPlugin.h:922
@ OrthancPluginReceivedInstanceAction_KeepAsIs
Definition OrthancCPlugin.h:1054
@ OrthancPluginReceivedInstanceAction_Discard
Definition OrthancCPlugin.h:1056
@ OrthancPluginReceivedInstanceAction_Modify
Definition OrthancCPlugin.h:1055
@ OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
Definition OrthancCPlugin.h:1032
@ OrthancPluginStorageCommitmentFailureReason_Success
Definition OrthancCPlugin.h:1009
@ OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
Definition OrthancCPlugin.h:1045
@ OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
Definition OrthancCPlugin.h:1039
@ OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
Definition OrthancCPlugin.h:1026
@ OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
Definition OrthancCPlugin.h:1020
@ OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
Definition OrthancCPlugin.h:1014
@ OrthancPluginMetricsType_Default
Definition OrthancCPlugin.h:976
@ OrthancPluginMetricsType_Timer
Definition OrthancCPlugin.h:983
@ OrthancPluginLoadDicomInstanceMode_UntilPixelData
Definition OrthancCPlugin.h:1077
@ OrthancPluginLoadDicomInstanceMode_WholeDicom
Definition OrthancCPlugin.h:1071
@ OrthancPluginLoadDicomInstanceMode_EmptyPixelData
Definition OrthancCPlugin.h:1084
@ OrthancPluginValueRepresentation_PN
Definition OrthancCPlugin.h:829
@ OrthancPluginValueRepresentation_UL
Definition OrthancCPlugin.h:837
@ OrthancPluginValueRepresentation_UN
Definition OrthancCPlugin.h:838
@ OrthancPluginValueRepresentation_DA
Definition OrthancCPlugin.h:818
@ OrthancPluginValueRepresentation_OF
Definition OrthancCPlugin.h:827
@ OrthancPluginValueRepresentation_OW
Definition OrthancCPlugin.h:828
@ OrthancPluginValueRepresentation_CS
Definition OrthancCPlugin.h:817
@ OrthancPluginValueRepresentation_US
Definition OrthancCPlugin.h:839
@ OrthancPluginValueRepresentation_SH
Definition OrthancCPlugin.h:830
@ OrthancPluginValueRepresentation_FL
Definition OrthancCPlugin.h:822
@ OrthancPluginValueRepresentation_DT
Definition OrthancCPlugin.h:820
@ OrthancPluginValueRepresentation_TM
Definition OrthancCPlugin.h:835
@ OrthancPluginValueRepresentation_SQ
Definition OrthancCPlugin.h:832
@ OrthancPluginValueRepresentation_DS
Definition OrthancCPlugin.h:819
@ OrthancPluginValueRepresentation_OB
Definition OrthancCPlugin.h:826
@ OrthancPluginValueRepresentation_SL
Definition OrthancCPlugin.h:831
@ OrthancPluginValueRepresentation_ST
Definition OrthancCPlugin.h:834
@ OrthancPluginValueRepresentation_IS
Definition OrthancCPlugin.h:823
@ OrthancPluginValueRepresentation_LT
Definition OrthancCPlugin.h:825
@ OrthancPluginValueRepresentation_SS
Definition OrthancCPlugin.h:833
@ OrthancPluginValueRepresentation_UT
Definition OrthancCPlugin.h:840
@ OrthancPluginValueRepresentation_LO
Definition OrthancCPlugin.h:824
@ OrthancPluginValueRepresentation_AE
Definition OrthancCPlugin.h:814
@ OrthancPluginValueRepresentation_FD
Definition OrthancCPlugin.h:821
@ OrthancPluginValueRepresentation_UI
Definition OrthancCPlugin.h:836
@ OrthancPluginValueRepresentation_AS
Definition OrthancCPlugin.h:815
@ OrthancPluginValueRepresentation_AT
Definition OrthancCPlugin.h:816
@ OrthancPluginJobStopReason_Failure
Definition OrthancCPlugin.h:966
@ OrthancPluginJobStopReason_Success
Definition OrthancCPlugin.h:964
@ OrthancPluginJobStopReason_Canceled
Definition OrthancCPlugin.h:967
@ OrthancPluginJobStopReason_Paused
Definition OrthancCPlugin.h:965
@ OrthancPluginDicomToJsonFormat_Full
Definition OrthancCPlugin.h:853
@ OrthancPluginDicomToJsonFormat_Human
Definition OrthancCPlugin.h:855
@ OrthancPluginDicomToJsonFormat_Short
Definition OrthancCPlugin.h:854
@ OrthancPluginHttpMethod_Delete
Definition OrthancCPlugin.h:347
@ OrthancPluginHttpMethod_Post
Definition OrthancCPlugin.h:345
@ OrthancPluginHttpMethod_Put
Definition OrthancCPlugin.h:346
@ OrthancPluginHttpMethod_Get
Definition OrthancCPlugin.h:344
@ OrthancPluginInstanceOrigin_Unknown
Definition OrthancCPlugin.h:934
@ OrthancPluginInstanceOrigin_RestApi
Definition OrthancCPlugin.h:936
@ OrthancPluginInstanceOrigin_Lua
Definition OrthancCPlugin.h:938
@ OrthancPluginInstanceOrigin_WebDav
Definition OrthancCPlugin.h:939
@ OrthancPluginInstanceOrigin_DicomProtocol
Definition OrthancCPlugin.h:935
@ OrthancPluginInstanceOrigin_Plugin
Definition OrthancCPlugin.h:937
@ OrthancPluginContentType_Dicom
Definition OrthancCPlugin.h:724
@ OrthancPluginContentType_DicomAsJson
Definition OrthancCPlugin.h:725
@ OrthancPluginContentType_Unknown
Definition OrthancCPlugin.h:723
@ OrthancPluginContentType_DicomUntilPixelData
Definition OrthancCPlugin.h:726
An entry in the dictionary of DICOM tags.
Definition OrthancCPlugin.h:1934
uint32_t minMultiplicity
Definition OrthancCPlugin.h:1938
uint32_t maxMultiplicity
Definition OrthancCPlugin.h:1939
OrthancPluginValueRepresentation vr
Definition OrthancCPlugin.h:1937
uint16_t element
Definition OrthancCPlugin.h:1936
uint16_t group
Definition OrthancCPlugin.h:1935
The parameters of a REST request.
Definition OrthancCPlugin.h:358
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition OrthancCPlugin.h:387
const char *const * groups
The matched values for the groups of the regular expression.
Definition OrthancCPlugin.h:372
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition OrthancCPlugin.h:397
uint32_t groupsCount
The number of groups of the regular expression.
Definition OrthancCPlugin.h:367
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition OrthancCPlugin.h:412
const void * body
For a PUT or POST request, the content of the body.
Definition OrthancCPlugin.h:392
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition OrthancCPlugin.h:382
uint32_t headersCount
The number of HTTP headers.
Definition OrthancCPlugin.h:407
OrthancPluginHttpMethod method
The HTTP method.
Definition OrthancCPlugin.h:362
uint32_t getCount
For a GET request, the number of GET parameters.
Definition OrthancCPlugin.h:377
const char *const * headersValues
The values of the HTTP headers.
Definition OrthancCPlugin.h:417
A 64-bit memory buffer allocated by the core system of Orthanc.
Definition OrthancCPlugin.h:1157
uint64_t size
The number of bytes in the buffer.
Definition OrthancCPlugin.h:1166
void * data
The content of the buffer.
Definition OrthancCPlugin.h:1161
A 32-bit memory buffer allocated by the core system of Orthanc.
Definition OrthancCPlugin.h:1135
uint32_t size
The number of bytes in the buffer.
Definition OrthancCPlugin.h:1144
void * data
The content of the buffer.
Definition OrthancCPlugin.h:1139