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
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
698
699
700
713
714
715
729
730
731
760
761
775
776
781 typedef enum
782 {
787 _OrthancPluginImageFormat_INTERNAL = 0x7fffffff
789
790
827
828
834 typedef enum
835 {
840 _OrthancPluginDicomToJsonFormat_INTERNAL = 0x7fffffff
842
843
863
864
878
879
894
895
910
911
926
927
937
938
952
953
968
969
980
981
1030
1031
1043
1044
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
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