Mercurial > hg > orthanc-stone
comparison Framework/Toolbox/OrthancSlicesLoader.cpp @ 266:c9cf95b49a86 am-2
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 |