Orthanc Plugin SDK 1.12.2
Documentation of the plugin interface of Orthanc
OrthancCPlugin.h
1
107#pragma once
108
109
110#include <stdio.h>
111#include <string.h>
112
113#ifdef WIN32
114# define ORTHANC_PLUGINS_API __declspec(dllexport)
115#elif __GNUC__ >= 4
116# define ORTHANC_PLUGINS_API __attribute__ ((visibility ("default")))
117#else
118# define ORTHANC_PLUGINS_API
119#endif
120
121#define ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER 1
122#define ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER 12
123#define ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER 2
124
125
126#if !defined(ORTHANC_PLUGINS_VERSION_IS_ABOVE)
127#define ORTHANC_PLUGINS_VERSION_IS_ABOVE(major, minor, revision) \
128 (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER > major || \
129 (ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER == major && \
130 (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER > minor || \
131 (ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER == minor && \
132 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER >= revision))))
133#endif
134
135
136
137/********************************************************************
138 ** Check that function inlining is properly supported. The use of
139 ** inlining is required, to avoid the duplication of object code
140 ** between two compilation modules that would use the Orthanc Plugin
141 ** API.
142 ********************************************************************/
143
144/* If the auto-detection of the "inline" keyword below does not work
145 automatically and that your compiler is known to properly support
146 inlining, uncomment the following #define and adapt the definition
147 of "static inline". */
148
149/* #define ORTHANC_PLUGIN_INLINE static inline */
150
151#ifndef ORTHANC_PLUGIN_INLINE
152# if __STDC_VERSION__ >= 199901L
153/* This is C99 or above: http://predef.sourceforge.net/prestd.html */
154# define ORTHANC_PLUGIN_INLINE static inline
155# elif defined(__cplusplus)
156/* This is C++ */
157# define ORTHANC_PLUGIN_INLINE static inline
158# elif defined(__GNUC__)
159/* This is GCC running in C89 mode */
160# define ORTHANC_PLUGIN_INLINE static __inline
161# elif defined(_MSC_VER)
162/* This is Visual Studio running in C89 mode */
163# define ORTHANC_PLUGIN_INLINE static __inline
164# else
165# error Your compiler is not known to support the "inline" keyword
166# endif
167#endif
168
169
170
171/********************************************************************
172 ** Inclusion of standard libraries.
173 ********************************************************************/
174
180#include <stdint.h>
181
182#include <stdlib.h>
183
184
185
186/********************************************************************
187 ** Definition of the Orthanc Plugin API.
188 ********************************************************************/
189
192#ifdef __cplusplus
193extern "C"
194{
195#endif
196
200 typedef enum
201 {
311
312 _OrthancPluginErrorCode_INTERNAL = 0x7fffffff
314
315
320 ORTHANC_PLUGINS_API const char* OrthancPluginGetName();
321
322
326 typedef enum
327 {
333 _OrthancPluginHttpMethod_INTERNAL = 0x7fffffff
335
336
341 typedef struct
342 {
347
351 uint32_t groupsCount;
352
356 const char* const* groups;
357
361 uint32_t getCount;
362
366 const char* const* getKeys;
367
371 const char* const* getValues;
372
376 const void* body;
377
381 uint32_t bodySize;
382
383
384 /* --------------------------------------------------
385 New in version 0.8.1
386 -------------------------------------------------- */
387
391 uint32_t headersCount;
392
396 const char* const* headersKeys;
397
401 const char* const* headersValues;
402
404
405
406 typedef enum
407 {
408 /* Generic services */
409 _OrthancPluginService_LogInfo = 1,
410 _OrthancPluginService_LogWarning = 2,
411 _OrthancPluginService_LogError = 3,
412 _OrthancPluginService_GetOrthancPath = 4,
413 _OrthancPluginService_GetOrthancDirectory = 5,
414 _OrthancPluginService_GetConfigurationPath = 6,
415 _OrthancPluginService_SetPluginProperty = 7,
416 _OrthancPluginService_GetGlobalProperty = 8,
417 _OrthancPluginService_SetGlobalProperty = 9,
418 _OrthancPluginService_GetCommandLineArgumentsCount = 10,
419 _OrthancPluginService_GetCommandLineArgument = 11,
420 _OrthancPluginService_GetExpectedDatabaseVersion = 12,
421 _OrthancPluginService_GetConfiguration = 13,
422 _OrthancPluginService_BufferCompression = 14,
423 _OrthancPluginService_ReadFile = 15,
424 _OrthancPluginService_WriteFile = 16,
425 _OrthancPluginService_GetErrorDescription = 17,
426 _OrthancPluginService_CallHttpClient = 18,
427 _OrthancPluginService_RegisterErrorCode = 19,
428 _OrthancPluginService_RegisterDictionaryTag = 20,
429 _OrthancPluginService_DicomBufferToJson = 21,
430 _OrthancPluginService_DicomInstanceToJson = 22,
431 _OrthancPluginService_CreateDicom = 23,
432 _OrthancPluginService_ComputeMd5 = 24,
433 _OrthancPluginService_ComputeSha1 = 25,
434 _OrthancPluginService_LookupDictionary = 26,
435 _OrthancPluginService_CallHttpClient2 = 27,
436 _OrthancPluginService_GenerateUuid = 28,
437 _OrthancPluginService_RegisterPrivateDictionaryTag = 29,
438 _OrthancPluginService_AutodetectMimeType = 30,
439 _OrthancPluginService_SetMetricsValue = 31,
440 _OrthancPluginService_EncodeDicomWebJson = 32,
441 _OrthancPluginService_EncodeDicomWebXml = 33,
442 _OrthancPluginService_ChunkedHttpClient = 34, /* New in Orthanc 1.5.7 */
443 _OrthancPluginService_GetTagName = 35, /* New in Orthanc 1.5.7 */
444 _OrthancPluginService_EncodeDicomWebJson2 = 36, /* New in Orthanc 1.7.0 */
445 _OrthancPluginService_EncodeDicomWebXml2 = 37, /* New in Orthanc 1.7.0 */
446 _OrthancPluginService_CreateMemoryBuffer = 38, /* New in Orthanc 1.7.0 */
447 _OrthancPluginService_GenerateRestApiAuthorizationToken = 39, /* New in Orthanc 1.8.1 */
448 _OrthancPluginService_CreateMemoryBuffer64 = 40, /* New in Orthanc 1.9.0 */
449 _OrthancPluginService_CreateDicom2 = 41, /* New in Orthanc 1.9.0 */
450 _OrthancPluginService_GetDatabaseServerIdentifier = 42, /* New in Orthanc 1.11.1 */
451 _OrthancPluginService_SetMetricsIntegerValue = 43, /* New in Orthanc 1.12.1 */
452 _OrthancPluginService_SetCurrentThreadName = 44, /* New in Orthanc 1.12.2 */
453
454
455 /* Registration of callbacks */
456 _OrthancPluginService_RegisterRestCallback = 1000,
457 _OrthancPluginService_RegisterOnStoredInstanceCallback = 1001,
458 _OrthancPluginService_RegisterStorageArea = 1002,
459 _OrthancPluginService_RegisterOnChangeCallback = 1003,
460 _OrthancPluginService_RegisterRestCallbackNoLock = 1004,
461 _OrthancPluginService_RegisterWorklistCallback = 1005,
462 _OrthancPluginService_RegisterDecodeImageCallback = 1006,
463 _OrthancPluginService_RegisterIncomingHttpRequestFilter = 1007,
464 _OrthancPluginService_RegisterFindCallback = 1008,
465 _OrthancPluginService_RegisterMoveCallback = 1009,
466 _OrthancPluginService_RegisterIncomingHttpRequestFilter2 = 1010,
467 _OrthancPluginService_RegisterRefreshMetricsCallback = 1011,
468 _OrthancPluginService_RegisterChunkedRestCallback = 1012, /* New in Orthanc 1.5.7 */
469 _OrthancPluginService_RegisterStorageCommitmentScpCallback = 1013,
470 _OrthancPluginService_RegisterIncomingDicomInstanceFilter = 1014,
471 _OrthancPluginService_RegisterTranscoderCallback = 1015, /* New in Orthanc 1.7.0 */
472 _OrthancPluginService_RegisterStorageArea2 = 1016, /* New in Orthanc 1.9.0 */
473 _OrthancPluginService_RegisterIncomingCStoreInstanceFilter = 1017, /* New in Orthanc 1.10.0 */
474 _OrthancPluginService_RegisterReceivedInstanceCallback = 1018, /* New in Orthanc 1.10.0 */
475 _OrthancPluginService_RegisterWebDavCollection = 1019, /* New in Orthanc 1.10.1 */
476
477 /* Sending answers to REST calls */
478 _OrthancPluginService_AnswerBuffer = 2000,
479 _OrthancPluginService_CompressAndAnswerPngImage = 2001, /* Unused as of Orthanc 0.9.4 */
480 _OrthancPluginService_Redirect = 2002,
481 _OrthancPluginService_SendHttpStatusCode = 2003,
482 _OrthancPluginService_SendUnauthorized = 2004,
483 _OrthancPluginService_SendMethodNotAllowed = 2005,
484 _OrthancPluginService_SetCookie = 2006,
485 _OrthancPluginService_SetHttpHeader = 2007,
486 _OrthancPluginService_StartMultipartAnswer = 2008,
487 _OrthancPluginService_SendMultipartItem = 2009,
488 _OrthancPluginService_SendHttpStatus = 2010,
489 _OrthancPluginService_CompressAndAnswerImage = 2011,
490 _OrthancPluginService_SendMultipartItem2 = 2012,
491 _OrthancPluginService_SetHttpErrorDetails = 2013,
492
493 /* Access to the Orthanc database and API */
494 _OrthancPluginService_GetDicomForInstance = 3000,
495 _OrthancPluginService_RestApiGet = 3001,
496 _OrthancPluginService_RestApiPost = 3002,
497 _OrthancPluginService_RestApiDelete = 3003,
498 _OrthancPluginService_RestApiPut = 3004,
499 _OrthancPluginService_LookupPatient = 3005,
500 _OrthancPluginService_LookupStudy = 3006,
501 _OrthancPluginService_LookupSeries = 3007,
502 _OrthancPluginService_LookupInstance = 3008,
503 _OrthancPluginService_LookupStudyWithAccessionNumber = 3009,
504 _OrthancPluginService_RestApiGetAfterPlugins = 3010,
505 _OrthancPluginService_RestApiPostAfterPlugins = 3011,
506 _OrthancPluginService_RestApiDeleteAfterPlugins = 3012,
507 _OrthancPluginService_RestApiPutAfterPlugins = 3013,
508 _OrthancPluginService_ReconstructMainDicomTags = 3014,
509 _OrthancPluginService_RestApiGet2 = 3015,
510 _OrthancPluginService_CallRestApi = 3016, /* New in Orthanc 1.9.2 */
511
512 /* Access to DICOM instances */
513 _OrthancPluginService_GetInstanceRemoteAet = 4000,
514 _OrthancPluginService_GetInstanceSize = 4001,
515 _OrthancPluginService_GetInstanceData = 4002,
516 _OrthancPluginService_GetInstanceJson = 4003,
517 _OrthancPluginService_GetInstanceSimplifiedJson = 4004,
518 _OrthancPluginService_HasInstanceMetadata = 4005,
519 _OrthancPluginService_GetInstanceMetadata = 4006,
520 _OrthancPluginService_GetInstanceOrigin = 4007,
521 _OrthancPluginService_GetInstanceTransferSyntaxUid = 4008,
522 _OrthancPluginService_HasInstancePixelData = 4009,
523 _OrthancPluginService_CreateDicomInstance = 4010, /* New in Orthanc 1.7.0 */
524 _OrthancPluginService_FreeDicomInstance = 4011, /* New in Orthanc 1.7.0 */
525 _OrthancPluginService_GetInstanceFramesCount = 4012, /* New in Orthanc 1.7.0 */
526 _OrthancPluginService_GetInstanceRawFrame = 4013, /* New in Orthanc 1.7.0 */
527 _OrthancPluginService_GetInstanceDecodedFrame = 4014, /* New in Orthanc 1.7.0 */
528 _OrthancPluginService_TranscodeDicomInstance = 4015, /* New in Orthanc 1.7.0 */
529 _OrthancPluginService_SerializeDicomInstance = 4016, /* New in Orthanc 1.7.0 */
530 _OrthancPluginService_GetInstanceAdvancedJson = 4017, /* New in Orthanc 1.7.0 */
531 _OrthancPluginService_GetInstanceDicomWebJson = 4018, /* New in Orthanc 1.7.0 */
532 _OrthancPluginService_GetInstanceDicomWebXml = 4019, /* New in Orthanc 1.7.0 */
533 _OrthancPluginService_LoadDicomInstance = 4020, /* New in Orthanc 1.12.1 */
534
535 /* Services for plugins implementing a database back-end */
536 _OrthancPluginService_RegisterDatabaseBackend = 5000, /* New in Orthanc 0.8.6 */
537 _OrthancPluginService_DatabaseAnswer = 5001,
538 _OrthancPluginService_RegisterDatabaseBackendV2 = 5002, /* New in Orthanc 0.9.4 */
539 _OrthancPluginService_StorageAreaCreate = 5003,
540 _OrthancPluginService_StorageAreaRead = 5004,
541 _OrthancPluginService_StorageAreaRemove = 5005,
542 _OrthancPluginService_RegisterDatabaseBackendV3 = 5006, /* New in Orthanc 1.9.2 */
543 _OrthancPluginService_RegisterDatabaseBackendV4 = 5007, /* New in Orthanc 1.12.0 */
544
545 /* Primitives for handling images */
546 _OrthancPluginService_GetImagePixelFormat = 6000,
547 _OrthancPluginService_GetImageWidth = 6001,
548 _OrthancPluginService_GetImageHeight = 6002,
549 _OrthancPluginService_GetImagePitch = 6003,
550 _OrthancPluginService_GetImageBuffer = 6004,
551 _OrthancPluginService_UncompressImage = 6005,
552 _OrthancPluginService_FreeImage = 6006,
553 _OrthancPluginService_CompressImage = 6007,
554 _OrthancPluginService_ConvertPixelFormat = 6008,
555 _OrthancPluginService_GetFontsCount = 6009,
556 _OrthancPluginService_GetFontInfo = 6010,
557 _OrthancPluginService_DrawText = 6011,
558 _OrthancPluginService_CreateImage = 6012,
559 _OrthancPluginService_CreateImageAccessor = 6013,
560 _OrthancPluginService_DecodeDicomImage = 6014,
561
562 /* Primitives for handling C-Find, C-Move and worklists */
563 _OrthancPluginService_WorklistAddAnswer = 7000,
564 _OrthancPluginService_WorklistMarkIncomplete = 7001,
565 _OrthancPluginService_WorklistIsMatch = 7002,
566 _OrthancPluginService_WorklistGetDicomQuery = 7003,
567 _OrthancPluginService_FindAddAnswer = 7004,
568 _OrthancPluginService_FindMarkIncomplete = 7005,
569 _OrthancPluginService_GetFindQuerySize = 7006,
570 _OrthancPluginService_GetFindQueryTag = 7007,
571 _OrthancPluginService_GetFindQueryTagName = 7008,
572 _OrthancPluginService_GetFindQueryValue = 7009,
573 _OrthancPluginService_CreateFindMatcher = 7010,
574 _OrthancPluginService_FreeFindMatcher = 7011,
575 _OrthancPluginService_FindMatcherIsMatch = 7012,
576
577 /* Primitives for accessing Orthanc Peers (new in 1.4.2) */
578 _OrthancPluginService_GetPeers = 8000,
579 _OrthancPluginService_FreePeers = 8001,
580 _OrthancPluginService_GetPeersCount = 8003,
581 _OrthancPluginService_GetPeerName = 8004,
582 _OrthancPluginService_GetPeerUrl = 8005,
583 _OrthancPluginService_CallPeerApi = 8006,
584 _OrthancPluginService_GetPeerUserProperty = 8007,
585
586 /* Primitives for handling jobs (new in 1.4.2) */
587 _OrthancPluginService_CreateJob = 9000, /* Deprecated since SDK 1.11.3 */
588 _OrthancPluginService_FreeJob = 9001,
589 _OrthancPluginService_SubmitJob = 9002,
590 _OrthancPluginService_RegisterJobsUnserializer = 9003,
591 _OrthancPluginService_CreateJob2 = 9004, /* New in SDK 1.11.3 */
592
593 _OrthancPluginService_INTERNAL = 0x7fffffff
594 } _OrthancPluginService;
595
596
597 typedef enum
598 {
599 _OrthancPluginProperty_Description = 1,
600 _OrthancPluginProperty_RootUri = 2,
601 _OrthancPluginProperty_OrthancExplorer = 3,
602
603 _OrthancPluginProperty_INTERNAL = 0x7fffffff
604 } _OrthancPluginProperty;
605
606
607
612 typedef enum
613 {
621
629
637
645
653
663
671
679
687
695
696 _OrthancPluginPixelFormat_INTERNAL = 0x7fffffff
698
699
700
704 typedef enum
705 {
711 _OrthancPluginContentType_INTERNAL = 0x7fffffff
713
714
715
719 typedef enum
720 {
727 _OrthancPluginResourceType_INTERNAL = 0x7fffffff
729
730
731
736 typedef enum
737 {
758 _OrthancPluginChangeType_INTERNAL = 0x7fffffff
760
761
766 typedef enum
767 {
773 _OrthancPluginCompressionType_INTERNAL = 0x7fffffff
775
776
781 typedef enum
782 {
787 _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
789
790
795 typedef enum
796 {
825 _OrthancPluginValueRepresentation_INTERNAL = 0x7fffffff
827
828
834 typedef enum
835 {
840 _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
842
843
849 typedef enum
850 {
861 _OrthancPluginDicomToJsonFlags_INTERNAL = 0x7fffffff
863
864
870 typedef enum
871 {
876 _OrthancPluginCreateDicomFlags_INTERNAL = 0x7fffffff
878
879
885 typedef enum
886 {
892 _OrthancPluginIdentifierConstraint_INTERNAL = 0x7fffffff
894
895
900 typedef enum
901 {
908 _OrthancPluginConstraintType_INTERNAL = 0x7fffffff
910
911
915 typedef enum
916 {
924 _OrthancPluginInstanceOrigin_INTERNAL = 0x7fffffff
926
927
931 typedef enum
932 {
937
938
945 typedef enum
946 {
952
953
957 typedef enum
958 {
968
969
974 typedef enum
975 {
980
981
987 typedef enum
988 {
993
998
1004
1010
1016
1023
1030
1031
1035 typedef enum
1036 {
1041 _OrthancPluginReceivedInstanceAction_INTERNAL = 0x7fffffff
1043
1044
1049 typedef enum
1050 {
1055
1061
1068
1069 _OrthancPluginLoadDicomInstanceMode_INTERNAL = 0x7fffffff
1071
1072
1080 typedef struct
1081 {
1085 void* data;
1086
1090 uint32_t size;
1092
1093
1094
1102 typedef struct
1103 {
1107 void* data;
1108
1112 uint64_t size;
1114
1115
1116
1117
1122 typedef struct _OrthancPluginRestOutput_t OrthancPluginRestOutput;
1123
1124
1125
1130 typedef struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance;
1131
1132
1133
1138 typedef struct _OrthancPluginImage_t OrthancPluginImage;
1139
1140
1141
1146 typedef struct _OrthancPluginStorageArea_t OrthancPluginStorageArea;
1147
1148
1149
1154 typedef struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery;
1155
1156
1157
1162 typedef struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers;
1163
1164
1165
1170 typedef struct _OrthancPluginFindQuery_t OrthancPluginFindQuery;
1171
1172
1173
1178 typedef struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers;
1179
1180
1181
1186 typedef struct _OrthancPluginFindMatcher_t OrthancPluginFindMatcher;
1187
1188
1189
1194 typedef struct _OrthancPluginPeers_t OrthancPluginPeers;
1195
1196
1197
1202 typedef struct _OrthancPluginJob_t OrthancPluginJob;
1203
1204
1205
1211 typedef struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode;
1212
1213
1214
1221 const char* url,
1222 const OrthancPluginHttpRequest* request);
1223
1224
1225
1231 const OrthancPluginDicomInstance* instance,
1232 const char* instanceId);
1233
1234
1235
1241 OrthancPluginChangeType changeType,
1242 OrthancPluginResourceType resourceType,
1243 const char* resourceId);
1244
1245
1246
1252 OrthancPluginImage** target,
1253 const void* dicom,
1254 const uint32_t size,
1255 uint32_t frameIndex);
1256
1257
1258
1263 typedef void (*OrthancPluginFree) (void* buffer);
1264
1265
1266
1276 const char* bulkDataUri);
1277
1278
1279
1293 const char* uuid,
1294 const void* content,
1295 int64_t size,
1297
1298
1299
1320 void** content,
1321 int64_t* size,
1322 const char* uuid,
1324
1325
1326
1341 const char* uuid,
1343
1344
1345
1364 const char* uuid,
1366 uint64_t rangeStart);
1367
1368
1369
1381 const char* uuid,
1383
1384
1385
1401 const OrthancPluginWorklistQuery* query,
1402 const char* issuerAet,
1403 const char* calledAet);
1404
1405
1406
1432 const char* uri,
1433 const char* ip,
1434 uint32_t headersCount,
1435 const char* const* headersKeys,
1436 const char* const* headersValues);
1437
1438
1439
1467 const char* uri,
1468 const char* ip,
1469 uint32_t headersCount,
1470 const char* const* headersKeys,
1471 const char* const* headersValues,
1472 uint32_t getArgumentsCount,
1473 const char* const* getArgumentsKeys,
1474 const char* const* getArgumentsValues);
1475
1476
1477
1493 OrthancPluginFindAnswers* answers,
1494 const OrthancPluginFindQuery* query,
1495 const char* issuerAet,
1496 const char* calledAet);
1497
1498
1499
1535 typedef void* (*OrthancPluginMoveCallback) (
1536 OrthancPluginResourceType resourceType,
1537 const char* patientId,
1538 const char* accessionNumber,
1539 const char* studyInstanceUid,
1540 const char* seriesInstanceUid,
1541 const char* sopInstanceUid,
1542 const char* originatorAet,
1543 const char* sourceAet,
1544 const char* targetAet,
1545 uint16_t originatorId);
1546
1547
1560 typedef uint32_t (*OrthancPluginGetMoveSize) (void* moveDriver);
1561
1562
1575 typedef OrthancPluginErrorCode (*OrthancPluginApplyMove) (void* moveDriver);
1576
1577
1589 typedef void (*OrthancPluginFreeMove) (void* moveDriver);
1590
1591
1602 typedef void (*OrthancPluginJobFinalize) (void* job);
1603
1604
1615 typedef float (*OrthancPluginJobGetProgress) (void* job);
1616
1617
1631 typedef const char* (*OrthancPluginJobGetContent) (void* job);
1632
1633
1650 void* job);
1651
1652
1669 typedef const char* (*OrthancPluginJobGetSerialized) (void* job);
1670
1671
1690 void* job);
1691
1692
1706
1707
1731
1732
1747
1748
1762 typedef OrthancPluginJob* (*OrthancPluginJobsUnserializer) (const char* jobType,
1763 const char* serialized);
1764
1765
1766
1782
1783
1784
1812 uint32_t levelDepth,
1813 const uint16_t* levelTagGroup,
1814 const uint16_t* levelTagElement,
1815 const uint32_t* levelIndex,
1816 uint16_t tagGroup,
1817 uint16_t tagElement,
1819
1820
1821
1850 uint32_t levelDepth,
1851 const uint16_t* levelTagGroup,
1852 const uint16_t* levelTagElement,
1853 const uint32_t* levelIndex,
1854 uint16_t tagGroup,
1855 uint16_t tagElement,
1857 void* payload);
1858
1859
1860
1864 typedef struct _OrthancPluginContext_t
1865 {
1866 void* pluginsManager;
1867 const char* orthancVersion;
1868 OrthancPluginFree Free;
1869 OrthancPluginErrorCode (*InvokeService) (struct _OrthancPluginContext_t* context,
1870 _OrthancPluginService service,
1871 const void* params);
1873
1874
1875
1879 typedef struct
1880 {
1881 uint16_t group;
1882 uint16_t element;
1887
1888
1889
1898 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeString(
1899 OrthancPluginContext* context,
1900 char* str)
1901 {
1902 if (str != NULL)
1903 {
1904 context->Free(str);
1905 }
1906 }
1907
1908
1928 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginCheckVersionAdvanced(
1929 OrthancPluginContext* context,
1930 int32_t expectedMajor,
1931 int32_t expectedMinor,
1932 int32_t expectedRevision)
1933 {
1934 int32_t major, minor, revision;
1935
1936 if (sizeof(int) != sizeof(int32_t) || /* Ensure binary compatibility with Orthanc SDK <= 1.12.1 */
1937 sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
1938 sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
1939 sizeof(int32_t) != sizeof(_OrthancPluginService) ||
1940 sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
1941 sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
1942 sizeof(int32_t) != sizeof(OrthancPluginContentType) ||
1943 sizeof(int32_t) != sizeof(OrthancPluginResourceType) ||
1944 sizeof(int32_t) != sizeof(OrthancPluginChangeType) ||
1945 sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
1946 sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
1947 sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
1948 sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
1949 sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
1950 sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
1951 sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
1952 sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
1953 sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
1954 sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
1955 sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
1956 sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
1957 sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason) ||
1958 sizeof(int32_t) != sizeof(OrthancPluginLoadDicomInstanceMode))
1959 {
1960 /* Mismatch in the size of the enumerations */
1961 return 0;
1962 }
1963
1964 /* Assume compatibility with the mainline */
1965 if (!strcmp(context->orthancVersion, "mainline"))
1966 {
1967 return 1;
1968 }
1969
1970 /* Parse the version of the Orthanc core */
1971 if (
1972#ifdef _MSC_VER
1973 sscanf_s
1974#else
1975 sscanf
1976#endif
1977 (context->orthancVersion, "%4d.%4d.%4d", &major, &minor, &revision) != 3)
1978 {
1979 return 0;
1980 }
1981
1982 /* Check the major number of the version */
1983
1984 if (major > expectedMajor)
1985 {
1986 return 1;
1987 }
1988
1989 if (major < expectedMajor)
1990 {
1991 return 0;
1992 }
1993
1994 /* Check the minor number of the version */
1995
1996 if (minor > expectedMinor)
1997 {
1998 return 1;
1999 }
2000
2001 if (minor < expectedMinor)
2002 {
2003 return 0;
2004 }
2005
2006 /* Check the revision number of the version */
2007
2008 if (revision >= expectedRevision)
2009 {
2010 return 1;
2011 }
2012 else
2013 {
2014 return 0;
2015 }
2016 }
2017
2018
2035 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginCheckVersion(
2036 OrthancPluginContext* context)
2037 {
2039 context,
2040 ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER,
2041 ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER,
2042 ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER);
2043 }
2044
2045
2054 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer(
2055 OrthancPluginContext* context,
2057 {
2058 context->Free(buffer->data);
2059 }
2060
2061
2070 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeMemoryBuffer64(
2071 OrthancPluginContext* context,
2073 {
2074 context->Free(buffer->data);
2075 }
2076
2077
2086 ORTHANC_PLUGIN_INLINE void OrthancPluginLogError(
2087 OrthancPluginContext* context,
2088 const char* message)
2089 {
2090 context->InvokeService(context, _OrthancPluginService_LogError, message);
2091 }
2092
2093
2102 ORTHANC_PLUGIN_INLINE void OrthancPluginLogWarning(
2103 OrthancPluginContext* context,
2104 const char* message)
2105 {
2106 context->InvokeService(context, _OrthancPluginService_LogWarning, message);
2107 }
2108
2109
2118 ORTHANC_PLUGIN_INLINE void OrthancPluginLogInfo(
2119 OrthancPluginContext* context,
2120 const char* message)
2121 {
2122 context->InvokeService(context, _OrthancPluginService_LogInfo, message);
2123 }
2124
2125
2126
2127 typedef struct
2128 {
2129 const char* pathRegularExpression;
2131 } _OrthancPluginRestCallback;
2132
2154 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterRestCallback(
2155 OrthancPluginContext* context,
2156 const char* pathRegularExpression,
2158 {
2159 _OrthancPluginRestCallback params;
2160 params.pathRegularExpression = pathRegularExpression;
2161 params.callback = callback;
2162 context->InvokeService(context, _OrthancPluginService_RegisterRestCallback, &params);
2163 }
2164
2165
2166
2195 OrthancPluginContext* context,
2196 const char* pathRegularExpression,
2198 {
2199 _OrthancPluginRestCallback params;
2200 params.pathRegularExpression = pathRegularExpression;
2201 params.callback = callback;
2202 context->InvokeService(context, _OrthancPluginService_RegisterRestCallbackNoLock, &params);
2203 }
2204
2205
2206
2207 typedef struct
2208 {
2210 } _OrthancPluginOnStoredInstanceCallback;
2211
2233 OrthancPluginContext* context,
2235 {
2236 _OrthancPluginOnStoredInstanceCallback params;
2237 params.callback = callback;
2238
2239 context->InvokeService(context, _OrthancPluginService_RegisterOnStoredInstanceCallback, &params);
2240 }
2241
2242
2243
2244 typedef struct
2245 {
2247 const void* answer;
2248 uint32_t answerSize;
2249 const char* mimeType;
2250 } _OrthancPluginAnswerBuffer;
2251
2264 ORTHANC_PLUGIN_INLINE void OrthancPluginAnswerBuffer(
2265 OrthancPluginContext* context,
2267 const void* answer,
2268 uint32_t answerSize,
2269 const char* mimeType)
2270 {
2271 _OrthancPluginAnswerBuffer params;
2272 params.output = output;
2273 params.answer = answer;
2274 params.answerSize = answerSize;
2275 params.mimeType = mimeType;
2276 context->InvokeService(context, _OrthancPluginService_AnswerBuffer, &params);
2277 }
2278
2279
2280 typedef struct
2281 {
2284 uint32_t width;
2285 uint32_t height;
2286 uint32_t pitch;
2287 const void* buffer;
2288 } _OrthancPluginCompressAndAnswerPngImage;
2289
2290 typedef struct
2291 {
2293 OrthancPluginImageFormat imageFormat;
2294 OrthancPluginPixelFormat pixelFormat;
2295 uint32_t width;
2296 uint32_t height;
2297 uint32_t pitch;
2298 const void* buffer;
2299 uint8_t quality;
2300 } _OrthancPluginCompressAndAnswerImage;
2301
2302
2321 ORTHANC_PLUGIN_INLINE void OrthancPluginCompressAndAnswerPngImage(
2322 OrthancPluginContext* context,
2325 uint32_t width,
2326 uint32_t height,
2327 uint32_t pitch,
2328 const void* buffer)
2329 {
2330 _OrthancPluginCompressAndAnswerImage params;
2331 params.output = output;
2332 params.imageFormat = OrthancPluginImageFormat_Png;
2333 params.pixelFormat = format;
2334 params.width = width;
2335 params.height = height;
2336 params.pitch = pitch;
2337 params.buffer = buffer;
2338 params.quality = 0; /* No quality for PNG */
2339 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
2340 }
2341
2342
2343
2344 typedef struct
2345 {
2347 const char* instanceId;
2348 } _OrthancPluginGetDicomForInstance;
2349
2363 OrthancPluginContext* context,
2365 const char* instanceId)
2366 {
2367 _OrthancPluginGetDicomForInstance params;
2368 params.target = target;
2369 params.instanceId = instanceId;
2370 return context->InvokeService(context, _OrthancPluginService_GetDicomForInstance, &params);
2371 }
2372
2373
2374
2375 typedef struct
2376 {
2378 const char* uri;
2379 } _OrthancPluginRestApiGet;
2380
2396 OrthancPluginContext* context,
2398 const char* uri)
2399 {
2400 _OrthancPluginRestApiGet params;
2401 params.target = target;
2402 params.uri = uri;
2403 return context->InvokeService(context, _OrthancPluginService_RestApiGet, &params);
2404 }
2405
2406
2407
2426 OrthancPluginContext* context,
2428 const char* uri)
2429 {
2430 _OrthancPluginRestApiGet params;
2431 params.target = target;
2432 params.uri = uri;
2433 return context->InvokeService(context, _OrthancPluginService_RestApiGetAfterPlugins, &params);
2434 }
2435
2436
2437
2438 typedef struct
2439 {
2441 const char* uri;
2442 const void* body;
2443 uint32_t bodySize;
2444 } _OrthancPluginRestApiPostPut;
2445
2463 OrthancPluginContext* context,
2465 const char* uri,
2466 const void* body,
2467 uint32_t bodySize)
2468 {
2469 _OrthancPluginRestApiPostPut params;
2470 params.target = target;
2471 params.uri = uri;
2472 params.body = body;
2473 params.bodySize = bodySize;
2474 return context->InvokeService(context, _OrthancPluginService_RestApiPost, &params);
2475 }
2476
2477
2498 OrthancPluginContext* context,
2500 const char* uri,
2501 const void* body,
2502 uint32_t bodySize)
2503 {
2504 _OrthancPluginRestApiPostPut params;
2505 params.target = target;
2506 params.uri = uri;
2507 params.body = body;
2508 params.bodySize = bodySize;
2509 return context->InvokeService(context, _OrthancPluginService_RestApiPostAfterPlugins, &params);
2510 }
2511
2512
2513
2527 OrthancPluginContext* context,
2528 const char* uri)
2529 {
2530 return context->InvokeService(context, _OrthancPluginService_RestApiDelete, uri);
2531 }
2532
2533
2550 OrthancPluginContext* context,
2551 const char* uri)
2552 {
2553 return context->InvokeService(context, _OrthancPluginService_RestApiDeleteAfterPlugins, uri);
2554 }
2555
2556
2557
2575 OrthancPluginContext* context,
2577 const char* uri,
2578 const void* body,
2579 uint32_t bodySize)
2580 {
2581 _OrthancPluginRestApiPostPut params;
2582 params.target = target;
2583 params.uri = uri;
2584 params.body = body;
2585 params.bodySize = bodySize;
2586 return context->InvokeService(context, _OrthancPluginService_RestApiPut, &params);
2587 }
2588
2589
2590
2611 OrthancPluginContext* context,
2613 const char* uri,
2614 const void* body,
2615 uint32_t bodySize)
2616 {
2617 _OrthancPluginRestApiPostPut params;
2618 params.target = target;
2619 params.uri = uri;
2620 params.body = body;
2621 params.bodySize = bodySize;
2622 return context->InvokeService(context, _OrthancPluginService_RestApiPutAfterPlugins, &params);
2623 }
2624
2625
2626
2627 typedef struct
2628 {
2630 const char* argument;
2631 } _OrthancPluginOutputPlusArgument;
2632
2644 ORTHANC_PLUGIN_INLINE void OrthancPluginRedirect(
2645 OrthancPluginContext* context,
2647 const char* redirection)
2648 {
2649 _OrthancPluginOutputPlusArgument params;
2650 params.output = output;
2651 params.argument = redirection;
2652 context->InvokeService(context, _OrthancPluginService_Redirect, &params);
2653 }
2654
2655
2656
2657 typedef struct
2658 {
2659 char** result;
2660 const char* argument;
2661 } _OrthancPluginRetrieveDynamicString;
2662
2676 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupPatient(
2677 OrthancPluginContext* context,
2678 const char* patientID)
2679 {
2680 char* result;
2681
2682 _OrthancPluginRetrieveDynamicString params;
2683 params.result = &result;
2684 params.argument = patientID;
2685
2686 if (context->InvokeService(context, _OrthancPluginService_LookupPatient, &params) != OrthancPluginErrorCode_Success)
2687 {
2688 /* Error */
2689 return NULL;
2690 }
2691 else
2692 {
2693 return result;
2694 }
2695 }
2696
2697
2711 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupStudy(
2712 OrthancPluginContext* context,
2713 const char* studyUID)
2714 {
2715 char* result;
2716
2717 _OrthancPluginRetrieveDynamicString params;
2718 params.result = &result;
2719 params.argument = studyUID;
2720
2721 if (context->InvokeService(context, _OrthancPluginService_LookupStudy, &params) != OrthancPluginErrorCode_Success)
2722 {
2723 /* Error */
2724 return NULL;
2725 }
2726 else
2727 {
2728 return result;
2729 }
2730 }
2731
2732
2747 OrthancPluginContext* context,
2748 const char* accessionNumber)
2749 {
2750 char* result;
2751
2752 _OrthancPluginRetrieveDynamicString params;
2753 params.result = &result;
2754 params.argument = accessionNumber;
2755
2756 if (context->InvokeService(context, _OrthancPluginService_LookupStudyWithAccessionNumber, &params) != OrthancPluginErrorCode_Success)
2757 {
2758 /* Error */
2759 return NULL;
2760 }
2761 else
2762 {
2763 return result;
2764 }
2765 }
2766
2767
2781 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupSeries(
2782 OrthancPluginContext* context,
2783 const char* seriesUID)
2784 {
2785 char* result;
2786
2787 _OrthancPluginRetrieveDynamicString params;
2788 params.result = &result;
2789 params.argument = seriesUID;
2790
2791 if (context->InvokeService(context, _OrthancPluginService_LookupSeries, &params) != OrthancPluginErrorCode_Success)
2792 {
2793 /* Error */
2794 return NULL;
2795 }
2796 else
2797 {
2798 return result;
2799 }
2800 }
2801
2802
2816 ORTHANC_PLUGIN_INLINE char* OrthancPluginLookupInstance(
2817 OrthancPluginContext* context,
2818 const char* sopInstanceUID)
2819 {
2820 char* result;
2821
2822 _OrthancPluginRetrieveDynamicString params;
2823 params.result = &result;
2824 params.argument = sopInstanceUID;
2825
2826 if (context->InvokeService(context, _OrthancPluginService_LookupInstance, &params) != OrthancPluginErrorCode_Success)
2827 {
2828 /* Error */
2829 return NULL;
2830 }
2831 else
2832 {
2833 return result;
2834 }
2835 }
2836
2837
2838
2839 typedef struct
2840 {
2842 uint16_t status;
2843 } _OrthancPluginSendHttpStatusCode;
2844
2861 ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatusCode(
2862 OrthancPluginContext* context,
2864 uint16_t status)
2865 {
2866 _OrthancPluginSendHttpStatusCode params;
2867 params.output = output;
2868 params.status = status;
2869 context->InvokeService(context, _OrthancPluginService_SendHttpStatusCode, &params);
2870 }
2871
2872
2884 ORTHANC_PLUGIN_INLINE void OrthancPluginSendUnauthorized(
2885 OrthancPluginContext* context,
2887 const char* realm)
2888 {
2889 _OrthancPluginOutputPlusArgument params;
2890 params.output = output;
2891 params.argument = realm;
2892 context->InvokeService(context, _OrthancPluginService_SendUnauthorized, &params);
2893 }
2894
2895
2907 ORTHANC_PLUGIN_INLINE void OrthancPluginSendMethodNotAllowed(
2908 OrthancPluginContext* context,
2910 const char* allowedMethods)
2911 {
2912 _OrthancPluginOutputPlusArgument params;
2913 params.output = output;
2914 params.argument = allowedMethods;
2915 context->InvokeService(context, _OrthancPluginService_SendMethodNotAllowed, &params);
2916 }
2917
2918
2919 typedef struct
2920 {
2922 const char* key;
2923 const char* value;
2924 } _OrthancPluginSetHttpHeader;
2925
2937 ORTHANC_PLUGIN_INLINE void OrthancPluginSetCookie(
2938 OrthancPluginContext* context,
2940 const char* cookie,
2941 const char* value)
2942 {
2943 _OrthancPluginSetHttpHeader params;
2944 params.output = output;
2945 params.key = cookie;
2946 params.value = value;
2947 context->InvokeService(context, _OrthancPluginService_SetCookie, &params);
2948 }
2949
2950
2962 ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpHeader(
2963 OrthancPluginContext* context,
2965 const char* key,
2966 const char* value)
2967 {
2968 _OrthancPluginSetHttpHeader params;
2969 params.output = output;
2970 params.key = key;
2971 params.value = value;
2972 context->InvokeService(context, _OrthancPluginService_SetHttpHeader, &params);
2973 }
2974
2975
2976 typedef struct
2977 {
2978 char** resultStringToFree;
2979 const char** resultString;
2980 int64_t* resultInt64;
2981 const char* key;
2982 const OrthancPluginDicomInstance* instance;
2983 OrthancPluginInstanceOrigin* resultOrigin; /* New in Orthanc 0.9.5 SDK */
2984 } _OrthancPluginAccessDicomInstance;
2985
2986
2998 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceRemoteAet(
2999 OrthancPluginContext* context,
3000 const OrthancPluginDicomInstance* instance)
3001 {
3002 const char* result;
3003
3004 _OrthancPluginAccessDicomInstance params;
3005 memset(&params, 0, sizeof(params));
3006 params.resultString = &result;
3007 params.instance = instance;
3008
3009 if (context->InvokeService(context, _OrthancPluginService_GetInstanceRemoteAet, &params) != OrthancPluginErrorCode_Success)
3010 {
3011 /* Error */
3012 return NULL;
3013 }
3014 else
3015 {
3016 return result;
3017 }
3018 }
3019
3020
3031 ORTHANC_PLUGIN_INLINE int64_t OrthancPluginGetInstanceSize(
3032 OrthancPluginContext* context,
3033 const OrthancPluginDicomInstance* instance)
3034 {
3035 int64_t size;
3036
3037 _OrthancPluginAccessDicomInstance params;
3038 memset(&params, 0, sizeof(params));
3039 params.resultInt64 = &size;
3040 params.instance = instance;
3041
3042 if (context->InvokeService(context, _OrthancPluginService_GetInstanceSize, &params) != OrthancPluginErrorCode_Success)
3043 {
3044 /* Error */
3045 return -1;
3046 }
3047 else
3048 {
3049 return size;
3050 }
3051 }
3052
3053
3064 ORTHANC_PLUGIN_INLINE const void* OrthancPluginGetInstanceData(
3065 OrthancPluginContext* context,
3066 const OrthancPluginDicomInstance* instance)
3067 {
3068 const char* result;
3069
3070 _OrthancPluginAccessDicomInstance params;
3071 memset(&params, 0, sizeof(params));
3072 params.resultString = &result;
3073 params.instance = instance;
3074
3075 if (context->InvokeService(context, _OrthancPluginService_GetInstanceData, &params) != OrthancPluginErrorCode_Success)
3076 {
3077 /* Error */
3078 return NULL;
3079 }
3080 else
3081 {
3082 return result;
3083 }
3084 }
3085
3086
3100 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceJson(
3101 OrthancPluginContext* context,
3102 const OrthancPluginDicomInstance* instance)
3103 {
3104 char* result;
3105
3106 _OrthancPluginAccessDicomInstance params;
3107 memset(&params, 0, sizeof(params));
3108 params.resultStringToFree = &result;
3109 params.instance = instance;
3110
3111 if (context->InvokeService(context, _OrthancPluginService_GetInstanceJson, &params) != OrthancPluginErrorCode_Success)
3112 {
3113 /* Error */
3114 return NULL;
3115 }
3116 else
3117 {
3118 return result;
3119 }
3120 }
3121
3122
3138 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceSimplifiedJson(
3139 OrthancPluginContext* context,
3140 const OrthancPluginDicomInstance* instance)
3141 {
3142 char* result;
3143
3144 _OrthancPluginAccessDicomInstance params;
3145 memset(&params, 0, sizeof(params));
3146 params.resultStringToFree = &result;
3147 params.instance = instance;
3148
3149 if (context->InvokeService(context, _OrthancPluginService_GetInstanceSimplifiedJson, &params) != OrthancPluginErrorCode_Success)
3150 {
3151 /* Error */
3152 return NULL;
3153 }
3154 else
3155 {
3156 return result;
3157 }
3158 }
3159
3160
3177 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstanceMetadata(
3178 OrthancPluginContext* context,
3179 const OrthancPluginDicomInstance* instance,
3180 const char* metadata)
3181 {
3182 int64_t result;
3183
3184 _OrthancPluginAccessDicomInstance params;
3185 memset(&params, 0, sizeof(params));
3186 params.resultInt64 = &result;
3187 params.instance = instance;
3188 params.key = metadata;
3189
3190 if (context->InvokeService(context, _OrthancPluginService_HasInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3191 {
3192 /* Error */
3193 return -1;
3194 }
3195 else
3196 {
3197 return (result != 0);
3198 }
3199 }
3200
3201
3218 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetInstanceMetadata(
3219 OrthancPluginContext* context,
3220 const OrthancPluginDicomInstance* instance,
3221 const char* metadata)
3222 {
3223 const char* result;
3224
3225 _OrthancPluginAccessDicomInstance params;
3226 memset(&params, 0, sizeof(params));
3227 params.resultString = &result;
3228 params.instance = instance;
3229 params.key = metadata;
3230
3231 if (context->InvokeService(context, _OrthancPluginService_GetInstanceMetadata, &params) != OrthancPluginErrorCode_Success)
3232 {
3233 /* Error */
3234 return NULL;
3235 }
3236 else
3237 {
3238 return result;
3239 }
3240 }
3241
3242
3243
3244 typedef struct
3245 {
3249 OrthancPluginFree free;
3250 } _OrthancPluginRegisterStorageArea;
3251
3267 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea(
3268 OrthancPluginContext* context,
3272 {
3273 _OrthancPluginRegisterStorageArea params;
3274 params.create = create;
3275 params.read = read;
3276 params.remove = remove;
3277
3278#ifdef __cplusplus
3279 params.free = ::free;
3280#else
3281 params.free = free;
3282#endif
3283
3284 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea, &params);
3285 }
3286
3287
3288
3299 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancPath(OrthancPluginContext* context)
3300 {
3301 char* result;
3302
3303 _OrthancPluginRetrieveDynamicString params;
3304 params.result = &result;
3305 params.argument = NULL;
3306
3307 if (context->InvokeService(context, _OrthancPluginService_GetOrthancPath, &params) != OrthancPluginErrorCode_Success)
3308 {
3309 /* Error */
3310 return NULL;
3311 }
3312 else
3313 {
3314 return result;
3315 }
3316 }
3317
3318
3329 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetOrthancDirectory(OrthancPluginContext* context)
3330 {
3331 char* result;
3332
3333 _OrthancPluginRetrieveDynamicString params;
3334 params.result = &result;
3335 params.argument = NULL;
3336
3337 if (context->InvokeService(context, _OrthancPluginService_GetOrthancDirectory, &params) != OrthancPluginErrorCode_Success)
3338 {
3339 /* Error */
3340 return NULL;
3341 }
3342 else
3343 {
3344 return result;
3345 }
3346 }
3347
3348
3364 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfigurationPath(OrthancPluginContext* context)
3365 {
3366 char* result;
3367
3368 _OrthancPluginRetrieveDynamicString params;
3369 params.result = &result;
3370 params.argument = NULL;
3371
3372 if (context->InvokeService(context, _OrthancPluginService_GetConfigurationPath, &params) != OrthancPluginErrorCode_Success)
3373 {
3374 /* Error */
3375 return NULL;
3376 }
3377 else
3378 {
3379 return result;
3380 }
3381 }
3382
3383
3384
3385 typedef struct
3386 {
3388 } _OrthancPluginOnChangeCallback;
3389
3410 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterOnChangeCallback(
3411 OrthancPluginContext* context,
3413 {
3414 _OrthancPluginOnChangeCallback params;
3415 params.callback = callback;
3416
3417 context->InvokeService(context, _OrthancPluginService_RegisterOnChangeCallback, &params);
3418 }
3419
3420
3421
3422 typedef struct
3423 {
3424 const char* plugin;
3425 _OrthancPluginProperty property;
3426 const char* value;
3427 } _OrthancPluginSetPluginProperty;
3428
3429
3441 ORTHANC_PLUGIN_INLINE void OrthancPluginSetRootUri(
3442 OrthancPluginContext* context,
3443 const char* uri)
3444 {
3445 _OrthancPluginSetPluginProperty params;
3446 params.plugin = OrthancPluginGetName();
3447 params.property = _OrthancPluginProperty_RootUri;
3448 params.value = uri;
3449
3450 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3451 }
3452
3453
3463 ORTHANC_PLUGIN_INLINE void OrthancPluginSetDescription(
3464 OrthancPluginContext* context,
3465 const char* description)
3466 {
3467 _OrthancPluginSetPluginProperty params;
3468 params.plugin = OrthancPluginGetName();
3469 params.property = _OrthancPluginProperty_Description;
3470 params.value = description;
3471
3472 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3473 }
3474
3475
3485 ORTHANC_PLUGIN_INLINE void OrthancPluginExtendOrthancExplorer(
3486 OrthancPluginContext* context,
3487 const char* javascript)
3488 {
3489 _OrthancPluginSetPluginProperty params;
3490 params.plugin = OrthancPluginGetName();
3491 params.property = _OrthancPluginProperty_OrthancExplorer;
3492 params.value = javascript;
3493
3494 context->InvokeService(context, _OrthancPluginService_SetPluginProperty, &params);
3495 }
3496
3497
3498 typedef struct
3499 {
3500 char** result;
3501 int32_t property;
3502 const char* value;
3503 } _OrthancPluginGlobalProperty;
3504
3505
3519 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetGlobalProperty(
3520 OrthancPluginContext* context,
3521 int32_t property,
3522 const char* defaultValue)
3523 {
3524 char* result;
3525
3526 _OrthancPluginGlobalProperty params;
3527 params.result = &result;
3528 params.property = property;
3529 params.value = defaultValue;
3530
3531 if (context->InvokeService(context, _OrthancPluginService_GetGlobalProperty, &params) != OrthancPluginErrorCode_Success)
3532 {
3533 /* Error */
3534 return NULL;
3535 }
3536 else
3537 {
3538 return result;
3539 }
3540 }
3541
3542
3559 OrthancPluginContext* context,
3560 int32_t property,
3561 const char* value)
3562 {
3563 _OrthancPluginGlobalProperty params;
3564 params.result = NULL;
3565 params.property = property;
3566 params.value = value;
3567
3568 return context->InvokeService(context, _OrthancPluginService_SetGlobalProperty, &params);
3569 }
3570
3571
3572
3573 typedef struct
3574 {
3575 int32_t *resultInt32;
3576 uint32_t *resultUint32;
3577 int64_t *resultInt64;
3578 uint64_t *resultUint64;
3579 } _OrthancPluginReturnSingleValue;
3580
3589 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetCommandLineArgumentsCount(
3590 OrthancPluginContext* context)
3591 {
3592 uint32_t count = 0;
3593
3594 _OrthancPluginReturnSingleValue params;
3595 memset(&params, 0, sizeof(params));
3596 params.resultUint32 = &count;
3597
3598 if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgumentsCount, &params) != OrthancPluginErrorCode_Success)
3599 {
3600 /* Error */
3601 return 0;
3602 }
3603 else
3604 {
3605 return count;
3606 }
3607 }
3608
3609
3610
3623 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetCommandLineArgument(
3624 OrthancPluginContext* context,
3625 uint32_t argument)
3626 {
3627 char* result;
3628
3629 _OrthancPluginGlobalProperty params;
3630 params.result = &result;
3631 params.property = (int32_t) argument;
3632 params.value = NULL;
3633
3634 if (context->InvokeService(context, _OrthancPluginService_GetCommandLineArgument, &params) != OrthancPluginErrorCode_Success)
3635 {
3636 /* Error */
3637 return NULL;
3638 }
3639 else
3640 {
3641 return result;
3642 }
3643 }
3644
3645
3655 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetExpectedDatabaseVersion(
3656 OrthancPluginContext* context)
3657 {
3658 uint32_t count = 0;
3659
3660 _OrthancPluginReturnSingleValue params;
3661 memset(&params, 0, sizeof(params));
3662 params.resultUint32 = &count;
3663
3664 if (context->InvokeService(context, _OrthancPluginService_GetExpectedDatabaseVersion, &params) != OrthancPluginErrorCode_Success)
3665 {
3666 /* Error */
3667 return 0;
3668 }
3669 else
3670 {
3671 return count;
3672 }
3673 }
3674
3675
3676
3688 ORTHANC_PLUGIN_INLINE char *OrthancPluginGetConfiguration(OrthancPluginContext* context)
3689 {
3690 char* result;
3691
3692 _OrthancPluginRetrieveDynamicString params;
3693 params.result = &result;
3694 params.argument = NULL;
3695
3696 if (context->InvokeService(context, _OrthancPluginService_GetConfiguration, &params) != OrthancPluginErrorCode_Success)
3697 {
3698 /* Error */
3699 return NULL;
3700 }
3701 else
3702 {
3703 return result;
3704 }
3705 }
3706
3707
3708
3709 typedef struct
3710 {
3712 const char* subType;
3713 const char* contentType;
3714 } _OrthancPluginStartMultipartAnswer;
3715
3730 OrthancPluginContext* context,
3732 const char* subType,
3733 const char* contentType)
3734 {
3735 _OrthancPluginStartMultipartAnswer params;
3736 params.output = output;
3737 params.subType = subType;
3738 params.contentType = contentType;
3739 return context->InvokeService(context, _OrthancPluginService_StartMultipartAnswer, &params);
3740 }
3741
3742
3759 OrthancPluginContext* context,
3761 const void* answer,
3762 uint32_t answerSize)
3763 {
3764 _OrthancPluginAnswerBuffer params;
3765 params.output = output;
3766 params.answer = answer;
3767 params.answerSize = answerSize;
3768 params.mimeType = NULL;
3769 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem, &params);
3770 }
3771
3772
3773
3774 typedef struct
3775 {
3777 const void* source;
3778 uint32_t size;
3779 OrthancPluginCompressionType compression;
3780 uint8_t uncompress;
3781 } _OrthancPluginBufferCompression;
3782
3783
3801 OrthancPluginContext* context,
3803 const void* source,
3804 uint32_t size,
3805 OrthancPluginCompressionType compression,
3806 uint8_t uncompress)
3807 {
3808 _OrthancPluginBufferCompression params;
3809 params.target = target;
3810 params.source = source;
3811 params.size = size;
3812 params.compression = compression;
3813 params.uncompress = uncompress;
3814
3815 return context->InvokeService(context, _OrthancPluginService_BufferCompression, &params);
3816 }
3817
3818
3819
3820 typedef struct
3821 {
3823 const char* path;
3824 } _OrthancPluginReadFile;
3825
3838 OrthancPluginContext* context,
3840 const char* path)
3841 {
3842 _OrthancPluginReadFile params;
3843 params.target = target;
3844 params.path = path;
3845 return context->InvokeService(context, _OrthancPluginService_ReadFile, &params);
3846 }
3847
3848
3849
3850 typedef struct
3851 {
3852 const char* path;
3853 const void* data;
3854 uint32_t size;
3855 } _OrthancPluginWriteFile;
3856
3869 OrthancPluginContext* context,
3870 const char* path,
3871 const void* data,
3872 uint32_t size)
3873 {
3874 _OrthancPluginWriteFile params;
3875 params.path = path;
3876 params.data = data;
3877 params.size = size;
3878 return context->InvokeService(context, _OrthancPluginService_WriteFile, &params);
3879 }
3880
3881
3882
3883 typedef struct
3884 {
3885 const char** target;
3887 } _OrthancPluginGetErrorDescription;
3888
3899 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetErrorDescription(
3900 OrthancPluginContext* context,
3902 {
3903 const char* result = NULL;
3904
3905 _OrthancPluginGetErrorDescription params;
3906 params.target = &result;
3907 params.error = error;
3908
3909 if (context->InvokeService(context, _OrthancPluginService_GetErrorDescription, &params) != OrthancPluginErrorCode_Success ||
3910 result == NULL)
3911 {
3912 return "Unknown error code";
3913 }
3914 else
3915 {
3916 return result;
3917 }
3918 }
3919
3920
3921
3922 typedef struct
3923 {
3925 uint16_t status;
3926 const void* body;
3927 uint32_t bodySize;
3928 } _OrthancPluginSendHttpStatus;
3929
3952 ORTHANC_PLUGIN_INLINE void OrthancPluginSendHttpStatus(
3953 OrthancPluginContext* context,
3955 uint16_t status,
3956 const void* body,
3957 uint32_t bodySize)
3958 {
3959 _OrthancPluginSendHttpStatus params;
3960 params.output = output;
3961 params.status = status;
3962 params.body = body;
3963 params.bodySize = bodySize;
3964 context->InvokeService(context, _OrthancPluginService_SendHttpStatus, &params);
3965 }
3966
3967
3968
3969 typedef struct
3970 {
3971 const OrthancPluginImage* image;
3972 uint32_t* resultUint32;
3973 OrthancPluginPixelFormat* resultPixelFormat;
3974 void** resultBuffer;
3975 } _OrthancPluginGetImageInfo;
3976
3977
3989 OrthancPluginContext* context,
3990 const OrthancPluginImage* image)
3991 {
3993
3994 _OrthancPluginGetImageInfo params;
3995 memset(&params, 0, sizeof(params));
3996 params.image = image;
3997 params.resultPixelFormat = &target;
3998
3999 if (context->InvokeService(context, _OrthancPluginService_GetImagePixelFormat, &params) != OrthancPluginErrorCode_Success)
4000 {
4002 }
4003 else
4004 {
4005 return (OrthancPluginPixelFormat) target;
4006 }
4007 }
4008
4009
4010
4021 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageWidth(
4022 OrthancPluginContext* context,
4023 const OrthancPluginImage* image)
4024 {
4025 uint32_t width;
4026
4027 _OrthancPluginGetImageInfo params;
4028 memset(&params, 0, sizeof(params));
4029 params.image = image;
4030 params.resultUint32 = &width;
4031
4032 if (context->InvokeService(context, _OrthancPluginService_GetImageWidth, &params) != OrthancPluginErrorCode_Success)
4033 {
4034 return 0;
4035 }
4036 else
4037 {
4038 return width;
4039 }
4040 }
4041
4042
4043
4054 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImageHeight(
4055 OrthancPluginContext* context,
4056 const OrthancPluginImage* image)
4057 {
4058 uint32_t height;
4059
4060 _OrthancPluginGetImageInfo params;
4061 memset(&params, 0, sizeof(params));
4062 params.image = image;
4063 params.resultUint32 = &height;
4064
4065 if (context->InvokeService(context, _OrthancPluginService_GetImageHeight, &params) != OrthancPluginErrorCode_Success)
4066 {
4067 return 0;
4068 }
4069 else
4070 {
4071 return height;
4072 }
4073 }
4074
4075
4076
4089 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetImagePitch(
4090 OrthancPluginContext* context,
4091 const OrthancPluginImage* image)
4092 {
4093 uint32_t pitch;
4094
4095 _OrthancPluginGetImageInfo params;
4096 memset(&params, 0, sizeof(params));
4097 params.image = image;
4098 params.resultUint32 = &pitch;
4099
4100 if (context->InvokeService(context, _OrthancPluginService_GetImagePitch, &params) != OrthancPluginErrorCode_Success)
4101 {
4102 return 0;
4103 }
4104 else
4105 {
4106 return pitch;
4107 }
4108 }
4109
4110
4111
4123 ORTHANC_PLUGIN_INLINE void* OrthancPluginGetImageBuffer(
4124 OrthancPluginContext* context,
4125 const OrthancPluginImage* image)
4126 {
4127 void* target = NULL;
4128
4129 _OrthancPluginGetImageInfo params;
4130 memset(&params, 0, sizeof(params));
4131 params.resultBuffer = &target;
4132 params.image = image;
4133
4134 if (context->InvokeService(context, _OrthancPluginService_GetImageBuffer, &params) != OrthancPluginErrorCode_Success)
4135 {
4136 return NULL;
4137 }
4138 else
4139 {
4140 return target;
4141 }
4142 }
4143
4144
4145 typedef struct
4146 {
4147 OrthancPluginImage** target;
4148 const void* data;
4149 uint32_t size;
4151 } _OrthancPluginUncompressImage;
4152
4153
4167 OrthancPluginContext* context,
4168 const void* data,
4169 uint32_t size,
4171 {
4172 OrthancPluginImage* target = NULL;
4173
4174 _OrthancPluginUncompressImage params;
4175 memset(&params, 0, sizeof(params));
4176 params.target = &target;
4177 params.data = data;
4178 params.size = size;
4179 params.format = format;
4180
4181 if (context->InvokeService(context, _OrthancPluginService_UncompressImage, &params) != OrthancPluginErrorCode_Success)
4182 {
4183 return NULL;
4184 }
4185 else
4186 {
4187 return target;
4188 }
4189 }
4190
4191
4192
4193
4194 typedef struct
4195 {
4196 OrthancPluginImage* image;
4197 } _OrthancPluginFreeImage;
4198
4208 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeImage(
4209 OrthancPluginContext* context,
4210 OrthancPluginImage* image)
4211 {
4212 _OrthancPluginFreeImage params;
4213 params.image = image;
4214
4215 context->InvokeService(context, _OrthancPluginService_FreeImage, &params);
4216 }
4217
4218
4219
4220
4221 typedef struct
4222 {
4224 OrthancPluginImageFormat imageFormat;
4225 OrthancPluginPixelFormat pixelFormat;
4226 uint32_t width;
4227 uint32_t height;
4228 uint32_t pitch;
4229 const void* buffer;
4230 uint8_t quality;
4231 } _OrthancPluginCompressImage;
4232
4233
4254 OrthancPluginContext* context,
4257 uint32_t width,
4258 uint32_t height,
4259 uint32_t pitch,
4260 const void* buffer)
4261 {
4262 _OrthancPluginCompressImage params;
4263 memset(&params, 0, sizeof(params));
4264 params.target = target;
4265 params.imageFormat = OrthancPluginImageFormat_Png;
4266 params.pixelFormat = format;
4267 params.width = width;
4268 params.height = height;
4269 params.pitch = pitch;
4270 params.buffer = buffer;
4271 params.quality = 0; /* Unused for PNG */
4272
4273 return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4274 }
4275
4276
4299 OrthancPluginContext* context,
4302 uint32_t width,
4303 uint32_t height,
4304 uint32_t pitch,
4305 const void* buffer,
4306 uint8_t quality)
4307 {
4308 _OrthancPluginCompressImage params;
4309 memset(&params, 0, sizeof(params));
4310 params.target = target;
4311 params.imageFormat = OrthancPluginImageFormat_Jpeg;
4312 params.pixelFormat = format;
4313 params.width = width;
4314 params.height = height;
4315 params.pitch = pitch;
4316 params.buffer = buffer;
4317 params.quality = quality;
4318
4319 return context->InvokeService(context, _OrthancPluginService_CompressImage, &params);
4320 }
4321
4322
4323
4346 OrthancPluginContext* context,
4349 uint32_t width,
4350 uint32_t height,
4351 uint32_t pitch,
4352 const void* buffer,
4353 uint8_t quality)
4354 {
4355 _OrthancPluginCompressAndAnswerImage params;
4356 params.output = output;
4357 params.imageFormat = OrthancPluginImageFormat_Jpeg;
4358 params.pixelFormat = format;
4359 params.width = width;
4360 params.height = height;
4361 params.pitch = pitch;
4362 params.buffer = buffer;
4363 params.quality = quality;
4364 context->InvokeService(context, _OrthancPluginService_CompressAndAnswerImage, &params);
4365 }
4366
4367
4368
4369
4370 typedef struct
4371 {
4374 const char* url;
4375 const char* username;
4376 const char* password;
4377 const void* body;
4378 uint32_t bodySize;
4379 } _OrthancPluginCallHttpClient;
4380
4381
4399 OrthancPluginContext* context,
4401 const char* url,
4402 const char* username,
4403 const char* password)
4404 {
4405 _OrthancPluginCallHttpClient params;
4406 memset(&params, 0, sizeof(params));
4407
4408 params.target = target;
4409 params.method = OrthancPluginHttpMethod_Get;
4410 params.url = url;
4411 params.username = username;
4412 params.password = password;
4413
4414 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4415 }
4416
4417
4437 OrthancPluginContext* context,
4439 const char* url,
4440 const void* body,
4441 uint32_t bodySize,
4442 const char* username,
4443 const char* password)
4444 {
4445 _OrthancPluginCallHttpClient params;
4446 memset(&params, 0, sizeof(params));
4447
4448 params.target = target;
4449 params.method = OrthancPluginHttpMethod_Post;
4450 params.url = url;
4451 params.body = body;
4452 params.bodySize = bodySize;
4453 params.username = username;
4454 params.password = password;
4455
4456 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4457 }
4458
4459
4479 OrthancPluginContext* context,
4481 const char* url,
4482 const void* body,
4483 uint32_t bodySize,
4484 const char* username,
4485 const char* password)
4486 {
4487 _OrthancPluginCallHttpClient params;
4488 memset(&params, 0, sizeof(params));
4489
4490 params.target = target;
4491 params.method = OrthancPluginHttpMethod_Put;
4492 params.url = url;
4493 params.body = body;
4494 params.bodySize = bodySize;
4495 params.username = username;
4496 params.password = password;
4497
4498 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4499 }
4500
4501
4517 OrthancPluginContext* context,
4518 const char* url,
4519 const char* username,
4520 const char* password)
4521 {
4522 _OrthancPluginCallHttpClient params;
4523 memset(&params, 0, sizeof(params));
4524
4525 params.method = OrthancPluginHttpMethod_Delete;
4526 params.url = url;
4527 params.username = username;
4528 params.password = password;
4529
4530 return context->InvokeService(context, _OrthancPluginService_CallHttpClient, &params);
4531 }
4532
4533
4534
4535 typedef struct
4536 {
4537 OrthancPluginImage** target;
4538 const OrthancPluginImage* source;
4539 OrthancPluginPixelFormat targetFormat;
4540 } _OrthancPluginConvertPixelFormat;
4541
4542
4555 OrthancPluginContext* context,
4556 const OrthancPluginImage* source,
4557 OrthancPluginPixelFormat targetFormat)
4558 {
4559 OrthancPluginImage* target = NULL;
4560
4561 _OrthancPluginConvertPixelFormat params;
4562 params.target = &target;
4563 params.source = source;
4564 params.targetFormat = targetFormat;
4565
4566 if (context->InvokeService(context, _OrthancPluginService_ConvertPixelFormat, &params) != OrthancPluginErrorCode_Success)
4567 {
4568 return NULL;
4569 }
4570 else
4571 {
4572 return target;
4573 }
4574 }
4575
4576
4577
4589 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontsCount(
4590 OrthancPluginContext* context)
4591 {
4592 uint32_t count = 0;
4593
4594 _OrthancPluginReturnSingleValue params;
4595 memset(&params, 0, sizeof(params));
4596 params.resultUint32 = &count;
4597
4598 if (context->InvokeService(context, _OrthancPluginService_GetFontsCount, &params) != OrthancPluginErrorCode_Success)
4599 {
4600 /* Error */
4601 return 0;
4602 }
4603 else
4604 {
4605 return count;
4606 }
4607 }
4608
4609
4610
4611
4612 typedef struct
4613 {
4614 uint32_t fontIndex; /* in */
4615 const char** name; /* out */
4616 uint32_t* size; /* out */
4617 } _OrthancPluginGetFontInfo;
4618
4629 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetFontName(
4630 OrthancPluginContext* context,
4631 uint32_t fontIndex)
4632 {
4633 const char* result = NULL;
4634
4635 _OrthancPluginGetFontInfo params;
4636 memset(&params, 0, sizeof(params));
4637 params.name = &result;
4638 params.fontIndex = fontIndex;
4639
4640 if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4641 {
4642 return NULL;
4643 }
4644 else
4645 {
4646 return result;
4647 }
4648 }
4649
4650
4661 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFontSize(
4662 OrthancPluginContext* context,
4663 uint32_t fontIndex)
4664 {
4665 uint32_t result;
4666
4667 _OrthancPluginGetFontInfo params;
4668 memset(&params, 0, sizeof(params));
4669 params.size = &result;
4670 params.fontIndex = fontIndex;
4671
4672 if (context->InvokeService(context, _OrthancPluginService_GetFontInfo, &params) != OrthancPluginErrorCode_Success)
4673 {
4674 return 0;
4675 }
4676 else
4677 {
4678 return result;
4679 }
4680 }
4681
4682
4683
4684 typedef struct
4685 {
4686 OrthancPluginImage* image;
4687 uint32_t fontIndex;
4688 const char* utf8Text;
4689 int32_t x;
4690 int32_t y;
4691 uint8_t r;
4692 uint8_t g;
4693 uint8_t b;
4694 } _OrthancPluginDrawText;
4695
4696
4715 OrthancPluginContext* context,
4716 OrthancPluginImage* image,
4717 uint32_t fontIndex,
4718 const char* utf8Text,
4719 int32_t x,
4720 int32_t y,
4721 uint8_t r,
4722 uint8_t g,
4723 uint8_t b)
4724 {
4725 _OrthancPluginDrawText params;
4726 memset(&params, 0, sizeof(params));
4727 params.image = image;
4728 params.fontIndex = fontIndex;
4729 params.utf8Text = utf8Text;
4730 params.x = x;
4731 params.y = y;
4732 params.r = r;
4733 params.g = g;
4734 params.b = b;
4735
4736 return context->InvokeService(context, _OrthancPluginService_DrawText, &params);
4737 }
4738
4739
4740
4741 typedef struct
4742 {
4743 OrthancPluginStorageArea* storageArea;
4744 const char* uuid;
4745 const void* content;
4746 uint64_t size;
4748 } _OrthancPluginStorageAreaCreate;
4749
4750
4769 OrthancPluginContext* context,
4770 OrthancPluginStorageArea* storageArea,
4771 const char* uuid,
4772 const void* content,
4773 uint64_t size,
4775 {
4776 _OrthancPluginStorageAreaCreate params;
4777 params.storageArea = storageArea;
4778 params.uuid = uuid;
4779 params.content = content;
4780 params.size = size;
4781 params.type = type;
4782
4783 return context->InvokeService(context, _OrthancPluginService_StorageAreaCreate, &params);
4784 }
4785
4786
4787 typedef struct
4788 {
4790 OrthancPluginStorageArea* storageArea;
4791 const char* uuid;
4793 } _OrthancPluginStorageAreaRead;
4794
4795
4813 OrthancPluginContext* context,
4815 OrthancPluginStorageArea* storageArea,
4816 const char* uuid,
4818 {
4819 _OrthancPluginStorageAreaRead params;
4820 params.target = target;
4821 params.storageArea = storageArea;
4822 params.uuid = uuid;
4823 params.type = type;
4824
4825 return context->InvokeService(context, _OrthancPluginService_StorageAreaRead, &params);
4826 }
4827
4828
4829 typedef struct
4830 {
4831 OrthancPluginStorageArea* storageArea;
4832 const char* uuid;
4834 } _OrthancPluginStorageAreaRemove;
4835
4852 OrthancPluginContext* context,
4853 OrthancPluginStorageArea* storageArea,
4854 const char* uuid,
4856 {
4857 _OrthancPluginStorageAreaRemove params;
4858 params.storageArea = storageArea;
4859 params.uuid = uuid;
4860 params.type = type;
4861
4862 return context->InvokeService(context, _OrthancPluginService_StorageAreaRemove, &params);
4863 }
4864
4865
4866
4867 typedef struct
4868 {
4869 OrthancPluginErrorCode* target;
4870 int32_t code;
4871 uint16_t httpStatus;
4872 const char* message;
4873 } _OrthancPluginRegisterErrorCode;
4874
4891 OrthancPluginContext* context,
4892 int32_t code,
4893 uint16_t httpStatus,
4894 const char* message)
4895 {
4897
4898 _OrthancPluginRegisterErrorCode params;
4899 params.target = &target;
4900 params.code = code;
4901 params.httpStatus = httpStatus;
4902 params.message = message;
4903
4904 if (context->InvokeService(context, _OrthancPluginService_RegisterErrorCode, &params) == OrthancPluginErrorCode_Success)
4905 {
4906 return target;
4907 }
4908 else
4909 {
4910 /* There was an error while assigned the error. Use a generic code. */
4912 }
4913 }
4914
4915
4916
4917 typedef struct
4918 {
4919 uint16_t group;
4920 uint16_t element;
4922 const char* name;
4923 uint32_t minMultiplicity;
4924 uint32_t maxMultiplicity;
4925 } _OrthancPluginRegisterDictionaryTag;
4926
4947 OrthancPluginContext* context,
4948 uint16_t group,
4949 uint16_t element,
4951 const char* name,
4952 uint32_t minMultiplicity,
4953 uint32_t maxMultiplicity)
4954 {
4955 _OrthancPluginRegisterDictionaryTag params;
4956 params.group = group;
4957 params.element = element;
4958 params.vr = vr;
4959 params.name = name;
4960 params.minMultiplicity = minMultiplicity;
4961 params.maxMultiplicity = maxMultiplicity;
4962
4963 return context->InvokeService(context, _OrthancPluginService_RegisterDictionaryTag, &params);
4964 }
4965
4966
4967
4968 typedef struct
4969 {
4970 uint16_t group;
4971 uint16_t element;
4973 const char* name;
4974 uint32_t minMultiplicity;
4975 uint32_t maxMultiplicity;
4976 const char* privateCreator;
4977 } _OrthancPluginRegisterPrivateDictionaryTag;
4978
5000 OrthancPluginContext* context,
5001 uint16_t group,
5002 uint16_t element,
5004 const char* name,
5005 uint32_t minMultiplicity,
5006 uint32_t maxMultiplicity,
5007 const char* privateCreator)
5008 {
5009 _OrthancPluginRegisterPrivateDictionaryTag params;
5010 params.group = group;
5011 params.element = element;
5012 params.vr = vr;
5013 params.name = name;
5014 params.minMultiplicity = minMultiplicity;
5015 params.maxMultiplicity = maxMultiplicity;
5016 params.privateCreator = privateCreator;
5017
5018 return context->InvokeService(context, _OrthancPluginService_RegisterPrivateDictionaryTag, &params);
5019 }
5020
5021
5022
5023 typedef struct
5024 {
5025 OrthancPluginStorageArea* storageArea;
5027 } _OrthancPluginReconstructMainDicomTags;
5028
5044 OrthancPluginContext* context,
5045 OrthancPluginStorageArea* storageArea,
5047 {
5048 _OrthancPluginReconstructMainDicomTags params;
5049 params.level = level;
5050 params.storageArea = storageArea;
5051
5052 return context->InvokeService(context, _OrthancPluginService_ReconstructMainDicomTags, &params);
5053 }
5054
5055
5056 typedef struct
5057 {
5058 char** result;
5059 const char* instanceId;
5060 const void* buffer;
5061 uint32_t size;
5064 uint32_t maxStringLength;
5065 } _OrthancPluginDicomToJson;
5066
5067
5087 ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomBufferToJson(
5088 OrthancPluginContext* context,
5089 const void* buffer,
5090 uint32_t size,
5093 uint32_t maxStringLength)
5094 {
5095 char* result;
5096
5097 _OrthancPluginDicomToJson params;
5098 memset(&params, 0, sizeof(params));
5099 params.result = &result;
5100 params.buffer = buffer;
5101 params.size = size;
5102 params.format = format;
5103 params.flags = flags;
5104 params.maxStringLength = maxStringLength;
5105
5106 if (context->InvokeService(context, _OrthancPluginService_DicomBufferToJson, &params) != OrthancPluginErrorCode_Success)
5107 {
5108 /* Error */
5109 return NULL;
5110 }
5111 else
5112 {
5113 return result;
5114 }
5115 }
5116
5117
5136 ORTHANC_PLUGIN_INLINE char* OrthancPluginDicomInstanceToJson(
5137 OrthancPluginContext* context,
5138 const char* instanceId,
5141 uint32_t maxStringLength)
5142 {
5143 char* result;
5144
5145 _OrthancPluginDicomToJson params;
5146 memset(&params, 0, sizeof(params));
5147 params.result = &result;
5148 params.instanceId = instanceId;
5149 params.format = format;
5150 params.flags = flags;
5151 params.maxStringLength = maxStringLength;
5152
5153 if (context->InvokeService(context, _OrthancPluginService_DicomInstanceToJson, &params) != OrthancPluginErrorCode_Success)
5154 {
5155 /* Error */
5156 return NULL;
5157 }
5158 else
5159 {
5160 return result;
5161 }
5162 }
5163
5164
5165 typedef struct
5166 {
5168 const char* uri;
5169 uint32_t headersCount;
5170 const char* const* headersKeys;
5171 const char* const* headersValues;
5172 int32_t afterPlugins;
5173 } _OrthancPluginRestApiGet2;
5174
5195 OrthancPluginContext* context,
5197 const char* uri,
5198 uint32_t headersCount,
5199 const char* const* headersKeys,
5200 const char* const* headersValues,
5201 int32_t afterPlugins)
5202 {
5203 _OrthancPluginRestApiGet2 params;
5204 params.target = target;
5205 params.uri = uri;
5206 params.headersCount = headersCount;
5207 params.headersKeys = headersKeys;
5208 params.headersValues = headersValues;
5209 params.afterPlugins = afterPlugins;
5210
5211 return context->InvokeService(context, _OrthancPluginService_RestApiGet2, &params);
5212 }
5213
5214
5215
5216 typedef struct
5217 {
5219 } _OrthancPluginWorklistCallback;
5220
5233 OrthancPluginContext* context,
5235 {
5236 _OrthancPluginWorklistCallback params;
5237 params.callback = callback;
5238
5239 return context->InvokeService(context, _OrthancPluginService_RegisterWorklistCallback, &params);
5240 }
5241
5242
5243
5244 typedef struct
5245 {
5247 const OrthancPluginWorklistQuery* query;
5248 const void* dicom;
5249 uint32_t size;
5250 } _OrthancPluginWorklistAnswersOperation;
5251
5269 OrthancPluginContext* context,
5271 const OrthancPluginWorklistQuery* query,
5272 const void* dicom,
5273 uint32_t size)
5274 {
5275 _OrthancPluginWorklistAnswersOperation params;
5276 params.answers = answers;
5277 params.query = query;
5278 params.dicom = dicom;
5279 params.size = size;
5280
5281 return context->InvokeService(context, _OrthancPluginService_WorklistAddAnswer, &params);
5282 }
5283
5284
5299 OrthancPluginContext* context,
5301 {
5302 _OrthancPluginWorklistAnswersOperation params;
5303 params.answers = answers;
5304 params.query = NULL;
5305 params.dicom = NULL;
5306 params.size = 0;
5307
5308 return context->InvokeService(context, _OrthancPluginService_WorklistMarkIncomplete, &params);
5309 }
5310
5311
5312 typedef struct
5313 {
5314 const OrthancPluginWorklistQuery* query;
5315 const void* dicom;
5316 uint32_t size;
5317 int32_t* isMatch;
5319 } _OrthancPluginWorklistQueryOperation;
5320
5336 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginWorklistIsMatch(
5337 OrthancPluginContext* context,
5338 const OrthancPluginWorklistQuery* query,
5339 const void* dicom,
5340 uint32_t size)
5341 {
5342 int32_t isMatch = 0;
5343
5344 _OrthancPluginWorklistQueryOperation params;
5345 params.query = query;
5346 params.dicom = dicom;
5347 params.size = size;
5348 params.isMatch = &isMatch;
5349 params.target = NULL;
5350
5351 if (context->InvokeService(context, _OrthancPluginService_WorklistIsMatch, &params) == OrthancPluginErrorCode_Success)
5352 {
5353 return isMatch;
5354 }
5355 else
5356 {
5357 /* Error: Assume non-match */
5358 return 0;
5359 }
5360 }
5361
5362
5376 OrthancPluginContext* context,
5378 const OrthancPluginWorklistQuery* query)
5379 {
5380 _OrthancPluginWorklistQueryOperation params;
5381 params.query = query;
5382 params.dicom = NULL;
5383 params.size = 0;
5384 params.isMatch = NULL;
5385 params.target = target;
5386
5387 return context->InvokeService(context, _OrthancPluginService_WorklistGetDicomQuery, &params);
5388 }
5389
5390
5402 OrthancPluginContext* context,
5403 const OrthancPluginDicomInstance* instance)
5404 {
5406
5407 _OrthancPluginAccessDicomInstance params;
5408 memset(&params, 0, sizeof(params));
5409 params.resultOrigin = &origin;
5410 params.instance = instance;
5411
5412 if (context->InvokeService(context, _OrthancPluginService_GetInstanceOrigin, &params) != OrthancPluginErrorCode_Success)
5413 {
5414 /* Error */
5416 }
5417 else
5418 {
5419 return origin;
5420 }
5421 }
5422
5423
5424 typedef struct
5425 {
5427 const char* json;
5428 const OrthancPluginImage* pixelData;
5430 } _OrthancPluginCreateDicom;
5431
5458 OrthancPluginContext* context,
5460 const char* json,
5461 const OrthancPluginImage* pixelData,
5463 {
5464 _OrthancPluginCreateDicom params;
5465 params.target = target;
5466 params.json = json;
5467 params.pixelData = pixelData;
5468 params.flags = flags;
5469
5470 return context->InvokeService(context, _OrthancPluginService_CreateDicom, &params);
5471 }
5472
5473
5474 typedef struct
5475 {
5477 } _OrthancPluginDecodeImageCallback;
5478
5494 OrthancPluginContext* context,
5496 {
5497 _OrthancPluginDecodeImageCallback params;
5498 params.callback = callback;
5499
5500 return context->InvokeService(context, _OrthancPluginService_RegisterDecodeImageCallback, &params);
5501 }
5502
5503
5504
5505 typedef struct
5506 {
5507 OrthancPluginImage** target;
5509 uint32_t width;
5510 uint32_t height;
5511 uint32_t pitch;
5512 void* buffer;
5513 const void* constBuffer;
5514 uint32_t bufferSize;
5515 uint32_t frameIndex;
5516 } _OrthancPluginCreateImage;
5517
5518
5532 OrthancPluginContext* context,
5534 uint32_t width,
5535 uint32_t height)
5536 {
5537 OrthancPluginImage* target = NULL;
5538
5539 _OrthancPluginCreateImage params;
5540 memset(&params, 0, sizeof(params));
5541 params.target = &target;
5542 params.format = format;
5543 params.width = width;
5544 params.height = height;
5545
5546 if (context->InvokeService(context, _OrthancPluginService_CreateImage, &params) != OrthancPluginErrorCode_Success)
5547 {
5548 return NULL;
5549 }
5550 else
5551 {
5552 return target;
5553 }
5554 }
5555
5556
5575 OrthancPluginContext* context,
5577 uint32_t width,
5578 uint32_t height,
5579 uint32_t pitch,
5580 void* buffer)
5581 {
5582 OrthancPluginImage* target = NULL;
5583
5584 _OrthancPluginCreateImage params;
5585 memset(&params, 0, sizeof(params));
5586 params.target = &target;
5587 params.format = format;
5588 params.width = width;
5589 params.height = height;
5590 params.pitch = pitch;
5591 params.buffer = buffer;
5592
5593 if (context->InvokeService(context, _OrthancPluginService_CreateImageAccessor, &params) != OrthancPluginErrorCode_Success)
5594 {
5595 return NULL;
5596 }
5597 else
5598 {
5599 return target;
5600 }
5601 }
5602
5603
5604
5621 OrthancPluginContext* context,
5622 const void* buffer,
5623 uint32_t bufferSize,
5624 uint32_t frameIndex)
5625 {
5626 OrthancPluginImage* target = NULL;
5627
5628 _OrthancPluginCreateImage params;
5629 memset(&params, 0, sizeof(params));
5630 params.target = &target;
5631 params.constBuffer = buffer;
5632 params.bufferSize = bufferSize;
5633 params.frameIndex = frameIndex;
5634
5635 if (context->InvokeService(context, _OrthancPluginService_DecodeDicomImage, &params) != OrthancPluginErrorCode_Success)
5636 {
5637 return NULL;
5638 }
5639 else
5640 {
5641 return target;
5642 }
5643 }
5644
5645
5646
5647 typedef struct
5648 {
5649 char** result;
5650 const void* buffer;
5651 uint32_t size;
5652 } _OrthancPluginComputeHash;
5653
5666 ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeMd5(
5667 OrthancPluginContext* context,
5668 const void* buffer,
5669 uint32_t size)
5670 {
5671 char* result;
5672
5673 _OrthancPluginComputeHash params;
5674 params.result = &result;
5675 params.buffer = buffer;
5676 params.size = size;
5677
5678 if (context->InvokeService(context, _OrthancPluginService_ComputeMd5, &params) != OrthancPluginErrorCode_Success)
5679 {
5680 /* Error */
5681 return NULL;
5682 }
5683 else
5684 {
5685 return result;
5686 }
5687 }
5688
5689
5702 ORTHANC_PLUGIN_INLINE char* OrthancPluginComputeSha1(
5703 OrthancPluginContext* context,
5704 const void* buffer,
5705 uint32_t size)
5706 {
5707 char* result;
5708
5709 _OrthancPluginComputeHash params;
5710 params.result = &result;
5711 params.buffer = buffer;
5712 params.size = size;
5713
5714 if (context->InvokeService(context, _OrthancPluginService_ComputeSha1, &params) != OrthancPluginErrorCode_Success)
5715 {
5716 /* Error */
5717 return NULL;
5718 }
5719 else
5720 {
5721 return result;
5722 }
5723 }
5724
5725
5726
5727 typedef struct
5728 {
5730 const char* name;
5731 } _OrthancPluginLookupDictionary;
5732
5749 OrthancPluginContext* context,
5751 const char* name)
5752 {
5753 _OrthancPluginLookupDictionary params;
5754 params.target = target;
5755 params.name = name;
5756 return context->InvokeService(context, _OrthancPluginService_LookupDictionary, &params);
5757 }
5758
5759
5760
5761 typedef struct
5762 {
5764 const void* answer;
5765 uint32_t answerSize;
5766 uint32_t headersCount;
5767 const char* const* headersKeys;
5768 const char* const* headersValues;
5769 } _OrthancPluginSendMultipartItem2;
5770
5792 OrthancPluginContext* context,
5794 const void* answer,
5795 uint32_t answerSize,
5796 uint32_t headersCount,
5797 const char* const* headersKeys,
5798 const char* const* headersValues)
5799 {
5800 _OrthancPluginSendMultipartItem2 params;
5801 params.output = output;
5802 params.answer = answer;
5803 params.answerSize = answerSize;
5804 params.headersCount = headersCount;
5805 params.headersKeys = headersKeys;
5806 params.headersValues = headersValues;
5807
5808 return context->InvokeService(context, _OrthancPluginService_SendMultipartItem2, &params);
5809 }
5810
5811
5812 typedef struct
5813 {
5815 } _OrthancPluginIncomingHttpRequestFilter;
5816
5830 OrthancPluginContext* context,
5832 {
5833 _OrthancPluginIncomingHttpRequestFilter params;
5834 params.callback = callback;
5835
5836 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter, &params);
5837 }
5838
5839
5840
5841 typedef struct
5842 {
5843 OrthancPluginMemoryBuffer* answerBody;
5844 OrthancPluginMemoryBuffer* answerHeaders;
5845 uint16_t* httpStatus;
5847 const char* url;
5848 uint32_t headersCount;
5849 const char* const* headersKeys;
5850 const char* const* headersValues;
5851 const void* body;
5852 uint32_t bodySize;
5853 const char* username;
5854 const char* password;
5855 uint32_t timeout;
5856 const char* certificateFile;
5857 const char* certificateKeyFile;
5858 const char* certificateKeyPassword;
5859 uint8_t pkcs11;
5860 } _OrthancPluginCallHttpClient2;
5861
5862
5863
5905 OrthancPluginContext* context,
5906 OrthancPluginMemoryBuffer* answerBody,
5907 OrthancPluginMemoryBuffer* answerHeaders,
5908 uint16_t* httpStatus,
5910 const char* url,
5911 uint32_t headersCount,
5912 const char* const* headersKeys,
5913 const char* const* headersValues,
5914 const void* body,
5915 uint32_t bodySize,
5916 const char* username,
5917 const char* password,
5918 uint32_t timeout,
5919 const char* certificateFile,
5920 const char* certificateKeyFile,
5921 const char* certificateKeyPassword,
5922 uint8_t pkcs11)
5923 {
5924 _OrthancPluginCallHttpClient2 params;
5925 memset(&params, 0, sizeof(params));
5926
5927 params.answerBody = answerBody;
5928 params.answerHeaders = answerHeaders;
5929 params.httpStatus = httpStatus;
5930 params.method = method;
5931 params.url = url;
5932 params.headersCount = headersCount;
5933 params.headersKeys = headersKeys;
5934 params.headersValues = headersValues;
5935 params.body = body;
5936 params.bodySize = bodySize;
5937 params.username = username;
5938 params.password = password;
5939 params.timeout = timeout;
5940 params.certificateFile = certificateFile;
5941 params.certificateKeyFile = certificateKeyFile;
5942 params.certificateKeyPassword = certificateKeyPassword;
5943 params.pkcs11 = pkcs11;
5944
5945 return context->InvokeService(context, _OrthancPluginService_CallHttpClient2, &params);
5946 }
5947
5948
5959 ORTHANC_PLUGIN_INLINE char* OrthancPluginGenerateUuid(
5960 OrthancPluginContext* context)
5961 {
5962 char* result;
5963
5964 _OrthancPluginRetrieveDynamicString params;
5965 params.result = &result;
5966 params.argument = NULL;
5967
5968 if (context->InvokeService(context, _OrthancPluginService_GenerateUuid, &params) != OrthancPluginErrorCode_Success)
5969 {
5970 /* Error */
5971 return NULL;
5972 }
5973 else
5974 {
5975 return result;
5976 }
5977 }
5978
5979
5980
5981
5982 typedef struct
5983 {
5985 } _OrthancPluginFindCallback;
5986
5999 OrthancPluginContext* context,
6001 {
6002 _OrthancPluginFindCallback params;
6003 params.callback = callback;
6004
6005 return context->InvokeService(context, _OrthancPluginService_RegisterFindCallback, &params);
6006 }
6007
6008
6009 typedef struct
6010 {
6011 OrthancPluginFindAnswers *answers;
6012 const OrthancPluginFindQuery *query;
6013 const void *dicom;
6014 uint32_t size;
6015 uint32_t index;
6016 uint32_t *resultUint32;
6017 uint16_t *resultGroup;
6018 uint16_t *resultElement;
6019 char **resultString;
6020 } _OrthancPluginFindOperation;
6021
6038 OrthancPluginContext* context,
6039 OrthancPluginFindAnswers* answers,
6040 const void* dicom,
6041 uint32_t size)
6042 {
6043 _OrthancPluginFindOperation params;
6044 memset(&params, 0, sizeof(params));
6045 params.answers = answers;
6046 params.dicom = dicom;
6047 params.size = size;
6048
6049 return context->InvokeService(context, _OrthancPluginService_FindAddAnswer, &params);
6050 }
6051
6052
6067 OrthancPluginContext* context,
6068 OrthancPluginFindAnswers* answers)
6069 {
6070 _OrthancPluginFindOperation params;
6071 memset(&params, 0, sizeof(params));
6072 params.answers = answers;
6073
6074 return context->InvokeService(context, _OrthancPluginService_FindMarkIncomplete, &params);
6075 }
6076
6077
6078
6090 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetFindQuerySize(
6091 OrthancPluginContext* context,
6092 const OrthancPluginFindQuery* query)
6093 {
6094 uint32_t count = 0;
6095
6096 _OrthancPluginFindOperation params;
6097 memset(&params, 0, sizeof(params));
6098 params.query = query;
6099 params.resultUint32 = &count;
6100
6101 if (context->InvokeService(context, _OrthancPluginService_GetFindQuerySize, &params) != OrthancPluginErrorCode_Success)
6102 {
6103 /* Error */
6104 return 0;
6105 }
6106 else
6107 {
6108 return count;
6109 }
6110 }
6111
6112
6128 OrthancPluginContext* context,
6129 uint16_t* group,
6130 uint16_t* element,
6131 const OrthancPluginFindQuery* query,
6132 uint32_t index)
6133 {
6134 _OrthancPluginFindOperation params;
6135 memset(&params, 0, sizeof(params));
6136 params.query = query;
6137 params.index = index;
6138 params.resultGroup = group;
6139 params.resultElement = element;
6140
6141 return context->InvokeService(context, _OrthancPluginService_GetFindQueryTag, &params);
6142 }
6143
6144
6158 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryTagName(
6159 OrthancPluginContext* context,
6160 const OrthancPluginFindQuery* query,
6161 uint32_t index)
6162 {
6163 char* result;
6164
6165 _OrthancPluginFindOperation params;
6166 memset(&params, 0, sizeof(params));
6167 params.query = query;
6168 params.index = index;
6169 params.resultString = &result;
6170
6171 if (context->InvokeService(context, _OrthancPluginService_GetFindQueryTagName, &params) != OrthancPluginErrorCode_Success)
6172 {
6173 /* Error */
6174 return NULL;
6175 }
6176 else
6177 {
6178 return result;
6179 }
6180 }
6181
6182
6196 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetFindQueryValue(
6197 OrthancPluginContext* context,
6198 const OrthancPluginFindQuery* query,
6199 uint32_t index)
6200 {
6201 char* result;
6202
6203 _OrthancPluginFindOperation params;
6204 memset(&params, 0, sizeof(params));
6205 params.query = query;
6206 params.index = index;
6207 params.resultString = &result;
6208
6209 if (context->InvokeService(context, _OrthancPluginService_GetFindQueryValue, &params) != OrthancPluginErrorCode_Success)
6210 {
6211 /* Error */
6212 return NULL;
6213 }
6214 else
6215 {
6216 return result;
6217 }
6218 }
6219
6220
6221
6222
6223 typedef struct
6224 {
6226 OrthancPluginGetMoveSize getMoveSize;
6227 OrthancPluginApplyMove applyMove;
6228 OrthancPluginFreeMove freeMove;
6229 } _OrthancPluginMoveCallback;
6230
6245 OrthancPluginContext* context,
6247 OrthancPluginGetMoveSize getMoveSize,
6248 OrthancPluginApplyMove applyMove,
6249 OrthancPluginFreeMove freeMove)
6250 {
6251 _OrthancPluginMoveCallback params;
6252 params.callback = callback;
6253 params.getMoveSize = getMoveSize;
6254 params.applyMove = applyMove;
6255 params.freeMove = freeMove;
6256
6257 return context->InvokeService(context, _OrthancPluginService_RegisterMoveCallback, &params);
6258 }
6259
6260
6261
6262 typedef struct
6263 {
6264 OrthancPluginFindMatcher** target;
6265 const void* query;
6266 uint32_t size;
6267 } _OrthancPluginCreateFindMatcher;
6268
6269
6284 OrthancPluginContext* context,
6285 const void* query,
6286 uint32_t size)
6287 {
6288 OrthancPluginFindMatcher* target = NULL;
6289
6290 _OrthancPluginCreateFindMatcher params;
6291 memset(&params, 0, sizeof(params));
6292 params.target = &target;
6293 params.query = query;
6294 params.size = size;
6295
6296 if (context->InvokeService(context, _OrthancPluginService_CreateFindMatcher, &params) != OrthancPluginErrorCode_Success)
6297 {
6298 return NULL;
6299 }
6300 else
6301 {
6302 return target;
6303 }
6304 }
6305
6306
6307 typedef struct
6308 {
6309 OrthancPluginFindMatcher* matcher;
6310 } _OrthancPluginFreeFindMatcher;
6311
6321 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeFindMatcher(
6322 OrthancPluginContext* context,
6323 OrthancPluginFindMatcher* matcher)
6324 {
6325 _OrthancPluginFreeFindMatcher params;
6326 params.matcher = matcher;
6327
6328 context->InvokeService(context, _OrthancPluginService_FreeFindMatcher, &params);
6329 }
6330
6331
6332 typedef struct
6333 {
6334 const OrthancPluginFindMatcher* matcher;
6335 const void* dicom;
6336 uint32_t size;
6337 int32_t* isMatch;
6338 } _OrthancPluginFindMatcherIsMatch;
6339
6354 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginFindMatcherIsMatch(
6355 OrthancPluginContext* context,
6356 const OrthancPluginFindMatcher* matcher,
6357 const void* dicom,
6358 uint32_t size)
6359 {
6360 int32_t isMatch = 0;
6361
6362 _OrthancPluginFindMatcherIsMatch params;
6363 params.matcher = matcher;
6364 params.dicom = dicom;
6365 params.size = size;
6366 params.isMatch = &isMatch;
6367
6368 if (context->InvokeService(context, _OrthancPluginService_FindMatcherIsMatch, &params) == OrthancPluginErrorCode_Success)
6369 {
6370 return isMatch;
6371 }
6372 else
6373 {
6374 /* Error: Assume non-match */
6375 return 0;
6376 }
6377 }
6378
6379
6380 typedef struct
6381 {
6383 } _OrthancPluginIncomingHttpRequestFilter2;
6384
6397 OrthancPluginContext* context,
6399 {
6400 _OrthancPluginIncomingHttpRequestFilter2 params;
6401 params.callback = callback;
6402
6403 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingHttpRequestFilter2, &params);
6404 }
6405
6406
6407
6408 typedef struct
6409 {
6410 OrthancPluginPeers** peers;
6411 } _OrthancPluginGetPeers;
6412
6425 OrthancPluginContext* context)
6426 {
6427 OrthancPluginPeers* peers = NULL;
6428
6429 _OrthancPluginGetPeers params;
6430 memset(&params, 0, sizeof(params));
6431 params.peers = &peers;
6432
6433 if (context->InvokeService(context, _OrthancPluginService_GetPeers, &params) != OrthancPluginErrorCode_Success)
6434 {
6435 return NULL;
6436 }
6437 else
6438 {
6439 return peers;
6440 }
6441 }
6442
6443
6444 typedef struct
6445 {
6446 OrthancPluginPeers* peers;
6447 } _OrthancPluginFreePeers;
6448
6458 ORTHANC_PLUGIN_INLINE void OrthancPluginFreePeers(
6459 OrthancPluginContext* context,
6460 OrthancPluginPeers* peers)
6461 {
6462 _OrthancPluginFreePeers params;
6463 params.peers = peers;
6464
6465 context->InvokeService(context, _OrthancPluginService_FreePeers, &params);
6466 }
6467
6468
6469 typedef struct
6470 {
6471 uint32_t* target;
6472 const OrthancPluginPeers* peers;
6473 } _OrthancPluginGetPeersCount;
6474
6488 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetPeersCount(
6489 OrthancPluginContext* context,
6490 const OrthancPluginPeers* peers)
6491 {
6492 uint32_t target = 0;
6493
6494 _OrthancPluginGetPeersCount params;
6495 memset(&params, 0, sizeof(params));
6496 params.target = &target;
6497 params.peers = peers;
6498
6499 if (context->InvokeService(context, _OrthancPluginService_GetPeersCount, &params) != OrthancPluginErrorCode_Success)
6500 {
6501 /* Error */
6502 return 0;
6503 }
6504 else
6505 {
6506 return target;
6507 }
6508 }
6509
6510
6511 typedef struct
6512 {
6513 const char** target;
6514 const OrthancPluginPeers* peers;
6515 uint32_t peerIndex;
6516 const char* userProperty;
6517 } _OrthancPluginGetPeerProperty;
6518
6536 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerName(
6537 OrthancPluginContext* context,
6538 const OrthancPluginPeers* peers,
6539 uint32_t peerIndex)
6540 {
6541 const char* target = NULL;
6542
6543 _OrthancPluginGetPeerProperty params;
6544 memset(&params, 0, sizeof(params));
6545 params.target = &target;
6546 params.peers = peers;
6547 params.peerIndex = peerIndex;
6548 params.userProperty = NULL;
6549
6550 if (context->InvokeService(context, _OrthancPluginService_GetPeerName, &params) != OrthancPluginErrorCode_Success)
6551 {
6552 /* Error */
6553 return NULL;
6554 }
6555 else
6556 {
6557 return target;
6558 }
6559 }
6560
6561
6577 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUrl(
6578 OrthancPluginContext* context,
6579 const OrthancPluginPeers* peers,
6580 uint32_t peerIndex)
6581 {
6582 const char* target = NULL;
6583
6584 _OrthancPluginGetPeerProperty params;
6585 memset(&params, 0, sizeof(params));
6586 params.target = &target;
6587 params.peers = peers;
6588 params.peerIndex = peerIndex;
6589 params.userProperty = NULL;
6590
6591 if (context->InvokeService(context, _OrthancPluginService_GetPeerUrl, &params) != OrthancPluginErrorCode_Success)
6592 {
6593 /* Error */
6594 return NULL;
6595 }
6596 else
6597 {
6598 return target;
6599 }
6600 }
6601
6602
6603
6623 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetPeerUserProperty(
6624 OrthancPluginContext* context,
6625 const OrthancPluginPeers* peers,
6626 uint32_t peerIndex,
6627 const char* userProperty)
6628 {
6629 const char* target = NULL;
6630
6631 _OrthancPluginGetPeerProperty params;
6632 memset(&params, 0, sizeof(params));
6633 params.target = &target;
6634 params.peers = peers;
6635 params.peerIndex = peerIndex;
6636 params.userProperty = userProperty;
6637
6638 if (context->InvokeService(context, _OrthancPluginService_GetPeerUserProperty, &params) != OrthancPluginErrorCode_Success)
6639 {
6640 /* No such user property */
6641 return NULL;
6642 }
6643 else
6644 {
6645 return target;
6646 }
6647 }
6648
6649
6650
6651 typedef struct
6652 {
6653 OrthancPluginMemoryBuffer* answerBody;
6654 OrthancPluginMemoryBuffer* answerHeaders;
6655 uint16_t* httpStatus;
6656 const OrthancPluginPeers* peers;
6657 uint32_t peerIndex;
6659 const char* uri;
6660 uint32_t additionalHeadersCount;
6661 const char* const* additionalHeadersKeys;
6662 const char* const* additionalHeadersValues;
6663 const void* body;
6664 uint32_t bodySize;
6665 uint32_t timeout;
6666 } _OrthancPluginCallPeerApi;
6667
6705 OrthancPluginContext* context,
6706 OrthancPluginMemoryBuffer* answerBody,
6707 OrthancPluginMemoryBuffer* answerHeaders,
6708 uint16_t* httpStatus,
6709 const OrthancPluginPeers* peers,
6710 uint32_t peerIndex,
6712 const char* uri,
6713 uint32_t additionalHeadersCount,
6714 const char* const* additionalHeadersKeys,
6715 const char* const* additionalHeadersValues,
6716 const void* body,
6717 uint32_t bodySize,
6718 uint32_t timeout)
6719 {
6720 _OrthancPluginCallPeerApi params;
6721 memset(&params, 0, sizeof(params));
6722
6723 params.answerBody = answerBody;
6724 params.answerHeaders = answerHeaders;
6725 params.httpStatus = httpStatus;
6726 params.peers = peers;
6727 params.peerIndex = peerIndex;
6728 params.method = method;
6729 params.uri = uri;
6730 params.additionalHeadersCount = additionalHeadersCount;
6731 params.additionalHeadersKeys = additionalHeadersKeys;
6732 params.additionalHeadersValues = additionalHeadersValues;
6733 params.body = body;
6734 params.bodySize = bodySize;
6735 params.timeout = timeout;
6736
6737 return context->InvokeService(context, _OrthancPluginService_CallPeerApi, &params);
6738 }
6739
6740
6741
6742
6743
6744 typedef struct
6745 {
6746 OrthancPluginJob** target;
6747 void *job;
6748 OrthancPluginJobFinalize finalize;
6749 const char *type;
6750 OrthancPluginJobGetProgress getProgress;
6751 OrthancPluginJobGetContent getContent;
6752 OrthancPluginJobGetSerialized getSerialized;
6756 } _OrthancPluginCreateJob;
6757
6791 OrthancPluginContext *context,
6792 void *job,
6793 OrthancPluginJobFinalize finalize,
6794 const char *type,
6795 OrthancPluginJobGetProgress getProgress,
6796 OrthancPluginJobGetContent getContent,
6797 OrthancPluginJobGetSerialized getSerialized,
6801 {
6802 OrthancPluginJob* target = NULL;
6803
6804 _OrthancPluginCreateJob params;
6805 memset(&params, 0, sizeof(params));
6806
6807 params.target = &target;
6808 params.job = job;
6809 params.finalize = finalize;
6810 params.type = type;
6811 params.getProgress = getProgress;
6812 params.getContent = getContent;
6813 params.getSerialized = getSerialized;
6814 params.step = step;
6815 params.stop = stop;
6816 params.reset = reset;
6817
6818 if (context->InvokeService(context, _OrthancPluginService_CreateJob, &params) != OrthancPluginErrorCode_Success ||
6819 target == NULL)
6820 {
6821 /* Error */
6822 return NULL;
6823 }
6824 else
6825 {
6826 return target;
6827 }
6828 }
6829
6830
6831 typedef struct
6832 {
6833 OrthancPluginJob** target;
6834 void *job;
6835 OrthancPluginJobFinalize finalize;
6836 const char *type;
6837 OrthancPluginJobGetProgress getProgress;
6838 OrthancPluginJobGetContent2 getContent;
6839 OrthancPluginJobGetSerialized2 getSerialized;
6843 } _OrthancPluginCreateJob2;
6844
6877 OrthancPluginContext *context,
6878 void *job,
6879 OrthancPluginJobFinalize finalize,
6880 const char *type,
6881 OrthancPluginJobGetProgress getProgress,
6882 OrthancPluginJobGetContent2 getContent,
6883 OrthancPluginJobGetSerialized2 getSerialized,
6887 {
6888 OrthancPluginJob* target = NULL;
6889
6890 _OrthancPluginCreateJob2 params;
6891 memset(&params, 0, sizeof(params));
6892
6893 params.target = &target;
6894 params.job = job;
6895 params.finalize = finalize;
6896 params.type = type;
6897 params.getProgress = getProgress;
6898 params.getContent = getContent;
6899 params.getSerialized = getSerialized;
6900 params.step = step;
6901 params.stop = stop;
6902 params.reset = reset;
6903
6904 if (context->InvokeService(context, _OrthancPluginService_CreateJob2, &params) != OrthancPluginErrorCode_Success ||
6905 target == NULL)
6906 {
6907 /* Error */
6908 return NULL;
6909 }
6910 else
6911 {
6912 return target;
6913 }
6914 }
6915
6916
6917 typedef struct
6918 {
6919 OrthancPluginJob* job;
6920 } _OrthancPluginFreeJob;
6921
6931 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeJob(
6932 OrthancPluginContext* context,
6933 OrthancPluginJob* job)
6934 {
6935 _OrthancPluginFreeJob params;
6936 params.job = job;
6937
6938 context->InvokeService(context, _OrthancPluginService_FreeJob, &params);
6939 }
6940
6941
6942
6943 typedef struct
6944 {
6945 char** resultId;
6946 OrthancPluginJob *job;
6947 int32_t priority;
6948 } _OrthancPluginSubmitJob;
6949
6963 ORTHANC_PLUGIN_INLINE char *OrthancPluginSubmitJob(
6964 OrthancPluginContext *context,
6965 OrthancPluginJob *job,
6966 int32_t priority)
6967 {
6968 char* resultId = NULL;
6969
6970 _OrthancPluginSubmitJob params;
6971 memset(&params, 0, sizeof(params));
6972
6973 params.resultId = &resultId;
6974 params.job = job;
6975 params.priority = priority;
6976
6977 if (context->InvokeService(context, _OrthancPluginService_SubmitJob, &params) != OrthancPluginErrorCode_Success ||
6978 resultId == NULL)
6979 {
6980 /* Error */
6981 return NULL;
6982 }
6983 else
6984 {
6985 return resultId;
6986 }
6987 }
6988
6989
6990
6991 typedef struct
6992 {
6993 OrthancPluginJobsUnserializer unserializer;
6994 } _OrthancPluginJobsUnserializer;
6995
7008 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterJobsUnserializer(
7009 OrthancPluginContext* context,
7010 OrthancPluginJobsUnserializer unserializer)
7011 {
7012 _OrthancPluginJobsUnserializer params;
7013 params.unserializer = unserializer;
7014
7015 context->InvokeService(context, _OrthancPluginService_RegisterJobsUnserializer, &params);
7016 }
7017
7018
7019
7020 typedef struct
7021 {
7023 const char* details;
7024 uint8_t log;
7025 } _OrthancPluginSetHttpErrorDetails;
7026
7044 ORTHANC_PLUGIN_INLINE void OrthancPluginSetHttpErrorDetails(
7045 OrthancPluginContext* context,
7047 const char* details,
7048 uint8_t log)
7049 {
7050 _OrthancPluginSetHttpErrorDetails params;
7051 params.output = output;
7052 params.details = details;
7053 params.log = log;
7054 context->InvokeService(context, _OrthancPluginService_SetHttpErrorDetails, &params);
7055 }
7056
7057
7058
7059 typedef struct
7060 {
7061 const char** result;
7062 const char* argument;
7063 } _OrthancPluginRetrieveStaticString;
7064
7076 ORTHANC_PLUGIN_INLINE const char* OrthancPluginAutodetectMimeType(
7077 OrthancPluginContext* context,
7078 const char* path)
7079 {
7080 const char* result = NULL;
7081
7082 _OrthancPluginRetrieveStaticString params;
7083 params.result = &result;
7084 params.argument = path;
7085
7086 if (context->InvokeService(context, _OrthancPluginService_AutodetectMimeType, &params) != OrthancPluginErrorCode_Success)
7087 {
7088 /* Error */
7089 return NULL;
7090 }
7091 else
7092 {
7093 return result;
7094 }
7095 }
7096
7097
7098
7099 typedef struct
7100 {
7101 const char* name;
7102 float value;
7104 } _OrthancPluginSetMetricsValue;
7105
7122 ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsValue(
7123 OrthancPluginContext* context,
7124 const char* name,
7125 float value,
7127 {
7128 _OrthancPluginSetMetricsValue params;
7129 params.name = name;
7130 params.value = value;
7131 params.type = type;
7132 context->InvokeService(context, _OrthancPluginService_SetMetricsValue, &params);
7133 }
7134
7135
7136
7137 typedef struct
7138 {
7140 } _OrthancPluginRegisterRefreshMetricsCallback;
7141
7154 OrthancPluginContext* context,
7156 {
7157 _OrthancPluginRegisterRefreshMetricsCallback params;
7158 params.callback = callback;
7159 context->InvokeService(context, _OrthancPluginService_RegisterRefreshMetricsCallback, &params);
7160 }
7161
7162
7163
7164
7165 typedef struct
7166 {
7167 char** target;
7168 const void* dicom;
7169 uint32_t dicomSize;
7171 } _OrthancPluginEncodeDicomWeb;
7172
7189 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson(
7190 OrthancPluginContext* context,
7191 const void* dicom,
7192 uint32_t dicomSize,
7194 {
7195 char* target = NULL;
7196
7197 _OrthancPluginEncodeDicomWeb params;
7198 params.target = &target;
7199 params.dicom = dicom;
7200 params.dicomSize = dicomSize;
7201 params.callback = callback;
7202
7203 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson, &params) != OrthancPluginErrorCode_Success)
7204 {
7205 /* Error */
7206 return NULL;
7207 }
7208 else
7209 {
7210 return target;
7211 }
7212 }
7213
7214
7231 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml(
7232 OrthancPluginContext* context,
7233 const void* dicom,
7234 uint32_t dicomSize,
7236 {
7237 char* target = NULL;
7238
7239 _OrthancPluginEncodeDicomWeb params;
7240 params.target = &target;
7241 params.dicom = dicom;
7242 params.dicomSize = dicomSize;
7243 params.callback = callback;
7244
7245 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml, &params) != OrthancPluginErrorCode_Success)
7246 {
7247 /* Error */
7248 return NULL;
7249 }
7250 else
7251 {
7252 return target;
7253 }
7254 }
7255
7256
7257
7258 typedef struct
7259 {
7260 char** target;
7261 const void* dicom;
7262 uint32_t dicomSize;
7264 void* payload;
7265 } _OrthancPluginEncodeDicomWeb2;
7266
7283 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebJson2(
7284 OrthancPluginContext* context,
7285 const void* dicom,
7286 uint32_t dicomSize,
7288 void* payload)
7289 {
7290 char* target = NULL;
7291
7292 _OrthancPluginEncodeDicomWeb2 params;
7293 params.target = &target;
7294 params.dicom = dicom;
7295 params.dicomSize = dicomSize;
7296 params.callback = callback;
7297 params.payload = payload;
7298
7299 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebJson2, &params) != OrthancPluginErrorCode_Success)
7300 {
7301 /* Error */
7302 return NULL;
7303 }
7304 else
7305 {
7306 return target;
7307 }
7308 }
7309
7310
7327 ORTHANC_PLUGIN_INLINE char* OrthancPluginEncodeDicomWebXml2(
7328 OrthancPluginContext* context,
7329 const void* dicom,
7330 uint32_t dicomSize,
7332 void* payload)
7333 {
7334 char* target = NULL;
7335
7336 _OrthancPluginEncodeDicomWeb2 params;
7337 params.target = &target;
7338 params.dicom = dicom;
7339 params.dicomSize = dicomSize;
7340 params.callback = callback;
7341 params.payload = payload;
7342
7343 if (context->InvokeService(context, _OrthancPluginService_EncodeDicomWebXml2, &params) != OrthancPluginErrorCode_Success)
7344 {
7345 /* Error */
7346 return NULL;
7347 }
7348 else
7349 {
7350 return target;
7351 }
7352 }
7353
7354
7355
7372 void* answer,
7373 const char* key,
7374 const char* value);
7375
7376
7393 void* answer,
7394 const void* data,
7395 uint32_t size);
7396
7397
7412 typedef uint8_t (*OrthancPluginChunkedClientRequestIsDone) (void* request);
7413
7414
7430
7431
7445 typedef const void* (*OrthancPluginChunkedClientRequestGetChunkData) (void* request);
7446
7447
7461 typedef uint32_t (*OrthancPluginChunkedClientRequestGetChunkSize) (void* request);
7462
7463
7464 typedef struct
7465 {
7466 void* answer;
7469 uint16_t* httpStatus;
7471 const char* url;
7472 uint32_t headersCount;
7473 const char* const* headersKeys;
7474 const char* const* headersValues;
7475 void* request;
7480 const char* username;
7481 const char* password;
7482 uint32_t timeout;
7483 const char* certificateFile;
7484 const char* certificateKeyFile;
7485 const char* certificateKeyPassword;
7486 uint8_t pkcs11;
7487 } _OrthancPluginChunkedHttpClient;
7488
7489
7541 OrthancPluginContext* context,
7542 void* answer,
7545 uint16_t* httpStatus,
7547 const char* url,
7548 uint32_t headersCount,
7549 const char* const* headersKeys,
7550 const char* const* headersValues,
7551 void* request,
7556 const char* username,
7557 const char* password,
7558 uint32_t timeout,
7559 const char* certificateFile,
7560 const char* certificateKeyFile,
7561 const char* certificateKeyPassword,
7562 uint8_t pkcs11)
7563 {
7564 _OrthancPluginChunkedHttpClient params;
7565 memset(&params, 0, sizeof(params));
7566
7567 /* In common with OrthancPluginHttpClient() */
7568 params.httpStatus = httpStatus;
7569 params.method = method;
7570 params.url = url;
7571 params.headersCount = headersCount;
7572 params.headersKeys = headersKeys;
7573 params.headersValues = headersValues;
7574 params.username = username;
7575 params.password = password;
7576 params.timeout = timeout;
7577 params.certificateFile = certificateFile;
7578 params.certificateKeyFile = certificateKeyFile;
7579 params.certificateKeyPassword = certificateKeyPassword;
7580 params.pkcs11 = pkcs11;
7581
7582 /* For chunked body/answer */
7583 params.answer = answer;
7584 params.answerAddChunk = answerAddChunk;
7585 params.answerAddHeader = answerAddHeader;
7586 params.request = request;
7587 params.requestIsDone = requestIsDone;
7588 params.requestChunkData = requestChunkData;
7589 params.requestChunkSize = requestChunkSize;
7590 params.requestNext = requestNext;
7591
7592 return context->InvokeService(context, _OrthancPluginService_ChunkedHttpClient, &params);
7593 }
7594
7595
7596
7601 typedef struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader;
7602
7603
7604
7622 const char* url,
7623 const OrthancPluginHttpRequest* request);
7624
7625
7641 const void* data,
7642 uint32_t size);
7643
7644
7661 OrthancPluginRestOutput* output);
7662
7663
7679
7680 typedef struct
7681 {
7682 const char* pathRegularExpression;
7683 OrthancPluginRestCallback getHandler;
7685 OrthancPluginRestCallback deleteHandler;
7690 } _OrthancPluginChunkedRestCallback;
7691
7692
7723 OrthancPluginContext* context,
7724 const char* pathRegularExpression,
7725 OrthancPluginRestCallback getHandler,
7727 OrthancPluginRestCallback deleteHandler,
7732 {
7733 _OrthancPluginChunkedRestCallback params;
7734 params.pathRegularExpression = pathRegularExpression;
7735 params.getHandler = getHandler;
7736 params.postHandler = postHandler;
7737 params.deleteHandler = deleteHandler;
7738 params.putHandler = putHandler;
7739 params.addChunk = addChunk;
7740 params.execute = execute;
7741 params.finalize = finalize;
7742
7743 context->InvokeService(context, _OrthancPluginService_RegisterChunkedRestCallback, &params);
7744 }
7745
7746
7747
7748
7749
7750 typedef struct
7751 {
7752 char** result;
7753 uint16_t group;
7754 uint16_t element;
7755 const char* privateCreator;
7756 } _OrthancPluginGetTagName;
7757
7773 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetTagName(
7774 OrthancPluginContext* context,
7775 uint16_t group,
7776 uint16_t element,
7777 const char* privateCreator)
7778 {
7779 char* result;
7780
7781 _OrthancPluginGetTagName params;
7782 params.result = &result;
7783 params.group = group;
7784 params.element = element;
7785 params.privateCreator = privateCreator;
7786
7787 if (context->InvokeService(context, _OrthancPluginService_GetTagName, &params) != OrthancPluginErrorCode_Success)
7788 {
7789 /* Error */
7790 return NULL;
7791 }
7792 else
7793 {
7794 return result;
7795 }
7796 }
7797
7798
7799
7829 void** handler /* out */,
7830 const char* jobId,
7831 const char* transactionUid,
7832 const char* const* sopClassUids,
7833 const char* const* sopInstanceUids,
7834 uint32_t countInstances,
7835 const char* remoteAet,
7836 const char* calledAet);
7837
7838
7850 typedef void (*OrthancPluginStorageCommitmentDestructor) (void* handler);
7851
7852
7873 void* handler,
7874 const char* sopClassUid,
7875 const char* sopInstanceUid);
7876
7877
7878 typedef struct
7879 {
7883 } _OrthancPluginRegisterStorageCommitmentScpCallback;
7884
7899 OrthancPluginContext* context,
7903 {
7904 _OrthancPluginRegisterStorageCommitmentScpCallback params;
7905 params.factory = factory;
7906 params.destructor = destructor;
7907 params.lookup = lookup;
7908 return context->InvokeService(context, _OrthancPluginService_RegisterStorageCommitmentScpCallback, &params);
7909 }
7910
7911
7912
7939 const OrthancPluginDicomInstance* instance);
7940
7941
7942 typedef struct
7943 {
7945 } _OrthancPluginIncomingDicomInstanceFilter;
7946
7960 OrthancPluginContext* context,
7962 {
7963 _OrthancPluginIncomingDicomInstanceFilter params;
7964 params.callback = callback;
7965
7966 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingDicomInstanceFilter, &params);
7967 }
7968
7969
8001 uint16_t* dimseStatus /* out */,
8002 const OrthancPluginDicomInstance* instance);
8003
8004
8005 typedef struct
8006 {
8008 } _OrthancPluginIncomingCStoreInstanceFilter;
8009
8023 OrthancPluginContext* context,
8025 {
8026 _OrthancPluginIncomingCStoreInstanceFilter params;
8027 params.callback = callback;
8028
8029 return context->InvokeService(context, _OrthancPluginService_RegisterIncomingCStoreInstanceFilter, &params);
8030 }
8031
8068 OrthancPluginMemoryBuffer64* modifiedDicomBuffer,
8069 const void* receivedDicomBuffer,
8070 uint64_t receivedDicomBufferSize,
8072
8073
8074 typedef struct
8075 {
8077 } _OrthancPluginReceivedInstanceCallback;
8078
8100 OrthancPluginContext* context,
8102 {
8103 _OrthancPluginReceivedInstanceCallback params;
8104 params.callback = callback;
8105
8106 return context->InvokeService(context, _OrthancPluginService_RegisterReceivedInstanceCallback, &params);
8107 }
8108
8123 OrthancPluginContext* context,
8124 const OrthancPluginDicomInstance* instance)
8125 {
8126 char* result;
8127
8128 _OrthancPluginAccessDicomInstance params;
8129 memset(&params, 0, sizeof(params));
8130 params.resultStringToFree = &result;
8131 params.instance = instance;
8132
8133 if (context->InvokeService(context, _OrthancPluginService_GetInstanceTransferSyntaxUid, &params) != OrthancPluginErrorCode_Success)
8134 {
8135 /* Error */
8136 return NULL;
8137 }
8138 else
8139 {
8140 return result;
8141 }
8142 }
8143
8144
8157 ORTHANC_PLUGIN_INLINE int32_t OrthancPluginHasInstancePixelData(
8158 OrthancPluginContext* context,
8159 const OrthancPluginDicomInstance* instance)
8160 {
8161 int64_t hasPixelData;
8162
8163 _OrthancPluginAccessDicomInstance params;
8164 memset(&params, 0, sizeof(params));
8165 params.resultInt64 = &hasPixelData;
8166 params.instance = instance;
8167
8168 if (context->InvokeService(context, _OrthancPluginService_HasInstancePixelData, &params) != OrthancPluginErrorCode_Success ||
8169 hasPixelData < 0 ||
8170 hasPixelData > 1)
8171 {
8172 /* Error */
8173 return -1;
8174 }
8175 else
8176 {
8177 return (hasPixelData != 0);
8178 }
8179 }
8180
8181
8182
8183
8184
8185
8186 typedef struct
8187 {
8189 const void* buffer;
8190 uint32_t size;
8191 const char* transferSyntax;
8192 } _OrthancPluginCreateDicomInstance;
8193
8208 OrthancPluginContext* context,
8209 const void* buffer,
8210 uint32_t size)
8211 {
8212 OrthancPluginDicomInstance* target = NULL;
8213
8214 _OrthancPluginCreateDicomInstance params;
8215 params.target = &target;
8216 params.buffer = buffer;
8217 params.size = size;
8218
8219 if (context->InvokeService(context, _OrthancPluginService_CreateDicomInstance, &params) != OrthancPluginErrorCode_Success)
8220 {
8221 /* Error */
8222 return NULL;
8223 }
8224 else
8225 {
8226 return target;
8227 }
8228 }
8229
8230 typedef struct
8231 {
8233 } _OrthancPluginFreeDicomInstance;
8234
8245 ORTHANC_PLUGIN_INLINE void OrthancPluginFreeDicomInstance(
8246 OrthancPluginContext* context,
8248 {
8249 _OrthancPluginFreeDicomInstance params;
8250 params.dicom = dicom;
8251
8252 context->InvokeService(context, _OrthancPluginService_FreeDicomInstance, &params);
8253 }
8254
8255
8256 typedef struct
8257 {
8258 uint32_t* targetUint32;
8259 OrthancPluginMemoryBuffer* targetBuffer;
8260 OrthancPluginImage** targetImage;
8261 char** targetStringToFree;
8262 const OrthancPluginDicomInstance* instance;
8263 uint32_t frameIndex;
8266 uint32_t maxStringLength;
8267 OrthancPluginDicomWebBinaryCallback2 dicomWebCallback;
8268 void* dicomWebPayload;
8269 } _OrthancPluginAccessDicomInstance2;
8270
8282 ORTHANC_PLUGIN_INLINE uint32_t OrthancPluginGetInstanceFramesCount(
8283 OrthancPluginContext* context,
8284 const OrthancPluginDicomInstance* instance)
8285 {
8286 uint32_t count;
8287
8288 _OrthancPluginAccessDicomInstance2 params;
8289 memset(&params, 0, sizeof(params));
8290 params.targetUint32 = &count;
8291 params.instance = instance;
8292
8293 if (context->InvokeService(context, _OrthancPluginService_GetInstanceFramesCount, &params) != OrthancPluginErrorCode_Success)
8294 {
8295 /* Error */
8296 return 0;
8297 }
8298 else
8299 {
8300 return count;
8301 }
8302 }
8303
8304
8323 OrthancPluginContext* context,
8325 const OrthancPluginDicomInstance* instance,
8326 uint32_t frameIndex)
8327 {
8328 _OrthancPluginAccessDicomInstance2 params;
8329 memset(&params, 0, sizeof(params));
8330 params.targetBuffer = target;
8331 params.instance = instance;
8332 params.frameIndex = frameIndex;
8333
8334 return context->InvokeService(context, _OrthancPluginService_GetInstanceRawFrame, &params);
8335 }
8336
8337
8351 OrthancPluginContext* context,
8352 const OrthancPluginDicomInstance* instance,
8353 uint32_t frameIndex)
8354 {
8355 OrthancPluginImage* target = NULL;
8356
8357 _OrthancPluginAccessDicomInstance2 params;
8358 memset(&params, 0, sizeof(params));
8359 params.targetImage = &target;
8360 params.instance = instance;
8361 params.frameIndex = frameIndex;
8362
8363 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDecodedFrame, &params) != OrthancPluginErrorCode_Success)
8364 {
8365 return NULL;
8366 }
8367 else
8368 {
8369 return target;
8370 }
8371 }
8372
8373
8390 OrthancPluginContext* context,
8391 const void* buffer,
8392 uint32_t size,
8393 const char* transferSyntax)
8394 {
8395 OrthancPluginDicomInstance* target = NULL;
8396
8397 _OrthancPluginCreateDicomInstance params;
8398 params.target = &target;
8399 params.buffer = buffer;
8400 params.size = size;
8401 params.transferSyntax = transferSyntax;
8402
8403 if (context->InvokeService(context, _OrthancPluginService_TranscodeDicomInstance, &params) != OrthancPluginErrorCode_Success)
8404 {
8405 /* Error */
8406 return NULL;
8407 }
8408 else
8409 {
8410 return target;
8411 }
8412 }
8413
8428 OrthancPluginContext* context,
8430 const OrthancPluginDicomInstance* instance)
8431 {
8432 _OrthancPluginAccessDicomInstance2 params;
8433 memset(&params, 0, sizeof(params));
8434 params.targetBuffer = target;
8435 params.instance = instance;
8436
8437 return context->InvokeService(context, _OrthancPluginService_SerializeDicomInstance, &params);
8438 }
8439
8440
8459 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceAdvancedJson(
8460 OrthancPluginContext* context,
8461 const OrthancPluginDicomInstance* instance,
8464 uint32_t maxStringLength)
8465 {
8466 char* result = NULL;
8467
8468 _OrthancPluginAccessDicomInstance2 params;
8469 memset(&params, 0, sizeof(params));
8470 params.targetStringToFree = &result;
8471 params.instance = instance;
8472 params.format = format;
8473 params.flags = flags;
8474 params.maxStringLength = maxStringLength;
8475
8476 if (context->InvokeService(context, _OrthancPluginService_GetInstanceAdvancedJson, &params) != OrthancPluginErrorCode_Success)
8477 {
8478 /* Error */
8479 return NULL;
8480 }
8481 else
8482 {
8483 return result;
8484 }
8485 }
8486
8487
8502 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebJson(
8503 OrthancPluginContext* context,
8504 const OrthancPluginDicomInstance* instance,
8506 void* payload)
8507 {
8508 char* target = NULL;
8509
8510 _OrthancPluginAccessDicomInstance2 params;
8511 params.targetStringToFree = &target;
8512 params.instance = instance;
8513 params.dicomWebCallback = callback;
8514 params.dicomWebPayload = payload;
8515
8516 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebJson, &params) != OrthancPluginErrorCode_Success)
8517 {
8518 /* Error */
8519 return NULL;
8520 }
8521 else
8522 {
8523 return target;
8524 }
8525 }
8526
8527
8542 ORTHANC_PLUGIN_INLINE char* OrthancPluginGetInstanceDicomWebXml(
8543 OrthancPluginContext* context,
8544 const OrthancPluginDicomInstance* instance,
8546 void* payload)
8547 {
8548 char* target = NULL;
8549
8550 _OrthancPluginAccessDicomInstance2 params;
8551 params.targetStringToFree = &target;
8552 params.instance = instance;
8553 params.dicomWebCallback = callback;
8554 params.dicomWebPayload = payload;
8555
8556 if (context->InvokeService(context, _OrthancPluginService_GetInstanceDicomWebXml, &params) != OrthancPluginErrorCode_Success)
8557 {
8558 /* Error */
8559 return NULL;
8560 }
8561 else
8562 {
8563 return target;
8564 }
8565 }
8566
8567
8568
8588 OrthancPluginMemoryBuffer* transcoded /* out */,
8589 const void* buffer,
8590 uint64_t size,
8591 const char* const* allowedSyntaxes,
8592 uint32_t countSyntaxes,
8593 uint8_t allowNewSopInstanceUid);
8594
8595
8596 typedef struct
8597 {
8599 } _OrthancPluginTranscoderCallback;
8600
8615 OrthancPluginContext* context,
8617 {
8618 _OrthancPluginTranscoderCallback params;
8619 params.callback = callback;
8620
8621 return context->InvokeService(context, _OrthancPluginService_RegisterTranscoderCallback, &params);
8622 }
8623
8624
8625
8626 typedef struct
8627 {
8629 uint32_t size;
8630 } _OrthancPluginCreateMemoryBuffer;
8631
8650 OrthancPluginContext* context,
8652 uint32_t size)
8653 {
8654 _OrthancPluginCreateMemoryBuffer params;
8655 params.target = target;
8656 params.size = size;
8657
8658 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer, &params);
8659 }
8660
8661
8688 OrthancPluginContext* context)
8689 {
8690 char* result;
8691
8692 _OrthancPluginRetrieveDynamicString params;
8693 params.result = &result;
8694 params.argument = NULL;
8695
8696 if (context->InvokeService(context, _OrthancPluginService_GenerateRestApiAuthorizationToken,
8698 {
8699 /* Error */
8700 return NULL;
8701 }
8702 else
8703 {
8704 return result;
8705 }
8706 }
8707
8708
8709
8710 typedef struct
8711 {
8713 uint64_t size;
8714 } _OrthancPluginCreateMemoryBuffer64;
8715
8734 OrthancPluginContext* context,
8736 uint64_t size)
8737 {
8738 _OrthancPluginCreateMemoryBuffer64 params;
8739 params.target = target;
8740 params.size = size;
8741
8742 return context->InvokeService(context, _OrthancPluginService_CreateMemoryBuffer64, &params);
8743 }
8744
8745
8746 typedef struct
8747 {
8752 } _OrthancPluginRegisterStorageArea2;
8753
8770 ORTHANC_PLUGIN_INLINE void OrthancPluginRegisterStorageArea2(
8771 OrthancPluginContext* context,
8776 {
8777 _OrthancPluginRegisterStorageArea2 params;
8778 params.create = create;
8779 params.readWhole = readWhole;
8780 params.readRange = readRange;
8781 params.remove = remove;
8782 context->InvokeService(context, _OrthancPluginService_RegisterStorageArea2, &params);
8783 }
8784
8785
8786
8787 typedef struct
8788 {
8789 _OrthancPluginCreateDicom createDicom;
8790 const char* privateCreator;
8791 } _OrthancPluginCreateDicom2;
8792
8818 OrthancPluginContext* context,
8820 const char* json,
8821 const OrthancPluginImage* pixelData,
8823 const char* privateCreator)
8824 {
8825 _OrthancPluginCreateDicom2 params;
8826 params.createDicom.target = target;
8827 params.createDicom.json = json;
8828 params.createDicom.pixelData = pixelData;
8829 params.createDicom.flags = flags;
8830 params.privateCreator = privateCreator;
8831
8832 return context->InvokeService(context, _OrthancPluginService_CreateDicom2, &params);
8833 }
8834
8835
8836
8837
8838
8839
8840 typedef struct
8841 {
8842 OrthancPluginMemoryBuffer* answerBody;
8843 OrthancPluginMemoryBuffer* answerHeaders;
8844 uint16_t* httpStatus;
8846 const char* uri;
8847 uint32_t headersCount;
8848 const char* const* headersKeys;
8849 const char* const* headersValues;
8850 const void* body;
8851 uint32_t bodySize;
8852 uint8_t afterPlugins;
8853 } _OrthancPluginCallRestApi;
8854
8886 OrthancPluginContext* context,
8887 OrthancPluginMemoryBuffer* answerBody,
8888 OrthancPluginMemoryBuffer* answerHeaders,
8889 uint16_t* httpStatus,
8891 const char* uri,
8892 uint32_t headersCount,
8893 const char* const* headersKeys,
8894 const char* const* headersValues,
8895 const void* body,
8896 uint32_t bodySize,
8897 uint8_t afterPlugins)
8898 {
8899 _OrthancPluginCallRestApi params;
8900 memset(&params, 0, sizeof(params));
8901
8902 params.answerBody = answerBody;
8903 params.answerHeaders = answerHeaders;
8904 params.httpStatus = httpStatus;
8905 params.method = method;
8906 params.uri = uri;
8907 params.headersCount = headersCount;
8908 params.headersKeys = headersKeys;
8909 params.headersValues = headersValues;
8910 params.body = body;
8911 params.bodySize = bodySize;
8912 params.afterPlugins = afterPlugins;
8913
8914 return context->InvokeService(context, _OrthancPluginService_CallRestApi, &params);
8915 }
8916
8917
8918
8923 typedef struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection;
8924
8925
8944 const char* name,
8945 uint64_t size,
8946 const char* mimeType,
8947 const char* dateTime);
8948
8949
8965 const char* name,
8966 const char* dateTime);
8967
8968
8992 const void* data,
8993 uint64_t size,
8994 const char* mimeType,
8995 const char* dateTime);
8996
8997
9012 uint8_t* isExisting, /* out */
9013 uint32_t pathSize,
9014 const char* const* pathItems,
9015 void* payload);
9016
9017
9037 uint8_t* isExisting, /* out */
9041 uint32_t pathSize,
9042 const char* const* pathItems,
9043 void* payload);
9044
9045
9065 uint32_t pathSize,
9066 const char* const* pathItems,
9067 void* payload);
9068
9069
9086 uint8_t* isReadOnly, /* out */
9087 uint32_t pathSize,
9088 const char* const* pathItems,
9089 const void* data,
9090 uint64_t size,
9091 void* payload);
9092
9093
9108 uint8_t* isReadOnly, /* out */
9109 uint32_t pathSize,
9110 const char* const* pathItems,
9111 void* payload);
9112
9113
9128 uint8_t* isReadOnly, /* out */
9129 uint32_t pathSize,
9130 const char* const* pathItems,
9131 void* payload);
9132
9133
9134 typedef struct
9135 {
9136 const char* uri;
9143 void* payload;
9144 } _OrthancPluginRegisterWebDavCollection;
9145
9167 OrthancPluginContext* context,
9168 const char* uri,
9175 void* payload)
9176 {
9177 _OrthancPluginRegisterWebDavCollection params;
9178 params.uri = uri;
9179 params.isExistingFolder = isExistingFolder;
9180 params.listFolder = listFolder;
9181 params.retrieveFile = retrieveFile;
9182 params.storeFile = storeFile;
9183 params.createFolder = createFolder;
9184 params.deleteItem = deleteItem;
9185 params.payload = payload;
9186
9187 return context->InvokeService(context, _OrthancPluginService_RegisterWebDavCollection, &params);
9188 }
9189
9190
9199 ORTHANC_PLUGIN_INLINE const char* OrthancPluginGetDatabaseServerIdentifier(
9200 OrthancPluginContext* context)
9201 {
9202 const char* result;
9203
9204 _OrthancPluginRetrieveStaticString params;
9205 params.result = &result;
9206 params.argument = NULL;
9207
9208 if (context->InvokeService(context, _OrthancPluginService_GetDatabaseServerIdentifier, &params) != OrthancPluginErrorCode_Success)
9209 {
9210 /* Error */
9211 return NULL;
9212 }
9213 else
9214 {
9215 return result;
9216 }
9217 }
9218
9219
9228 void* backend,
9229 const void* request,
9230 uint64_t requestSize);
9231
9237 typedef void (*OrthancPluginFinalizeDatabaseBackendV4) (void* backend);
9238
9239 typedef struct
9240 {
9241 void* backend;
9242 uint32_t maxDatabaseRetries;
9245 } _OrthancPluginRegisterDatabaseBackendV4;
9246
9265 OrthancPluginContext* context,
9266 void* backend,
9267 uint32_t maxDatabaseRetries,
9270 {
9271 _OrthancPluginRegisterDatabaseBackendV4 params;
9272 params.backend = backend;
9273 params.maxDatabaseRetries = maxDatabaseRetries;
9274 params.operations = operations;
9275 params.finalize = finalize;
9276
9277 return context->InvokeService(context, _OrthancPluginService_RegisterDatabaseBackendV4, &params);
9278 }
9279
9280
9281 typedef struct
9282 {
9284 const char* instanceId;
9286 } _OrthancPluginLoadDicomInstance;
9287
9302 OrthancPluginContext* context,
9303 const char* instanceId,
9305 {
9306 OrthancPluginDicomInstance* target = NULL;
9307
9308 _OrthancPluginLoadDicomInstance params;
9309 params.target = &target;
9310 params.instanceId = instanceId;
9311 params.mode = mode;
9312
9313 if (context->InvokeService(context, _OrthancPluginService_LoadDicomInstance, &params) != OrthancPluginErrorCode_Success)
9314 {
9315 /* Error */
9316 return NULL;
9317 }
9318 else
9319 {
9320 return target;
9321 }
9322 }
9323
9324
9325 typedef struct
9326 {
9327 const char* name;
9328 int64_t value;
9330 } _OrthancPluginSetMetricsIntegerValue;
9331
9347 ORTHANC_PLUGIN_INLINE void OrthancPluginSetMetricsIntegerValue(
9348 OrthancPluginContext* context,
9349 const char* name,
9350 int64_t value,
9352 {
9353 _OrthancPluginSetMetricsIntegerValue params;
9354 params.name = name;
9355 params.value = value;
9356 params.type = type;
9357 context->InvokeService(context, _OrthancPluginService_SetMetricsIntegerValue, &params);
9358 }
9359
9360
9375 OrthancPluginContext* context,
9376 const char* threadName)
9377 {
9378 return context->InvokeService(context, _OrthancPluginService_SetCurrentThreadName, threadName);
9379 }
9380
9381#ifdef __cplusplus
9382}
9383#endif
9384
9385
OrthancPluginErrorCode OrthancPluginRegisterDatabaseBackendV4(OrthancPluginContext *context, void *backend, uint32_t maxDatabaseRetries, OrthancPluginCallDatabaseBackendV4 operations, OrthancPluginFinalizeDatabaseBackendV4 finalize)
Register a custom database back-end.
Definition: OrthancCPlugin.h:9264
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:9226
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:8067
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:8942
void OrthancPluginRegisterStorageArea(OrthancPluginContext *context, OrthancPluginStorageCreate create, OrthancPluginStorageRead read, OrthancPluginStorageRemove remove)
Register a custom storage area.
Definition: OrthancCPlugin.h:3267
void OrthancPluginRegisterOnStoredInstanceCallback(OrthancPluginContext *context, OrthancPluginOnStoredInstanceCallback callback)
Register a callback for received instances.
Definition: OrthancCPlugin.h:2232
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:1273
OrthancPluginErrorCode OrthancPluginRegisterDecodeImageCallback(OrthancPluginContext *context, OrthancPluginDecodeImageCallback callback)
Register a callback to handle the decoding of DICOM images.
Definition: OrthancCPlugin.h:5493
OrthancPluginChangeType
Definition: OrthancCPlugin.h:737
OrthancPluginErrorCode(* OrthancPluginStorageReadWhole)(OrthancPluginMemoryBuffer64 *target, const char *uuid, OrthancPluginContentType type)
Callback for reading a whole file from the storage area.
Definition: OrthancCPlugin.h:1339
OrthancPluginErrorCode OrthancPluginRegisterIncomingCStoreInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingCStoreInstanceFilter callback)
Register a callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition: OrthancCPlugin.h:8022
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:1251
void OrthancPluginRegisterRefreshMetricsCallback(OrthancPluginContext *context, OrthancPluginRefreshMetricsCallback callback)
Register a callback to refresh the metrics.
Definition: OrthancCPlugin.h:7153
OrthancPluginErrorCode(* OrthancPluginWebDavCreateFolderCallback)(uint8_t *isReadOnly, uint32_t pathSize, const char *const *pathItems, void *payload)
Callback to create a folder.
Definition: OrthancCPlugin.h:9107
struct _OrthancPluginWebDavCollection_t OrthancPluginWebDavCollection
Opaque structure that represents a WebDAV collection.
Definition: OrthancCPlugin.h:8923
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:1809
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:9062
int32_t(* OrthancPluginIncomingDicomInstanceFilter)(const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc.
Definition: OrthancCPlugin.h:7938
OrthancPluginErrorCode OrthancPluginStorageAreaRemove(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Remove a file from the storage area.
Definition: OrthancCPlugin.h:4851
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:8587
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter2(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter2 callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:6396
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:8990
OrthancPluginErrorCode(* OrthancPluginStorageRead)(void **content, int64_t *size, const char *uuid, OrthancPluginContentType type)
Callback for reading from the storage area.
Definition: OrthancCPlugin.h:1319
void OrthancPluginRegisterRestCallback(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback.
Definition: OrthancCPlugin.h:2154
uint32_t OrthancPluginGetExpectedDatabaseVersion(OrthancPluginContext *context)
Get the expected version of the database schema.
Definition: OrthancCPlugin.h:3655
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:8099
int32_t OrthancPluginCheckVersion(OrthancPluginContext *context)
Check the compatibility of the plugin wrt. the version of its hosting Orthanc.
Definition: OrthancCPlugin.h:2035
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:9036
OrthancPluginJob *(* OrthancPluginJobsUnserializer)(const char *jobType, const char *serialized)
Callback executed to unserialize a custom job.
Definition: OrthancCPlugin.h:1762
struct _OrthancPluginRestOutput_t OrthancPluginRestOutput
Opaque structure that represents the HTTP connection to the client application.
Definition: OrthancCPlugin.h:1122
void OrthancPluginRegisterOnChangeCallback(OrthancPluginContext *context, OrthancPluginOnChangeCallback callback)
Register a callback to monitor changes.
Definition: OrthancCPlugin.h:3410
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:8770
OrthancPluginErrorCode(* OrthancPluginWebDavAddFolder)(OrthancPluginWebDavCollection *collection, const char *name, const char *dateTime)
Declare a subfolder while returning the content of a folder.
Definition: OrthancCPlugin.h:8963
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:9166
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:1465
OrthancPluginErrorCode(* OrthancPluginRestCallback)(OrthancPluginRestOutput *output, const char *url, const OrthancPluginHttpRequest *request)
Signature of a callback function that answers to a REST request.
Definition: OrthancCPlugin.h:1219
void(* OrthancPluginRefreshMetricsCallback)()
Callback executed to update the metrics of the plugin.
Definition: OrthancCPlugin.h:1781
OrthancPluginErrorCode OrthancPluginRegisterTranscoderCallback(OrthancPluginContext *context, OrthancPluginTranscoderCallback callback)
Register a callback to handle the transcoding of DICOM images.
Definition: OrthancCPlugin.h:8614
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:1230
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:9085
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:9127
OrthancPluginErrorCode OrthancPluginReconstructMainDicomTags(OrthancPluginContext *context, OrthancPluginStorageArea *storageArea, OrthancPluginResourceType level)
Reconstruct the main DICOM tags.
Definition: OrthancCPlugin.h:5043
OrthancPluginErrorCode(* OrthancPluginStorageRemove)(const char *uuid, OrthancPluginContentType type)
Callback for removing a file from the storage area.
Definition: OrthancCPlugin.h:1380
OrthancPluginErrorCode(* OrthancPluginStorageCreate)(const char *uuid, const void *content, int64_t size, OrthancPluginContentType type)
Callback for writing to the storage area.
Definition: OrthancCPlugin.h:1292
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:1847
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:1240
void(* OrthancPluginFinalizeDatabaseBackendV4)(void *backend)
Signature of a callback function that is triggered when the database plugin must be finalized.
Definition: OrthancCPlugin.h:9237
struct _OrthancPluginServerChunkedRequestReader_t OrthancPluginServerChunkedRequestReader
Opaque structure that reads the content of a HTTP request body during a chunked HTTP transfer.
Definition: OrthancCPlugin.h:7601
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:9011
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:1430
void OrthancPluginRegisterJobsUnserializer(OrthancPluginContext *context, OrthancPluginJobsUnserializer unserializer)
Register an unserializer for custom jobs.
Definition: OrthancCPlugin.h:7008
void(* OrthancPluginFree)(void *buffer)
Signature of a function to free dynamic memory.
Definition: OrthancCPlugin.h:1263
void OrthancPluginRegisterRestCallbackNoLock(OrthancPluginContext *context, const char *pathRegularExpression, OrthancPluginRestCallback callback)
Register a REST callback, without locking.
Definition: OrthancCPlugin.h:2194
OrthancPluginErrorCode OrthancPluginStorageAreaRead(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, OrthancPluginStorageArea *storageArea, const char *uuid, OrthancPluginContentType type)
Read a file from the storage area.
Definition: OrthancCPlugin.h:4812
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:1928
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:1362
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:7722
int32_t(* OrthancPluginIncomingCStoreInstanceFilter)(uint16_t *dimseStatus, const OrthancPluginDicomInstance *instance)
Callback to filter incoming DICOM instances received by Orthanc through C-STORE.
Definition: OrthancCPlugin.h:8000
OrthancPluginErrorCode OrthancPluginRegisterIncomingDicomInstanceFilter(OrthancPluginContext *context, OrthancPluginIncomingDicomInstanceFilter callback)
Register a callback to filter incoming DICOM instances.
Definition: OrthancCPlugin.h:7959
OrthancPluginErrorCode OrthancPluginRegisterIncomingHttpRequestFilter(OrthancPluginContext *context, OrthancPluginIncomingHttpRequestFilter callback)
Register a callback to filter incoming HTTP requests.
Definition: OrthancCPlugin.h:5829
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:4768
@ OrthancPluginChangeType_OrthancStopped
Definition: OrthancCPlugin.h:749
@ OrthancPluginChangeType_OrthancStarted
Definition: OrthancCPlugin.h:748
@ OrthancPluginChangeType_Deleted
Definition: OrthancCPlugin.h:739
@ OrthancPluginChangeType_JobFailure
Definition: OrthancCPlugin.h:756
@ OrthancPluginChangeType_NewInstance
Definition: OrthancCPlugin.h:741
@ OrthancPluginChangeType_NewPatient
Definition: OrthancCPlugin.h:742
@ OrthancPluginChangeType_JobSubmitted
Definition: OrthancCPlugin.h:754
@ OrthancPluginChangeType_NewSeries
Definition: OrthancCPlugin.h:743
@ OrthancPluginChangeType_StablePatient
Definition: OrthancCPlugin.h:745
@ OrthancPluginChangeType_UpdatedPeers
Definition: OrthancCPlugin.h:752
@ OrthancPluginChangeType_StableStudy
Definition: OrthancCPlugin.h:747
@ OrthancPluginChangeType_CompletedSeries
Definition: OrthancCPlugin.h:738
@ OrthancPluginChangeType_NewChildInstance
Definition: OrthancCPlugin.h:740
@ OrthancPluginChangeType_UpdatedAttachment
Definition: OrthancCPlugin.h:750
@ OrthancPluginChangeType_UpdatedMetadata
Definition: OrthancCPlugin.h:751
@ OrthancPluginChangeType_StableSeries
Definition: OrthancCPlugin.h:746
@ OrthancPluginChangeType_UpdatedModalities
Definition: OrthancCPlugin.h:753
@ OrthancPluginChangeType_JobSuccess
Definition: OrthancCPlugin.h:755
@ OrthancPluginChangeType_NewStudy
Definition: OrthancCPlugin.h:744
uint32_t OrthancPluginGetFindQuerySize(OrthancPluginContext *context, const OrthancPluginFindQuery *query)
Get the number of tags in a C-Find query.
Definition: OrthancCPlugin.h:6090
struct _OrthancPluginFindQuery_t OrthancPluginFindQuery
Opaque structure to an object that represents a C-Find query.
Definition: OrthancCPlugin.h:1170
OrthancPluginErrorCode(* OrthancPluginApplyMove)(void *moveDriver)
Callback to apply one C-Move suboperation.
Definition: OrthancCPlugin.h:1575
OrthancPluginErrorCode OrthancPluginFindMarkIncomplete(OrthancPluginContext *context, OrthancPluginFindAnswers *answers)
Mark the set of C-Find answers as incomplete.
Definition: OrthancCPlugin.h:6066
void(* OrthancPluginStorageCommitmentDestructor)(void *handler)
Callback to free one storage commitment SCP handler.
Definition: OrthancCPlugin.h:7850
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:1399
OrthancPluginErrorCode OrthancPluginRegisterMoveCallback(OrthancPluginContext *context, OrthancPluginMoveCallback callback, OrthancPluginGetMoveSize getMoveSize, OrthancPluginApplyMove applyMove, OrthancPluginFreeMove freeMove)
Register a callback to handle C-Move requests.
Definition: OrthancCPlugin.h:6244
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:6196
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:7828
OrthancPluginErrorCode OrthancPluginRegisterFindCallback(OrthancPluginContext *context, OrthancPluginFindCallback callback)
Register a callback to handle C-Find requests.
Definition: OrthancCPlugin.h:5998
OrthancPluginErrorCode OrthancPluginWorklistGetDicomQuery(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginWorklistQuery *query)
Retrieve the worklist query as a DICOM file.
Definition: OrthancCPlugin.h:5375
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:7871
int32_t OrthancPluginWorklistIsMatch(OrthancPluginContext *context, const OrthancPluginWorklistQuery *query, const void *dicom, uint32_t size)
Test whether a worklist matches the query.
Definition: OrthancCPlugin.h:5336
OrthancPluginErrorCode OrthancPluginFindAddAnswer(OrthancPluginContext *context, OrthancPluginFindAnswers *answers, const void *dicom, uint32_t size)
Add one answer to some C-Find request.
Definition: OrthancCPlugin.h:6037
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:7898
struct _OrthancPluginFindAnswers_t OrthancPluginFindAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1178
struct _OrthancPluginWorklistAnswers_t OrthancPluginWorklistAnswers
Opaque structure to an object that represents the answers to a C-Find query for worklists.
Definition: OrthancCPlugin.h:1162
OrthancPluginErrorCode(* OrthancPluginFindCallback)(OrthancPluginFindAnswers *answers, const OrthancPluginFindQuery *query, const char *issuerAet, const char *calledAet)
Callback to handle incoming C-Find SCP requests.
Definition: OrthancCPlugin.h:1492
uint32_t(* OrthancPluginGetMoveSize)(void *moveDriver)
Callback to read the size of a C-Move driver.
Definition: OrthancCPlugin.h:1560
OrthancPluginErrorCode OrthancPluginRegisterWorklistCallback(OrthancPluginContext *context, OrthancPluginWorklistCallback callback)
Register a callback to handle modality worklists requests.
Definition: OrthancCPlugin.h:5232
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:6158
OrthancPluginErrorCode OrthancPluginWorklistMarkIncomplete(OrthancPluginContext *context, OrthancPluginWorklistAnswers *answers)
Mark the set of worklist answers as incomplete.
Definition: OrthancCPlugin.h:5298
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:6127
void(* OrthancPluginFreeMove)(void *moveDriver)
Callback to free one C-Move driver.
Definition: OrthancCPlugin.h:1589
struct _OrthancPluginWorklistQuery_t OrthancPluginWorklistQuery
Opaque structure to an object that represents a C-Find query for worklists.
Definition: OrthancCPlugin.h:1154
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:1535
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:5268
int32_t OrthancPluginHasInstancePixelData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Check whether the DICOM file has pixel data.
Definition: OrthancCPlugin.h:8157
char * OrthancPluginGetInstanceDicomWebXml(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:8542
struct _OrthancPluginDicomInstance_t OrthancPluginDicomInstance
Opaque structure that represents a DICOM instance that is managed by the Orthanc core.
Definition: OrthancCPlugin.h:1130
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:8322
const char * OrthancPluginGetInstanceRemoteAet(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the AET of a DICOM instance.
Definition: OrthancCPlugin.h:2998
OrthancPluginDicomInstance * OrthancPluginLoadDicomInstance(OrthancPluginContext *context, const char *instanceId, OrthancPluginLoadDicomInstanceMode mode)
Load a DICOM instance from the Orthanc server.
Definition: OrthancCPlugin.h:9301
char * OrthancPluginGetInstanceJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file.
Definition: OrthancCPlugin.h:3100
OrthancPluginDicomInstance * OrthancPluginTranscodeDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size, const char *transferSyntax)
Parse and transcode a DICOM instance.
Definition: OrthancCPlugin.h:8389
int32_t OrthancPluginHasInstanceMetadata(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, const char *metadata)
Check whether a DICOM instance is associated with some metadata.
Definition: OrthancCPlugin.h:3177
OrthancPluginDicomInstance * OrthancPluginCreateDicomInstance(OrthancPluginContext *context, const void *buffer, uint32_t size)
Parse a DICOM instance.
Definition: OrthancCPlugin.h:8207
uint32_t OrthancPluginGetInstanceFramesCount(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the number of frames in a DICOM instance.
Definition: OrthancCPlugin.h:8282
OrthancPluginInstanceOrigin OrthancPluginGetInstanceOrigin(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the origin of a DICOM file.
Definition: OrthancCPlugin.h:5401
int64_t OrthancPluginGetInstanceSize(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the size of a DICOM file.
Definition: OrthancCPlugin.h:3031
char * OrthancPluginGetInstanceDicomWebJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:8502
char * OrthancPluginGetInstanceTransferSyntaxUid(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the transfer syntax of a DICOM file.
Definition: OrthancCPlugin.h:8122
void OrthancPluginFreeDicomInstance(OrthancPluginContext *context, OrthancPluginDicomInstance *dicom)
Free a DICOM instance.
Definition: OrthancCPlugin.h:8245
OrthancPluginErrorCode OrthancPluginSerializeDicomInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const OrthancPluginDicomInstance *instance)
Writes a DICOM instance to a memory buffer.
Definition: OrthancCPlugin.h:8427
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:3218
char * OrthancPluginGetInstanceSimplifiedJson(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the DICOM tag hierarchy as a JSON file (with simplification).
Definition: OrthancCPlugin.h:3138
const void * OrthancPluginGetInstanceData(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance)
Get the data of a DICOM file.
Definition: OrthancCPlugin.h:3064
OrthancPluginImage * OrthancPluginGetInstanceDecodedFrame(OrthancPluginContext *context, const OrthancPluginDicomInstance *instance, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:8350
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:8459
OrthancPluginImage * OrthancPluginConvertPixelFormat(OrthancPluginContext *context, const OrthancPluginImage *source, OrthancPluginPixelFormat targetFormat)
Change the pixel format of an image.
Definition: OrthancCPlugin.h:4554
OrthancPluginPixelFormat
Definition: OrthancCPlugin.h:613
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:4714
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:4298
uint32_t OrthancPluginGetImagePitch(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pitch of an image.
Definition: OrthancCPlugin.h:4089
OrthancPluginPixelFormat OrthancPluginGetImagePixelFormat(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the pixel format of an image.
Definition: OrthancCPlugin.h:3988
OrthancPluginImage * OrthancPluginCreateImage(OrthancPluginContext *context, OrthancPluginPixelFormat format, uint32_t width, uint32_t height)
Create an image.
Definition: OrthancCPlugin.h:5531
uint32_t OrthancPluginGetFontsCount(OrthancPluginContext *context)
Return the number of available fonts.
Definition: OrthancCPlugin.h:4589
uint32_t OrthancPluginGetImageHeight(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the height of an image.
Definition: OrthancCPlugin.h:4054
void * OrthancPluginGetImageBuffer(OrthancPluginContext *context, const OrthancPluginImage *image)
Return a pointer to the content of an image.
Definition: OrthancCPlugin.h:4123
void OrthancPluginFreeImage(OrthancPluginContext *context, OrthancPluginImage *image)
Free an image.
Definition: OrthancCPlugin.h:4208
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:4253
OrthancPluginImage * OrthancPluginDecodeDicomImage(OrthancPluginContext *context, const void *buffer, uint32_t bufferSize, uint32_t frameIndex)
Decode one frame from a DICOM instance.
Definition: OrthancCPlugin.h:5620
OrthancPluginImage * OrthancPluginUncompressImage(OrthancPluginContext *context, const void *data, uint32_t size, OrthancPluginImageFormat format)
Decode a compressed image.
Definition: OrthancCPlugin.h:4166
const char * OrthancPluginGetFontName(OrthancPluginContext *context, uint32_t fontIndex)
Return the name of a font.
Definition: OrthancCPlugin.h:4629
OrthancPluginImageFormat
Definition: OrthancCPlugin.h:782
struct _OrthancPluginStorageArea_t OrthancPluginStorageArea
Opaque structure that represents the storage area that is actually used by Orthanc.
Definition: OrthancCPlugin.h:1146
OrthancPluginCompressionType
Definition: OrthancCPlugin.h:767
uint32_t OrthancPluginGetImageWidth(OrthancPluginContext *context, const OrthancPluginImage *image)
Return the width of an image.
Definition: OrthancCPlugin.h:4021
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:3800
uint32_t OrthancPluginGetFontSize(OrthancPluginContext *context, uint32_t fontIndex)
Return the size of a font.
Definition: OrthancCPlugin.h:4661
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:5574
struct _OrthancPluginImage_t OrthancPluginImage
Opaque structure that represents an image that is uncompressed in memory.
Definition: OrthancCPlugin.h:1138
@ OrthancPluginPixelFormat_RGBA32
Color image in RGBA32 format.
Definition: OrthancCPlugin.h:652
@ OrthancPluginPixelFormat_RGB48
Color image in RGB48 format.
Definition: OrthancCPlugin.h:662
@ OrthancPluginPixelFormat_Grayscale8
Graylevel 8bpp image.
Definition: OrthancCPlugin.h:620
@ OrthancPluginPixelFormat_SignedGrayscale16
Graylevel, signed 16bpp image.
Definition: OrthancCPlugin.h:636
@ OrthancPluginPixelFormat_Float32
Graylevel, floating-point 32bpp image.
Definition: OrthancCPlugin.h:678
@ OrthancPluginPixelFormat_RGB24
Color image in RGB24 format.
Definition: OrthancCPlugin.h:644
@ OrthancPluginPixelFormat_BGRA32
Color image in BGRA32 format.
Definition: OrthancCPlugin.h:686
@ OrthancPluginPixelFormat_Unknown
Definition: OrthancCPlugin.h:654
@ OrthancPluginPixelFormat_Grayscale64
Graylevel, unsigned 64bpp image.
Definition: OrthancCPlugin.h:694
@ OrthancPluginPixelFormat_Grayscale32
Graylevel, unsigned 32bpp image.
Definition: OrthancCPlugin.h:670
@ OrthancPluginPixelFormat_Grayscale16
Graylevel, unsigned 16bpp image.
Definition: OrthancCPlugin.h:628
@ OrthancPluginImageFormat_Png
Definition: OrthancCPlugin.h:783
@ OrthancPluginImageFormat_Jpeg
Definition: OrthancCPlugin.h:784
@ OrthancPluginImageFormat_Dicom
Definition: OrthancCPlugin.h:785
@ OrthancPluginCompressionType_Gzip
Definition: OrthancCPlugin.h:770
@ OrthancPluginCompressionType_ZlibWithSize
Definition: OrthancCPlugin.h:769
@ OrthancPluginCompressionType_Zlib
Definition: OrthancCPlugin.h:768
@ OrthancPluginCompressionType_GzipWithSize
Definition: OrthancCPlugin.h:771
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:2462
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:2497
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:2610
char * OrthancPluginLookupStudyWithAccessionNumber(OrthancPluginContext *context, const char *accessionNumber)
Look for a study, using the accession number.
Definition: OrthancCPlugin.h:2746
char * OrthancPluginLookupSeries(OrthancPluginContext *context, const char *seriesUID)
Look for a series.
Definition: OrthancCPlugin.h:2781
OrthancPluginErrorCode OrthancPluginSetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *value)
Set the value of a global property.
Definition: OrthancCPlugin.h:3558
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:2574
char * OrthancPluginGetGlobalProperty(OrthancPluginContext *context, int32_t property, const char *defaultValue)
Get the value of a global property.
Definition: OrthancCPlugin.h:3519
char * OrthancPluginLookupStudy(OrthancPluginContext *context, const char *studyUID)
Look for a study.
Definition: OrthancCPlugin.h:2711
OrthancPluginErrorCode OrthancPluginRestApiGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *uri)
Make a GET call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2395
char * OrthancPluginLookupInstance(OrthancPluginContext *context, const char *sopInstanceUID)
Look for an instance.
Definition: OrthancCPlugin.h:2816
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:2425
char * OrthancPluginLookupPatient(OrthancPluginContext *context, const char *patientID)
Look for a patient.
Definition: OrthancCPlugin.h:2676
OrthancPluginErrorCode OrthancPluginRestApiDelete(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the built-in Orthanc REST API.
Definition: OrthancCPlugin.h:2526
OrthancPluginErrorCode OrthancPluginRestApiDeleteAfterPlugins(OrthancPluginContext *context, const char *uri)
Make a DELETE call to the REST API, as tainted by the plugins.
Definition: OrthancCPlugin.h:2549
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:8885
char * OrthancPluginGenerateRestApiAuthorizationToken(OrthancPluginContext *context)
Generate a token to grant full access to the REST API of Orthanc.
Definition: OrthancCPlugin.h:8687
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:5194
OrthancPluginErrorCode OrthancPluginGetDicomForInstance(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *instanceId)
Retrieve a DICOM instance using its Orthanc identifier.
Definition: OrthancCPlugin.h:2362
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:2321
void OrthancPluginSendUnauthorized(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *realm)
Signal that a REST request is not authorized.
Definition: OrthancCPlugin.h:2884
void OrthancPluginSetHttpErrorDetails(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *details, uint8_t log)
Provide a detailed description for an HTTP error.
Definition: OrthancCPlugin.h:7044
void OrthancPluginSendMethodNotAllowed(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *allowedMethods)
Signal that this URI does not support this HTTP method.
Definition: OrthancCPlugin.h:2907
void OrthancPluginAnswerBuffer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const void *answer, uint32_t answerSize, const char *mimeType)
Answer to a REST request.
Definition: OrthancCPlugin.h:2264
void OrthancPluginSendHttpStatusCode(OrthancPluginContext *context, OrthancPluginRestOutput *output, uint16_t status)
Send a HTTP status code.
Definition: OrthancCPlugin.h:2861
void OrthancPluginSetHttpHeader(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *key, const char *value)
Set some HTTP header.
Definition: OrthancCPlugin.h:2962
void OrthancPluginSetCookie(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *cookie, const char *value)
Set a cookie.
Definition: OrthancCPlugin.h:2937
void OrthancPluginRedirect(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *redirection)
Redirect a REST request.
Definition: OrthancCPlugin.h:2644
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:4345
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:3758
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:5791
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:3952
OrthancPluginErrorCode OrthancPluginStartMultipartAnswer(OrthancPluginContext *context, OrthancPluginRestOutput *output, const char *subType, const char *contentType)
Start an HTTP multipart answer.
Definition: OrthancCPlugin.h:3729
OrthancPluginErrorCode(* OrthancPluginJobStop)(void *job, OrthancPluginJobStopReason reason)
Callback executed once one custom job leaves the "running" state.
Definition: OrthancCPlugin.h:1729
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderExecute)(OrthancPluginServerChunkedRequestReader *reader, OrthancPluginRestOutput *output)
Callback invoked whenever the request body is entirely received.
Definition: OrthancCPlugin.h:7659
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:5904
struct _OrthancPluginJob_t OrthancPluginJob
Opaque structure to a job to be executed by Orthanc.
Definition: OrthancCPlugin.h:1202
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:8817
void OrthancPluginLogInfo(OrthancPluginContext *context, const char *message)
Log an information.
Definition: OrthancCPlugin.h:2118
OrthancPluginErrorCode(* OrthancPluginServerChunkedRequestReaderFactory)(OrthancPluginServerChunkedRequestReader **reader, const char *url, const OrthancPluginHttpRequest *request)
Callback to create a reader to handle incoming chunked HTTP transfers.
Definition: OrthancCPlugin.h:7620
void OrthancPluginFreeFindMatcher(OrthancPluginContext *context, OrthancPluginFindMatcher *matcher)
Free a C-Find matcher.
Definition: OrthancCPlugin.h:6321
void OrthancPluginFreePeers(OrthancPluginContext *context, OrthancPluginPeers *peers)
Free the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6458
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:4999
OrthancPluginIdentifierConstraint
Definition: OrthancCPlugin.h:886
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:4946
OrthancPluginResourceType
Definition: OrthancCPlugin.h:720
void OrthancPluginSetMetricsIntegerValue(OrthancPluginContext *context, const char *name, int64_t value, OrthancPluginMetricsType type)
Set the value of an integer metrics.
Definition: OrthancCPlugin.h:9347
OrthancPluginErrorCode OrthancPluginWriteFile(OrthancPluginContext *context, const char *path, const void *data, uint32_t size)
Write a file.
Definition: OrthancCPlugin.h:3868
uint32_t OrthancPluginGetCommandLineArgumentsCount(OrthancPluginContext *context)
Get the number of command-line arguments.
Definition: OrthancCPlugin.h:3589
char * OrthancPluginComputeMd5(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute an MD5 hash.
Definition: OrthancCPlugin.h:5666
OrthancPluginErrorCode
Definition: OrthancCPlugin.h:201
struct _OrthancPluginPeers_t OrthancPluginPeers
Opaque structure to the set of remote Orthanc Peers that are known to the local Orthanc server.
Definition: OrthancCPlugin.h:1194
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:4436
uint32_t(* OrthancPluginChunkedClientRequestGetChunkSize)(void *request)
Callback to read the size of the current request chunk during a chunked transfer.
Definition: OrthancCPlugin.h:7461
OrthancPluginErrorCode OrthancPluginRegisterErrorCode(OrthancPluginContext *context, int32_t code, uint16_t httpStatus, const char *message)
Declare a custom error code for this plugin.
Definition: OrthancCPlugin.h:4890
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, uint32_t size)
Create a 32-bit memory buffer.
Definition: OrthancCPlugin.h:8649
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:6876
OrthancPluginDicomWebBinaryMode
Definition: OrthancCPlugin.h:975
OrthancPluginErrorCode(* OrthancPluginJobGetContent2)(OrthancPluginMemoryBuffer *target, void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1649
OrthancPluginErrorCode(* OrthancPluginChunkedClientRequestNext)(void *request)
Callback to advance in the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7429
struct _OrthancPluginDicomWebNode_t OrthancPluginDicomWebNode
Opaque structure that represents a node in a JSON or XML document used in DICOMweb.
Definition: OrthancCPlugin.h:1211
float(* OrthancPluginJobGetProgress)(void *job)
Callback to check the progress of one custom job.
Definition: OrthancCPlugin.h:1615
char * OrthancPluginEncodeDicomWebJson(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7189
OrthancPluginFindMatcher * OrthancPluginCreateFindMatcher(OrthancPluginContext *context, const void *query, uint32_t size)
Create a C-Find matcher.
Definition: OrthancCPlugin.h:6283
OrthancPluginDicomToJsonFlags
Definition: OrthancCPlugin.h:850
OrthancPluginJobStepStatus
Definition: OrthancCPlugin.h:932
OrthancPluginCreateDicomFlags
Definition: OrthancCPlugin.h:871
void(* OrthancPluginServerChunkedRequestReaderFinalize)(OrthancPluginServerChunkedRequestReader *reader)
Callback invoked to release the resources associated with an incoming HTTP chunked transfer.
Definition: OrthancCPlugin.h:7677
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:6354
void OrthancPluginExtendOrthancExplorer(OrthancPluginContext *context, const char *javascript)
Extend the JavaScript code of Orthanc Explorer.
Definition: OrthancCPlugin.h:3485
void OrthancPluginLogWarning(OrthancPluginContext *context, const char *message)
Log a warning.
Definition: OrthancCPlugin.h:2102
const char * OrthancPluginGetPeerName(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the symbolic name of an Orthanc peer.
Definition: OrthancCPlugin.h:6536
OrthancPluginPeers * OrthancPluginGetPeers(OrthancPluginContext *context)
Return the list of available Orthanc peers.
Definition: OrthancCPlugin.h:6424
OrthancPluginConstraintType
Definition: OrthancCPlugin.h:901
char * OrthancPluginGetOrthancDirectory(OrthancPluginContext *context)
Return the directory containing the Orthanc.
Definition: OrthancCPlugin.h:3329
OrthancPluginErrorCode OrthancPluginReadFile(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *path)
Read a file.
Definition: OrthancCPlugin.h:3837
OrthancPluginJobStepStatus(* OrthancPluginJobStep)(void *job)
Callback to execute one step of a custom job.
Definition: OrthancCPlugin.h:1705
char * OrthancPluginComputeSha1(OrthancPluginContext *context, const void *buffer, uint32_t size)
Compute a SHA-1 hash.
Definition: OrthancCPlugin.h:5702
char * OrthancPluginGetCommandLineArgument(OrthancPluginContext *context, uint32_t argument)
Get the value of a command-line argument.
Definition: OrthancCPlugin.h:3623
void OrthancPluginSetMetricsValue(OrthancPluginContext *context, const char *name, float value, OrthancPluginMetricsType type)
Set the value of a floating-point metrics.
Definition: OrthancCPlugin.h:7122
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:7639
OrthancPluginReceivedInstanceAction
Definition: OrthancCPlugin.h:1036
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:7540
int32_t(* OrthancPluginJobGetSerialized2)(OrthancPluginMemoryBuffer *target, void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1689
void OrthancPluginFreeMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:2070
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:4478
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:5087
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:5457
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:5136
void OrthancPluginFreeJob(OrthancPluginContext *context, OrthancPluginJob *job)
Free a custom job.
Definition: OrthancCPlugin.h:6931
const char * OrthancPluginGetDatabaseServerIdentifier(OrthancPluginContext *context)
Gets the DatabaseServerIdentifier.
Definition: OrthancCPlugin.h:9199
char * OrthancPluginGenerateUuid(OrthancPluginContext *context)
Generate an UUID.
Definition: OrthancCPlugin.h:5959
OrthancPluginStorageCommitmentFailureReason
Definition: OrthancCPlugin.h:988
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:7392
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:6623
OrthancPluginMetricsType
Definition: OrthancCPlugin.h:958
const char * OrthancPluginAutodetectMimeType(OrthancPluginContext *context, const char *path)
Detect the MIME type of a file.
Definition: OrthancCPlugin.h:7076
OrthancPluginErrorCode OrthancPluginHttpDelete(OrthancPluginContext *context, const char *url, const char *username, const char *password)
Issue a HTTP DELETE call.
Definition: OrthancCPlugin.h:4516
uint8_t(* OrthancPluginChunkedClientRequestIsDone)(void *request)
Callback to know whether the request body is entirely read during a chunked transfer.
Definition: OrthancCPlugin.h:7412
const void *(* OrthancPluginChunkedClientRequestGetChunkData)(void *request)
Callback to read the current chunk of the request body during a chunked transfer.
Definition: OrthancCPlugin.h:7445
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:6790
void OrthancPluginFreeMemoryBuffer(OrthancPluginContext *context, OrthancPluginMemoryBuffer *buffer)
Free a memory buffer.
Definition: OrthancCPlugin.h:2054
char * OrthancPluginEncodeDicomWebXml(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback callback)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7231
const char *(* OrthancPluginJobGetSerialized)(void *job)
Callback to serialize one custom job.
Definition: OrthancCPlugin.h:1669
char * OrthancPluginGetConfiguration(OrthancPluginContext *context)
Return the content of the configuration file(s).
Definition: OrthancCPlugin.h:3688
OrthancPluginErrorCode OrthancPluginCreateMemoryBuffer64(OrthancPluginContext *context, OrthancPluginMemoryBuffer64 *target, uint64_t size)
Create a 64-bit memory buffer.
Definition: OrthancCPlugin.h:8733
OrthancPluginLoadDicomInstanceMode
Definition: OrthancCPlugin.h:1050
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:7371
uint32_t OrthancPluginGetPeersCount(OrthancPluginContext *context, const OrthancPluginPeers *peers)
Get the number of Orthanc peers.
Definition: OrthancCPlugin.h:6488
const char *(* OrthancPluginJobGetContent)(void *job)
Callback to retrieve the content of one custom job.
Definition: OrthancCPlugin.h:1631
OrthancPluginValueRepresentation
Definition: OrthancCPlugin.h:796
char * OrthancPluginSubmitJob(OrthancPluginContext *context, OrthancPluginJob *job, int32_t priority)
Submit a new job to the jobs engine of Orthanc.
Definition: OrthancCPlugin.h:6963
OrthancPluginErrorCode OrthancPluginHttpGet(OrthancPluginContext *context, OrthancPluginMemoryBuffer *target, const char *url, const char *username, const char *password)
Issue a HTTP GET call.
Definition: OrthancCPlugin.h:4398
OrthancPluginJobStopReason
Definition: OrthancCPlugin.h:946
char * OrthancPluginGetOrthancPath(OrthancPluginContext *context)
Return the path to the Orthanc executable.
Definition: OrthancCPlugin.h:3299
OrthancPluginDicomToJsonFormat
Definition: OrthancCPlugin.h:835
void OrthancPluginLogError(OrthancPluginContext *context, const char *message)
Log an error.
Definition: OrthancCPlugin.h:2086
char * OrthancPluginGetConfigurationPath(OrthancPluginContext *context)
Return the path to the configuration file(s).
Definition: OrthancCPlugin.h:3364
OrthancPluginHttpMethod
Definition: OrthancCPlugin.h:327
void OrthancPluginSetRootUri(OrthancPluginContext *context, const char *uri)
Set the URI where the plugin provides its Web interface.
Definition: OrthancCPlugin.h:3441
char * OrthancPluginEncodeDicomWebXml2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb XML.
Definition: OrthancCPlugin.h:7327
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:6704
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:1186
char * OrthancPluginEncodeDicomWebJson2(OrthancPluginContext *context, const void *dicom, uint32_t dicomSize, OrthancPluginDicomWebBinaryCallback2 callback, void *payload)
Convert a DICOM instance to DICOMweb JSON.
Definition: OrthancCPlugin.h:7283
OrthancPluginErrorCode OrthancPluginLookupDictionary(OrthancPluginContext *context, OrthancPluginDictionaryEntry *target, const char *name)
Get information about the given DICOM tag.
Definition: OrthancCPlugin.h:5748
OrthancPluginInstanceOrigin
Definition: OrthancCPlugin.h:916
void(* OrthancPluginJobFinalize)(void *job)
Callback to finalize one custom job.
Definition: OrthancCPlugin.h:1602
void OrthancPluginFreeString(OrthancPluginContext *context, char *str)
Free a string.
Definition: OrthancCPlugin.h:1898
OrthancPluginErrorCode OrthancPluginSetCurrentThreadName(OrthancPluginContext *context, const char *threadName)
Set the name of the current thread.
Definition: OrthancCPlugin.h:9374
OrthancPluginErrorCode(* OrthancPluginJobReset)(void *job)
Callback executed once one stopped custom job is started again.
Definition: OrthancCPlugin.h:1746
const char * OrthancPluginGetErrorDescription(OrthancPluginContext *context, OrthancPluginErrorCode error)
Get the description of a given error code.
Definition: OrthancCPlugin.h:3899
struct _OrthancPluginContext_t OrthancPluginContext
Data structure that contains information about the Orthanc core.
OrthancPluginContentType
Definition: OrthancCPlugin.h:705
const char * OrthancPluginGetPeerUrl(OrthancPluginContext *context, const OrthancPluginPeers *peers, uint32_t peerIndex)
Get the base URL of an Orthanc peer.
Definition: OrthancCPlugin.h:6577
void OrthancPluginSetDescription(OrthancPluginContext *context, const char *description)
Set a description for this plugin.
Definition: OrthancCPlugin.h:3463
char * OrthancPluginGetTagName(OrthancPluginContext *context, uint16_t group, uint16_t element, const char *privateCreator)
Returns the symbolic name of a DICOM tag.
Definition: OrthancCPlugin.h:7773
@ OrthancPluginIdentifierConstraint_Wildcard
Definition: OrthancCPlugin.h:890
@ OrthancPluginIdentifierConstraint_Equal
Definition: OrthancCPlugin.h:887
@ OrthancPluginIdentifierConstraint_SmallerOrEqual
Definition: OrthancCPlugin.h:888
@ OrthancPluginIdentifierConstraint_GreaterOrEqual
Definition: OrthancCPlugin.h:889
@ OrthancPluginResourceType_Instance
Definition: OrthancCPlugin.h:724
@ OrthancPluginResourceType_None
Definition: OrthancCPlugin.h:725
@ OrthancPluginResourceType_Series
Definition: OrthancCPlugin.h:723
@ OrthancPluginResourceType_Study
Definition: OrthancCPlugin.h:722
@ OrthancPluginResourceType_Patient
Definition: OrthancCPlugin.h:721
@ OrthancPluginErrorCode_CreateDicomBadParent
Definition: OrthancCPlugin.h:289
@ OrthancPluginErrorCode_MainDicomTagsMultiplyDefined
Definition: OrthancCPlugin.h:247
@ OrthancPluginErrorCode_SQLiteFlush
Definition: OrthancCPlugin.h:257
@ OrthancPluginErrorCode_IncompatibleDatabaseVersion
Definition: OrthancCPlugin.h:221
@ OrthancPluginErrorCode_BadSequenceOfCalls
Definition: OrthancCPlugin.h:209
@ OrthancPluginErrorCode_SharedLibrary
Definition: OrthancCPlugin.h:228
@ OrthancPluginErrorCode_NullPointer
Definition: OrthancCPlugin.h:238
@ OrthancPluginErrorCode_NotLuaPredicate
Definition: OrthancCPlugin.h:299
@ OrthancPluginErrorCode_LuaAlreadyExecuted
Definition: OrthancCPlugin.h:297
@ OrthancPluginErrorCode_NotAcceptable
Definition: OrthancCPlugin.h:237
@ OrthancPluginErrorCode_FullStorage
Definition: OrthancCPlugin.h:222
@ OrthancPluginErrorCode_DatabaseBackendAlreadyRegistered
Definition: OrthancCPlugin.h:302
@ OrthancPluginErrorCode_InexistentFile
Definition: OrthancCPlugin.h:216
@ OrthancPluginErrorCode_CreateDicomParentEncoding
Definition: OrthancCPlugin.h:291
@ OrthancPluginErrorCode_CannotOrderSlices
Definition: OrthancCPlugin.h:305
@ OrthancPluginErrorCode_InternalError
Definition: OrthancCPlugin.h:202
@ OrthancPluginErrorCode_DiscontinuedAbi
Definition: OrthancCPlugin.h:243
@ OrthancPluginErrorCode_NoCFindHandler
Definition: OrthancCPlugin.h:275
@ OrthancPluginErrorCode_SQLiteCommitWithoutTransaction
Definition: OrthancCPlugin.h:255
@ OrthancPluginErrorCode_DatabasePlugin
Definition: OrthancCPlugin.h:234
@ OrthancPluginErrorCode_SQLiteStatementAlreadyUsed
Definition: OrthancCPlugin.h:252
@ OrthancPluginErrorCode_SQLiteCannotRun
Definition: OrthancCPlugin.h:258
@ OrthancPluginErrorCode_UnknownPluginService
Definition: OrthancCPlugin.h:229
@ OrthancPluginErrorCode_JsonToLuaTable
Definition: OrthancCPlugin.h:294
@ OrthancPluginErrorCode_CreateDicomOverrideTag
Definition: OrthancCPlugin.h:285
@ OrthancPluginErrorCode_SQLiteBindOutOfRange
Definition: OrthancCPlugin.h:260
@ OrthancPluginErrorCode_ParameterOutOfRange
Definition: OrthancCPlugin.h:206
@ OrthancPluginErrorCode_SQLiteRegisterFunction
Definition: OrthancCPlugin.h:256
@ OrthancPluginErrorCode_SQLiteTransactionBegin
Definition: OrthancCPlugin.h:264
@ OrthancPluginErrorCode_CreateDicomNoPayload
Definition: OrthancCPlugin.h:287
@ OrthancPluginErrorCode_Unauthorized
Definition: OrthancCPlugin.h:232
@ OrthancPluginErrorCode_RegularFileExpected
Definition: OrthancCPlugin.h:271
@ OrthancPluginErrorCode_DicomPortInUse
Definition: OrthancCPlugin.h:269
@ OrthancPluginErrorCode_BadApplicationEntityTitle
Definition: OrthancCPlugin.h:274
@ OrthancPluginErrorCode_NoCStoreHandler
Definition: OrthancCPlugin.h:277
@ OrthancPluginErrorCode_PathToExecutable
Definition: OrthancCPlugin.h:272
@ OrthancPluginErrorCode_NoSopClassOrInstance
Definition: OrthancCPlugin.h:279
@ OrthancPluginErrorCode_BadFont
Definition: OrthancCPlugin.h:233
@ OrthancPluginErrorCode_DatabaseUnavailable
Definition: OrthancCPlugin.h:239
@ OrthancPluginErrorCode_CannotCreateLua
Definition: OrthancCPlugin.h:295
@ OrthancPluginErrorCode_SQLiteExecute
Definition: OrthancCPlugin.h:253
@ OrthancPluginErrorCode_UriSyntax
Definition: OrthancCPlugin.h:215
@ OrthancPluginErrorCode_DirectoryOverFile
Definition: OrthancCPlugin.h:265
@ OrthancPluginErrorCode_Revision
Definition: OrthancCPlugin.h:246
@ OrthancPluginErrorCode_InexistentTag
Definition: OrthancCPlugin.h:224
@ OrthancPluginErrorCode_IncompatibleImageFormat
Definition: OrthancCPlugin.h:226
@ OrthancPluginErrorCode_UnsupportedMediaType
Definition: OrthancCPlugin.h:310
@ OrthancPluginErrorCode_DicomFindUnavailable
Definition: OrthancCPlugin.h:281
@ OrthancPluginErrorCode_SQLiteCannotStep
Definition: OrthancCPlugin.h:259
@ OrthancPluginErrorCode_CreateDicomParentIsInstance
Definition: OrthancCPlugin.h:290
@ OrthancPluginErrorCode_StorageAreaAlreadyRegistered
Definition: OrthancCPlugin.h:301
@ OrthancPluginErrorCode_LuaReturnsNoString
Definition: OrthancCPlugin.h:300
@ OrthancPluginErrorCode_UnknownResource
Definition: OrthancCPlugin.h:220
@ OrthancPluginErrorCode_CreateDicomNotString
Definition: OrthancCPlugin.h:284
@ OrthancPluginErrorCode_HttpPortInUse
Definition: OrthancCPlugin.h:268
@ OrthancPluginErrorCode_SslDisabled
Definition: OrthancCPlugin.h:304
@ OrthancPluginErrorCode_UnknownModality
Definition: OrthancCPlugin.h:292
@ OrthancPluginErrorCode_BadHttpStatusInRest
Definition: OrthancCPlugin.h:270
@ OrthancPluginErrorCode_BadGeometry
Definition: OrthancCPlugin.h:241
@ OrthancPluginErrorCode_AlreadyExistingTag
Definition: OrthancCPlugin.h:307
@ OrthancPluginErrorCode_FileStorageCannotWrite
Definition: OrthancCPlugin.h:266
@ OrthancPluginErrorCode_CreateDicomUseDataUriScheme
Definition: OrthancCPlugin.h:288
@ OrthancPluginErrorCode_DirectoryExpected
Definition: OrthancCPlugin.h:267
@ OrthancPluginErrorCode_NoCMoveHandler
Definition: OrthancCPlugin.h:276
@ OrthancPluginErrorCode_SQLitePrepareStatement
Definition: OrthancCPlugin.h:261
@ OrthancPluginErrorCode_CorruptedFile
Definition: OrthancCPlugin.h:223
@ OrthancPluginErrorCode_StorageAreaPlugin
Definition: OrthancCPlugin.h:235
@ OrthancPluginErrorCode_BadJobOrdering
Definition: OrthancCPlugin.h:293
@ OrthancPluginErrorCode_DatabaseCannotSerialize
Definition: OrthancCPlugin.h:245
@ OrthancPluginErrorCode_CanceledJob
Definition: OrthancCPlugin.h:240
@ OrthancPluginErrorCode_BadRange
Definition: OrthancCPlugin.h:244
@ OrthancPluginErrorCode_NotImplemented
Definition: OrthancCPlugin.h:205
@ OrthancPluginErrorCode_SslInitialization
Definition: OrthancCPlugin.h:242
@ OrthancPluginErrorCode_IncompatibleImageSize
Definition: OrthancCPlugin.h:227
@ OrthancPluginErrorCode_BadFileFormat
Definition: OrthancCPlugin.h:218
@ OrthancPluginErrorCode_BadRequest
Definition: OrthancCPlugin.h:211
@ OrthancPluginErrorCode_SystemCommand
Definition: OrthancCPlugin.h:213
@ OrthancPluginErrorCode_NoStorageCommitmentHandler
Definition: OrthancCPlugin.h:308
@ OrthancPluginErrorCode_SQLiteAlreadyOpened
Definition: OrthancCPlugin.h:250
@ OrthancPluginErrorCode_Plugin
Definition: OrthancCPlugin.h:204
@ OrthancPluginErrorCode_CannotExecuteLua
Definition: OrthancCPlugin.h:296
@ OrthancPluginErrorCode_SQLiteRollbackWithoutTransaction
Definition: OrthancCPlugin.h:254
@ OrthancPluginErrorCode_UnknownDicomTag
Definition: OrthancCPlugin.h:230
@ OrthancPluginErrorCode_ForbiddenAccess
Definition: OrthancCPlugin.h:248
@ OrthancPluginErrorCode_NoPresentationContext
Definition: OrthancCPlugin.h:280
@ OrthancPluginErrorCode_EmptyRequest
Definition: OrthancCPlugin.h:236
@ OrthancPluginErrorCode_DatabaseNotInitialized
Definition: OrthancCPlugin.h:303
@ OrthancPluginErrorCode_DicomMoveUnavailable
Definition: OrthancCPlugin.h:282
@ OrthancPluginErrorCode_SQLiteTransactionCommit
Definition: OrthancCPlugin.h:263
@ OrthancPluginErrorCode_BadJson
Definition: OrthancCPlugin.h:231
@ OrthancPluginErrorCode_Success
Definition: OrthancCPlugin.h:203
@ OrthancPluginErrorCode_NetworkProtocol
Definition: OrthancCPlugin.h:212
@ OrthancPluginErrorCode_NoApplicationEntityFilter
Definition: OrthancCPlugin.h:278
@ OrthancPluginErrorCode_InexistentItem
Definition: OrthancCPlugin.h:210
@ OrthancPluginErrorCode_Timeout
Definition: OrthancCPlugin.h:219
@ OrthancPluginErrorCode_LuaBadOutput
Definition: OrthancCPlugin.h:298
@ OrthancPluginErrorCode_SQLiteTransactionAlreadyStarted
Definition: OrthancCPlugin.h:262
@ OrthancPluginErrorCode_NoCGetHandler
Definition: OrthancCPlugin.h:309
@ OrthancPluginErrorCode_SQLiteNotOpened
Definition: OrthancCPlugin.h:249
@ OrthancPluginErrorCode_ReadOnly
Definition: OrthancCPlugin.h:225
@ OrthancPluginErrorCode_CannotStoreInstance
Definition: OrthancCPlugin.h:283
@ OrthancPluginErrorCode_CannotWriteFile
Definition: OrthancCPlugin.h:217
@ OrthancPluginErrorCode_BadParameterType
Definition: OrthancCPlugin.h:208
@ OrthancPluginErrorCode_NotEnoughMemory
Definition: OrthancCPlugin.h:207
@ OrthancPluginErrorCode_CreateDicomUseContent
Definition: OrthancCPlugin.h:286
@ OrthancPluginErrorCode_Database
Definition: OrthancCPlugin.h:214
@ OrthancPluginErrorCode_SQLiteCannotOpen
Definition: OrthancCPlugin.h:251
@ OrthancPluginErrorCode_MakeDirectory
Definition: OrthancCPlugin.h:273
@ OrthancPluginErrorCode_NoWorklistHandler
Definition: OrthancCPlugin.h:306
@ OrthancPluginDicomWebBinaryMode_InlineBinary
Definition: OrthancCPlugin.h:977
@ OrthancPluginDicomWebBinaryMode_BulkDataUri
Definition: OrthancCPlugin.h:978
@ OrthancPluginDicomWebBinaryMode_Ignore
Definition: OrthancCPlugin.h:976
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii
Definition: OrthancCPlugin.h:856
@ OrthancPluginDicomToJsonFlags_IncludeBinary
Definition: OrthancCPlugin.h:852
@ OrthancPluginDicomToJsonFlags_IncludePixelData
Definition: OrthancCPlugin.h:855
@ OrthancPluginDicomToJsonFlags_IncludeUnknownTags
Definition: OrthancCPlugin.h:854
@ OrthancPluginDicomToJsonFlags_SkipGroupLengths
Definition: OrthancCPlugin.h:859
@ OrthancPluginDicomToJsonFlags_None
Definition: OrthancCPlugin.h:851
@ OrthancPluginDicomToJsonFlags_ConvertBinaryToNull
Definition: OrthancCPlugin.h:857
@ OrthancPluginDicomToJsonFlags_StopAfterPixelData
Definition: OrthancCPlugin.h:858
@ OrthancPluginDicomToJsonFlags_IncludePrivateTags
Definition: OrthancCPlugin.h:853
@ OrthancPluginJobStepStatus_Continue
Definition: OrthancCPlugin.h:935
@ OrthancPluginJobStepStatus_Success
Definition: OrthancCPlugin.h:933
@ OrthancPluginJobStepStatus_Failure
Definition: OrthancCPlugin.h:934
@ OrthancPluginCreateDicomFlags_DecodeDataUriScheme
Definition: OrthancCPlugin.h:873
@ OrthancPluginCreateDicomFlags_None
Definition: OrthancCPlugin.h:872
@ OrthancPluginCreateDicomFlags_GenerateIdentifiers
Definition: OrthancCPlugin.h:874
@ OrthancPluginConstraintType_SmallerOrEqual
Definition: OrthancCPlugin.h:903
@ OrthancPluginConstraintType_List
Definition: OrthancCPlugin.h:906
@ OrthancPluginConstraintType_GreaterOrEqual
Definition: OrthancCPlugin.h:904
@ OrthancPluginConstraintType_Equal
Definition: OrthancCPlugin.h:902
@ OrthancPluginConstraintType_Wildcard
Definition: OrthancCPlugin.h:905
@ OrthancPluginReceivedInstanceAction_KeepAsIs
Definition: OrthancCPlugin.h:1037
@ OrthancPluginReceivedInstanceAction_Discard
Definition: OrthancCPlugin.h:1039
@ OrthancPluginReceivedInstanceAction_Modify
Definition: OrthancCPlugin.h:1038
@ OrthancPluginStorageCommitmentFailureReason_ReferencedSOPClassNotSupported
Definition: OrthancCPlugin.h:1015
@ OrthancPluginStorageCommitmentFailureReason_Success
Definition: OrthancCPlugin.h:992
@ OrthancPluginStorageCommitmentFailureReason_DuplicateTransactionUID
Definition: OrthancCPlugin.h:1028
@ OrthancPluginStorageCommitmentFailureReason_ClassInstanceConflict
Definition: OrthancCPlugin.h:1022
@ OrthancPluginStorageCommitmentFailureReason_ResourceLimitation
Definition: OrthancCPlugin.h:1009
@ OrthancPluginStorageCommitmentFailureReason_NoSuchObjectInstance
Definition: OrthancCPlugin.h:1003
@ OrthancPluginStorageCommitmentFailureReason_ProcessingFailure
Definition: OrthancCPlugin.h:997
@ OrthancPluginMetricsType_Default
Definition: OrthancCPlugin.h:959
@ OrthancPluginMetricsType_Timer
Definition: OrthancCPlugin.h:966
@ OrthancPluginLoadDicomInstanceMode_UntilPixelData
Definition: OrthancCPlugin.h:1060
@ OrthancPluginLoadDicomInstanceMode_WholeDicom
Definition: OrthancCPlugin.h:1054
@ OrthancPluginLoadDicomInstanceMode_EmptyPixelData
Definition: OrthancCPlugin.h:1067
@ OrthancPluginValueRepresentation_PN
Definition: OrthancCPlugin.h:812
@ OrthancPluginValueRepresentation_UL
Definition: OrthancCPlugin.h:820
@ OrthancPluginValueRepresentation_UN
Definition: OrthancCPlugin.h:821
@ OrthancPluginValueRepresentation_DA
Definition: OrthancCPlugin.h:801
@ OrthancPluginValueRepresentation_OF
Definition: OrthancCPlugin.h:810
@ OrthancPluginValueRepresentation_OW
Definition: OrthancCPlugin.h:811
@ OrthancPluginValueRepresentation_CS
Definition: OrthancCPlugin.h:800
@ OrthancPluginValueRepresentation_US
Definition: OrthancCPlugin.h:822
@ OrthancPluginValueRepresentation_SH
Definition: OrthancCPlugin.h:813
@ OrthancPluginValueRepresentation_FL
Definition: OrthancCPlugin.h:805
@ OrthancPluginValueRepresentation_DT
Definition: OrthancCPlugin.h:803
@ OrthancPluginValueRepresentation_TM
Definition: OrthancCPlugin.h:818
@ OrthancPluginValueRepresentation_SQ
Definition: OrthancCPlugin.h:815
@ OrthancPluginValueRepresentation_DS
Definition: OrthancCPlugin.h:802
@ OrthancPluginValueRepresentation_OB
Definition: OrthancCPlugin.h:809
@ OrthancPluginValueRepresentation_SL
Definition: OrthancCPlugin.h:814
@ OrthancPluginValueRepresentation_ST
Definition: OrthancCPlugin.h:817
@ OrthancPluginValueRepresentation_IS
Definition: OrthancCPlugin.h:806
@ OrthancPluginValueRepresentation_LT
Definition: OrthancCPlugin.h:808
@ OrthancPluginValueRepresentation_SS
Definition: OrthancCPlugin.h:816
@ OrthancPluginValueRepresentation_UT
Definition: OrthancCPlugin.h:823
@ OrthancPluginValueRepresentation_LO
Definition: OrthancCPlugin.h:807
@ OrthancPluginValueRepresentation_AE
Definition: OrthancCPlugin.h:797
@ OrthancPluginValueRepresentation_FD
Definition: OrthancCPlugin.h:804
@ OrthancPluginValueRepresentation_UI
Definition: OrthancCPlugin.h:819
@ OrthancPluginValueRepresentation_AS
Definition: OrthancCPlugin.h:798
@ OrthancPluginValueRepresentation_AT
Definition: OrthancCPlugin.h:799
@ OrthancPluginJobStopReason_Failure
Definition: OrthancCPlugin.h:949
@ OrthancPluginJobStopReason_Success
Definition: OrthancCPlugin.h:947
@ OrthancPluginJobStopReason_Canceled
Definition: OrthancCPlugin.h:950
@ OrthancPluginJobStopReason_Paused
Definition: OrthancCPlugin.h:948
@ OrthancPluginDicomToJsonFormat_Full
Definition: OrthancCPlugin.h:836
@ OrthancPluginDicomToJsonFormat_Human
Definition: OrthancCPlugin.h:838
@ OrthancPluginDicomToJsonFormat_Short
Definition: OrthancCPlugin.h:837
@ OrthancPluginHttpMethod_Delete
Definition: OrthancCPlugin.h:331
@ OrthancPluginHttpMethod_Post
Definition: OrthancCPlugin.h:329
@ OrthancPluginHttpMethod_Put
Definition: OrthancCPlugin.h:330
@ OrthancPluginHttpMethod_Get
Definition: OrthancCPlugin.h:328
@ OrthancPluginInstanceOrigin_Unknown
Definition: OrthancCPlugin.h:917
@ OrthancPluginInstanceOrigin_RestApi
Definition: OrthancCPlugin.h:919
@ OrthancPluginInstanceOrigin_Lua
Definition: OrthancCPlugin.h:921
@ OrthancPluginInstanceOrigin_WebDav
Definition: OrthancCPlugin.h:922
@ OrthancPluginInstanceOrigin_DicomProtocol
Definition: OrthancCPlugin.h:918
@ OrthancPluginInstanceOrigin_Plugin
Definition: OrthancCPlugin.h:920
@ OrthancPluginContentType_Dicom
Definition: OrthancCPlugin.h:707
@ OrthancPluginContentType_DicomAsJson
Definition: OrthancCPlugin.h:708
@ OrthancPluginContentType_Unknown
Definition: OrthancCPlugin.h:706
@ OrthancPluginContentType_DicomUntilPixelData
Definition: OrthancCPlugin.h:709
An entry in the dictionary of DICOM tags.
Definition: OrthancCPlugin.h:1880
uint32_t minMultiplicity
Definition: OrthancCPlugin.h:1884
uint32_t maxMultiplicity
Definition: OrthancCPlugin.h:1885
OrthancPluginValueRepresentation vr
Definition: OrthancCPlugin.h:1883
uint16_t element
Definition: OrthancCPlugin.h:1882
uint16_t group
Definition: OrthancCPlugin.h:1881
The parameters of a REST request.
Definition: OrthancCPlugin.h:342
const char *const * getValues
For a GET request, the values of the GET parameters.
Definition: OrthancCPlugin.h:371
const char *const * groups
The matched values for the groups of the regular expression.
Definition: OrthancCPlugin.h:356
uint32_t bodySize
For a PUT or POST request, the number of bytes of the body.
Definition: OrthancCPlugin.h:381
uint32_t groupsCount
The number of groups of the regular expression.
Definition: OrthancCPlugin.h:351
const char *const * headersKeys
The keys of the HTTP headers (always converted to low-case).
Definition: OrthancCPlugin.h:396
const void * body
For a PUT or POST request, the content of the body.
Definition: OrthancCPlugin.h:376
const char *const * getKeys
For a GET request, the keys of the GET parameters.
Definition: OrthancCPlugin.h:366
uint32_t headersCount
The number of HTTP headers.
Definition: OrthancCPlugin.h:391
OrthancPluginHttpMethod method
The HTTP method.
Definition: OrthancCPlugin.h:346
uint32_t getCount
For a GET request, the number of GET parameters.
Definition: OrthancCPlugin.h:361
const char *const * headersValues
The values of the HTTP headers.
Definition: OrthancCPlugin.h:401
A 64-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1103
uint64_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1112
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1107
A 32-bit memory buffer allocated by the core system of Orthanc.
Definition: OrthancCPlugin.h:1081
uint32_t size
The number of bytes in the buffer.
Definition: OrthancCPlugin.h:1090
void * data
The content of the buffer.
Definition: OrthancCPlugin.h:1085