Mercurial > hg > orthanc-stone

comparison Samples/Shared/RadiographyEditorApp.cpp @ 848:80829436ce0c am-mainline

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
starting to re-implement radiography editor with latest framework
author Alain Mazy <alain@mazy.be>
date Thu, 13 Jun 2019 16:47:02 +0200
parents
children 56e4e9281076
comparison
equal deleted inserted replaced
842:2b245953b44b 848:80829436ce0c
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-2019 Osimis S.A., 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 #include "RadiographyEditorApp.h"
22
23 #include "../../Applications/Sdl/SdlOpenGLWindow.h"
24
25 #include "../../Framework/Scene2D/CairoCompositor.h"
26 #include "../../Framework/Scene2D/OpenGLCompositor.h"
27 #include "../../Framework/Scene2D/ColorTextureSceneLayer.h"
28 #include "../../Framework/Scene2D/PanSceneTracker.h"
29 #include "../../Framework/Scene2D/RotateSceneTracker.h"
30 #include "../../Framework/Scene2D/Scene2D.h"
31 #include "../../Framework/Scene2D/ZoomSceneTracker.h"
32 #include "../../Framework/Scene2DViewport/CreateAngleMeasureTracker.h"
33 #include "../../Framework/Scene2DViewport/CreateLineMeasureTracker.h"
34 #include "../../Framework/StoneInitialization.h"
35
36 // From Orthanc framework
37 #include <Core/Logging.h>
38 #include <Core/OrthancException.h>
39 #include <Core/Images/Image.h>
40 #include <Core/Images/ImageProcessing.h>
41 #include <Core/Images/PngWriter.h>
42
43 #include <boost/ref.hpp>
44 #include <boost/make_shared.hpp>
45 #include <SDL.h>
46
47 #include <stdio.h>
48
49 namespace OrthancStone
50 {
51 const char* MeasureToolToString(size_t i)
52 {
53 static const char* descs[] = {
54 "GuiTool_Rotate",
55 "GuiTool_Pan",
56 "GuiTool_Zoom",
57 "GuiTool_LineMeasure",
58 "GuiTool_CircleMeasure",
59 "GuiTool_AngleMeasure",
60 "GuiTool_EllipseMeasure",
61 "GuiTool_LAST"
62 };
63 if (i >= GuiTool_LAST)
64 {
65 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError, "Wrong tool index");
66 }
67 return descs[i];
68 }
69
70 boost::shared_ptr<Scene2D> RadiographyEditorApp::GetScene()
71 {
72 return controller_->GetScene();
73 }
74
75 boost::shared_ptr<const Scene2D> RadiographyEditorApp::GetScene() const
76 {
77 return controller_->GetScene();
78 }
79
80 void RadiographyEditorApp::SelectNextTool()
81 {
82 currentTool_ = static_cast<GuiTool>(currentTool_ + 1);
83 if (currentTool_ == GuiTool_LAST)
84 currentTool_ = static_cast<GuiTool>(0);;
85 printf("Current tool is now: %s\n", MeasureToolToString(currentTool_));
86 }
87
88 void RadiographyEditorApp::DisplayInfoText()
89 {
90 // do not try to use stuff too early!
91 if (compositor_.get() == NULL)
92 return;
93
94 std::stringstream msg;
95
96 for (std::map<std::string, std::string>::const_iterator kv = infoTextMap_.begin();
97 kv != infoTextMap_.end(); ++kv)
98 {
99 msg << kv->first << " : " << kv->second << std::endl;
100 }
101 std::string msgS = msg.str();
102
103 TextSceneLayer* layerP = NULL;
104 if (GetScene()->HasLayer(FIXED_INFOTEXT_LAYER_ZINDEX))
105 {
106 TextSceneLayer& layer = dynamic_cast<TextSceneLayer&>(
107 GetScene()->GetLayer(FIXED_INFOTEXT_LAYER_ZINDEX));
108 layerP = &layer;
109 }
110 else
111 {
112 std::auto_ptr<TextSceneLayer> layer(new TextSceneLayer);
113 layerP = layer.get();
114 layer->SetColor(0, 255, 0);
115 layer->SetFontIndex(1);
116 layer->SetBorder(20);
117 layer->SetAnchor(BitmapAnchor_TopLeft);
118 //layer->SetPosition(0,0);
119 GetScene()->SetLayer(FIXED_INFOTEXT_LAYER_ZINDEX, layer.release());
120 }
121 // position the fixed info text in the upper right corner
122 layerP->SetText(msgS.c_str());
123 double cX = compositor_->GetWidth() * (-0.5);
124 double cY = compositor_->GetHeight() * (-0.5);
125 GetScene()->GetCanvasToSceneTransform().Apply(cX,cY);
126 layerP->SetPosition(cX, cY);
127 }
128
129 void RadiographyEditorApp::DisplayFloatingCtrlInfoText(const PointerEvent& e)
130 {
131 ScenePoint2D p = e.GetMainPosition().Apply(GetScene()->GetCanvasToSceneTransform());
132
133 char buf[128];
134 sprintf(buf, "S:(%0.02f,%0.02f) C:(%0.02f,%0.02f)",
135 p.GetX(), p.GetY(),
136 e.GetMainPosition().GetX(), e.GetMainPosition().GetY());
137
138 if (GetScene()->HasLayer(FLOATING_INFOTEXT_LAYER_ZINDEX))
139 {
140 TextSceneLayer& layer =
141 dynamic_cast<TextSceneLayer&>(GetScene()->GetLayer(FLOATING_INFOTEXT_LAYER_ZINDEX));
142 layer.SetText(buf);
143 layer.SetPosition(p.GetX(), p.GetY());
144 }
145 else
146 {
147 std::auto_ptr<TextSceneLayer> layer(new TextSceneLayer);
148 layer->SetColor(0, 255, 0);
149 layer->SetText(buf);
150 layer->SetBorder(20);
151 layer->SetAnchor(BitmapAnchor_BottomCenter);
152 layer->SetPosition(p.GetX(), p.GetY());
153 GetScene()->SetLayer(FLOATING_INFOTEXT_LAYER_ZINDEX, layer.release());
154 }
155 }
156
157 void RadiographyEditorApp::HideInfoText()
158 {
159 GetScene()->DeleteLayer(FLOATING_INFOTEXT_LAYER_ZINDEX);
160 }
161
162 ScenePoint2D RadiographyEditorApp::GetRandomPointInScene() const
163 {
164 unsigned int w = compositor_->GetWidth();
165 LOG(TRACE) << "compositor_->GetWidth() = " <<
166 compositor_->GetWidth();
167 unsigned int h = compositor_->GetHeight();
168 LOG(TRACE) << "compositor_->GetHeight() = " <<
169 compositor_->GetHeight();
170
171 if ((w >= RAND_MAX) || (h >= RAND_MAX))
172 LOG(WARNING) << "Canvas is too big : tools will not be randomly placed";
173
174 int x = rand() % w;
175 int y = rand() % h;
176 LOG(TRACE) << "random x = " << x << "random y = " << y;
177
178 ScenePoint2D p = compositor_->GetPixelCenterCoordinates(x, y);
179 LOG(TRACE) << "--> p.GetX() = " << p.GetX() << " p.GetY() = " << p.GetY();
180
181 ScenePoint2D r = p.Apply(GetScene()->GetCanvasToSceneTransform());
182 LOG(TRACE) << "--> r.GetX() = " << r.GetX() << " r.GetY() = " << r.GetY();
183 return r;
184 }
185
186 void RadiographyEditorApp::CreateRandomMeasureTool()
187 {
188 static bool srandCalled = false;
189 if (!srandCalled)
190 {
191 srand(42);
192 srandCalled = true;
193 }
194
195 int i = rand() % 2;
196 LOG(TRACE) << "random i = " << i;
197 switch (i)
198 {
199 case 0:
200 // line measure
201 {
202 boost::shared_ptr<CreateLineMeasureCommand> cmd =
203 boost::make_shared<CreateLineMeasureCommand>(
204 boost::ref(IObserver::GetBroker()),
205 controller_,
206 GetRandomPointInScene());
207 cmd->SetEnd(GetRandomPointInScene());
208 controller_->PushCommand(cmd);
209 }
210 break;
211 case 1:
212 // angle measure
213 {
214 boost::shared_ptr<CreateAngleMeasureCommand> cmd =
215 boost::make_shared<CreateAngleMeasureCommand>(
216 boost::ref(IObserver::GetBroker()),
217 controller_,
218 GetRandomPointInScene());
219 cmd->SetCenter(GetRandomPointInScene());
220 cmd->SetSide2End(GetRandomPointInScene());
221 controller_->PushCommand(cmd);
222 }
223 break;
224 }
225 }
226
227 void RadiographyEditorApp::OnMouseMove(int x, int y, OrthancStone::KeyboardModifiers modifiers)
228 {
229 DisplayInfoText();
230 if (activeTracker_.get() == NULL && (modifiers & OrthancStone::KeyboardModifiers_Alt))
231 {
232 // The "left-ctrl" key is down, while no tracker is present
233 // Let's display the info text
234 PointerEvent e;
235 e.AddPosition(compositor_->GetPixelCenterCoordinates(x, y));
236
237 DisplayFloatingCtrlInfoText(e);
238 }
239 else {
240 HideInfoText();
241 //LOG(TRACE) << "(event.type == SDL_MOUSEMOTION)";
242 if (activeTracker_.get() != NULL)
243 {
244 //LOG(TRACE) << "(activeTracker_.get() != NULL)";
245 PointerEvent e;
246 e.AddPosition(compositor_->GetPixelCenterCoordinates(x, y));
247
248 //LOG(TRACE) << "event.button.x = " << event.button.x << " " <<
249 // "event.button.y = " << event.button.y;
250 LOG(TRACE) << "activeTracker_->PointerMove(e); " <<
251 e.GetMainPosition().GetX() << " " << e.GetMainPosition().GetY();
252
253 activeTracker_->PointerMove(e);
254 if (!activeTracker_->IsAlive())
255 activeTracker_.reset();
256 }
257 }
258 }
259
260 void RadiographyEditorApp::OnKeyPressed(char keyChar, OrthancStone::KeyboardModifiers modifiers)
261 {
262 DisplayInfoText();
263
264 switch (keyChar)
265 {
266 case '\033': // escape
267 {
268 if (activeTracker_)
269 {
270 activeTracker_->Cancel();
271 if (!activeTracker_->IsAlive())
272 activeTracker_.reset();
273 }
274 };break;
275 case 't':
276 {
277 if (!activeTracker_)
278 SelectNextTool();
279 else
280 {
281 LOG(WARNING) << "You cannot change the active tool when an interaction"
282 " is taking place";
283 }
284 };break;
285 case 'm':
286 CreateRandomMeasureTool();
287 break;
288 case 's':
289 controller_->FitContent(compositor_->GetWidth(),
290 compositor_->GetHeight());
291 break;
292 case 'z':
293 LOG(TRACE) << "z has been pressed. modifier = " << modifiers;
294 if (modifiers & OrthancStone::KeyboardModifiers_Control)
295 {
296 if (controller_->CanUndo())
297 {
298 LOG(TRACE) << "Undoing...";
299 controller_->Undo();
300 }
301 else
302 {
303 LOG(WARNING) << "Nothing to undo!!!";
304 }
305 }
306 break;
307
308 case 'y':
309 LOG(TRACE) << "y has been pressed. modifier = " << modifiers;
310 if (modifiers & OrthancStone::KeyboardModifiers_Control)
311 {
312 if (controller_->CanRedo())
313 {
314 LOG(TRACE) << "Redoing...";
315 controller_->Redo();
316 }
317 else
318 {
319 LOG(WARNING) << "Nothing to redo!!!";
320 }
321 }
322 break;
323
324 case 'c':
325 TakeScreenshot(
326 "screenshot.png",
327 compositor_->GetWidth(),
328 compositor_->GetHeight());
329 break;
330
331 }
332 }
333
334 void RadiographyEditorApp::OnMouseDown(int x, int y, OrthancStone::KeyboardModifiers modifiers, OrthancStone::MouseButton button)
335 {
336 DisplayInfoText();
337 PointerEvent e;
338 e.AddPosition(compositor_->GetPixelCenterCoordinates(x, y));
339 // TODO: set modifiers in e
340
341 if (activeTracker_)
342 {
343 activeTracker_->PointerDown(e);
344 if (!activeTracker_->IsAlive())
345 activeTracker_.reset();
346 }
347 else
348 {
349 // we ATTEMPT to create a tracker if need be
350 activeTracker_ = CreateSuitableTracker(button, e);
351 }
352 }
353
354 void RadiographyEditorApp::OnMouseUp(int x, int y, OrthancStone::KeyboardModifiers modifiers, OrthancStone::MouseButton button)
355 {
356 DisplayInfoText();
357 if (activeTracker_)
358 {
359 PointerEvent e;
360 e.AddPosition(compositor_->GetPixelCenterCoordinates(x, y));
361 // TODO: set modifiers in e
362
363 activeTracker_->PointerUp(e);
364 if (!activeTracker_->IsAlive())
365 activeTracker_.reset();
366 }
367 }
368
369 void RadiographyEditorApp::HandleApplicationEvent(
370 const SDL_Event & event)
371 {
372 DisplayInfoText();
373
374 if (event.type == SDL_MOUSEMOTION)
375 {
376 int scancodeCount = 0;
377 const uint8_t* keyboardState = SDL_GetKeyboardState(&scancodeCount);
378
379 if (activeTracker_.get() == NULL &&
380 SDL_SCANCODE_LALT < scancodeCount &&
381 keyboardState[SDL_SCANCODE_LALT])
382 {
383 // The "left-ctrl" key is down, while no tracker is present
384 // Let's display the info text
385 PointerEvent e;
386 e.AddPosition(compositor_->GetPixelCenterCoordinates(
387 event.button.x, event.button.y));
388 // TODO: set modifiers in e
389
390 DisplayFloatingCtrlInfoText(e);
391 }
392 else
393 {
394 HideInfoText();
395 //LOG(TRACE) << "(event.type == SDL_MOUSEMOTION)";
396 if (activeTracker_.get() != NULL)
397 {
398 //LOG(TRACE) << "(activeTracker_.get() != NULL)";
399 PointerEvent e;
400 e.AddPosition(compositor_->GetPixelCenterCoordinates(
401 event.button.x, event.button.y));
402 // TODO: set modifiers in e
403
404 //LOG(TRACE) << "event.button.x = " << event.button.x << " " <<
405 // "event.button.y = " << event.button.y;
406 LOG(TRACE) << "activeTracker_->PointerMove(e); " <<
407 e.GetMainPosition().GetX() << " " << e.GetMainPosition().GetY();
408
409 activeTracker_->PointerMove(e);
410 if (!activeTracker_->IsAlive())
411 activeTracker_.reset();
412 }
413 }
414 }
415 else if (event.type == SDL_MOUSEBUTTONUP)
416 {
417 if (activeTracker_)
418 {
419 PointerEvent e;
420 e.AddPosition(compositor_->GetPixelCenterCoordinates(event.button.x, event.button.y));
421 // TODO: set modifiers in e
422 activeTracker_->PointerUp(e);
423 if (!activeTracker_->IsAlive())
424 activeTracker_.reset();
425 }
426 }
427 else if (event.type == SDL_MOUSEBUTTONDOWN)
428 {
429 PointerEvent e;
430 e.AddPosition(compositor_->GetPixelCenterCoordinates(
431 event.button.x, event.button.y));
432 // TODO: set modifiers in e
433 if (activeTracker_)
434 {
435 activeTracker_->PointerDown(e);
436 if (!activeTracker_->IsAlive())
437 activeTracker_.reset();
438 }
439 else
440 {
441 // we ATTEMPT to create a tracker if need be
442 // activeTracker_ = CreateSuitableTracker(event, e);
443 }
444 }
445 else if (event.type == SDL_KEYDOWN &&
446 event.key.repeat == 0 /* Ignore key bounce */)
447 {
448 switch (event.key.keysym.sym)
449 {
450 case SDLK_ESCAPE:
451 if (activeTracker_)
452 {
453 activeTracker_->Cancel();
454 if (!activeTracker_->IsAlive())
455 activeTracker_.reset();
456 }
457 break;
458
459 case SDLK_t:
460 if (!activeTracker_)
461 SelectNextTool();
462 else
463 {
464 LOG(WARNING) << "You cannot change the active tool when an interaction"
465 " is taking place";
466 }
467 break;
468
469 case SDLK_m:
470 CreateRandomMeasureTool();
471 break;
472 case SDLK_s:
473 controller_->FitContent(compositor_->GetWidth(),
474 compositor_->GetHeight());
475 break;
476
477 case SDLK_z:
478 LOG(TRACE) << "SDLK_z has been pressed. event.key.keysym.mod == " << event.key.keysym.mod;
479 if (event.key.keysym.mod & KMOD_CTRL)
480 {
481 if (controller_->CanUndo())
482 {
483 LOG(TRACE) << "Undoing...";
484 controller_->Undo();
485 }
486 else
487 {
488 LOG(WARNING) << "Nothing to undo!!!";
489 }
490 }
491 break;
492
493 case SDLK_y:
494 LOG(TRACE) << "SDLK_y has been pressed. event.key.keysym.mod == " << event.key.keysym.mod;
495 if (event.key.keysym.mod & KMOD_CTRL)
496 {
497 if (controller_->CanRedo())
498 {
499 LOG(TRACE) << "Redoing...";
500 controller_->Redo();
501 }
502 else
503 {
504 LOG(WARNING) << "Nothing to redo!!!";
505 }
506 }
507 break;
508
509 case SDLK_c:
510 TakeScreenshot(
511 "screenshot.png",
512 compositor_->GetWidth(),
513 compositor_->GetHeight());
514 break;
515
516 default:
517 break;
518 }
519 }
520 }
521
522
523 void RadiographyEditorApp::OnSceneTransformChanged(
524 const ViewportController::SceneTransformChanged& message)
525 {
526 DisplayInfoText();
527 }
528
529 boost::shared_ptr<IFlexiblePointerTracker> RadiographyEditorApp::CreateSuitableTracker(
530 OrthancStone::MouseButton button,
531 const PointerEvent & e)
532 {
533 using namespace Orthanc;
534
535 switch (button)
536 {
537 case OrthancStone::MouseButton_Middle:
538 return boost::shared_ptr<IFlexiblePointerTracker>(new PanSceneTracker
539 (controller_, e));
540
541 case OrthancStone::MouseButton_Right:
542 return boost::shared_ptr<IFlexiblePointerTracker>(new ZoomSceneTracker
543 (controller_, e, compositor_->GetHeight()));
544
545 case OrthancStone::MouseButton_Left:
546 {
547 //LOG(TRACE) << "CreateSuitableTracker: case SDL_BUTTON_LEFT:";
548 // TODO: we need to iterate on the set of measuring tool and perform
549 // a hit test to check if a tracker needs to be created for edition.
550 // Otherwise, depending upon the active tool, we might want to create
551 // a "measuring tool creation" tracker
552
553 // TODO: if there are conflicts, we should prefer a tracker that
554 // pertains to the type of measuring tool currently selected (TBD?)
555 boost::shared_ptr<IFlexiblePointerTracker> hitTestTracker = TrackerHitTest(e);
556
557 if (hitTestTracker != NULL)
558 {
559 //LOG(TRACE) << "hitTestTracker != NULL";
560 return hitTestTracker;
561 }
562 else
563 {
564 switch (currentTool_)
565 {
566 case GuiTool_Rotate:
567 //LOG(TRACE) << "Creating RotateSceneTracker";
568 return boost::shared_ptr<IFlexiblePointerTracker>(new RotateSceneTracker(
569 controller_, e));
570 case GuiTool_Pan:
571 return boost::shared_ptr<IFlexiblePointerTracker>(new PanSceneTracker(
572 controller_, e));
573 case GuiTool_Zoom:
574 return boost::shared_ptr<IFlexiblePointerTracker>(new ZoomSceneTracker(
575 controller_, e, compositor_->GetHeight()));
576 //case GuiTool_AngleMeasure:
577 // return new AngleMeasureTracker(GetScene(), e);
578 //case GuiTool_CircleMeasure:
579 // return new CircleMeasureTracker(GetScene(), e);
580 //case GuiTool_EllipseMeasure:
581 // return new EllipseMeasureTracker(GetScene(), e);
582 case GuiTool_LineMeasure:
583 return boost::shared_ptr<IFlexiblePointerTracker>(new CreateLineMeasureTracker(
584 IObserver::GetBroker(), controller_, e));
585 case GuiTool_AngleMeasure:
586 return boost::shared_ptr<IFlexiblePointerTracker>(new CreateAngleMeasureTracker(
587 IObserver::GetBroker(), controller_, e));
588 case GuiTool_CircleMeasure:
589 LOG(ERROR) << "Not implemented yet!";
590 return boost::shared_ptr<IFlexiblePointerTracker>();
591 case GuiTool_EllipseMeasure:
592 LOG(ERROR) << "Not implemented yet!";
593 return boost::shared_ptr<IFlexiblePointerTracker>();
594 default:
595 throw OrthancException(ErrorCode_InternalError, "Wrong tool!");
596 }
597 }
598 }
599 default:
600 return boost::shared_ptr<IFlexiblePointerTracker>();
601 }
602 }
603
604
605 RadiographyEditorApp::RadiographyEditorApp(OrthancStone::IOracle& oracle,
606 IObservable& oracleObservable,
607 ICompositorFactory* compositorFactory) :
608 IObserver(oracleObservable.GetBroker()),
609 oracle_(oracle),
610 compositorFactory_(compositorFactory),
611 currentTool_(GuiTool_Rotate)
612 {
613 controller_ = boost::shared_ptr<ViewportController>(new ViewportController(IObserver::GetBroker()));
614
615 controller_->RegisterObserverCallback(
616 new Callable<RadiographyEditorApp, ViewportController::SceneTransformChanged>
617 (*this, &RadiographyEditorApp::OnSceneTransformChanged));
618
619 TEXTURE_2x2_1_ZINDEX = 1;
620 TEXTURE_1x1_ZINDEX = 2;
621 TEXTURE_2x2_2_ZINDEX = 3;
622 LINESET_1_ZINDEX = 4;
623 LINESET_2_ZINDEX = 5;
624 FLOATING_INFOTEXT_LAYER_ZINDEX = 6;
625 FIXED_INFOTEXT_LAYER_ZINDEX = 7;
626 }
627
628 void RadiographyEditorApp::PrepareScene()
629 {
630 // Texture of 2x2 size
631 {
632 Orthanc::Image i(Orthanc::PixelFormat_RGB24, 2, 2, false);
633
634 uint8_t* p = reinterpret_cast<uint8_t*>(i.GetRow(0));
635 p[0] = 255;
636 p[1] = 0;
637 p[2] = 0;
638
639 p[3] = 0;
640 p[4] = 255;
641 p[5] = 0;
642
643 p = reinterpret_cast<uint8_t*>(i.GetRow(1));
644 p[0] = 0;
645 p[1] = 0;
646 p[2] = 255;
647
648 p[3] = 255;
649 p[4] = 0;
650 p[5] = 0;
651
652 GetScene()->SetLayer(TEXTURE_2x2_1_ZINDEX, new ColorTextureSceneLayer(i));
653
654 std::auto_ptr<ColorTextureSceneLayer> l(new ColorTextureSceneLayer(i));
655 l->SetOrigin(-3, 2);
656 l->SetPixelSpacing(1.5, 1);
657 l->SetAngle(20.0 / 180.0 * M_PI);
658 GetScene()->SetLayer(TEXTURE_2x2_2_ZINDEX, l.release());
659 }
660
661 // Texture of 1x1 size
662 {
663 Orthanc::Image i(Orthanc::PixelFormat_RGB24, 1, 1, false);
664
665 uint8_t* p = reinterpret_cast<uint8_t*>(i.GetRow(0));
666 p[0] = 255;
667 p[1] = 0;
668 p[2] = 0;
669
670 std::auto_ptr<ColorTextureSceneLayer> l(new ColorTextureSceneLayer(i));
671 l->SetOrigin(-2, 1);
672 l->SetAngle(20.0 / 180.0 * M_PI);
673 GetScene()->SetLayer(TEXTURE_1x1_ZINDEX, l.release());
674 }
675
676 // Some lines
677 {
678 std::auto_ptr<PolylineSceneLayer> layer(new PolylineSceneLayer);
679
680 layer->SetThickness(1);
681
682 PolylineSceneLayer::Chain chain;
683 chain.push_back(ScenePoint2D(0 - 0.5, 0 - 0.5));
684 chain.push_back(ScenePoint2D(0 - 0.5, 2 - 0.5));
685 chain.push_back(ScenePoint2D(2 - 0.5, 2 - 0.5));
686 chain.push_back(ScenePoint2D(2 - 0.5, 0 - 0.5));
687 layer->AddChain(chain, true, 255, 0, 0);
688
689 chain.clear();
690 chain.push_back(ScenePoint2D(-5, -5));
691 chain.push_back(ScenePoint2D(5, -5));
692 chain.push_back(ScenePoint2D(5, 5));
693 chain.push_back(ScenePoint2D(-5, 5));
694 layer->AddChain(chain, true, 0, 255, 0);
695
696 double dy = 1.01;
697 chain.clear();
698 chain.push_back(ScenePoint2D(-4, -4));
699 chain.push_back(ScenePoint2D(4, -4 + dy));
700 chain.push_back(ScenePoint2D(-4, -4 + 2.0 * dy));
701 chain.push_back(ScenePoint2D(4, 2));
702 layer->AddChain(chain, false, 0, 0, 255);
703
704 GetScene()->SetLayer(LINESET_1_ZINDEX, layer.release());
705 }
706
707 // Some text
708 {
709 std::auto_ptr<TextSceneLayer> layer(new TextSceneLayer);
710 layer->SetText("Hello");
711 GetScene()->SetLayer(LINESET_2_ZINDEX, layer.release());
712 }
713 }
714
715
716 void RadiographyEditorApp::DisableTracker()
717 {
718 if (activeTracker_)
719 {
720 activeTracker_->Cancel();
721 activeTracker_.reset();
722 }
723 }
724
725 void RadiographyEditorApp::TakeScreenshot(const std::string& target,
726 unsigned int canvasWidth,
727 unsigned int canvasHeight)
728 {
729 CairoCompositor compositor(*GetScene(), canvasWidth, canvasHeight);
730 compositor.SetFont(0, Orthanc::EmbeddedResources::UBUNTU_FONT, FONT_SIZE_0, Orthanc::Encoding_Latin1);
731 compositor.Refresh();
732
733 Orthanc::ImageAccessor canvas;
734 compositor.GetCanvas().GetReadOnlyAccessor(canvas);
735
736 Orthanc::Image png(Orthanc::PixelFormat_RGB24, canvas.GetWidth(), canvas.GetHeight(), false);
737 Orthanc::ImageProcessing::Convert(png, canvas);
738
739 Orthanc::PngWriter writer;
740 writer.WriteToFile(target, png);
741 }
742
743
744 boost::shared_ptr<IFlexiblePointerTracker> RadiographyEditorApp::TrackerHitTest(const PointerEvent & e)
745 {
746 // std::vector<boost::shared_ptr<MeasureTool>> measureTools_;
747 return boost::shared_ptr<IFlexiblePointerTracker>();
748 }
749
750
751 void RadiographyEditorApp::FitContent(unsigned int width, unsigned int height)
752 {
753 controller_->FitContent(width, height);
754 }
755
756 void RadiographyEditorApp::UpdateSize()
757 {
758 if (dynamic_cast<OpenGLCompositor*>(compositor_.get()) != NULL)
759 {
760 dynamic_cast<OpenGLCompositor*>(compositor_.get())->UpdateSize();
761 }
762 }
763
764 void RadiographyEditorApp::Refresh()
765 {
766 compositor_.reset(compositorFactory_->GetCompositor(*GetScene()));
767 compositor_->Refresh();
768
769 // the following is paramount because the compositor holds a reference
770 // to the scene and we do not want this reference to become dangling
771 // TODO ???? compositor_.reset(NULL);
772 }
773
774 void RadiographyEditorApp::SetInfoDisplayMessage(
775 std::string key, std::string value)
776 {
777 if (value == "")
778 infoTextMap_.erase(key);
779 else
780 infoTextMap_[key] = value;
781 DisplayInfoText();
782 }
783
784 }