Mercurial > hg > orthanc-stone
comparison Framework/Widgets/SliceViewerWidget.cpp @ 394:17d54c028805
rename ILayerRenderer::GetLayerSlice() to GetLayerPlane()
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Sat, 10 Nov 2018 08:44:18 +0100 |
parents | 20f149669c1f |
children | ed7146fa2c98 |
comparison
equal
deleted
inserted
replaced
393:e7a494bdd956 | 394:17d54c028805 |
---|---|
35 namespace OrthancStone | 35 namespace OrthancStone |
36 { | 36 { |
37 class SliceViewerWidget::Scene : public boost::noncopyable | 37 class SliceViewerWidget::Scene : public boost::noncopyable |
38 { | 38 { |
39 private: | 39 private: |
40 CoordinateSystem3D slice_; | 40 CoordinateSystem3D plane_; |
41 double thickness_; | 41 double thickness_; |
42 size_t countMissing_; | 42 size_t countMissing_; |
43 std::vector<ILayerRenderer*> renderers_; | 43 std::vector<ILayerRenderer*> renderers_; |
44 | 44 |
45 public: | 45 public: |
59 renderers_[index] = NULL; | 59 renderers_[index] = NULL; |
60 countMissing_++; | 60 countMissing_++; |
61 } | 61 } |
62 } | 62 } |
63 | 63 |
64 Scene(const CoordinateSystem3D& slice, | 64 Scene(const CoordinateSystem3D& plane, |
65 double thickness, | 65 double thickness, |
66 size_t countLayers) : | 66 size_t countLayers) : |
67 slice_(slice), | 67 plane_(plane), |
68 thickness_(thickness), | 68 thickness_(thickness), |
69 countMissing_(countLayers), | 69 countMissing_(countLayers), |
70 renderers_(countLayers, NULL) | 70 renderers_(countLayers, NULL) |
71 { | 71 { |
72 if (thickness <= 0) | 72 if (thickness <= 0) |
95 | 95 |
96 renderers_[index] = renderer; | 96 renderers_[index] = renderer; |
97 countMissing_--; | 97 countMissing_--; |
98 } | 98 } |
99 | 99 |
100 const CoordinateSystem3D& GetSlice() const | 100 const CoordinateSystem3D& GetPlane() const |
101 { | 101 { |
102 return slice_; | 102 return plane_; |
103 } | 103 } |
104 | 104 |
105 bool HasRenderer(size_t index) | 105 bool HasRenderer(size_t index) |
106 { | 106 { |
107 return renderers_[index] != NULL; | 107 return renderers_[index] != NULL; |
117 return countMissing_; | 117 return countMissing_; |
118 } | 118 } |
119 | 119 |
120 bool RenderScene(CairoContext& context, | 120 bool RenderScene(CairoContext& context, |
121 const ViewportGeometry& view, | 121 const ViewportGeometry& view, |
122 const CoordinateSystem3D& viewportSlice) | 122 const CoordinateSystem3D& viewportPlane) |
123 { | 123 { |
124 bool fullQuality = true; | 124 bool fullQuality = true; |
125 cairo_t *cr = context.GetObject(); | 125 cairo_t *cr = context.GetObject(); |
126 | 126 |
127 for (size_t i = 0; i < renderers_.size(); i++) | 127 for (size_t i = 0; i < renderers_.size(); i++) |
128 { | 128 { |
129 if (renderers_[i] != NULL) | 129 if (renderers_[i] != NULL) |
130 { | 130 { |
131 const CoordinateSystem3D& frameSlice = renderers_[i]->GetLayerSlice(); | 131 const CoordinateSystem3D& framePlane = renderers_[i]->GetLayerPlane(); |
132 | 132 |
133 double x0, y0, x1, y1, x2, y2; | 133 double x0, y0, x1, y1, x2, y2; |
134 viewportSlice.ProjectPoint(x0, y0, frameSlice.GetOrigin()); | 134 viewportPlane.ProjectPoint(x0, y0, framePlane.GetOrigin()); |
135 viewportSlice.ProjectPoint(x1, y1, frameSlice.GetOrigin() + frameSlice.GetAxisX()); | 135 viewportPlane.ProjectPoint(x1, y1, framePlane.GetOrigin() + framePlane.GetAxisX()); |
136 viewportSlice.ProjectPoint(x2, y2, frameSlice.GetOrigin() + frameSlice.GetAxisY()); | 136 viewportPlane.ProjectPoint(x2, y2, framePlane.GetOrigin() + framePlane.GetAxisY()); |
137 | 137 |
138 /** | 138 /** |
139 * Now we solve the system of linear equations Ax + b = x', given: | 139 * Now we solve the system of linear equations Ax + b = x', given: |
140 * A [0 ; 0] + b = [x0 ; y0] | 140 * A [0 ; 0] + b = [x0 ; y0] |
141 * A [1 ; 0] + b = [x1 ; y1] | 141 * A [1 ; 0] + b = [x1 ; y1] |
204 { | 204 { |
205 renderers_[index]->SetLayerStyle(style); | 205 renderers_[index]->SetLayerStyle(style); |
206 } | 206 } |
207 } | 207 } |
208 | 208 |
209 bool ContainsPlane(const CoordinateSystem3D& slice) const | 209 bool ContainsPlane(const CoordinateSystem3D& plane) const |
210 { | 210 { |
211 bool isOpposite; | 211 bool isOpposite; |
212 if (!GeometryToolbox::IsParallelOrOpposite(isOpposite, | 212 if (!GeometryToolbox::IsParallelOrOpposite(isOpposite, |
213 slice.GetNormal(), | 213 plane.GetNormal(), |
214 slice_.GetNormal())) | 214 plane_.GetNormal())) |
215 { | 215 { |
216 return false; | 216 return false; |
217 } | 217 } |
218 else | 218 else |
219 { | 219 { |
220 double z = (slice_.ProjectAlongNormal(slice.GetOrigin()) - | 220 double z = (plane_.ProjectAlongNormal(plane.GetOrigin()) - |
221 slice_.ProjectAlongNormal(slice_.GetOrigin())); | 221 plane_.ProjectAlongNormal(plane_.GetOrigin())); |
222 | 222 |
223 if (z < 0) | 223 if (z < 0) |
224 { | 224 { |
225 z = -z; | 225 z = -z; |
226 } | 226 } |
259 ILayerSource& source) const | 259 ILayerSource& source) const |
260 { | 260 { |
261 extent.Reset(); | 261 extent.Reset(); |
262 | 262 |
263 std::vector<Vector> points; | 263 std::vector<Vector> points; |
264 if (source.GetExtent(points, slice_)) | 264 if (source.GetExtent(points, plane_)) |
265 { | 265 { |
266 for (size_t i = 0; i < points.size(); i++) | 266 for (size_t i = 0; i < points.size(); i++) |
267 { | 267 { |
268 double x, y; | 268 double x, y; |
269 slice_.ProjectPoint(x, y, points[i]); | 269 plane_.ProjectPoint(x, y, points[i]); |
270 extent.AddPoint(x, y); | 270 extent.AddPoint(x, y); |
271 } | 271 } |
272 } | 272 } |
273 } | 273 } |
274 | 274 |
293 bool SliceViewerWidget::RenderScene(CairoContext& context, | 293 bool SliceViewerWidget::RenderScene(CairoContext& context, |
294 const ViewportGeometry& view) | 294 const ViewportGeometry& view) |
295 { | 295 { |
296 if (currentScene_.get() != NULL) | 296 if (currentScene_.get() != NULL) |
297 { | 297 { |
298 return currentScene_->RenderScene(context, view, slice_); | 298 return currentScene_->RenderScene(context, view, plane_); |
299 } | 299 } |
300 else | 300 else |
301 { | 301 { |
302 return true; | 302 return true; |
303 } | 303 } |
314 else | 314 else |
315 { | 315 { |
316 thickness = pendingScene_->GetThickness(); | 316 thickness = pendingScene_->GetThickness(); |
317 } | 317 } |
318 | 318 |
319 pendingScene_.reset(new Scene(slice_, thickness, layers_.size())); | 319 pendingScene_.reset(new Scene(plane_, thickness, layers_.size())); |
320 } | 320 } |
321 | 321 |
322 | 322 |
323 void SliceViewerWidget::UpdateLayer(size_t index, | 323 void SliceViewerWidget::UpdateLayer(size_t index, |
324 ILayerRenderer* renderer, | 324 ILayerRenderer* renderer, |
325 const CoordinateSystem3D& slice) | 325 const CoordinateSystem3D& plane) |
326 { | 326 { |
327 LOG(INFO) << "Updating layer " << index; | 327 LOG(INFO) << "Updating layer " << index; |
328 | 328 |
329 std::auto_ptr<ILayerRenderer> tmp(renderer); | 329 std::auto_ptr<ILayerRenderer> tmp(renderer); |
330 | 330 |
340 | 340 |
341 assert(layers_.size() == styles_.size()); | 341 assert(layers_.size() == styles_.size()); |
342 renderer->SetLayerStyle(styles_[index]); | 342 renderer->SetLayerStyle(styles_[index]); |
343 | 343 |
344 if (currentScene_.get() != NULL && | 344 if (currentScene_.get() != NULL && |
345 currentScene_->ContainsPlane(slice)) | 345 currentScene_->ContainsPlane(plane)) |
346 { | 346 { |
347 currentScene_->SetLayer(index, tmp.release()); | 347 currentScene_->SetLayer(index, tmp.release()); |
348 NotifyContentChanged(); | 348 NotifyContentChanged(); |
349 } | 349 } |
350 else if (pendingScene_.get() != NULL && | 350 else if (pendingScene_.get() != NULL && |
351 pendingScene_->ContainsPlane(slice)) | 351 pendingScene_->ContainsPlane(plane)) |
352 { | 352 { |
353 pendingScene_->SetLayer(index, tmp.release()); | 353 pendingScene_->SetLayer(index, tmp.release()); |
354 | 354 |
355 if (currentScene_.get() == NULL || | 355 if (currentScene_.get() == NULL || |
356 !currentScene_->IsComplete() || | 356 !currentScene_->IsComplete() || |
501 | 501 |
502 NotifyContentChanged(); | 502 NotifyContentChanged(); |
503 } | 503 } |
504 | 504 |
505 | 505 |
506 void SliceViewerWidget::SetSlice(const CoordinateSystem3D& slice) | 506 void SliceViewerWidget::SetSlice(const CoordinateSystem3D& plane) |
507 { | 507 { |
508 LOG(INFO) << "Setting slice origin: (" << slice.GetOrigin()[0] | 508 LOG(INFO) << "Setting slice origin: (" << plane.GetOrigin()[0] |
509 << "," << slice.GetOrigin()[1] | 509 << "," << plane.GetOrigin()[1] |
510 << "," << slice.GetOrigin()[2] << ")"; | 510 << "," << plane.GetOrigin()[2] << ")"; |
511 | 511 |
512 Slice displayedSlice(slice_, THIN_SLICE_THICKNESS); | 512 Slice displayedSlice(plane_, THIN_SLICE_THICKNESS); |
513 | 513 |
514 //if (!displayedSlice.ContainsPlane(slice)) | 514 //if (!displayedSlice.ContainsPlane(slice)) |
515 { | 515 { |
516 if (currentScene_.get() == NULL || | 516 if (currentScene_.get() == NULL || |
517 (pendingScene_.get() != NULL && | 517 (pendingScene_.get() != NULL && |
518 pendingScene_->IsComplete())) | 518 pendingScene_->IsComplete())) |
519 { | 519 { |
520 currentScene_ = pendingScene_; | 520 currentScene_ = pendingScene_; |
521 } | 521 } |
522 | 522 |
523 slice_ = slice; | 523 plane_ = plane; |
524 ResetPendingScene(); | 524 ResetPendingScene(); |
525 | 525 |
526 InvalidateAllLayers(); // TODO Removing this line avoid loading twice the image in WASM | 526 InvalidateAllLayers(); // TODO Removing this line avoid loading twice the image in WASM |
527 } | 527 } |
528 } | 528 } |
534 if (LookupLayer(i, message.GetOrigin())) | 534 if (LookupLayer(i, message.GetOrigin())) |
535 { | 535 { |
536 LOG(INFO) << ": Geometry ready for layer " << i << " in " << GetName(); | 536 LOG(INFO) << ": Geometry ready for layer " << i << " in " << GetName(); |
537 | 537 |
538 changedLayers_[i] = true; | 538 changedLayers_[i] = true; |
539 //layers_[i]->ScheduleLayerCreation(slice_); | 539 //layers_[i]->ScheduleLayerCreation(plane_); |
540 } | 540 } |
541 EmitMessage(GeometryChangedMessage(*this)); | 541 EmitMessage(GeometryChangedMessage(*this)); |
542 } | 542 } |
543 | 543 |
544 | 544 |
547 for (size_t i = 0; i < layers_.size(); i++) | 547 for (size_t i = 0; i < layers_.size(); i++) |
548 { | 548 { |
549 assert(layers_[i] != NULL); | 549 assert(layers_[i] != NULL); |
550 changedLayers_[i] = true; | 550 changedLayers_[i] = true; |
551 | 551 |
552 //layers_[i]->ScheduleLayerCreation(slice_); | 552 //layers_[i]->ScheduleLayerCreation(plane_); |
553 } | 553 } |
554 } | 554 } |
555 | 555 |
556 | 556 |
557 void SliceViewerWidget::InvalidateLayer(size_t layer) | 557 void SliceViewerWidget::InvalidateLayer(size_t layer) |
562 } | 562 } |
563 | 563 |
564 assert(layers_[layer] != NULL); | 564 assert(layers_[layer] != NULL); |
565 changedLayers_[layer] = true; | 565 changedLayers_[layer] = true; |
566 | 566 |
567 //layers_[layer]->ScheduleLayerCreation(slice_); | 567 //layers_[layer]->ScheduleLayerCreation(plane_); |
568 } | 568 } |
569 | 569 |
570 | 570 |
571 void SliceViewerWidget::OnContentChanged(const ILayerSource::ContentChangedMessage& message) | 571 void SliceViewerWidget::OnContentChanged(const ILayerSource::ContentChangedMessage& message) |
572 { | 572 { |
580 } | 580 } |
581 | 581 |
582 | 582 |
583 void SliceViewerWidget::OnSliceChanged(const ILayerSource::SliceChangedMessage& message) | 583 void SliceViewerWidget::OnSliceChanged(const ILayerSource::SliceChangedMessage& message) |
584 { | 584 { |
585 if (message.GetSlice().ContainsPlane(slice_)) | 585 if (message.GetSlice().ContainsPlane(plane_)) |
586 { | 586 { |
587 size_t index; | 587 size_t index; |
588 if (LookupLayer(index, message.GetOrigin())) | 588 if (LookupLayer(index, message.GetOrigin())) |
589 { | 589 { |
590 InvalidateLayer(index); | 590 InvalidateLayer(index); |
640 | 640 |
641 for (size_t i = 0; i < changedLayers_.size(); i++) | 641 for (size_t i = 0; i < changedLayers_.size(); i++) |
642 { | 642 { |
643 if (changedLayers_[i]) | 643 if (changedLayers_[i]) |
644 { | 644 { |
645 layers_[i]->ScheduleLayerCreation(slice_); | 645 layers_[i]->ScheduleLayerCreation(plane_); |
646 } | 646 } |
647 } | 647 } |
648 | 648 |
649 ResetChangedLayers(); | 649 ResetChangedLayers(); |
650 } | 650 } |