Mercurial > hg > orthanc-stone
annotate Framework/Widgets/LayerWidget.cpp @ 79:4e21f6b3aa0d wasm
cleaning up
| author | Sebastien Jodogne <s.jodogne@gmail.com> |
|---|---|
| date | Wed, 24 May 2017 21:23:29 +0200 |
| parents | 93b917b02fee |
| children | c75377306598 |
| rev | line source |
|---|---|
| 66 | 1 /** |
| 2 * Stone of Orthanc | |
| 3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics | |
| 4 * Department, University Hospital of Liege, Belgium | |
| 5 * Copyright (C) 2017 Osimis, Belgium | |
| 6 * | |
| 7 * This program is free software: you can redistribute it and/or | |
| 8 * modify it under the terms of the GNU Affero General Public License | |
| 9 * as published by the Free Software Foundation, either version 3 of | |
| 10 * the License, or (at your option) any later version. | |
| 11 * | |
| 12 * This program is distributed in the hope that it will be useful, but | |
| 13 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 15 * Affero General Public License for more details. | |
| 16 * | |
| 17 * You should have received a copy of the GNU Affero General Public License | |
| 18 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| 19 **/ | |
| 20 | |
| 21 | |
| 22 #include "LayerWidget.h" | |
| 23 | |
| 24 #include "../../Resources/Orthanc/Core/Logging.h" | |
| 25 | |
| 26 namespace OrthancStone | |
| 27 { | |
| 28 class LayerWidget::Scene : public boost::noncopyable | |
| 29 { | |
| 30 private: | |
| 31 SliceGeometry slice_; | |
| 32 size_t countMissing_; | |
| 33 std::vector<ILayerRenderer*> renderers_; | |
| 34 | |
| 35 void DeleteLayer(size_t index) | |
| 36 { | |
| 37 if (index >= renderers_.size()) | |
| 38 { | |
| 39 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
| 40 } | |
| 41 | |
| 42 assert(countMissing_ <= renderers_.size()); | |
| 43 | |
| 44 if (renderers_[index] != NULL) | |
| 45 { | |
| 46 assert(countMissing_ < renderers_.size()); | |
| 47 delete renderers_[index]; | |
| 48 renderers_[index] = NULL; | |
| 49 countMissing_++; | |
| 50 } | |
| 51 } | |
| 52 | |
| 53 public: | |
| 54 Scene(const SliceGeometry& slice, | |
| 55 size_t countLayers) : | |
| 56 slice_(slice), | |
| 57 countMissing_(countLayers), | |
| 58 renderers_(countLayers, NULL) | |
| 59 { | |
| 60 } | |
| 61 | |
| 62 ~Scene() | |
| 63 { | |
| 64 for (size_t i = 0; i < renderers_.size(); i++) | |
| 65 { | |
| 66 DeleteLayer(i); | |
| 67 } | |
| 68 } | |
| 69 | |
| 70 void SetLayer(size_t index, | |
| 71 ILayerRenderer* renderer) // Takes ownership | |
| 72 { | |
| 73 if (renderer == NULL) | |
| 74 { | |
| 75 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); | |
| 76 } | |
| 77 | |
| 78 DeleteLayer(index); | |
| 79 | |
| 80 renderers_[index] = renderer; | |
| 81 countMissing_--; | |
| 82 } | |
| 83 | |
| 84 const SliceGeometry& GetSlice() const | |
| 85 { | |
| 86 return slice_; | |
| 87 } | |
| 88 | |
| 89 bool IsComplete() const | |
| 90 { | |
| 91 return countMissing_ == 0; | |
| 92 } | |
| 93 | |
| 94 bool RenderScene(CairoContext& context, | |
| 95 const ViewportGeometry& view) | |
| 96 { | |
| 97 bool fullQuality = true; | |
| 98 | |
| 99 for (size_t i = 0; i < renderers_.size(); i++) | |
| 100 { | |
| 101 if (renderers_[i] != NULL && | |
| 77 | 102 !renderers_[i]->RenderLayer(context, view, slice_)) |
| 66 | 103 { |
| 104 return false; | |
| 105 } | |
| 106 | |
| 107 if (renderers_[i] != NULL && | |
| 108 !renderers_[i]->IsFullQuality()) | |
| 109 { | |
| 110 fullQuality = false; | |
| 111 } | |
| 112 } | |
| 113 | |
| 114 if (!fullQuality) | |
| 115 { | |
| 116 double x, y; | |
| 117 view.MapDisplayToScene(x, y, static_cast<double>(view.GetDisplayWidth()) / 2.0, 10); | |
| 118 | |
| 119 cairo_t *cr = context.GetObject(); | |
| 120 cairo_translate(cr, x, y); | |
| 121 cairo_arc(cr, 0, 0, 5.0 / view.GetZoom(), 0, 2 * M_PI); | |
| 122 cairo_set_line_width(cr, 2.0 / view.GetZoom()); | |
| 123 cairo_set_source_rgb(cr, 1, 1, 1); | |
| 124 cairo_stroke_preserve(cr); | |
| 125 cairo_set_source_rgb(cr, 1, 0, 0); | |
| 126 cairo_fill(cr); | |
| 127 } | |
| 128 | |
| 129 return true; | |
| 130 } | |
| 131 | |
| 132 void SetLayerStyle(size_t index, | |
| 133 const RenderStyle& style) | |
| 134 { | |
| 135 if (renderers_[index] != NULL) | |
| 136 { | |
| 137 renderers_[index]->SetLayerStyle(style); | |
| 138 } | |
| 139 } | |
| 140 }; | |
| 141 | |
| 142 | |
| 143 bool LayerWidget::LookupLayer(size_t& index /* out */, | |
| 144 ILayerSource& layer) const | |
| 145 { | |
| 146 LayersIndex::const_iterator found = layersIndex_.find(&layer); | |
| 147 | |
| 148 if (found == layersIndex_.end()) | |
| 149 { | |
| 150 return false; | |
| 151 } | |
| 152 else | |
| 153 { | |
| 154 index = found->second; | |
| 155 assert(index < layers_.size() && | |
| 156 layers_[index] == &layer); | |
| 157 return true; | |
| 158 } | |
| 159 } | |
| 160 | |
| 161 | |
| 162 void LayerWidget::GetSceneExtent(double& x1, | |
| 163 double& y1, | |
| 164 double& x2, | |
| 165 double& y2) | |
| 166 { | |
| 167 bool first = true; | |
| 168 | |
| 169 for (size_t i = 0; i < layers_.size(); i++) | |
| 170 { | |
| 171 double ax, ay, bx, by; | |
| 172 | |
| 173 assert(layers_[i] != NULL); | |
| 174 if (layers_[i]->GetExtent(ax, ay, bx, by, slice_)) | |
| 175 { | |
| 176 if (ax > bx) | |
| 177 { | |
| 178 std::swap(ax, bx); | |
| 179 } | |
| 180 | |
| 181 if (ay > by) | |
| 182 { | |
| 183 std::swap(ay, by); | |
| 184 } | |
| 185 | |
|
71
30c768873d47
OrthancSliceLoader::ScheduleLoadInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
186 LOG(INFO) << "Extent of layer " << i << ": (" << ax << "," << ay << ")->(" << bx << "," << by << ")"; |
| 66 | 187 |
| 188 if (first) | |
| 189 { | |
| 190 x1 = ax; | |
| 191 y1 = ay; | |
| 192 x2 = bx; | |
| 193 y2 = by; | |
| 194 first = false; | |
| 195 } | |
| 196 else | |
| 197 { | |
| 198 x1 = std::min(x1, ax); | |
| 199 y1 = std::min(y1, ay); | |
| 200 x2 = std::max(x2, bx); | |
| 201 y2 = std::max(y2, by); | |
| 202 } | |
| 203 } | |
| 204 } | |
| 205 | |
| 206 if (first) | |
| 207 { | |
| 208 // Set a default extent of (-1,-1) -> (0,0) | |
| 209 x1 = -1; | |
| 210 y1 = -1; | |
| 211 x2 = 1; | |
| 212 y2 = 1; | |
| 213 } | |
| 214 | |
| 215 // Ensure the extent is non-empty | |
| 216 if (x1 >= x2) | |
| 217 { | |
| 218 double tmp = x1; | |
| 219 x1 = tmp - 0.5; | |
| 220 x2 = tmp + 0.5; | |
| 221 } | |
| 222 | |
| 223 if (y1 >= y2) | |
| 224 { | |
| 225 double tmp = y1; | |
| 226 y1 = tmp - 0.5; | |
| 227 y2 = tmp + 0.5; | |
| 228 } | |
| 229 } | |
| 230 | |
| 231 | |
| 232 bool LayerWidget::RenderScene(CairoContext& context, | |
| 233 const ViewportGeometry& view) | |
| 234 { | |
| 235 if (currentScene_.get() != NULL) | |
| 236 { | |
| 237 return currentScene_->RenderScene(context, view); | |
| 238 } | |
| 239 else | |
| 240 { | |
| 241 return true; | |
| 242 } | |
| 243 } | |
| 244 | |
| 245 | |
| 246 void LayerWidget::ResetPendingScene() | |
| 247 { | |
| 248 pendingScene_.reset(new Scene(slice_, layers_.size())); | |
| 249 } | |
| 250 | |
| 251 | |
| 252 void LayerWidget::UpdateLayer(size_t index, | |
| 253 ILayerRenderer* renderer, | |
| 77 | 254 const Slice& slice) |
| 66 | 255 { |
|
71
30c768873d47
OrthancSliceLoader::ScheduleLoadInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
256 LOG(INFO) << "Updating layer " << index; |
| 66 | 257 |
| 258 std::auto_ptr<ILayerRenderer> tmp(renderer); | |
| 259 | |
| 260 if (renderer == NULL) | |
| 261 { | |
| 262 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); | |
| 263 } | |
| 264 | |
| 265 if (index >= layers_.size()) | |
| 266 { | |
| 267 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
| 268 } | |
| 269 | |
| 270 assert(layers_.size() == styles_.size()); | |
| 271 renderer->SetLayerStyle(styles_[index]); | |
| 272 | |
| 273 if (currentScene_.get() != NULL && | |
| 78 | 274 slice.ContainsPlane(currentScene_->GetSlice())) |
| 66 | 275 { |
| 276 currentScene_->SetLayer(index, tmp.release()); | |
| 277 NotifyChange(); | |
| 278 } | |
| 279 else if (pendingScene_.get() != NULL && | |
| 78 | 280 slice.ContainsPlane(pendingScene_->GetSlice())) |
| 66 | 281 { |
| 282 pendingScene_->SetLayer(index, tmp.release()); | |
| 283 | |
| 284 if (currentScene_.get() == NULL || | |
| 285 pendingScene_->IsComplete()) | |
| 286 { | |
| 287 currentScene_ = pendingScene_; | |
| 288 NotifyChange(); | |
| 289 } | |
| 290 } | |
| 291 } | |
| 292 | |
| 293 | |
| 294 LayerWidget::LayerWidget() : | |
| 78 | 295 started_(false) |
| 66 | 296 { |
| 297 SetBackgroundCleared(true); | |
| 298 } | |
| 299 | |
| 300 | |
| 301 LayerWidget::~LayerWidget() | |
| 302 { | |
| 303 for (size_t i = 0; i < layers_.size(); i++) | |
| 304 { | |
| 305 delete layers_[i]; | |
| 306 } | |
| 307 } | |
| 308 | |
| 309 | |
| 310 size_t LayerWidget::AddLayer(ILayerSource* layer) // Takes ownership | |
| 311 { | |
| 312 if (layer == NULL) | |
| 313 { | |
| 314 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); | |
| 315 } | |
| 316 | |
| 317 size_t index = layers_.size(); | |
| 318 layers_.push_back(layer); | |
| 319 styles_.push_back(RenderStyle()); | |
| 320 layersIndex_[layer] = index; | |
| 321 | |
| 322 ResetPendingScene(); | |
| 323 layer->SetObserver(*this); | |
| 324 | |
| 325 return index; | |
| 326 } | |
| 327 | |
| 328 | |
| 329 void LayerWidget::SetLayerStyle(size_t layer, | |
| 330 const RenderStyle& style) | |
| 331 { | |
| 332 if (layer >= layers_.size()) | |
| 333 { | |
| 334 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
| 335 } | |
| 336 | |
| 337 assert(layers_.size() == styles_.size()); | |
| 338 styles_[layer] = style; | |
| 339 | |
| 340 if (currentScene_.get() != NULL) | |
| 341 { | |
| 342 currentScene_->SetLayerStyle(layer, style); | |
| 343 } | |
| 344 | |
| 345 if (pendingScene_.get() != NULL) | |
| 346 { | |
| 347 pendingScene_->SetLayerStyle(layer, style); | |
| 348 } | |
| 349 | |
| 350 NotifyChange(); | |
| 351 } | |
| 352 | |
| 353 | |
| 78 | 354 void LayerWidget::SetSlice(const SliceGeometry& slice) |
| 66 | 355 { |
| 356 if (!slice_.IsSamePlane(slice, 100.0 * std::numeric_limits<double>::epsilon())) | |
| 357 { | |
| 358 if (currentScene_.get() == NULL || | |
| 359 (pendingScene_.get() != NULL && | |
| 360 pendingScene_->IsComplete())) | |
| 361 { | |
| 362 currentScene_ = pendingScene_; | |
| 363 } | |
| 364 | |
| 365 slice_ = slice; | |
| 366 ResetPendingScene(); | |
| 367 | |
| 368 if (started_) | |
| 369 { | |
| 370 for (size_t i = 0; i < layers_.size(); i++) | |
| 371 { | |
| 372 assert(layers_[i] != NULL); | |
| 373 layers_[i]->ScheduleLayerCreation(slice_); | |
| 374 } | |
| 375 } | |
| 376 } | |
| 377 } | |
| 378 | |
| 379 | |
| 380 void LayerWidget::NotifyGeometryReady(ILayerSource& source) | |
| 381 { | |
| 382 size_t i; | |
| 383 if (LookupLayer(i, source)) | |
|
71
30c768873d47
OrthancSliceLoader::ScheduleLoadInstance
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
66
diff
changeset
|
384 LOG(INFO) << "Geometry ready for layer " << i; |
| 66 | 385 |
| 386 SetDefaultView(); | |
| 387 layers_[i]->ScheduleLayerCreation(slice_); | |
| 388 } | |
| 389 | |
| 390 | |
| 77 | 391 void LayerWidget::NotifyGeometryError(ILayerSource& source) |
| 392 { | |
| 393 LOG(ERROR) << "Cannot get geometry"; | |
| 394 } | |
| 395 | |
| 396 | |
| 66 | 397 void LayerWidget::NotifySourceChange(ILayerSource& source) |
| 398 { | |
| 399 source.ScheduleLayerCreation(slice_); | |
| 400 } | |
| 401 | |
| 402 | |
| 403 void LayerWidget::NotifySliceChange(ILayerSource& source, | |
| 77 | 404 const Slice& slice) |
| 66 | 405 { |
| 77 | 406 if (slice.ContainsPlane(slice_)) |
| 66 | 407 { |
| 408 source.ScheduleLayerCreation(slice_); | |
| 409 } | |
| 410 } | |
| 411 | |
| 412 | |
| 413 void LayerWidget::NotifyLayerReady(ILayerRenderer* renderer, | |
| 414 ILayerSource& source, | |
| 77 | 415 const Slice& slice) |
| 66 | 416 { |
| 417 std::auto_ptr<ILayerRenderer> tmp(renderer); | |
| 418 | |
| 419 size_t index; | |
| 420 if (LookupLayer(index, source)) | |
| 421 { | |
| 77 | 422 LOG(INFO) << "Renderer ready for layer " << index; |
| 423 UpdateLayer(index, tmp.release(), slice); | |
| 66 | 424 } |
| 425 } | |
| 426 | |
| 427 | |
| 428 void LayerWidget::NotifyLayerError(ILayerSource& source, | |
| 429 const SliceGeometry& viewportSlice) | |
| 430 { | |
| 431 size_t i; | |
| 432 if (LookupLayer(i, source)) | |
| 433 LOG(ERROR) << "Error on layer " << i; | |
| 434 } | |
| 435 | |
| 436 | |
| 437 void LayerWidget::Start() | |
| 438 { | |
| 439 if (started_) | |
| 440 { | |
| 441 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
| 442 } | |
| 443 | |
| 444 for (size_t i = 0; i < layers_.size(); i++) | |
| 445 { | |
| 446 assert(layers_[i] != NULL); | |
| 447 layers_[i]->Start(); | |
| 448 } | |
| 449 } | |
| 450 } |