Mercurial > hg > orthanc-java
annotate JavaSDK/be/uclouvain/orthanc/Functions.java @ 41:d0b0bb6dfb4a
typo
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Wed, 03 Jul 2024 18:00:06 +0200 |
parents | 15dc698243ac |
children |
rev | line source |
---|---|
0 | 1 package be.uclouvain.orthanc; |
2 | |
3 /** | |
18 | 4 * SPDX-FileCopyrightText: 2023-2024 Sebastien Jodogne, UCLouvain, Belgium |
0 | 5 * SPDX-License-Identifier: GPL-3.0-or-later |
6 */ | |
7 | |
8 /** | |
9 * Java plugin for Orthanc | |
18 | 10 * Copyright (C) 2023-2024 Sebastien Jodogne, UCLouvain, Belgium |
0 | 11 * |
12 * This program is free software: you can redistribute it and/or | |
13 * modify it under the terms of the GNU General Public License as | |
14 * published by the Free Software Foundation, either version 3 of the | |
15 * License, or (at your option) any later version. | |
16 * | |
17 * This program is distributed in the hope that it will be useful, but | |
18 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
20 * General Public License for more details. | |
21 * | |
22 * You should have received a copy of the GNU General Public License | |
23 * along with this program. If not, see http://www.gnu.org/licenses/. | |
24 **/ | |
25 | |
26 | |
8
26c08ff926a3
added warning about auto-generated files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
27 // WARNING: Auto-generated file. Do not modify it by hand. |
26c08ff926a3
added warning about auto-generated files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
28 |
0 | 29 /** |
30 * Wrapper around the global functions provided by the Orthanc SDK. | |
31 **/ | |
32 public class Functions { | |
33 | |
34 /** | |
35 * Check that the version of the hosting Orthanc is above a given version. | |
36 * | |
37 * This function checks whether the version of the Orthanc server running this | |
38 * plugin, is above the given version. Contrarily to OrthancPluginCheckVersion(), | |
39 * it is up to the developer of the plugin to make sure that all the Orthanc SDK | |
40 * services called by the plugin are actually implemented in the given version of | |
41 * Orthanc. | |
42 * | |
43 * @param expectedMajor Expected major version. | |
44 * @param expectedMinor Expected minor version. | |
45 * @param expectedRevision Expected revision. | |
46 * @return 1 if and only if the versions are compatible. If the result is 0, the | |
47 * initialization of the plugin should fail. | |
48 **/ | |
49 public static int checkVersionAdvanced( | |
50 int expectedMajor, | |
51 int expectedMinor, | |
52 int expectedRevision) { | |
53 return NativeSDK.OrthancPluginCheckVersionAdvanced(expectedMajor, expectedMinor, expectedRevision); | |
54 } | |
55 | |
56 /** | |
57 * Check the compatibility of the plugin wrt. the version of its hosting Orthanc. | |
58 * | |
59 * This function checks whether the version of the Orthanc server running this | |
60 * plugin, is above the version of the current Orthanc SDK header. This guarantees | |
61 * that the plugin is compatible with the hosting Orthanc (i.e. it will not call | |
62 * unavailable services). The result of this function should always be checked in | |
63 * the OrthancPluginInitialize() entry point of the plugin. | |
64 * | |
65 * @return 1 if and only if the versions are compatible. If the result is 0, the | |
66 * initialization of the plugin should fail. | |
67 **/ | |
68 public static int checkVersion() { | |
69 return NativeSDK.OrthancPluginCheckVersion(); | |
70 } | |
71 | |
72 /** | |
73 * Log an error. | |
74 * | |
75 * Log an error message using the Orthanc logging system. | |
76 * | |
77 * @param message The message to be logged. | |
78 **/ | |
79 public static void logError( | |
80 String message) { | |
81 NativeSDK.OrthancPluginLogError(message); | |
82 } | |
83 | |
84 /** | |
85 * Log a warning. | |
86 * | |
87 * Log a warning message using the Orthanc logging system. | |
88 * | |
89 * @param message The message to be logged. | |
90 **/ | |
91 public static void logWarning( | |
92 String message) { | |
93 NativeSDK.OrthancPluginLogWarning(message); | |
94 } | |
95 | |
96 /** | |
97 * Log an information. | |
98 * | |
99 * Log an information message using the Orthanc logging system. | |
100 * | |
101 * @param message The message to be logged. | |
102 **/ | |
103 public static void logInfo( | |
104 String message) { | |
105 NativeSDK.OrthancPluginLogInfo(message); | |
106 } | |
107 | |
108 /** | |
109 * Retrieve a DICOM instance using its Orthanc identifier. | |
110 * | |
111 * Retrieve a DICOM instance using its Orthanc identifier. The DICOM file is stored | |
112 * into a newly allocated memory buffer. | |
113 * | |
114 * @param instanceId The Orthanc identifier of the DICOM instance of interest. | |
115 * @return The resulting memory buffer. | |
116 **/ | |
117 public static byte[] getDicomForInstance( | |
118 String instanceId) { | |
119 return NativeSDK.OrthancPluginGetDicomForInstance(instanceId); | |
120 } | |
121 | |
122 /** | |
123 * Make a GET call to the built-in Orthanc REST API. | |
124 * | |
125 * Make a GET call to the built-in Orthanc REST API. The result to the query is | |
126 * stored into a newly allocated memory buffer. | |
127 * | |
128 * Remark: If the resource is not existing (error 404), the error code will be | |
129 * OrthancPluginErrorCode_UnknownResource. | |
130 * | |
131 * @param uri The URI in the built-in Orthanc API. | |
132 * @return The resulting memory buffer. | |
133 **/ | |
134 public static byte[] restApiGet( | |
135 String uri) { | |
136 return NativeSDK.OrthancPluginRestApiGet(uri); | |
137 } | |
138 | |
139 /** | |
140 * Make a GET call to the REST API, as tainted by the plugins. | |
141 * | |
142 * Make a GET call to the Orthanc REST API, after all the plugins are applied. In | |
143 * other words, if some plugin overrides or adds the called URI to the built-in | |
144 * Orthanc REST API, this call will return the result provided by this plugin. The | |
145 * result to the query is stored into a newly allocated memory buffer. | |
146 * | |
147 * Remark: If the resource is not existing (error 404), the error code will be | |
148 * OrthancPluginErrorCode_UnknownResource. | |
149 * | |
150 * @param uri The URI in the built-in Orthanc API. | |
151 * @return The resulting memory buffer. | |
152 **/ | |
153 public static byte[] restApiGetAfterPlugins( | |
154 String uri) { | |
155 return NativeSDK.OrthancPluginRestApiGetAfterPlugins(uri); | |
156 } | |
157 | |
158 /** | |
159 * Make a POST call to the built-in Orthanc REST API. | |
160 * | |
161 * Make a POST call to the built-in Orthanc REST API. The result to the query is | |
162 * stored into a newly allocated memory buffer. | |
163 * | |
164 * Remark: If the resource is not existing (error 404), the error code will be | |
165 * OrthancPluginErrorCode_UnknownResource. | |
166 * | |
167 * @param uri The URI in the built-in Orthanc API. | |
168 * @param body The body of the POST request. | |
169 * @return The resulting memory buffer. | |
170 **/ | |
171 public static byte[] restApiPost( | |
172 String uri, | |
173 byte[] body) { | |
174 return NativeSDK.OrthancPluginRestApiPost(uri, body); | |
175 } | |
176 | |
177 /** | |
178 * Make a POST call to the REST API, as tainted by the plugins. | |
179 * | |
180 * Make a POST call to the Orthanc REST API, after all the plugins are applied. In | |
181 * other words, if some plugin overrides or adds the called URI to the built-in | |
182 * Orthanc REST API, this call will return the result provided by this plugin. The | |
183 * result to the query is stored into a newly allocated memory buffer. | |
184 * | |
185 * Remark: If the resource is not existing (error 404), the error code will be | |
186 * OrthancPluginErrorCode_UnknownResource. | |
187 * | |
188 * @param uri The URI in the built-in Orthanc API. | |
189 * @param body The body of the POST request. | |
190 * @return The resulting memory buffer. | |
191 **/ | |
192 public static byte[] restApiPostAfterPlugins( | |
193 String uri, | |
194 byte[] body) { | |
195 return NativeSDK.OrthancPluginRestApiPostAfterPlugins(uri, body); | |
196 } | |
197 | |
198 /** | |
199 * Make a DELETE call to the built-in Orthanc REST API. | |
200 * | |
201 * Make a DELETE call to the built-in Orthanc REST API. | |
202 * | |
203 * Remark: If the resource is not existing (error 404), the error code will be | |
204 * OrthancPluginErrorCode_UnknownResource. | |
205 * | |
206 * @param uri The URI to delete in the built-in Orthanc API. | |
207 **/ | |
208 public static void restApiDelete( | |
209 String uri) { | |
210 NativeSDK.OrthancPluginRestApiDelete(uri); | |
211 } | |
212 | |
213 /** | |
214 * Make a DELETE call to the REST API, as tainted by the plugins. | |
215 * | |
216 * Make a DELETE call to the Orthanc REST API, after all the plugins are applied. | |
217 * In other words, if some plugin overrides or adds the called URI to the built-in | |
218 * Orthanc REST API, this call will return the result provided by this plugin. | |
219 * | |
220 * Remark: If the resource is not existing (error 404), the error code will be | |
221 * OrthancPluginErrorCode_UnknownResource. | |
222 * | |
223 * @param uri The URI to delete in the built-in Orthanc API. | |
224 **/ | |
225 public static void restApiDeleteAfterPlugins( | |
226 String uri) { | |
227 NativeSDK.OrthancPluginRestApiDeleteAfterPlugins(uri); | |
228 } | |
229 | |
230 /** | |
231 * Make a PUT call to the built-in Orthanc REST API. | |
232 * | |
233 * Make a PUT call to the built-in Orthanc REST API. The result to the query is | |
234 * stored into a newly allocated memory buffer. | |
235 * | |
236 * Remark: If the resource is not existing (error 404), the error code will be | |
237 * OrthancPluginErrorCode_UnknownResource. | |
238 * | |
239 * @param uri The URI in the built-in Orthanc API. | |
240 * @param body The body of the PUT request. | |
241 * @return The resulting memory buffer. | |
242 **/ | |
243 public static byte[] restApiPut( | |
244 String uri, | |
245 byte[] body) { | |
246 return NativeSDK.OrthancPluginRestApiPut(uri, body); | |
247 } | |
248 | |
249 /** | |
250 * Make a PUT call to the REST API, as tainted by the plugins. | |
251 * | |
252 * Make a PUT call to the Orthanc REST API, after all the plugins are applied. In | |
253 * other words, if some plugin overrides or adds the called URI to the built-in | |
254 * Orthanc REST API, this call will return the result provided by this plugin. The | |
255 * result to the query is stored into a newly allocated memory buffer. | |
256 * | |
257 * Remark: If the resource is not existing (error 404), the error code will be | |
258 * OrthancPluginErrorCode_UnknownResource. | |
259 * | |
260 * @param uri The URI in the built-in Orthanc API. | |
261 * @param body The body of the PUT request. | |
262 * @return The resulting memory buffer. | |
263 **/ | |
264 public static byte[] restApiPutAfterPlugins( | |
265 String uri, | |
266 byte[] body) { | |
267 return NativeSDK.OrthancPluginRestApiPutAfterPlugins(uri, body); | |
268 } | |
269 | |
270 /** | |
271 * Look for a patient. | |
272 * | |
273 * Look for a patient stored in Orthanc, using its Patient ID tag (0x0010, 0x0020). | |
274 * This function uses the database index to run as fast as possible (it does not | |
275 * loop over all the stored patients). | |
276 * | |
277 * @param patientID The Patient ID of interest. | |
278 * @return The resulting string. | |
279 **/ | |
280 public static String lookupPatient( | |
281 String patientID) { | |
282 return NativeSDK.OrthancPluginLookupPatient(patientID); | |
283 } | |
284 | |
285 /** | |
286 * Look for a study. | |
287 * | |
288 * Look for a study stored in Orthanc, using its Study Instance UID tag (0x0020, | |
289 * 0x000d). This function uses the database index to run as fast as possible (it | |
290 * does not loop over all the stored studies). | |
291 * | |
292 * @param studyUID The Study Instance UID of interest. | |
293 * @return The resulting string. | |
294 **/ | |
295 public static String lookupStudy( | |
296 String studyUID) { | |
297 return NativeSDK.OrthancPluginLookupStudy(studyUID); | |
298 } | |
299 | |
300 /** | |
301 * Look for a study, using the accession number. | |
302 * | |
303 * Look for a study stored in Orthanc, using its Accession Number tag (0x0008, | |
304 * 0x0050). This function uses the database index to run as fast as possible (it | |
305 * does not loop over all the stored studies). | |
306 * | |
307 * @param accessionNumber The Accession Number of interest. | |
308 * @return The resulting string. | |
309 **/ | |
310 public static String lookupStudyWithAccessionNumber( | |
311 String accessionNumber) { | |
312 return NativeSDK.OrthancPluginLookupStudyWithAccessionNumber(accessionNumber); | |
313 } | |
314 | |
315 /** | |
316 * Look for a series. | |
317 * | |
318 * Look for a series stored in Orthanc, using its Series Instance UID tag (0x0020, | |
319 * 0x000e). This function uses the database index to run as fast as possible (it | |
320 * does not loop over all the stored series). | |
321 * | |
322 * @param seriesUID The Series Instance UID of interest. | |
323 * @return The resulting string. | |
324 **/ | |
325 public static String lookupSeries( | |
326 String seriesUID) { | |
327 return NativeSDK.OrthancPluginLookupSeries(seriesUID); | |
328 } | |
329 | |
330 /** | |
331 * Look for an instance. | |
332 * | |
333 * Look for an instance stored in Orthanc, using its SOP Instance UID tag (0x0008, | |
334 * 0x0018). This function uses the database index to run as fast as possible (it | |
335 * does not loop over all the stored instances). | |
336 * | |
337 * @param sopInstanceUID The SOP Instance UID of interest. | |
338 * @return The resulting string. | |
339 **/ | |
340 public static String lookupInstance( | |
341 String sopInstanceUID) { | |
342 return NativeSDK.OrthancPluginLookupInstance(sopInstanceUID); | |
343 } | |
344 | |
345 /** | |
346 * Return the path to the Orthanc executable. | |
347 * | |
348 * This function returns the path to the Orthanc executable. | |
349 * | |
350 * @return The resulting string. | |
351 **/ | |
352 public static String getOrthancPath() { | |
353 return NativeSDK.OrthancPluginGetOrthancPath(); | |
354 } | |
355 | |
356 /** | |
357 * Return the directory containing the Orthanc. | |
358 * | |
359 * This function returns the path to the directory containing the Orthanc | |
360 * executable. | |
361 * | |
362 * @return The resulting string. | |
363 **/ | |
364 public static String getOrthancDirectory() { | |
365 return NativeSDK.OrthancPluginGetOrthancDirectory(); | |
366 } | |
367 | |
368 /** | |
369 * Return the path to the configuration file(s). | |
370 * | |
371 * This function returns the path to the configuration file(s) that was specified | |
372 * when starting Orthanc. Since version 0.9.1, this path can refer to a folder that | |
373 * stores a set of configuration files. This function is deprecated in favor of | |
374 * OrthancPluginGetConfiguration(). | |
375 * | |
376 * @return The resulting string. | |
377 **/ | |
378 public static String getConfigurationPath() { | |
379 return NativeSDK.OrthancPluginGetConfigurationPath(); | |
380 } | |
381 | |
382 /** | |
383 * Set the URI where the plugin provides its Web interface. | |
384 * | |
385 * For plugins that come with a Web interface, this function declares the entry | |
386 * path where to find this interface. This information is notably used in the | |
387 * "Plugins" page of Orthanc Explorer. | |
388 * | |
389 * @param uri The root URI for this plugin. | |
390 **/ | |
391 public static void setRootUri( | |
392 String uri) { | |
393 NativeSDK.OrthancPluginSetRootUri(uri); | |
394 } | |
395 | |
396 /** | |
397 * Set a description for this plugin. | |
398 * | |
399 * Set a description for this plugin. It is displayed in the "Plugins" page of | |
400 * Orthanc Explorer. | |
401 * | |
402 * @param description The description. | |
403 **/ | |
404 public static void setDescription( | |
405 String description) { | |
406 NativeSDK.OrthancPluginSetDescription(description); | |
407 } | |
408 | |
409 /** | |
410 * Extend the JavaScript code of Orthanc Explorer. | |
411 * | |
412 * Add JavaScript code to customize the default behavior of Orthanc Explorer. This | |
413 * can for instance be used to add new buttons. | |
414 * | |
415 * @param javascript The custom JavaScript code. | |
416 **/ | |
417 public static void extendOrthancExplorer( | |
418 String javascript) { | |
419 NativeSDK.OrthancPluginExtendOrthancExplorer(javascript); | |
420 } | |
421 | |
422 /** | |
423 * Get the value of a global property. | |
424 * | |
425 * Get the value of a global property that is stored in the Orthanc database. | |
426 * Global properties whose index is below 1024 are reserved by Orthanc. | |
427 * | |
428 * @param property The global property of interest. | |
429 * @param defaultValue The value to return, if the global property is unset. | |
430 * @return The resulting string. | |
431 **/ | |
432 public static String getGlobalProperty( | |
433 int property, | |
434 String defaultValue) { | |
435 return NativeSDK.OrthancPluginGetGlobalProperty(property, defaultValue); | |
436 } | |
437 | |
438 /** | |
439 * Set the value of a global property. | |
440 * | |
441 * Set the value of a global property into the Orthanc database. Setting a global | |
442 * property can be used by plugins to save their internal parameters. Plugins are | |
443 * only allowed to set properties whose index are above or equal to 1024 | |
444 * (properties below 1024 are read-only and reserved by Orthanc). | |
445 * | |
446 * @param property The global property of interest. | |
447 * @param value The value to be set in the global property. | |
448 **/ | |
449 public static void setGlobalProperty( | |
450 int property, | |
451 String value) { | |
452 NativeSDK.OrthancPluginSetGlobalProperty(property, value); | |
453 } | |
454 | |
455 /** | |
456 * Get the number of command-line arguments. | |
457 * | |
458 * Retrieve the number of command-line arguments that were used to launch Orthanc. | |
459 * | |
460 * @return The number of arguments. | |
461 **/ | |
462 public static int getCommandLineArgumentsCount() { | |
463 return NativeSDK.OrthancPluginGetCommandLineArgumentsCount(); | |
464 } | |
465 | |
466 /** | |
467 * Get the value of a command-line argument. | |
468 * | |
469 * Get the value of one of the command-line arguments that were used to launch | |
470 * Orthanc. The number of available arguments can be retrieved by | |
471 * OrthancPluginGetCommandLineArgumentsCount(). | |
472 * | |
473 * @param argument The index of the argument. | |
474 * @return The resulting string. | |
475 **/ | |
476 public static String getCommandLineArgument( | |
477 int argument) { | |
478 return NativeSDK.OrthancPluginGetCommandLineArgument(argument); | |
479 } | |
480 | |
481 /** | |
482 * Get the expected version of the database schema. | |
483 * | |
484 * Retrieve the expected version of the database schema. | |
485 * | |
486 * @return The version. | |
487 **/ | |
488 public static int getExpectedDatabaseVersion() { | |
489 return NativeSDK.OrthancPluginGetExpectedDatabaseVersion(); | |
490 } | |
491 | |
492 /** | |
493 * Return the content of the configuration file(s). | |
494 * | |
495 * This function returns the content of the configuration that is used by Orthanc, | |
496 * formatted as a JSON string. | |
497 * | |
498 * @return The resulting string. | |
499 **/ | |
500 public static String getConfiguration() { | |
501 return NativeSDK.OrthancPluginGetConfiguration(); | |
502 } | |
503 | |
504 /** | |
505 * Compress or decompress a buffer. | |
506 * | |
507 * This function compresses or decompresses a buffer, using the version of the zlib | |
508 * library that is used by the Orthanc core. | |
509 * | |
510 * @param source The source buffer. | |
511 * @param compression The compression algorithm. | |
512 * @param uncompress If set to "0", the buffer must be compressed. If set to "1", | |
513 * the buffer must be uncompressed. | |
514 * @return The resulting memory buffer. | |
515 **/ | |
516 public static byte[] bufferCompression( | |
517 byte[] source, | |
518 CompressionType compression, | |
519 byte uncompress) { | |
520 return NativeSDK.OrthancPluginBufferCompression(source, compression.getValue(), uncompress); | |
521 } | |
522 | |
523 /** | |
524 * Read a file. | |
525 * | |
526 * Read the content of a file on the filesystem, and returns it into a newly | |
527 * allocated memory buffer. | |
528 * | |
529 * @param path The path of the file to be read. | |
530 * @return The resulting memory buffer. | |
531 **/ | |
532 public static byte[] readFile( | |
533 String path) { | |
534 return NativeSDK.OrthancPluginReadFile(path); | |
535 } | |
536 | |
537 /** | |
538 * Write a file. | |
539 * | |
540 * Write the content of a memory buffer to the filesystem. | |
541 * | |
542 * @param path The path of the file to be written. | |
543 * @param data The content of the memory buffer. | |
544 **/ | |
545 public static void writeFile( | |
546 String path, | |
547 byte[] data) { | |
548 NativeSDK.OrthancPluginWriteFile(path, data); | |
549 } | |
550 | |
551 /** | |
552 * Get the description of a given error code. | |
553 * | |
554 * This function returns the description of a given error code. | |
555 * | |
556 * @param error The error code of interest. | |
557 * @return The resulting string. | |
558 **/ | |
559 public static String getErrorDescription( | |
560 ErrorCode error) { | |
561 return NativeSDK.OrthancPluginGetErrorDescription(error.getValue()); | |
562 } | |
563 | |
564 /** | |
565 * Encode a PNG image. | |
566 * | |
567 * This function compresses the given memory buffer containing an image using the | |
568 * PNG specification, and stores the result of the compression into a newly | |
569 * allocated memory buffer. | |
570 * | |
571 * @param format The memory layout of the uncompressed image. | |
572 * @param width The width of the image. | |
573 * @param height The height of the image. | |
574 * @param pitch The pitch of the image (i.e. the number of bytes between 2 | |
575 * successive lines of the image in the memory buffer). | |
576 * @param buffer The memory buffer containing the uncompressed image. | |
577 * @return The resulting memory buffer. | |
578 **/ | |
579 public static byte[] compressPngImage( | |
580 PixelFormat format, | |
581 int width, | |
582 int height, | |
583 int pitch, | |
584 byte[] buffer) { | |
585 return NativeSDK.OrthancPluginCompressPngImage(format.getValue(), width, height, pitch, buffer); | |
586 } | |
587 | |
588 /** | |
589 * Encode a JPEG image. | |
590 * | |
591 * This function compresses the given memory buffer containing an image using the | |
592 * JPEG specification, and stores the result of the compression into a newly | |
593 * allocated memory buffer. | |
594 * | |
595 * @param format The memory layout of the uncompressed image. | |
596 * @param width The width of the image. | |
597 * @param height The height of the image. | |
598 * @param pitch The pitch of the image (i.e. the number of bytes between 2 | |
599 * successive lines of the image in the memory buffer). | |
600 * @param buffer The memory buffer containing the uncompressed image. | |
601 * @param quality The quality of the JPEG encoding, between 1 (worst quality, best | |
602 * compression) and 100 (best quality, worst compression). | |
603 * @return The resulting memory buffer. | |
604 **/ | |
605 public static byte[] compressJpegImage( | |
606 PixelFormat format, | |
607 int width, | |
608 int height, | |
609 int pitch, | |
610 byte[] buffer, | |
611 byte quality) { | |
612 return NativeSDK.OrthancPluginCompressJpegImage(format.getValue(), width, height, pitch, buffer, quality); | |
613 } | |
614 | |
615 /** | |
616 * Issue a HTTP GET call. | |
617 * | |
618 * Make a HTTP GET call to the given URL. The result to the query is stored into a | |
619 * newly allocated memory buffer. Favor OrthancPluginRestApiGet() if calling the | |
620 * built-in REST API of the Orthanc instance that hosts this plugin. | |
621 * | |
622 * @param url The URL of interest. | |
623 * @param username The username (can be "NULL" if no password protection). | |
624 * @param password The password (can be "NULL" if no password protection). | |
625 * @return The resulting memory buffer. | |
626 **/ | |
627 public static byte[] httpGet( | |
628 String url, | |
629 String username, | |
630 String password) { | |
631 return NativeSDK.OrthancPluginHttpGet(url, username, password); | |
632 } | |
633 | |
634 /** | |
635 * Issue a HTTP POST call. | |
636 * | |
637 * Make a HTTP POST call to the given URL. The result to the query is stored into a | |
638 * newly allocated memory buffer. Favor OrthancPluginRestApiPost() if calling the | |
639 * built-in REST API of the Orthanc instance that hosts this plugin. | |
640 * | |
641 * @param url The URL of interest. | |
642 * @param body The content of the body of the request. | |
643 * @param username The username (can be "NULL" if no password protection). | |
644 * @param password The password (can be "NULL" if no password protection). | |
645 * @return The resulting memory buffer. | |
646 **/ | |
647 public static byte[] httpPost( | |
648 String url, | |
649 byte[] body, | |
650 String username, | |
651 String password) { | |
652 return NativeSDK.OrthancPluginHttpPost(url, body, username, password); | |
653 } | |
654 | |
655 /** | |
656 * Issue a HTTP PUT call. | |
657 * | |
658 * Make a HTTP PUT call to the given URL. The result to the query is stored into a | |
659 * newly allocated memory buffer. Favor OrthancPluginRestApiPut() if calling the | |
660 * built-in REST API of the Orthanc instance that hosts this plugin. | |
661 * | |
662 * @param url The URL of interest. | |
663 * @param body The content of the body of the request. | |
664 * @param username The username (can be "NULL" if no password protection). | |
665 * @param password The password (can be "NULL" if no password protection). | |
666 * @return The resulting memory buffer. | |
667 **/ | |
668 public static byte[] httpPut( | |
669 String url, | |
670 byte[] body, | |
671 String username, | |
672 String password) { | |
673 return NativeSDK.OrthancPluginHttpPut(url, body, username, password); | |
674 } | |
675 | |
676 /** | |
677 * Issue a HTTP DELETE call. | |
678 * | |
679 * Make a HTTP DELETE call to the given URL. Favor OrthancPluginRestApiDelete() if | |
680 * calling the built-in REST API of the Orthanc instance that hosts this plugin. | |
681 * | |
682 * @param url The URL of interest. | |
683 * @param username The username (can be "NULL" if no password protection). | |
684 * @param password The password (can be "NULL" if no password protection). | |
685 **/ | |
686 public static void httpDelete( | |
687 String url, | |
688 String username, | |
689 String password) { | |
690 NativeSDK.OrthancPluginHttpDelete(url, username, password); | |
691 } | |
692 | |
693 /** | |
694 * Return the number of available fonts. | |
695 * | |
696 * This function returns the number of fonts that are built in the Orthanc core. | |
697 * These fonts can be used to draw texts on images through OrthancPluginDrawText(). | |
698 * | |
699 * @return The number of fonts. | |
700 **/ | |
701 public static int getFontsCount() { | |
702 return NativeSDK.OrthancPluginGetFontsCount(); | |
703 } | |
704 | |
705 /** | |
706 * Return the name of a font. | |
707 * | |
708 * This function returns the name of a font that is built in the Orthanc core. | |
709 * | |
710 * @param fontIndex The index of the font. This value must be less than | |
711 * OrthancPluginGetFontsCount(). | |
712 * @return The resulting string. | |
713 **/ | |
714 public static String getFontName( | |
715 int fontIndex) { | |
716 return NativeSDK.OrthancPluginGetFontName(fontIndex); | |
717 } | |
718 | |
719 /** | |
720 * Return the size of a font. | |
721 * | |
722 * This function returns the size of a font that is built in the Orthanc core. | |
723 * | |
724 * @param fontIndex The index of the font. This value must be less than | |
725 * OrthancPluginGetFontsCount(). | |
726 * @return The font size. | |
727 **/ | |
728 public static int getFontSize( | |
729 int fontIndex) { | |
730 return NativeSDK.OrthancPluginGetFontSize(fontIndex); | |
731 } | |
732 | |
733 /** | |
734 * Declare a custom error code for this plugin. | |
735 * | |
736 * This function declares a custom error code that can be generated by this plugin. | |
737 * This declaration is used to enrich the body of the HTTP answer in the case of an | |
738 * error, and to set the proper HTTP status code. | |
739 * | |
740 * @param code The error code that is internal to this plugin. | |
741 * @param httpStatus The HTTP status corresponding to this error. | |
742 * @param message The description of the error. | |
743 **/ | |
744 public static void registerErrorCode( | |
745 int code, | |
746 short httpStatus, | |
747 String message) { | |
748 NativeSDK.OrthancPluginRegisterErrorCode(code, httpStatus, message); | |
749 } | |
750 | |
751 /** | |
752 * Register a new tag into the DICOM dictionary. | |
753 * | |
754 * This function declares a new public tag in the dictionary of DICOM tags that are | |
755 * known to Orthanc. This function should be used in the OrthancPluginInitialize() | |
756 * callback. | |
757 * | |
758 * @param group The group of the tag. | |
759 * @param element The element of the tag. | |
760 * @param vr The value representation of the tag. | |
761 * @param name The nickname of the tag. | |
762 * @param minMultiplicity The minimum multiplicity of the tag (must be above 0). | |
763 * @param maxMultiplicity The maximum multiplicity of the tag. A value of 0 means | |
764 * an arbitrary multiplicity (""n""). | |
765 **/ | |
766 public static void registerDictionaryTag( | |
767 short group, | |
768 short element, | |
769 ValueRepresentation vr, | |
770 String name, | |
771 int minMultiplicity, | |
772 int maxMultiplicity) { | |
773 NativeSDK.OrthancPluginRegisterDictionaryTag(group, element, vr.getValue(), name, minMultiplicity, maxMultiplicity); | |
774 } | |
775 | |
776 /** | |
777 * Register a new private tag into the DICOM dictionary. | |
778 * | |
779 * This function declares a new private tag in the dictionary of DICOM tags that | |
780 * are known to Orthanc. This function should be used in the | |
781 * OrthancPluginInitialize() callback. | |
782 * | |
783 * @param group The group of the tag. | |
784 * @param element The element of the tag. | |
785 * @param vr The value representation of the tag. | |
786 * @param name The nickname of the tag. | |
787 * @param minMultiplicity The minimum multiplicity of the tag (must be above 0). | |
788 * @param maxMultiplicity The maximum multiplicity of the tag. A value of 0 means | |
789 * an arbitrary multiplicity (""n""). | |
790 * @param privateCreator The private creator of this private tag. | |
791 **/ | |
792 public static void registerPrivateDictionaryTag( | |
793 short group, | |
794 short element, | |
795 ValueRepresentation vr, | |
796 String name, | |
797 int minMultiplicity, | |
798 int maxMultiplicity, | |
799 String privateCreator) { | |
800 NativeSDK.OrthancPluginRegisterPrivateDictionaryTag(group, element, vr.getValue(), name, minMultiplicity, maxMultiplicity, privateCreator); | |
801 } | |
802 | |
803 /** | |
804 * Format a DICOM memory buffer as a JSON string. | |
805 * | |
806 * This function takes as input a memory buffer containing a DICOM file, and | |
807 * outputs a JSON string representing the tags of this DICOM file. | |
808 * | |
809 * @param buffer The memory buffer containing the DICOM file. | |
810 * @param format The output format. | |
811 * @param flags Flags governing the output. | |
812 * @param maxStringLength The maximum length of a field. Too long fields will be | |
813 * output as "null". The 0 value means no maximum length. | |
814 * @return The resulting string. | |
815 **/ | |
816 public static String dicomBufferToJson( | |
817 byte[] buffer, | |
818 DicomToJsonFormat format, | |
819 DicomToJsonFlags flags, | |
820 int maxStringLength) { | |
821 return NativeSDK.OrthancPluginDicomBufferToJson(buffer, format.getValue(), flags.getValue(), maxStringLength); | |
822 } | |
823 | |
824 /** | |
825 * Format a DICOM instance as a JSON string. | |
826 * | |
827 * This function formats a DICOM instance that is stored in Orthanc, and outputs a | |
828 * JSON string representing the tags of this DICOM instance. | |
829 * | |
830 * @param instanceId The Orthanc identifier of the instance. | |
831 * @param format The output format. | |
832 * @param flags Flags governing the output. | |
833 * @param maxStringLength The maximum length of a field. Too long fields will be | |
834 * output as "null". The 0 value means no maximum length. | |
835 * @return The resulting string. | |
836 **/ | |
837 public static String dicomInstanceToJson( | |
838 String instanceId, | |
839 DicomToJsonFormat format, | |
840 DicomToJsonFlags flags, | |
841 int maxStringLength) { | |
842 return NativeSDK.OrthancPluginDicomInstanceToJson(instanceId, format.getValue(), flags.getValue(), maxStringLength); | |
843 } | |
844 | |
845 /** | |
846 * Create a DICOM instance from a JSON string and an image. | |
847 * | |
848 * This function takes as input a string containing a JSON file describing the | |
849 * content of a DICOM instance. As an output, it writes the corresponding DICOM | |
850 * instance to a newly allocated memory buffer. Additionally, an image to be | |
851 * encoded within the DICOM instance can also be provided. | |
852 * | |
853 * Private tags will be associated with the private creator whose value is | |
854 * specified in the "DefaultPrivateCreator" configuration option of Orthanc. The | |
855 * function OrthancPluginCreateDicom2() can be used if another private creator must | |
856 * be used to create this instance. | |
857 * | |
858 * @param json The input JSON file. | |
859 * @param pixelData The image. Can be NULL, if the pixel data is encoded inside the | |
860 * JSON with the data URI scheme. | |
861 * @param flags Flags governing the output. | |
862 * @return The resulting memory buffer. | |
863 **/ | |
864 public static byte[] createDicom( | |
865 String json, | |
866 Image pixelData, | |
867 CreateDicomFlags flags) { | |
868 return NativeSDK.OrthancPluginCreateDicom(json, pixelData.getSelf(), flags.getValue()); | |
869 } | |
870 | |
871 /** | |
872 * Compute an MD5 hash. | |
873 * | |
874 * This functions computes the MD5 cryptographic hash of the given memory buffer. | |
875 * | |
876 * @param buffer The source memory buffer. | |
877 * @return The resulting string. | |
878 **/ | |
879 public static String computeMd5( | |
880 byte[] buffer) { | |
881 return NativeSDK.OrthancPluginComputeMd5(buffer); | |
882 } | |
883 | |
884 /** | |
885 * Compute a SHA-1 hash. | |
886 * | |
887 * This functions computes the SHA-1 cryptographic hash of the given memory buffer. | |
888 * | |
889 * @param buffer The source memory buffer. | |
890 * @return The resulting string. | |
891 **/ | |
892 public static String computeSha1( | |
893 byte[] buffer) { | |
894 return NativeSDK.OrthancPluginComputeSha1(buffer); | |
895 } | |
896 | |
897 /** | |
898 * Generate an UUID. | |
899 * | |
900 * Generate a random GUID/UUID (globally unique identifier). | |
901 * | |
902 * @return The resulting string. | |
903 **/ | |
904 public static String generateUuid() { | |
905 return NativeSDK.OrthancPluginGenerateUuid(); | |
906 } | |
907 | |
908 /** | |
909 * Detect the MIME type of a file. | |
910 * | |
911 * This function returns the MIME type of a file by inspecting its extension. | |
912 * | |
913 * @param path Path to the file. | |
914 * @return The resulting string. | |
915 **/ | |
916 public static String autodetectMimeType( | |
917 String path) { | |
918 return NativeSDK.OrthancPluginAutodetectMimeType(path); | |
919 } | |
920 | |
921 /** | |
922 * Set the value of a metrics. | |
923 * | |
924 * This function sets the value of a metrics to monitor the behavior of the plugin | |
925 * through tools such as Prometheus. The values of all the metrics are stored | |
926 * within the Orthanc context. | |
927 * | |
928 * @param name The name of the metrics to be set. | |
929 * @param value The value of the metrics. | |
930 * @param type The type of the metrics. This parameter is only taken into | |
931 * consideration the first time this metrics is set. | |
932 **/ | |
933 public static void setMetricsValue( | |
934 String name, | |
935 float value, | |
936 MetricsType type) { | |
937 NativeSDK.OrthancPluginSetMetricsValue(name, value, type.getValue()); | |
938 } | |
939 | |
940 /** | |
941 * Returns the symbolic name of a DICOM tag. | |
942 * | |
943 * This function makes a lookup to the dictionary of DICOM tags that are known to | |
944 * Orthanc, and returns the symbolic name of a DICOM tag. | |
945 * | |
946 * @param group The group of the tag. | |
947 * @param element The element of the tag. | |
948 * @param privateCreator For private tags, the name of the private creator (can be | |
949 * NULL). | |
950 * @return The resulting string. | |
951 **/ | |
952 public static String getTagName( | |
953 short group, | |
954 short element, | |
955 String privateCreator) { | |
956 return NativeSDK.OrthancPluginGetTagName(group, element, privateCreator); | |
957 } | |
958 | |
959 /** | |
960 * Generate a token to grant full access to the REST API of Orthanc | |
961 * | |
962 * This function generates a token that can be set in the HTTP header | |
963 * "Authorization" so as to grant full access to the REST API of Orthanc using an | |
964 * external HTTP client. Using this function avoids the need of adding a separate | |
965 * user in the "RegisteredUsers" configuration of Orthanc, which eases deployments. | |
966 * | |
967 * This feature is notably useful in multiprocess scenarios, where a subprocess | |
968 * created by a plugin has no access to the "OrthancPluginContext", and thus cannot | |
969 * call "OrthancPluginRestApi[Get|Post|Put|Delete]()". | |
970 * | |
971 * This situation is frequently encountered in Python plugins, where the | |
972 * "multiprocessing" package can be used to bypass the Global Interpreter Lock | |
973 * (GIL) and thus to improve performance and concurrency. | |
974 * | |
975 * @return The resulting string. | |
976 **/ | |
977 public static String generateRestApiAuthorizationToken() { | |
978 return NativeSDK.OrthancPluginGenerateRestApiAuthorizationToken(); | |
979 } | |
980 | |
981 /** | |
982 * Create a DICOM instance from a JSON string and an image, with a private creator. | |
983 * | |
984 * This function takes as input a string containing a JSON file describing the | |
985 * content of a DICOM instance. As an output, it writes the corresponding DICOM | |
986 * instance to a newly allocated memory buffer. Additionally, an image to be | |
987 * encoded within the DICOM instance can also be provided. | |
988 * | |
989 * Contrarily to the function OrthancPluginCreateDicom(), this function can be | |
990 * explicitly provided with a private creator. | |
991 * | |
992 * @param json The input JSON file. | |
993 * @param pixelData The image. Can be NULL, if the pixel data is encoded inside the | |
994 * JSON with the data URI scheme. | |
995 * @param flags Flags governing the output. | |
996 * @param privateCreator The private creator to be used for the private DICOM tags. | |
997 * Check out the global configuration option "Dictionary" of Orthanc. | |
998 * @return The resulting memory buffer. | |
999 **/ | |
1000 public static byte[] createDicom2( | |
1001 String json, | |
1002 Image pixelData, | |
1003 CreateDicomFlags flags, | |
1004 String privateCreator) { | |
1005 return NativeSDK.OrthancPluginCreateDicom2(json, pixelData.getSelf(), flags.getValue(), privateCreator); | |
1006 } | |
1007 | |
1008 } |