Mercurial > hg > orthanc-stone

comparison Framework/Widgets/SliceViewerWidget.cpp @ 394:17d54c028805

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