Mercurial > hg > orthanc-stone
comparison Samples/Sdl/Loader.cpp @ 636:fb00a8be03e2
starting DecodeOrthancImageCommand
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Thu, 09 May 2019 16:58:35 +0200 |
parents | ea8322566596 |
children | afc91cdc5128 |
comparison
equal
deleted
inserted
replaced
635:104c379f3f1b | 636:fb00a8be03e2 |
---|---|
28 #include "../../Framework/Volumes/ImageBuffer3D.h" | 28 #include "../../Framework/Volumes/ImageBuffer3D.h" |
29 | 29 |
30 // From Orthanc framework | 30 // From Orthanc framework |
31 #include <Core/DicomFormat/DicomArray.h> | 31 #include <Core/DicomFormat/DicomArray.h> |
32 #include <Core/DicomFormat/DicomImageInformation.h> | 32 #include <Core/DicomFormat/DicomImageInformation.h> |
33 #include <Core/Compression/ZlibCompressor.h> | |
34 #include <Core/Compression/GzipCompressor.h> | |
33 #include <Core/HttpClient.h> | 35 #include <Core/HttpClient.h> |
34 #include <Core/IDynamicObject.h> | 36 #include <Core/IDynamicObject.h> |
35 #include <Core/Images/Image.h> | 37 #include <Core/Images/Image.h> |
36 #include <Core/Images/ImageProcessing.h> | 38 #include <Core/Images/ImageProcessing.h> |
37 #include <Core/Images/PngWriter.h> | 39 #include <Core/Images/PngWriter.h> |
54 class IOracleCommand : public boost::noncopyable | 56 class IOracleCommand : public boost::noncopyable |
55 { | 57 { |
56 public: | 58 public: |
57 enum Type | 59 enum Type |
58 { | 60 { |
59 Type_OrthancApi | 61 Type_OrthancRestApi, |
62 Type_DecodeOrthancImage | |
60 }; | 63 }; |
61 | 64 |
62 virtual ~IOracleCommand() | 65 virtual ~IOracleCommand() |
63 { | 66 { |
64 } | 67 } |
131 | 134 |
132 | 135 |
133 | 136 |
134 typedef std::map<std::string, std::string> HttpHeaders; | 137 typedef std::map<std::string, std::string> HttpHeaders; |
135 | 138 |
136 class OrthancApiOracleCommand : public OracleCommandWithPayload | 139 class OrthancRestApiCommand : public OracleCommandWithPayload |
137 { | 140 { |
138 public: | 141 public: |
139 class SuccessMessage : public OrthancStone::OriginMessage<OrthancStone::MessageType_HttpRequestSuccess, // TODO | 142 class SuccessMessage : public OrthancStone::OriginMessage<OrthancStone::MessageType_HttpRequestSuccess, // TODO |
140 OrthancApiOracleCommand> | 143 OrthancRestApiCommand> |
141 { | 144 { |
142 private: | 145 private: |
143 HttpHeaders headers_; | 146 HttpHeaders headers_; |
144 std::string answer_; | 147 std::string answer_; |
145 | 148 |
146 public: | 149 public: |
147 SuccessMessage(const OrthancApiOracleCommand& command, | 150 SuccessMessage(const OrthancRestApiCommand& command, |
148 const HttpHeaders& answerHeaders, | 151 const HttpHeaders& answerHeaders, |
149 std::string& answer /* will be swapped to avoid a memcpy() */) : | 152 std::string& answer /* will be swapped to avoid a memcpy() */) : |
150 OriginMessage(command), | 153 OriginMessage(command), |
151 headers_(answerHeaders), | 154 headers_(answerHeaders), |
152 answer_(answer) | 155 answer_(answer) |
173 } | 176 } |
174 }; | 177 }; |
175 | 178 |
176 | 179 |
177 class FailureMessage : public OrthancStone::OriginMessage<OrthancStone::MessageType_HttpRequestError, // TODO | 180 class FailureMessage : public OrthancStone::OriginMessage<OrthancStone::MessageType_HttpRequestError, // TODO |
178 OrthancApiOracleCommand> | 181 OrthancRestApiCommand> |
179 { | 182 { |
180 private: | 183 private: |
181 Orthanc::HttpStatus status_; | 184 Orthanc::HttpStatus status_; |
182 | 185 |
183 public: | 186 public: |
184 FailureMessage(const OrthancApiOracleCommand& command, | 187 FailureMessage(const OrthancRestApiCommand& command, |
185 Orthanc::HttpStatus status) : | 188 Orthanc::HttpStatus status) : |
186 OriginMessage(command), | 189 OriginMessage(command), |
187 status_(status) | 190 status_(status) |
188 { | 191 { |
189 } | 192 } |
204 | 207 |
205 std::auto_ptr< OrthancStone::MessageHandler<SuccessMessage> > successCallback_; | 208 std::auto_ptr< OrthancStone::MessageHandler<SuccessMessage> > successCallback_; |
206 std::auto_ptr< OrthancStone::MessageHandler<FailureMessage> > failureCallback_; | 209 std::auto_ptr< OrthancStone::MessageHandler<FailureMessage> > failureCallback_; |
207 | 210 |
208 public: | 211 public: |
209 OrthancApiOracleCommand() : | 212 OrthancRestApiCommand() : |
210 method_(Orthanc::HttpMethod_Get), | 213 method_(Orthanc::HttpMethod_Get), |
211 uri_("/"), | 214 uri_("/"), |
212 timeout_(10) | 215 timeout_(10) |
213 { | 216 { |
214 } | 217 } |
215 | 218 |
216 virtual Type GetType() const | 219 virtual Type GetType() const |
217 { | 220 { |
218 return Type_OrthancApi; | 221 return Type_OrthancRestApi; |
219 } | 222 } |
220 | 223 |
221 void SetMethod(Orthanc::HttpMethod method) | 224 void SetMethod(Orthanc::HttpMethod method) |
222 { | 225 { |
223 method_ = method; | 226 method_ = method; |
237 { | 240 { |
238 Json::FastWriter writer; | 241 Json::FastWriter writer; |
239 body_ = writer.write(json); | 242 body_ = writer.write(json); |
240 } | 243 } |
241 | 244 |
245 void SetHttpHeaders(const HttpHeaders& headers) | |
246 { | |
247 headers_ = headers; | |
248 } | |
249 | |
242 void SetHttpHeader(const std::string& key, | 250 void SetHttpHeader(const std::string& key, |
243 const std::string& value) | 251 const std::string& value) |
244 { | 252 { |
245 headers_[key] = value; | 253 headers_[key] = value; |
246 } | 254 } |
281 unsigned int GetTimeout() const | 289 unsigned int GetTimeout() const |
282 { | 290 { |
283 return timeout_; | 291 return timeout_; |
284 } | 292 } |
285 }; | 293 }; |
294 | |
295 | |
296 | |
297 | |
298 class DecodeOrthancImageCommand : public OracleCommandWithPayload | |
299 { | |
300 public: | |
301 class SuccessMessage : public OrthancStone::OriginMessage<OrthancStone::MessageType_ImageReady, // TODO | |
302 DecodeOrthancImageCommand> | |
303 { | |
304 private: | |
305 std::auto_ptr<Orthanc::ImageAccessor> image_; | |
306 Orthanc::MimeType mime_; | |
307 unsigned int quality_; | |
308 | |
309 public: | |
310 SuccessMessage(const DecodeOrthancImageCommand& command, | |
311 Orthanc::ImageAccessor* image, // Takes ownership | |
312 Orthanc::MimeType mime, | |
313 unsigned int quality) : | |
314 OriginMessage(command), | |
315 image_(image), | |
316 mime_(mime), | |
317 quality_(quality) | |
318 { | |
319 if (image == NULL) | |
320 { | |
321 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); | |
322 } | |
323 } | |
324 | |
325 const Orthanc::ImageAccessor& GetImage() const | |
326 { | |
327 return *image_; | |
328 } | |
329 | |
330 Orthanc::MimeType GetMimeType() const | |
331 { | |
332 return mime_; | |
333 } | |
334 | |
335 unsigned int GetQuality() const | |
336 { | |
337 return quality_; | |
338 } | |
339 }; | |
340 | |
341 | |
342 class FailureMessage : public OrthancStone::OriginMessage<OrthancStone::MessageType_HttpRequestError, // TODO | |
343 DecodeOrthancImageCommand> | |
344 { | |
345 private: | |
346 Orthanc::HttpStatus status_; | |
347 | |
348 public: | |
349 FailureMessage(const DecodeOrthancImageCommand& command, | |
350 Orthanc::HttpStatus status) : | |
351 OriginMessage(command), | |
352 status_(status) | |
353 { | |
354 } | |
355 | |
356 Orthanc::HttpStatus GetHttpStatus() const | |
357 { | |
358 return status_; | |
359 } | |
360 }; | |
361 | |
362 | |
363 private: | |
364 std::string uri_; | |
365 HttpHeaders headers_; | |
366 unsigned int timeout_; | |
367 | |
368 std::auto_ptr< OrthancStone::MessageHandler<SuccessMessage> > successCallback_; | |
369 std::auto_ptr< OrthancStone::MessageHandler<FailureMessage> > failureCallback_; | |
370 | |
371 public: | |
372 DecodeOrthancImageCommand() : | |
373 uri_("/"), | |
374 timeout_(10) | |
375 { | |
376 } | |
377 | |
378 virtual Type GetType() const | |
379 { | |
380 return Type_DecodeOrthancImage; | |
381 } | |
382 | |
383 void SetUri(const std::string& uri) | |
384 { | |
385 uri_ = uri; | |
386 } | |
387 | |
388 void SetHttpHeader(const std::string& key, | |
389 const std::string& value) | |
390 { | |
391 headers_[key] = value; | |
392 } | |
393 | |
394 const std::string& GetUri() const | |
395 { | |
396 return uri_; | |
397 } | |
398 | |
399 const HttpHeaders& GetHttpHeaders() const | |
400 { | |
401 return headers_; | |
402 } | |
403 | |
404 void SetTimeout(unsigned int seconds) | |
405 { | |
406 timeout_ = seconds; | |
407 } | |
408 | |
409 unsigned int GetTimeout() const | |
410 { | |
411 return timeout_; | |
412 } | |
413 }; | |
414 | |
415 | |
286 | 416 |
287 | 417 |
288 | 418 |
289 class NativeOracle : public IOracle | 419 class NativeOracle : public IOracle |
290 { | 420 { |
334 State state_; | 464 State state_; |
335 boost::mutex mutex_; | 465 boost::mutex mutex_; |
336 std::vector<boost::thread*> workers_; | 466 std::vector<boost::thread*> workers_; |
337 | 467 |
338 | 468 |
469 void CopyHttpHeaders(Orthanc::HttpClient& client, | |
470 const HttpHeaders& headers) | |
471 { | |
472 for (HttpHeaders::const_iterator it = headers.begin(); it != headers.end(); it++ ) | |
473 { | |
474 client.AddHeader(it->first, it->second); | |
475 } | |
476 } | |
477 | |
478 | |
339 void Execute(const OrthancStone::IObserver& receiver, | 479 void Execute(const OrthancStone::IObserver& receiver, |
340 const OrthancApiOracleCommand& command) | 480 const OrthancRestApiCommand& command) |
341 { | 481 { |
342 Orthanc::HttpClient client(orthanc_, command.GetUri()); | 482 Orthanc::HttpClient client(orthanc_, command.GetUri()); |
343 client.SetMethod(command.GetMethod()); | 483 client.SetMethod(command.GetMethod()); |
344 client.SetTimeout(command.GetTimeout()); | 484 client.SetTimeout(command.GetTimeout()); |
345 | 485 |
486 CopyHttpHeaders(client, command.GetHttpHeaders()); | |
487 | |
346 if (command.GetMethod() == Orthanc::HttpMethod_Post || | 488 if (command.GetMethod() == Orthanc::HttpMethod_Post || |
347 command.GetMethod() == Orthanc::HttpMethod_Put) | 489 command.GetMethod() == Orthanc::HttpMethod_Put) |
348 { | 490 { |
349 client.SetBody(command.GetBody()); | 491 client.SetBody(command.GetBody()); |
350 } | 492 } |
351 | |
352 { | |
353 const HttpHeaders& headers = command.GetHttpHeaders(); | |
354 for (HttpHeaders::const_iterator it = headers.begin(); it != headers.end(); it++ ) | |
355 { | |
356 client.AddHeader(it->first, it->second); | |
357 } | |
358 } | |
359 | 493 |
360 std::string answer; | 494 std::string answer; |
361 HttpHeaders answerHeaders; | 495 HttpHeaders answerHeaders; |
362 | 496 |
363 bool success; | 497 bool success; |
370 success = false; | 504 success = false; |
371 } | 505 } |
372 | 506 |
373 if (success) | 507 if (success) |
374 { | 508 { |
375 OrthancApiOracleCommand::SuccessMessage message(command, answerHeaders, answer); | 509 OrthancRestApiCommand::SuccessMessage message(command, answerHeaders, answer); |
376 emitter_.EmitMessage(receiver, message); | 510 emitter_.EmitMessage(receiver, message); |
377 } | 511 } |
378 else | 512 else |
379 { | 513 { |
380 OrthancApiOracleCommand::FailureMessage message(command, client.GetLastStatus()); | 514 OrthancRestApiCommand::FailureMessage message(command, client.GetLastStatus()); |
515 emitter_.EmitMessage(receiver, message); | |
516 } | |
517 } | |
518 | |
519 | |
520 void Execute(const OrthancStone::IObserver& receiver, | |
521 const DecodeOrthancImageCommand& command) | |
522 { | |
523 Orthanc::HttpClient client(orthanc_, command.GetUri()); | |
524 client.SetTimeout(command.GetTimeout()); | |
525 | |
526 CopyHttpHeaders(client, command.GetHttpHeaders()); | |
527 | |
528 std::string answer; | |
529 HttpHeaders answerHeaders; | |
530 | |
531 bool success; | |
532 try | |
533 { | |
534 success = client.Apply(answer, answerHeaders); | |
535 } | |
536 catch (Orthanc::OrthancException& e) | |
537 { | |
538 success = false; | |
539 } | |
540 | |
541 if (success) | |
542 { | |
543 printf("OK %d\n", answer.size()); | |
544 | |
545 Orthanc::MimeType contentType = Orthanc::MimeType_Binary; | |
546 Orthanc::HttpCompression contentEncoding = Orthanc::HttpCompression_None; | |
547 | |
548 for (HttpHeaders::const_iterator it = answerHeaders.begin(); | |
549 it != answerHeaders.end(); ++it) | |
550 { | |
551 std::string s; | |
552 Orthanc::Toolbox::ToLowerCase(s, it->first); | |
553 | |
554 if (s == "content-encoding") | |
555 { | |
556 if (it->second == "gzip") | |
557 { | |
558 contentEncoding = Orthanc::HttpCompression_Gzip; | |
559 } | |
560 else | |
561 { | |
562 throw Orthanc::OrthancException(Orthanc::ErrorCode_NetworkProtocol, | |
563 "Unsupported HTTP Content-Encoding: " + it->second); | |
564 } | |
565 } | |
566 | |
567 if (s == "content-type") | |
568 { | |
569 contentType = Orthanc::StringToMimeType(it->second); | |
570 } | |
571 | |
572 printf(" [%s] == [%s]\n", it->first.c_str(), it->second.c_str()); | |
573 } | |
574 | |
575 if (contentEncoding == Orthanc::HttpCompression_Gzip) | |
576 { | |
577 std::string compressed; | |
578 answer.swap(compressed); | |
579 | |
580 Orthanc::GzipCompressor compressor; | |
581 compressor.Uncompress(answer, compressed.c_str(), compressed.size()); | |
582 } | |
583 | |
584 printf("[%s] %d => %d\n", Orthanc::EnumerationToString(contentType), contentEncoding, answer.size()); | |
585 | |
586 | |
587 | |
588 //DecodeOrthancImageCommand::SuccessMessage message(command, answerHeaders, answer); | |
589 //emitter_.EmitMessage(receiver, message); | |
590 } | |
591 else | |
592 { | |
593 DecodeOrthancImageCommand::FailureMessage message(command, client.GetLastStatus()); | |
381 emitter_.EmitMessage(receiver, message); | 594 emitter_.EmitMessage(receiver, message); |
382 } | 595 } |
383 } | 596 } |
384 | 597 |
385 | 598 |
394 | 607 |
395 try | 608 try |
396 { | 609 { |
397 switch (item.GetCommand().GetType()) | 610 switch (item.GetCommand().GetType()) |
398 { | 611 { |
399 case IOracleCommand::Type_OrthancApi: | 612 case IOracleCommand::Type_OrthancRestApi: |
400 Execute(item.GetReceiver(), | 613 Execute(item.GetReceiver(), |
401 dynamic_cast<const OrthancApiOracleCommand&>(item.GetCommand())); | 614 dynamic_cast<const OrthancRestApiCommand&>(item.GetCommand())); |
615 break; | |
616 | |
617 case IOracleCommand::Type_DecodeOrthancImage: | |
618 Execute(item.GetReceiver(), | |
619 dynamic_cast<const DecodeOrthancImageCommand&>(item.GetCommand())); | |
402 break; | 620 break; |
403 | 621 |
404 default: | 622 default: |
405 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | 623 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); |
406 } | 624 } |
800 return geometry_; | 1018 return geometry_; |
801 } | 1019 } |
802 | 1020 |
803 OrthancStone::CoordinateSystem3D GetFrameGeometry(unsigned int frame) const | 1021 OrthancStone::CoordinateSystem3D GetFrameGeometry(unsigned int frame) const |
804 { | 1022 { |
805 if (frame >= imageInformation_.GetNumberOfFrames()) | 1023 if (frame == 0) |
1024 { | |
1025 return geometry_; | |
1026 } | |
1027 else if (frame >= imageInformation_.GetNumberOfFrames()) | |
806 { | 1028 { |
807 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | 1029 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); |
808 } | 1030 } |
809 | 1031 else if (sopClassUid_ == OrthancStone::SopClassUid_RTDose) |
810 if (sopClassUid_ == OrthancStone::SopClassUid_RTDose) | |
811 { | 1032 { |
812 if (frame >= frameOffsets_.size()) | 1033 if (frame >= frameOffsets_.size()) |
813 { | 1034 { |
814 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); | 1035 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); |
815 } | 1036 } |
816 | 1037 |
817 return OrthancStone::CoordinateSystem3D( | 1038 return OrthancStone::CoordinateSystem3D( |
818 geometry_.GetOrigin() + frameOffsets_[frame] * geometry_.GetNormal(), | 1039 geometry_.GetOrigin() + frameOffsets_[frame] * geometry_.GetNormal(), |
819 geometry_.GetAxisX(), | 1040 geometry_.GetAxisX(), |
820 geometry_.GetAxisY()); | 1041 geometry_.GetAxisY()); |
1042 } | |
1043 else | |
1044 { | |
1045 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
821 } | 1046 } |
822 } | 1047 } |
823 | 1048 |
824 bool FrameContainsPlane(unsigned int frame, | 1049 bool FrameContainsPlane(unsigned int frame, |
825 const OrthancStone::CoordinateSystem3D& plane) const | 1050 const OrthancStone::CoordinateSystem3D& plane) const |
919 { | 1144 { |
920 private: | 1145 private: |
921 class MessageHandler : public Orthanc::IDynamicObject | 1146 class MessageHandler : public Orthanc::IDynamicObject |
922 { | 1147 { |
923 public: | 1148 public: |
924 virtual void Handle(const OrthancApiOracleCommand::SuccessMessage& message) const = 0; | 1149 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const = 0; |
925 }; | 1150 }; |
926 | 1151 |
927 void Handle(const OrthancApiOracleCommand::SuccessMessage& message) | 1152 void Handle(const OrthancRestApiCommand::SuccessMessage& message) |
928 { | 1153 { |
929 dynamic_cast<const MessageHandler&>(message.GetOrigin().GetPayload()).Handle(message); | 1154 dynamic_cast<const MessageHandler&>(message.GetOrigin().GetPayload()).Handle(message); |
930 } | 1155 } |
931 | 1156 |
932 | 1157 |
939 LoadSeriesGeometryHandler(AxialVolumeOrthancLoader& that) : | 1164 LoadSeriesGeometryHandler(AxialVolumeOrthancLoader& that) : |
940 that_(that) | 1165 that_(that) |
941 { | 1166 { |
942 } | 1167 } |
943 | 1168 |
944 virtual void Handle(const OrthancApiOracleCommand::SuccessMessage& message) const | 1169 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const |
945 { | 1170 { |
946 Json::Value value; | 1171 Json::Value value; |
947 message.ParseJsonBody(value); | 1172 message.ParseJsonBody(value); |
948 | 1173 |
949 if (value.type() != Json::objectValue) | 1174 if (value.type() != Json::objectValue) |
973 LoadInstanceGeometryHandler(AxialVolumeOrthancLoader& that) : | 1198 LoadInstanceGeometryHandler(AxialVolumeOrthancLoader& that) : |
974 that_(that) | 1199 that_(that) |
975 { | 1200 { |
976 } | 1201 } |
977 | 1202 |
978 virtual void Handle(const OrthancApiOracleCommand::SuccessMessage& message) const | 1203 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const |
979 { | 1204 { |
980 Json::Value value; | 1205 Json::Value value; |
981 message.ParseJsonBody(value); | 1206 message.ParseJsonBody(value); |
982 | 1207 |
983 if (value.type() != Json::objectValue) | 1208 if (value.type() != Json::objectValue) |
1001 AxialVolumeOrthancLoader(OrthancStone::IObservable& oracle) : | 1226 AxialVolumeOrthancLoader(OrthancStone::IObservable& oracle) : |
1002 IObserver(oracle.GetBroker()), | 1227 IObserver(oracle.GetBroker()), |
1003 active_(false) | 1228 active_(false) |
1004 { | 1229 { |
1005 oracle.RegisterObserverCallback( | 1230 oracle.RegisterObserverCallback( |
1006 new OrthancStone::Callable<AxialVolumeOrthancLoader, OrthancApiOracleCommand::SuccessMessage> | 1231 new OrthancStone::Callable<AxialVolumeOrthancLoader, OrthancRestApiCommand::SuccessMessage> |
1007 (*this, &AxialVolumeOrthancLoader::Handle)); | 1232 (*this, &AxialVolumeOrthancLoader::Handle)); |
1008 } | 1233 } |
1009 | 1234 |
1010 void LoadSeries(IOracle& oracle, | 1235 void LoadSeries(IOracle& oracle, |
1011 const std::string& seriesId) | 1236 const std::string& seriesId) |
1015 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | 1240 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); |
1016 } | 1241 } |
1017 | 1242 |
1018 active_ = true; | 1243 active_ = true; |
1019 | 1244 |
1020 std::auto_ptr<Refactoring::OrthancApiOracleCommand> command(new Refactoring::OrthancApiOracleCommand); | 1245 std::auto_ptr<Refactoring::OrthancRestApiCommand> command(new Refactoring::OrthancRestApiCommand); |
1021 command->SetUri("/series/" + seriesId + "/instances-tags"); | 1246 command->SetUri("/series/" + seriesId + "/instances-tags"); |
1022 command->SetPayload(new LoadSeriesGeometryHandler(*this)); | 1247 command->SetPayload(new LoadSeriesGeometryHandler(*this)); |
1023 | 1248 |
1024 oracle.Schedule(*this, command.release()); | 1249 oracle.Schedule(*this, command.release()); |
1025 } | 1250 } |
1037 // Tag "3004-000c" is "Grid Frame Offset Vector", which is | 1262 // Tag "3004-000c" is "Grid Frame Offset Vector", which is |
1038 // mandatory to read RT DOSE, but is too long to be returned by default | 1263 // mandatory to read RT DOSE, but is too long to be returned by default |
1039 | 1264 |
1040 // TODO => Should be part of a second call if needed | 1265 // TODO => Should be part of a second call if needed |
1041 | 1266 |
1042 std::auto_ptr<Refactoring::OrthancApiOracleCommand> command(new Refactoring::OrthancApiOracleCommand); | 1267 std::auto_ptr<Refactoring::OrthancRestApiCommand> command(new Refactoring::OrthancRestApiCommand); |
1043 command->SetUri("/instances/" + instanceId + "/tags?ignore-length=3004-000c"); | 1268 command->SetUri("/instances/" + instanceId + "/tags?ignore-length=3004-000c"); |
1044 command->SetPayload(new LoadInstanceGeometryHandler(*this)); | 1269 command->SetPayload(new LoadInstanceGeometryHandler(*this)); |
1045 | 1270 |
1046 oracle.Schedule(*this, command.release()); | 1271 oracle.Schedule(*this, command.release()); |
1047 } | 1272 } |
1052 | 1277 |
1053 | 1278 |
1054 class Toto : public OrthancStone::IObserver | 1279 class Toto : public OrthancStone::IObserver |
1055 { | 1280 { |
1056 private: | 1281 private: |
1057 void Handle(const Refactoring::OrthancApiOracleCommand::SuccessMessage& message) | 1282 void Handle(const Refactoring::OrthancRestApiCommand::SuccessMessage& message) |
1058 { | 1283 { |
1059 Json::Value v; | 1284 Json::Value v; |
1060 message.ParseJsonBody(v); | 1285 message.ParseJsonBody(v); |
1061 | 1286 |
1062 printf("ICI [%s]\n", v.toStyledString().c_str()); | 1287 printf("ICI [%s]\n", v.toStyledString().c_str()); |
1063 } | 1288 } |
1064 | 1289 |
1065 void Handle(const Refactoring::OrthancApiOracleCommand::FailureMessage& message) | 1290 void Handle(const Refactoring::OrthancRestApiCommand::FailureMessage& message) |
1066 { | 1291 { |
1067 printf("ERROR %d\n", message.GetHttpStatus()); | 1292 printf("ERROR %d\n", message.GetHttpStatus()); |
1068 } | 1293 } |
1069 | 1294 |
1070 public: | 1295 public: |
1071 Toto(OrthancStone::IObservable& oracle) : | 1296 Toto(OrthancStone::IObservable& oracle) : |
1072 IObserver(oracle.GetBroker()) | 1297 IObserver(oracle.GetBroker()) |
1073 { | 1298 { |
1074 oracle.RegisterObserverCallback | 1299 oracle.RegisterObserverCallback |
1075 (new OrthancStone::Callable | 1300 (new OrthancStone::Callable |
1076 <Toto, Refactoring::OrthancApiOracleCommand::SuccessMessage>(*this, &Toto::Handle)); | 1301 <Toto, Refactoring::OrthancRestApiCommand::SuccessMessage>(*this, &Toto::Handle)); |
1077 } | 1302 } |
1078 }; | 1303 }; |
1079 | 1304 |
1080 | 1305 |
1081 void Run(Refactoring::NativeApplicationContext& context) | 1306 void Run(Refactoring::NativeApplicationContext& context) |
1099 oracle.SetOrthancParameters(p); | 1324 oracle.SetOrthancParameters(p); |
1100 } | 1325 } |
1101 | 1326 |
1102 oracle.Start(); | 1327 oracle.Start(); |
1103 | 1328 |
1329 if (0) | |
1104 { | 1330 { |
1105 Json::Value v = Json::objectValue; | 1331 Json::Value v = Json::objectValue; |
1106 v["Level"] = "Series"; | 1332 v["Level"] = "Series"; |
1107 v["Query"] = Json::objectValue; | 1333 v["Query"] = Json::objectValue; |
1108 | 1334 |
1109 std::auto_ptr<Refactoring::OrthancApiOracleCommand> command(new Refactoring::OrthancApiOracleCommand); | 1335 std::auto_ptr<Refactoring::OrthancRestApiCommand> command(new Refactoring::OrthancRestApiCommand); |
1110 command->SetMethod(Orthanc::HttpMethod_Post); | 1336 command->SetMethod(Orthanc::HttpMethod_Post); |
1111 command->SetUri("/tools/find"); | 1337 command->SetUri("/tools/find"); |
1112 command->SetBody(v); | 1338 command->SetBody(v); |
1113 | 1339 |
1340 oracle.Schedule(*toto, command.release()); | |
1341 } | |
1342 | |
1343 if (0) | |
1344 { | |
1345 std::auto_ptr<Refactoring::DecodeOrthancImageCommand> command(new Refactoring::DecodeOrthancImageCommand); | |
1346 command->SetHttpHeader("Accept", std::string(Orthanc::EnumerationToString(Orthanc::MimeType_Jpeg))); | |
1347 command->SetUri("/instances/6687cc73-07cae193-52ff29c8-f646cb16-0753ed92/preview"); | |
1348 oracle.Schedule(*toto, command.release()); | |
1349 } | |
1350 | |
1351 if (0) | |
1352 { | |
1353 std::auto_ptr<Refactoring::DecodeOrthancImageCommand> command(new Refactoring::DecodeOrthancImageCommand); | |
1354 command->SetHttpHeader("Accept", std::string(Orthanc::EnumerationToString(Orthanc::MimeType_Png))); | |
1355 command->SetUri("/instances/6687cc73-07cae193-52ff29c8-f646cb16-0753ed92/preview"); | |
1356 oracle.Schedule(*toto, command.release()); | |
1357 } | |
1358 | |
1359 if (1) | |
1360 { | |
1361 std::auto_ptr<Refactoring::DecodeOrthancImageCommand> command(new Refactoring::DecodeOrthancImageCommand); | |
1362 command->SetHttpHeader("Accept", std::string(Orthanc::EnumerationToString(Orthanc::MimeType_Png))); | |
1363 command->SetUri("/instances/6687cc73-07cae193-52ff29c8-f646cb16-0753ed92/image-uint16"); | |
1364 oracle.Schedule(*toto, command.release()); | |
1365 } | |
1366 | |
1367 if (1) | |
1368 { | |
1369 std::auto_ptr<Refactoring::DecodeOrthancImageCommand> command(new Refactoring::DecodeOrthancImageCommand); | |
1370 command->SetHttpHeader("Accept-Encoding", "gzip"); | |
1371 command->SetHttpHeader("Accept", std::string(Orthanc::EnumerationToString(Orthanc::MimeType_Pam))); | |
1372 command->SetUri("/instances/6687cc73-07cae193-52ff29c8-f646cb16-0753ed92/image-uint16"); | |
1373 oracle.Schedule(*toto, command.release()); | |
1374 } | |
1375 | |
1376 if (1) | |
1377 { | |
1378 std::auto_ptr<Refactoring::DecodeOrthancImageCommand> command(new Refactoring::DecodeOrthancImageCommand); | |
1379 command->SetHttpHeader("Accept", std::string(Orthanc::EnumerationToString(Orthanc::MimeType_Pam))); | |
1380 command->SetUri("/instances/6687cc73-07cae193-52ff29c8-f646cb16-0753ed92/image-uint16"); | |
1114 oracle.Schedule(*toto, command.release()); | 1381 oracle.Schedule(*toto, command.release()); |
1115 } | 1382 } |
1116 | 1383 |
1117 // 2017-11-17-Anonymized | 1384 // 2017-11-17-Anonymized |
1118 loader1->LoadSeries(oracle, "cb3ea4d1-d08f3856-ad7b6314-74d88d77-60b05618"); // CT | 1385 loader1->LoadSeries(oracle, "cb3ea4d1-d08f3856-ad7b6314-74d88d77-60b05618"); // CT |