Mercurial > hg > orthanc-stone

comparison Samples/Sdl/Loader.cpp @ 636:fb00a8be03e2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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