Mercurial > hg > orthanc

comparison OrthancServer/OrthancRestApi.cpp @ 58:6da7fc87efaa orthanc-renaming

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
renaming cont
author Sebastien Jodogne <s.jodogne@gmail.com>
date Sun, 16 Sep 2012 09:24:13 +0200
parents OrthancServer/PalanthirRestApi.cpp@4bc019d2f969
children a70bb32802ae
comparison
equal deleted inserted replaced
57:4bc019d2f969 58:6da7fc87efaa
1 /**
2 * Palanthir - A Lightweight, RESTful DICOM Store
3 * Copyright (C) 2012 Medical Physics Department, CHU of Liege,
4 * Belgium
5 *
6 * This program is free software: you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation, either version 3 of the
9 * License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 **/
19
20
21 #include "PalanthirRestApi.h"
22
23 #include "PalanthirInitialization.h"
24 #include "FromDcmtkBridge.h"
25 #include "../Core/Uuid.h"
26
27 #include <dcmtk/dcmdata/dcistrmb.h>
28 #include <dcmtk/dcmdata/dcfilefo.h>
29 #include <boost/lexical_cast.hpp>
30
31 namespace Palanthir
32 {
33 static void SendJson(HttpOutput& output,
34 const Json::Value& value)
35 {
36 Json::StyledWriter writer;
37 std::string s = writer.write(value);
38 output.AnswerBufferWithContentType(s, "application/json");
39 }
40
41
42 static void SimplifyTagsRecursion(Json::Value& target,
43 const Json::Value& source)
44 {
45 assert(source.isObject());
46
47 target = Json::objectValue;
48 Json::Value::Members members = source.getMemberNames();
49
50 for (size_t i = 0; i < members.size(); i++)
51 {
52 const Json::Value& v = source[members[i]];
53 const std::string& name = v["Name"].asString();
54 const std::string& type = v["Type"].asString();
55
56 if (type == "String")
57 {
58 target[name] = v["Value"].asString();
59 }
60 else if (type == "TooLong" ||
61 type == "Null")
62 {
63 target[name] = Json::nullValue;
64 }
65 else if (type == "Sequence")
66 {
67 const Json::Value& array = v["Value"];
68 assert(array.isArray());
69
70 Json::Value children = Json::arrayValue;
71 for (size_t i = 0; i < array.size(); i++)
72 {
73 Json::Value c;
74 SimplifyTagsRecursion(c, array[i]);
75 children.append(c);
76 }
77
78 target[name] = children;
79 }
80 else
81 {
82 assert(0);
83 }
84 }
85 }
86
87
88 static void SimplifyTags(Json::Value& target,
89 const FileStorage& storage,
90 const std::string& fileUuid)
91 {
92 std::string s;
93 storage.ReadFile(s, fileUuid);
94
95 Json::Value source;
96 Json::Reader reader;
97 if (!reader.parse(s, source))
98 {
99 throw PalanthirException("Corrupted JSON file");
100 }
101
102 SimplifyTagsRecursion(target, source);
103 }
104
105
106 bool PalanthirRestApi::Store(Json::Value& result,
107 const std::string& postData)
108 {
109 // Prepare an input stream for the memory buffer
110 DcmInputBufferStream is;
111 if (postData.size() > 0)
112 {
113 is.setBuffer(&postData[0], postData.size());
114 }
115 is.setEos();
116
117 //printf("[%d]\n", postData.size());
118
119 DcmFileFormat dicomFile;
120 if (dicomFile.read(is).good())
121 {
122 DicomMap dicomSummary;
123 FromDcmtkBridge::Convert(dicomSummary, *dicomFile.getDataset());
124
125 Json::Value dicomJson;
126 FromDcmtkBridge::ToJson(dicomJson, *dicomFile.getDataset());
127
128 std::string instanceUuid;
129 StoreStatus status = StoreStatus_Failure;
130 if (postData.size() > 0)
131 {
132 status = index_.Store
133 (instanceUuid, storage_, reinterpret_cast<const char*>(&postData[0]),
134 postData.size(), dicomSummary, dicomJson, "");
135 }
136
137 switch (status)
138 {
139 case StoreStatus_Success:
140 result["ID"] = instanceUuid;
141 result["Path"] = "/instances/" + instanceUuid;
142 result["Status"] = "Success";
143 return true;
144
145 case StoreStatus_AlreadyStored:
146 result["ID"] = instanceUuid;
147 result["Path"] = "/instances/" + instanceUuid;
148 result["Status"] = "AlreadyStored";
149 return true;
150
151 default:
152 return false;
153 }
154 }
155
156 return false;
157 }
158
159 void PalanthirRestApi::ConnectToModality(DicomUserConnection& c,
160 const std::string& name)
161 {
162 std::string aet, address;
163 int port;
164 GetDicomModality(name, aet, address, port);
165 c.SetLocalApplicationEntityTitle(GetGlobalStringParameter("DicomAet", "PALANTHIR"));
166 c.SetDistantApplicationEntityTitle(aet);
167 c.SetDistantHost(address);
168 c.SetDistantPort(port);
169 c.Open();
170 }
171
172 bool PalanthirRestApi::MergeQueryAndTemplate(DicomMap& result,
173 const std::string& postData)
174 {
175 Json::Value query;
176 Json::Reader reader;
177
178 if (!reader.parse(postData, query) ||
179 query.type() != Json::objectValue)
180 {
181 return false;
182 }
183
184 Json::Value::Members members = query.getMemberNames();
185 for (size_t i = 0; i < members.size(); i++)
186 {
187 DicomTag t = FromDcmtkBridge::FindTag(members[i]);
188 result.SetValue(t, query[members[i]].asString());
189 }
190
191 return true;
192 }
193
194 bool PalanthirRestApi::DicomFindPatient(Json::Value& result,
195 DicomUserConnection& c,
196 const std::string& postData)
197 {
198 DicomMap m;
199 DicomMap::SetupFindPatientTemplate(m);
200 if (!MergeQueryAndTemplate(m, postData))
201 {
202 return false;
203 }
204
205 DicomFindAnswers answers;
206 c.FindPatient(answers, m);
207 answers.ToJson(result);
208 return true;
209 }
210
211 bool PalanthirRestApi::DicomFindStudy(Json::Value& result,
212 DicomUserConnection& c,
213 const std::string& postData)
214 {
215 DicomMap m;
216 DicomMap::SetupFindStudyTemplate(m);
217 if (!MergeQueryAndTemplate(m, postData))
218 {
219 return false;
220 }
221
222 if (m.GetValue(DicomTag::ACCESSION_NUMBER).AsString().size() <= 2 &&
223 m.GetValue(DicomTag::PATIENT_ID).AsString().size() <= 2)
224 {
225 return false;
226 }
227
228 DicomFindAnswers answers;
229 c.FindStudy(answers, m);
230 answers.ToJson(result);
231 return true;
232 }
233
234 bool PalanthirRestApi::DicomFindSeries(Json::Value& result,
235 DicomUserConnection& c,
236 const std::string& postData)
237 {
238 DicomMap m;
239 DicomMap::SetupFindSeriesTemplate(m);
240 if (!MergeQueryAndTemplate(m, postData))
241 {
242 return false;
243 }
244
245 if ((m.GetValue(DicomTag::ACCESSION_NUMBER).AsString().size() <= 2 &&
246 m.GetValue(DicomTag::PATIENT_ID).AsString().size() <= 2) ||
247 m.GetValue(DicomTag::STUDY_UID).AsString().size() <= 2)
248 {
249 return false;
250 }
251
252 DicomFindAnswers answers;
253 c.FindSeries(answers, m);
254 answers.ToJson(result);
255 return true;
256 }
257
258 bool PalanthirRestApi::DicomFind(Json::Value& result,
259 DicomUserConnection& c,
260 const std::string& postData)
261 {
262 DicomMap m;
263 DicomMap::SetupFindPatientTemplate(m);
264 if (!MergeQueryAndTemplate(m, postData))
265 {
266 return false;
267 }
268
269 DicomFindAnswers patients;
270 c.FindPatient(patients, m);
271
272 // Loop over the found patients
273 result = Json::arrayValue;
274 for (size_t i = 0; i < patients.GetSize(); i++)
275 {
276 Json::Value patient(Json::objectValue);
277 FromDcmtkBridge::ToJson(patient, patients.GetAnswer(i));
278
279 DicomMap::SetupFindStudyTemplate(m);
280 if (!MergeQueryAndTemplate(m, postData))
281 {
282 return false;
283 }
284 m.CopyTagIfExists(patients.GetAnswer(i), DicomTag::PATIENT_ID);
285
286 DicomFindAnswers studies;
287 c.FindStudy(studies, m);
288
289 patient["Studies"] = Json::arrayValue;
290
291 // Loop over the found studies
292 for (size_t j = 0; j < studies.GetSize(); j++)
293 {
294 Json::Value study(Json::objectValue);
295 FromDcmtkBridge::ToJson(study, studies.GetAnswer(j));
296
297 DicomMap::SetupFindSeriesTemplate(m);
298 if (!MergeQueryAndTemplate(m, postData))
299 {
300 return false;
301 }
302 m.CopyTagIfExists(studies.GetAnswer(j), DicomTag::PATIENT_ID);
303 m.CopyTagIfExists(studies.GetAnswer(j), DicomTag::STUDY_UID);
304
305 DicomFindAnswers series;
306 c.FindSeries(series, m);
307
308 // Loop over the found series
309 study["Series"] = Json::arrayValue;
310 for (size_t k = 0; k < series.GetSize(); k++)
311 {
312 Json::Value series2(Json::objectValue);
313 FromDcmtkBridge::ToJson(series2, series.GetAnswer(k));
314 study["Series"].append(series2);
315 }
316
317 patient["Studies"].append(study);
318 }
319
320 result.append(patient);
321 }
322
323 return true;
324 }
325
326
327
328 bool PalanthirRestApi::DicomStore(Json::Value& result,
329 DicomUserConnection& c,
330 const std::string& postData)
331 {
332 Json::Value found(Json::objectValue);
333
334 if (!Toolbox::IsUuid(postData))
335 {
336 // This is not a UUID, assume this is a DICOM instance
337 c.Store(postData);
338 }
339 else if (index_.GetSeries(found, postData))
340 {
341 // The UUID corresponds to a series
342 for (size_t i = 0; i < found["Instances"].size(); i++)
343 {
344 std::string uuid = found["Instances"][i].asString();
345 Json::Value instance(Json::objectValue);
346 if (index_.GetInstance(instance, uuid))
347 {
348 std::string content;
349 storage_.ReadFile(content, instance["FileUuid"].asString());
350 c.Store(content);
351 }
352 else
353 {
354 return false;
355 }
356 }
357 }
358 else if (index_.GetInstance(found, postData))
359 {
360 // The UUID corresponds to an instance
361 std::string content;
362 storage_.ReadFile(content, found["FileUuid"].asString());
363 c.Store(content);
364 }
365 else
366 {
367 return false;
368 }
369
370 return true;
371 }
372
373
374 PalanthirRestApi::PalanthirRestApi(ServerIndex& index,
375 const std::string& path) :
376 index_(index),
377 storage_(path)
378 {
379 GetListOfDicomModalities(modalities_);
380 }
381
382
383 void PalanthirRestApi::Handle(
384 HttpOutput& output,
385 const std::string& method,
386 const UriComponents& uri,
387 const Arguments& headers,
388 const Arguments& arguments,
389 const std::string& postData)
390 {
391 if (uri.size() == 0)
392 {
393 if (method == "GET")
394 {
395 output.Redirect("/app/explorer.html");
396 }
397 else
398 {
399 output.SendMethodNotAllowedError("GET");
400 }
401
402 return;
403 }
404
405 bool existingResource = false;
406 Json::Value result(Json::objectValue);
407
408
409 // List all the instances ---------------------------------------------------
410
411 if (uri.size() == 1 && uri[0] == "instances")
412 {
413 if (method == "GET")
414 {
415 result = Json::Value(Json::arrayValue);
416 index_.GetAllUuids(result, "Instances");
417 existingResource = true;
418 }
419 else if (method == "POST")
420 {
421 // Add a new instance to the storage
422 if (Store(result, postData))
423 {
424 SendJson(output, result);
425 return;
426 }
427 else
428 {
429 output.SendHeader(Palanthir_HttpStatus_415_UnsupportedMediaType);
430 return;
431 }
432 }
433 else
434 {
435 output.SendMethodNotAllowedError("GET,POST");
436 return;
437 }
438 }
439
440
441 // List all the patients, studies or series ---------------------------------
442
443 if (uri.size() == 1 &&
444 (uri[0] == "series" ||
445 uri[0] == "studies" ||
446 uri[0] == "patients"))
447 {
448 if (method == "GET")
449 {
450 result = Json::Value(Json::arrayValue);
451
452 if (uri[0] == "instances")
453 index_.GetAllUuids(result, "Instances");
454 else if (uri[0] == "series")
455 index_.GetAllUuids(result, "Series");
456 else if (uri[0] == "studies")
457 index_.GetAllUuids(result, "Studies");
458 else if (uri[0] == "patients")
459 index_.GetAllUuids(result, "Patients");
460
461 existingResource = true;
462 }
463 else
464 {
465 output.SendMethodNotAllowedError("GET");
466 return;
467 }
468 }
469
470
471 // Information about a single object ----------------------------------------
472
473 else if (uri.size() == 2 &&
474 (uri[0] == "instances" ||
475 uri[0] == "series" ||
476 uri[0] == "studies" ||
477 uri[0] == "patients"))
478 {
479 if (method == "GET")
480 {
481 if (uri[0] == "patients")
482 {
483 existingResource = index_.GetPatient(result, uri[1]);
484 }
485 else if (uri[0] == "studies")
486 {
487 existingResource = index_.GetStudy(result, uri[1]);
488 }
489 else if (uri[0] == "series")
490 {
491 existingResource = index_.GetSeries(result, uri[1]);
492 }
493 else if (uri[0] == "instances")
494 {
495 existingResource = index_.GetInstance(result, uri[1]);
496 }
497 }
498 else if (method == "DELETE")
499 {
500 if (uri[0] == "patients")
501 {
502 existingResource = index_.DeletePatient(result, uri[1]);
503 }
504 else if (uri[0] == "studies")
505 {
506 existingResource = index_.DeleteStudy(result, uri[1]);
507 }
508 else if (uri[0] == "series")
509 {
510 existingResource = index_.DeleteSeries(result, uri[1]);
511 }
512 else if (uri[0] == "instances")
513 {
514 existingResource = index_.DeleteInstance(result, uri[1]);
515 }
516
517 if (existingResource)
518 {
519 result["Status"] = "Success";
520 }
521 }
522 else
523 {
524 output.SendMethodNotAllowedError("GET,DELETE");
525 return;
526 }
527 }
528
529
530 // Get the DICOM or the JSON file of one instance ---------------------------
531
532 else if (uri.size() == 3 &&
533 uri[0] == "instances" &&
534 (uri[2] == "file" ||
535 uri[2] == "tags" ||
536 uri[2] == "simplified-tags"))
537 {
538 std::string fileUuid, contentType;
539 if (uri[2] == "file")
540 {
541 existingResource = index_.GetDicomFile(fileUuid, uri[1]);
542 contentType = "application/dicom";
543 }
544 else if (uri[2] == "tags" ||
545 uri[2] == "simplified-tags")
546 {
547 existingResource = index_.GetJsonFile(fileUuid, uri[1]);
548 contentType = "application/json";
549 }
550
551 if (existingResource)
552 {
553 if (uri[2] == "simplified-tags")
554 {
555 Json::Value v;
556 SimplifyTags(v, storage_, fileUuid);
557 SendJson(output, v);
558 return;
559 }
560 else
561 {
562 output.AnswerFile(storage_, fileUuid, contentType);
563 return;
564 }
565 }
566 }
567
568
569 else if (uri.size() == 3 &&
570 uri[0] == "instances" &&
571 uri[2] == "frames")
572 {
573 Json::Value instance(Json::objectValue);
574 existingResource = index_.GetInstance(instance, uri[1]);
575
576 if (existingResource)
577 {
578 result = Json::arrayValue;
579
580 unsigned int numberOfFrames = 1;
581 try
582 {
583 Json::Value tmp = instance["MainDicomTags"]["NumberOfFrames"];
584 numberOfFrames = boost::lexical_cast<unsigned int>(tmp.asString());
585 }
586 catch (boost::bad_lexical_cast)
587 {
588 }
589
590 for (unsigned int i = 0; i < numberOfFrames; i++)
591 {
592 result.append(i);
593 }
594 }
595 }
596
597
598 else if (uri[0] == "instances" &&
599 ((uri.size() == 3 &&
600 (uri[2] == "preview" ||
601 uri[2] == "image-uint8" ||
602 uri[2] == "image-uint16")) ||
603 (uri.size() == 5 &&
604 uri[2] == "frames" &&
605 (uri[4] == "preview" ||
606 uri[4] == "image-uint8" ||
607 uri[4] == "image-uint16"))))
608 {
609 std::string uuid;
610 existingResource = index_.GetDicomFile(uuid, uri[1]);
611
612 std::string action = uri[2];
613
614 unsigned int frame = 0;
615 if (existingResource &&
616 uri.size() == 5)
617 {
618 // Access to multi-frame image
619 action = uri[4];
620 try
621 {
622 frame = boost::lexical_cast<unsigned int>(uri[3]);
623 }
624 catch (boost::bad_lexical_cast)
625 {
626 existingResource = false;
627 }
628 }
629
630 if (existingResource)
631 {
632 std::string dicomContent, png;
633 storage_.ReadFile(dicomContent, uuid);
634 try
635 {
636 if (action == "preview")
637 {
638 FromDcmtkBridge::ExtractPngImage(png, dicomContent, frame, ImageExtractionMode_Preview);
639 }
640 else if (action == "image-uint8")
641 {
642 FromDcmtkBridge::ExtractPngImage(png, dicomContent, frame, ImageExtractionMode_UInt8);
643 }
644 else if (action == "image-uint16")
645 {
646 FromDcmtkBridge::ExtractPngImage(png, dicomContent, frame, ImageExtractionMode_UInt16);
647 }
648 else
649 {
650 throw PalanthirException(ErrorCode_InternalError);
651 }
652
653 output.AnswerBufferWithContentType(png, "image/png");
654 return;
655 }
656 catch (PalanthirException&)
657 {
658 output.Redirect("/app/images/Unsupported.png");
659 return;
660 }
661 }
662 }
663
664
665
666 // Changes API --------------------------------------------------------------
667
668 if (uri.size() == 1 && uri[0] == "changes")
669 {
670 if (method == "GET")
671 {
672 const static unsigned int MAX_RESULTS = 100;
673
674 std::string filter = GetArgument(arguments, "filter", "");
675 int64_t since;
676 unsigned int limit;
677 try
678 {
679 since = boost::lexical_cast<int64_t>(GetArgument(arguments, "since", "0"));
680 limit = boost::lexical_cast<unsigned int>(GetArgument(arguments, "limit", "0"));
681 }
682 catch (boost::bad_lexical_cast)
683 {
684 output.SendHeader(Palanthir_HttpStatus_400_BadRequest);
685 return;
686 }
687
688 if (limit == 0 || limit > MAX_RESULTS)
689 {
690 limit = MAX_RESULTS;
691 }
692
693 if (!index_.GetChanges(result, since, filter, limit))
694 {
695 output.SendHeader(Palanthir_HttpStatus_400_BadRequest);
696 return;
697 }
698
699 existingResource = true;
700 }
701 else
702 {
703 output.SendMethodNotAllowedError("GET");
704 return;
705 }
706 }
707
708
709 // DICOM bridge -------------------------------------------------------------
710
711 if (uri.size() == 1 &&
712 uri[0] == "modalities")
713 {
714 if (method == "GET")
715 {
716 result = Json::Value(Json::arrayValue);
717 existingResource = true;
718
719 for (Modalities::const_iterator it = modalities_.begin();
720 it != modalities_.end(); it++)
721 {
722 result.append(*it);
723 }
724 }
725 else
726 {
727 output.SendMethodNotAllowedError("GET");
728 return;
729 }
730 }
731
732 if ((uri.size() == 2 ||
733 uri.size() == 3) &&
734 uri[0] == "modalities")
735 {
736 if (modalities_.find(uri[1]) == modalities_.end())
737 {
738 // Unknown modality
739 }
740 else if (uri.size() == 2)
741 {
742 if (method != "GET")
743 {
744 output.SendMethodNotAllowedError("POST");
745 return;
746 }
747 else
748 {
749 existingResource = true;
750 result = Json::arrayValue;
751 result.append("find-patient");
752 result.append("find-study");
753 result.append("find-series");
754 result.append("find");
755 result.append("store");
756 }
757 }
758 else if (uri.size() == 3)
759 {
760 if (uri[2] != "find-patient" &&
761 uri[2] != "find-study" &&
762 uri[2] != "find-series" &&
763 uri[2] != "find" &&
764 uri[2] != "store")
765 {
766 // Unknown request
767 }
768 else if (method != "POST")
769 {
770 output.SendMethodNotAllowedError("POST");
771 return;
772 }
773 else
774 {
775 DicomUserConnection connection;
776 ConnectToModality(connection, uri[1]);
777 existingResource = true;
778
779 if ((uri[2] == "find-patient" && !DicomFindPatient(result, connection, postData)) ||
780 (uri[2] == "find-study" && !DicomFindStudy(result, connection, postData)) ||
781 (uri[2] == "find-series" && !DicomFindSeries(result, connection, postData)) ||
782 (uri[2] == "find" && !DicomFind(result, connection, postData)) ||
783 (uri[2] == "store" && !DicomStore(result, connection, postData)))
784 {
785 output.SendHeader(Palanthir_HttpStatus_400_BadRequest);
786 return;
787 }
788 }
789 }
790 }
791
792
793 if (existingResource)
794 {
795 SendJson(output, result);
796 }
797 else
798 {
799 output.SendHeader(Palanthir_HttpStatus_404_NotFound);
800 }
801 }
802 }