Mercurial > hg > orthanc-stone

comparison Framework/Toolbox/OrthancSlicesLoader.cpp @ 266:c9cf95b49a86 am-2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
removed OrthancSlicesLoader::ISliceLoaderObserver; now using standard messages instead
author am@osimis.io
date Tue, 21 Aug 2018 18:14:22 +0200
parents 9afafb192180
children 89d02de83c03
comparison
equal deleted inserted replaced
265:30dc6e383b0b 266:c9cf95b49a86
251 251
252 switch (operation->GetMode()) 252 switch (operation->GetMode())
253 { 253 {
254 case Mode_FrameGeometry: 254 case Mode_FrameGeometry:
255 case Mode_SeriesGeometry: 255 case Mode_SeriesGeometry:
256 that_.userCallback_.OnSliceGeometryError(that_); 256 that_.EmitMessage(IMessage(MessageType_SliceGeometryError));
257 that_.state_ = State_Error; 257 that_.state_ = State_Error;
258 break; 258 break;
259 259
260 case Mode_LoadImage: 260 case Mode_LoadImage:
261 that_.userCallback_.OnSliceImageError(that_, operation->GetSliceIndex(), 261 {
262 operation->GetSlice(), 262 OrthancSlicesLoader::SliceImageErrorMessage msg(operation->GetSliceIndex(),
263 operation->GetQuality()); 263 operation->GetSlice(),
264 break; 264 operation->GetQuality());
265 that_.EmitMessage(msg);
266 }; break;
265 267
266 default: 268 default:
267 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); 269 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
268 } 270 }
269 } 271 }
270 }; 272 };
271 273
272 void OrthancSlicesLoader::ISliceLoaderObserver::HandleMessage(IObservable& from, const IMessage& message) 274 void OrthancSlicesLoader::HandleMessage(const IObservable& from, const IMessage& message)
273 { 275 {
274 switch (message.GetType()) 276 // forward messages to its own observers
275 { 277 IObservable::broker_.EmitMessage(from, IObservable::observers_, message);
276 case MessageType_SliceGeometryReady:
277 OnSliceGeometryReady(dynamic_cast<OrthancSlicesLoader&>(from));
278 break;
279 case MessageType_SliceGeometryError:
280 OnSliceGeometryError(dynamic_cast<OrthancSlicesLoader&>(from));
281 break;
282 case MessageType_SliceImageReady:
283 {
284 const SliceImageReadyMessage& msg = dynamic_cast<const SliceImageReadyMessage&>(message);
285 OnSliceImageReady(dynamic_cast<OrthancSlicesLoader&>(from),
286 msg.sliceIndex_,
287 msg.slice_,
288 msg.image_,
289 msg.effectiveQuality_);
290 }; break;
291 case MessageType_SliceImageError:
292 {
293 const SliceImageErrorMessage& msg = dynamic_cast<const SliceImageErrorMessage&>(message);
294 OnSliceImageError(dynamic_cast<OrthancSlicesLoader&>(from),
295 msg.sliceIndex_,
296 msg.slice_,
297 msg.effectiveQuality_);
298 }; break;
299 default:
300 VLOG("unhandled message type" << message.GetType());
301 }
302 } 278 }
303 279
304 280
305 void OrthancSlicesLoader::NotifySliceImageSuccess(const Operation& operation, 281 void OrthancSlicesLoader::NotifySliceImageSuccess(const Operation& operation,
306 std::auto_ptr<Orthanc::ImageAccessor>& image) const 282 std::auto_ptr<Orthanc::ImageAccessor>& image) const
309 { 285 {
310 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); 286 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
311 } 287 }
312 else 288 else
313 { 289 {
314 userCallback_.OnSliceImageReady 290 OrthancSlicesLoader::SliceImageReadyMessage msg(operation.GetSliceIndex(), operation.GetSlice(), image, operation.GetQuality());
315 (*this, operation.GetSliceIndex(), operation.GetSlice(), image, operation.GetQuality()); 291 EmitMessage(msg);
316 } 292 }
317 } 293 }
318 294
319 295
320 void OrthancSlicesLoader::NotifySliceImageError(const Operation& operation) const 296 void OrthancSlicesLoader::NotifySliceImageError(const Operation& operation) const
321 { 297 {
322 userCallback_.OnSliceImageError 298 OrthancSlicesLoader::SliceImageErrorMessage msg(operation.GetSliceIndex(), operation.GetSlice(), operation.GetQuality());
323 (*this, operation.GetSliceIndex(), operation.GetSlice(), operation.GetQuality()); 299 EmitMessage(msg);
324 } 300 }
325 301
326 302
327 void OrthancSlicesLoader::SortAndFinalizeSlices() 303 void OrthancSlicesLoader::SortAndFinalizeSlices()
328 { 304 {
343 state_ = State_GeometryReady; 319 state_ = State_GeometryReady;
344 320
345 if (ok) 321 if (ok)
346 { 322 {
347 LOG(INFO) << "Loaded a series with " << slices_.GetSliceCount() << " slice(s)"; 323 LOG(INFO) << "Loaded a series with " << slices_.GetSliceCount() << " slice(s)";
348 userCallback_.OnSliceGeometryReady(*this); 324 EmitMessage(IMessage(MessageType_SliceGeometryReady));
349 } 325 }
350 else 326 else
351 { 327 {
352 LOG(ERROR) << "This series is empty"; 328 LOG(ERROR) << "This series is empty";
353 userCallback_.OnSliceGeometryError(*this); 329 EmitMessage(IMessage(MessageType_SliceGeometryError));
354 } 330 }
355 } 331 }
356 332
357 333
358 void OrthancSlicesLoader::ParseSeriesGeometry(const void* answer, 334 void OrthancSlicesLoader::ParseSeriesGeometry(const void* answer,
360 { 336 {
361 Json::Value series; 337 Json::Value series;
362 if (!MessagingToolbox::ParseJson(series, answer, size) || 338 if (!MessagingToolbox::ParseJson(series, answer, size) ||
363 series.type() != Json::objectValue) 339 series.type() != Json::objectValue)
364 { 340 {
365 userCallback_.OnSliceGeometryError(*this); 341 EmitMessage(IMessage(MessageType_SliceGeometryError));
366 return; 342 return;
367 } 343 }
368 344
369 Json::Value::Members instances = series.getMemberNames(); 345 Json::Value::Members instances = series.getMemberNames();
370 346
407 { 383 {
408 Json::Value tags; 384 Json::Value tags;
409 if (!MessagingToolbox::ParseJson(tags, answer, size) || 385 if (!MessagingToolbox::ParseJson(tags, answer, size) ||
410 tags.type() != Json::objectValue) 386 tags.type() != Json::objectValue)
411 { 387 {
412 userCallback_.OnSliceGeometryError(*this); 388 EmitMessage(IMessage(MessageType_SliceGeometryError));
413 return; 389 return;
414 } 390 }
415 391
416 OrthancPlugins::FullOrthancDataset dataset(tags); 392 OrthancPlugins::FullOrthancDataset dataset(tags);
417 393
434 slices_.AddSlice(slice.release()); 410 slices_.AddSlice(slice.release());
435 } 411 }
436 else 412 else
437 { 413 {
438 LOG(WARNING) << "Skipping invalid multi-frame instance " << instanceId; 414 LOG(WARNING) << "Skipping invalid multi-frame instance " << instanceId;
439 userCallback_.OnSliceGeometryError(*this); 415 EmitMessage(IMessage(MessageType_SliceGeometryError));
440 return; 416 return;
441 } 417 }
442 } 418 }
443 419
444 SortAndFinalizeSlices(); 420 SortAndFinalizeSlices();
452 { 428 {
453 Json::Value tags; 429 Json::Value tags;
454 if (!MessagingToolbox::ParseJson(tags, answer, size) || 430 if (!MessagingToolbox::ParseJson(tags, answer, size) ||
455 tags.type() != Json::objectValue) 431 tags.type() != Json::objectValue)
456 { 432 {
457 userCallback_.OnSliceGeometryError(*this); 433 EmitMessage(IMessage(MessageType_SliceGeometryError));
458 return; 434 return;
459 } 435 }
460 436
461 OrthancPlugins::FullOrthancDataset dataset(tags); 437 OrthancPlugins::FullOrthancDataset dataset(tags);
462 438
466 MessagingToolbox::ConvertDataset(dicom, dataset); 442 MessagingToolbox::ConvertDataset(dicom, dataset);
467 443
468 std::auto_ptr<Slice> slice(new Slice); 444 std::auto_ptr<Slice> slice(new Slice);
469 if (slice->ParseOrthancFrame(dicom, instanceId, frame)) 445 if (slice->ParseOrthancFrame(dicom, instanceId, frame))
470 { 446 {
471 LOG(INFO) << "Loaded instance " << instanceId; 447 LOG(INFO) << "Loaded instance geometry " << instanceId;
472 slices_.AddSlice(slice.release()); 448 slices_.AddSlice(slice.release());
473 userCallback_.OnSliceGeometryReady(*this); 449 EmitMessage(IMessage(MessageType_SliceGeometryReady));
474 } 450 }
475 else 451 else
476 { 452 {
477 LOG(WARNING) << "Skipping invalid instance " << instanceId; 453 LOG(WARNING) << "Skipping invalid instance " << instanceId;
478 userCallback_.OnSliceGeometryError(*this); 454 EmitMessage(IMessage(MessageType_SliceGeometryError));
479 } 455 }
480 } 456 }
481 457
482 458
483 void OrthancSlicesLoader::ParseSliceImagePng(const Operation& operation, 459 void OrthancSlicesLoader::ParseSliceImagePng(const Operation& operation,
798 774
799 } 775 }
800 776
801 777
802 OrthancSlicesLoader::OrthancSlicesLoader(MessageBroker& broker, 778 OrthancSlicesLoader::OrthancSlicesLoader(MessageBroker& broker,
803 ISliceLoaderObserver& callback, 779 //ISliceLoaderObserver& callback,
804 IWebService& orthanc) : 780 IWebService& orthanc) :
781 IObservable(broker),
805 webCallback_(new WebCallback(broker, *this)), 782 webCallback_(new WebCallback(broker, *this)),
806 userCallback_(callback), 783 //userCallback_(callback),
807 orthanc_(orthanc), 784 orthanc_(orthanc),
808 state_(State_Initialization) 785 state_(State_Initialization)
809 { 786 {
810 } 787 }
811 788