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