Mercurial > hg > orthanc-stone

comparison Samples/Sdl/TrackerSampleApp.cpp @ 728:8190213e2279 am-dev

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merged default into am-dev
author Alain Mazy <am@osimis.io>
date Tue, 21 May 2019 13:25:58 +0200
parents 28b9e3a54200
children 4d69256d2a46 284f37dc1c66
comparison
equal deleted inserted replaced
690:f185cfcb72a0 728:8190213e2279
18 * along with this program. If not, see <http://www.gnu.org/licenses/>. 18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 **/ 19 **/
20 20
21 #include "TrackerSampleApp.h" 21 #include "TrackerSampleApp.h"
22 22
23 #include "../Common/CreateLineMeasureTracker.h" 23 #include <Framework/Scene2DViewport/CreateLineMeasureTracker.h>
24 #include "../Common/CreateAngleMeasureTracker.h" 24 #include <Framework/Scene2DViewport/CreateAngleMeasureTracker.h>
25 25
26 #include "../../Applications/Sdl/SdlOpenGLWindow.h" 26 #include <Framework/Scene2D/PanSceneTracker.h>
27 27 #include <Framework/Scene2D/RotateSceneTracker.h>
28 #include "../../Framework/Scene2D/PanSceneTracker.h" 28 #include <Framework/Scene2D/Scene2D.h>
29 #include "../../Framework/Scene2D/RotateSceneTracker.h" 29 #include <Framework/Scene2D/ZoomSceneTracker.h>
30 #include "../../Framework/Scene2D/Scene2D.h" 30 #include <Framework/Scene2D/CairoCompositor.h>
31 #include "../../Framework/Scene2D/ZoomSceneTracker.h" 31 #include <Framework/Scene2D/ColorTextureSceneLayer.h>
32 #include "../../Framework/Scene2D/CairoCompositor.h" 32 #include <Framework/Scene2D/OpenGLCompositor.h>
33 #include "../../Framework/Scene2D/ColorTextureSceneLayer.h" 33
34 #include "../../Framework/Scene2D/OpenGLCompositor.h" 34 #include <Framework/StoneInitialization.h>
35 #include "../../Framework/StoneInitialization.h" 35
36 36 #include <Applications/Sdl/SdlOpenGLWindow.h>
37 // From Orthanc framework 37
38 // From Orthanc framework
38 #include <Core/Logging.h> 39 #include <Core/Logging.h>
39 #include <Core/OrthancException.h> 40 #include <Core/OrthancException.h>
40 #include <Core/Images/Image.h> 41 #include <Core/Images/Image.h>
41 #include <Core/Images/ImageProcessing.h> 42 #include <Core/Images/ImageProcessing.h>
42 #include <Core/Images/PngWriter.h> 43 #include <Core/Images/PngWriter.h>
65 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError, "Wrong tool index"); 66 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError, "Wrong tool index");
66 } 67 }
67 return descs[i]; 68 return descs[i];
68 } 69 }
69 70
70 Scene2D& TrackerSampleApp::GetScene() 71 Scene2DPtr TrackerSampleApp::GetScene()
71 { 72 {
72 return scene_; 73 return controller_->GetScene();
73 } 74 }
74 75
75 void TrackerSampleApp::SelectNextTool() 76 void TrackerSampleApp::SelectNextTool()
76 { 77 {
77 currentTool_ = static_cast<GuiTool>(currentTool_ + 1); 78 currentTool_ = static_cast<GuiTool>(currentTool_ + 1);
85 // do not try to use stuff too early! 86 // do not try to use stuff too early!
86 if (compositor_.get() == NULL) 87 if (compositor_.get() == NULL)
87 return; 88 return;
88 89
89 std::stringstream msg; 90 std::stringstream msg;
90 for (auto kv : infoTextMap_) 91
91 { 92 for (std::map<std::string, std::string>::const_iterator kv = infoTextMap_.begin();
92 msg << kv.first << " : " << kv.second << std::endl; 93 kv != infoTextMap_.end(); ++kv)
93 } 94 {
94 auto msgS = msg.str(); 95 msg << kv->first << " : " << kv->second << std::endl;
96 }
97 std::string msgS = msg.str();
95 98
96 TextSceneLayer* layerP = NULL; 99 TextSceneLayer* layerP = NULL;
97 if (scene_.HasLayer(FIXED_INFOTEXT_LAYER_ZINDEX)) 100 if (GetScene()->HasLayer(FIXED_INFOTEXT_LAYER_ZINDEX))
98 { 101 {
99 TextSceneLayer& layer = dynamic_cast<TextSceneLayer&>( 102 TextSceneLayer& layer = dynamic_cast<TextSceneLayer&>(
100 scene_.GetLayer(FIXED_INFOTEXT_LAYER_ZINDEX)); 103 GetScene()->GetLayer(FIXED_INFOTEXT_LAYER_ZINDEX));
101 layerP = &layer; 104 layerP = &layer;
102 } 105 }
103 else 106 else
104 { 107 {
105 std::auto_ptr<TextSceneLayer> layer(new TextSceneLayer); 108 std::auto_ptr<TextSceneLayer> layer(new TextSceneLayer);
107 layer->SetColor(0, 255, 0); 110 layer->SetColor(0, 255, 0);
108 layer->SetFontIndex(1); 111 layer->SetFontIndex(1);
109 layer->SetBorder(20); 112 layer->SetBorder(20);
110 layer->SetAnchor(BitmapAnchor_TopLeft); 113 layer->SetAnchor(BitmapAnchor_TopLeft);
111 //layer->SetPosition(0,0); 114 //layer->SetPosition(0,0);
112 scene_.SetLayer(FIXED_INFOTEXT_LAYER_ZINDEX, layer.release()); 115 GetScene()->SetLayer(FIXED_INFOTEXT_LAYER_ZINDEX, layer.release());
113 } 116 }
114 // position the fixed info text in the upper right corner 117 // position the fixed info text in the upper right corner
115 layerP->SetText(msgS.c_str()); 118 layerP->SetText(msgS.c_str());
116 double cX = compositor_->GetCanvasWidth() * (-0.5); 119 double cX = compositor_->GetCanvasWidth() * (-0.5);
117 double cY = compositor_->GetCanvasHeight() * (-0.5); 120 double cY = compositor_->GetCanvasHeight() * (-0.5);
118 scene_.GetCanvasToSceneTransform().Apply(cX,cY); 121 GetScene()->GetCanvasToSceneTransform().Apply(cX,cY);
119 layerP->SetPosition(cX, cY); 122 layerP->SetPosition(cX, cY);
120 } 123 }
121 124
122 void TrackerSampleApp::DisplayFloatingCtrlInfoText(const PointerEvent& e) 125 void TrackerSampleApp::DisplayFloatingCtrlInfoText(const PointerEvent& e)
123 { 126 {
124 ScenePoint2D p = e.GetMainPosition().Apply(scene_.GetCanvasToSceneTransform()); 127 ScenePoint2D p = e.GetMainPosition().Apply(GetScene()->GetCanvasToSceneTransform());
125 128
126 char buf[128]; 129 char buf[128];
127 sprintf(buf, "S:(%0.02f,%0.02f) C:(%0.02f,%0.02f)", 130 sprintf(buf, "S:(%0.02f,%0.02f) C:(%0.02f,%0.02f)",
128 p.GetX(), p.GetY(), 131 p.GetX(), p.GetY(),
129 e.GetMainPosition().GetX(), e.GetMainPosition().GetY()); 132 e.GetMainPosition().GetX(), e.GetMainPosition().GetY());
130 133
131 if (scene_.HasLayer(FLOATING_INFOTEXT_LAYER_ZINDEX)) 134 if (GetScene()->HasLayer(FLOATING_INFOTEXT_LAYER_ZINDEX))
132 { 135 {
133 TextSceneLayer& layer = 136 TextSceneLayer& layer =
134 dynamic_cast<TextSceneLayer&>(scene_.GetLayer(FLOATING_INFOTEXT_LAYER_ZINDEX)); 137 dynamic_cast<TextSceneLayer&>(GetScene()->GetLayer(FLOATING_INFOTEXT_LAYER_ZINDEX));
135 layer.SetText(buf); 138 layer.SetText(buf);
136 layer.SetPosition(p.GetX(), p.GetY()); 139 layer.SetPosition(p.GetX(), p.GetY());
137 } 140 }
138 else 141 else
139 { 142 {
141 layer->SetColor(0, 255, 0); 144 layer->SetColor(0, 255, 0);
142 layer->SetText(buf); 145 layer->SetText(buf);
143 layer->SetBorder(20); 146 layer->SetBorder(20);
144 layer->SetAnchor(BitmapAnchor_BottomCenter); 147 layer->SetAnchor(BitmapAnchor_BottomCenter);
145 layer->SetPosition(p.GetX(), p.GetY()); 148 layer->SetPosition(p.GetX(), p.GetY());
146 scene_.SetLayer(FLOATING_INFOTEXT_LAYER_ZINDEX, layer.release()); 149 GetScene()->SetLayer(FLOATING_INFOTEXT_LAYER_ZINDEX, layer.release());
147 } 150 }
148 } 151 }
149 152
150 void TrackerSampleApp::HideInfoText() 153 void TrackerSampleApp::HideInfoText()
151 { 154 {
152 scene_.DeleteLayer(FLOATING_INFOTEXT_LAYER_ZINDEX); 155 GetScene()->DeleteLayer(FLOATING_INFOTEXT_LAYER_ZINDEX);
153 } 156 }
154 157
155 void TrackerSampleApp::HandleApplicationEvent( 158 void TrackerSampleApp::HandleApplicationEvent(
156 const SDL_Event & event) 159 const SDL_Event & event)
157 { 160 {
189 // "event.button.y = " << event.button.y; 192 // "event.button.y = " << event.button.y;
190 //LOG(TRACE) << "activeTracker_->PointerMove(e); " << 193 //LOG(TRACE) << "activeTracker_->PointerMove(e); " <<
191 // e.GetMainPosition().GetX() << " " << e.GetMainPosition().GetY(); 194 // e.GetMainPosition().GetX() << " " << e.GetMainPosition().GetY();
192 195
193 activeTracker_->PointerMove(e); 196 activeTracker_->PointerMove(e);
194 if (!activeTracker_->IsActive()) 197 if (!activeTracker_->IsAlive())
195 activeTracker_ = NULL; 198 activeTracker_.reset();
196 } 199 }
197 } 200 }
198 } 201 }
199 else if (event.type == SDL_MOUSEBUTTONUP) 202 else if (event.type == SDL_MOUSEBUTTONUP)
200 { 203 {
201 if (activeTracker_) 204 if (activeTracker_)
202 { 205 {
203 PointerEvent e; 206 PointerEvent e;
204 e.AddPosition(compositor_->GetPixelCenterCoordinates(event.button.x, event.button.y)); 207 e.AddPosition(compositor_->GetPixelCenterCoordinates(event.button.x, event.button.y));
205 activeTracker_->PointerUp(e); 208 activeTracker_->PointerUp(e);
206 if (!activeTracker_->IsActive()) 209 if (!activeTracker_->IsAlive())
207 activeTracker_ = NULL; 210 activeTracker_.reset();
208 } 211 }
209 } 212 }
210 else if (event.type == SDL_MOUSEBUTTONDOWN) 213 else if (event.type == SDL_MOUSEBUTTONDOWN)
211 { 214 {
212 PointerEvent e; 215 PointerEvent e;
213 e.AddPosition(compositor_->GetPixelCenterCoordinates( 216 e.AddPosition(compositor_->GetPixelCenterCoordinates(
214 event.button.x, event.button.y)); 217 event.button.x, event.button.y));
215 if (activeTracker_) 218 if (activeTracker_)
216 { 219 {
217 activeTracker_->PointerDown(e); 220 activeTracker_->PointerDown(e);
218 if (!activeTracker_->IsActive()) 221 if (!activeTracker_->IsAlive())
219 activeTracker_ = NULL; 222 activeTracker_.reset();
220 } 223 }
221 else 224 else
222 { 225 {
223 // we ATTEMPT to create a tracker if need be 226 // we ATTEMPT to create a tracker if need be
224 activeTracker_ = CreateSuitableTracker(event, e); 227 activeTracker_ = CreateSuitableTracker(event, e);
231 { 234 {
232 case SDLK_ESCAPE: 235 case SDLK_ESCAPE:
233 if (activeTracker_) 236 if (activeTracker_)
234 { 237 {
235 activeTracker_->Cancel(); 238 activeTracker_->Cancel();
236 if (!activeTracker_->IsActive()) 239 if (!activeTracker_->IsAlive())
237 activeTracker_ = NULL; 240 activeTracker_.reset();
238 } 241 }
239 break; 242 break;
240 243
241 case SDLK_t: 244 case SDLK_t:
242 if (!activeTracker_) 245 if (!activeTracker_)
247 " is taking place"; 250 " is taking place";
248 } 251 }
249 break; 252 break;
250 253
251 case SDLK_s: 254 case SDLK_s:
252 scene_.FitContent(compositor_->GetCanvasWidth(), 255 controller_->FitContent(compositor_->GetCanvasWidth(),
253 compositor_->GetCanvasHeight()); 256 compositor_->GetCanvasHeight());
254 break; 257 break;
255 258
256 case SDLK_c: 259 case SDLK_c:
257 TakeScreenshot( 260 TakeScreenshot(
265 } 268 }
266 } 269 }
267 } 270 }
268 271
269 272
270 void TrackerSampleApp::OnSceneTransformChanged(const Scene2D::SceneTransformChanged& message) 273 void TrackerSampleApp::OnSceneTransformChanged(
274 const ViewportController::SceneTransformChanged& message)
271 { 275 {
272 DisplayInfoText(); 276 DisplayInfoText();
273 } 277 }
274 278
275 FlexiblePointerTrackerPtr TrackerSampleApp::CreateSuitableTracker( 279 FlexiblePointerTrackerPtr TrackerSampleApp::CreateSuitableTracker(
277 const PointerEvent & e) 281 const PointerEvent & e)
278 { 282 {
279 switch (event.button.button) 283 switch (event.button.button)
280 { 284 {
281 case SDL_BUTTON_MIDDLE: 285 case SDL_BUTTON_MIDDLE:
282 return CreateSimpleTrackerAdapter(PointerTrackerPtr( 286 return FlexiblePointerTrackerPtr(new PanSceneTracker
283 new PanSceneTracker(scene_, e))); 287 (controller_, e));
284 288
285 case SDL_BUTTON_RIGHT: 289 case SDL_BUTTON_RIGHT:
286 return CreateSimpleTrackerAdapter(PointerTrackerPtr( 290 return FlexiblePointerTrackerPtr(new ZoomSceneTracker
287 new ZoomSceneTracker(scene_, e, compositor_->GetCanvasHeight()))); 291 (controller_, e, compositor_->GetCanvasHeight()));
288 292
289 case SDL_BUTTON_LEFT: 293 case SDL_BUTTON_LEFT:
290 { 294 {
291 //LOG(TRACE) << "CreateSuitableTracker: case SDL_BUTTON_LEFT:"; 295 //LOG(TRACE) << "CreateSuitableTracker: case SDL_BUTTON_LEFT:";
292 // TODO: we need to iterate on the set of measuring tool and perform 296 // TODO: we need to iterate on the set of measuring tool and perform
307 { 311 {
308 switch (currentTool_) 312 switch (currentTool_)
309 { 313 {
310 case GuiTool_Rotate: 314 case GuiTool_Rotate:
311 //LOG(TRACE) << "Creating RotateSceneTracker"; 315 //LOG(TRACE) << "Creating RotateSceneTracker";
312 return CreateSimpleTrackerAdapter(PointerTrackerPtr( 316 return FlexiblePointerTrackerPtr(new RotateSceneTracker(
313 new RotateSceneTracker(scene_, e))); 317 controller_, e));
314 case GuiTool_Pan: 318 case GuiTool_Pan:
315 return CreateSimpleTrackerAdapter(PointerTrackerPtr( 319 return FlexiblePointerTrackerPtr(new PanSceneTracker(
316 new PanSceneTracker(scene_, e))); 320 controller_, e));
317 case GuiTool_Zoom: 321 case GuiTool_Zoom:
318 return CreateSimpleTrackerAdapter(PointerTrackerPtr( 322 return FlexiblePointerTrackerPtr(new ZoomSceneTracker(
319 new ZoomSceneTracker(scene_, e, compositor_->GetCanvasHeight()))); 323 controller_, e, compositor_->GetCanvasHeight()));
320 //case GuiTool_AngleMeasure: 324 //case GuiTool_AngleMeasure:
321 // return new AngleMeasureTracker(scene_, measureTools_, undoStack_, e); 325 // return new AngleMeasureTracker(GetScene(), e);
322 //case GuiTool_CircleMeasure: 326 //case GuiTool_CircleMeasure:
323 // return new CircleMeasureTracker(scene_, measureTools_, undoStack_, e); 327 // return new CircleMeasureTracker(GetScene(), e);
324 //case GuiTool_EllipseMeasure: 328 //case GuiTool_EllipseMeasure:
325 // return new EllipseMeasureTracker(scene_, measureTools_, undoStack_, e); 329 // return new EllipseMeasureTracker(GetScene(), e);
326 case GuiTool_LineMeasure: 330 case GuiTool_LineMeasure:
327 return FlexiblePointerTrackerPtr(new CreateLineMeasureTracker( 331 return FlexiblePointerTrackerPtr(new CreateLineMeasureTracker(
328 IObserver::GetBroker(), scene_, undoStack_, measureTools_, e)); 332 IObserver::GetBroker(), controller_, e));
329 case GuiTool_AngleMeasure: 333 case GuiTool_AngleMeasure:
330 return FlexiblePointerTrackerPtr(new CreateAngleMeasureTracker( 334 return FlexiblePointerTrackerPtr(new CreateAngleMeasureTracker(
331 IObserver::GetBroker(), scene_, undoStack_, measureTools_, e)); 335 IObserver::GetBroker(), controller_, e));
332 return NULL;
333 case GuiTool_CircleMeasure: 336 case GuiTool_CircleMeasure:
334 LOG(ERROR) << "Not implemented yet!"; 337 LOG(ERROR) << "Not implemented yet!";
335 return NULL; 338 return FlexiblePointerTrackerPtr();
336 case GuiTool_EllipseMeasure: 339 case GuiTool_EllipseMeasure:
337 LOG(ERROR) << "Not implemented yet!"; 340 LOG(ERROR) << "Not implemented yet!";
338 return NULL; 341 return FlexiblePointerTrackerPtr();
339 default: 342 default:
340 throw OrthancException(ErrorCode_InternalError, "Wrong tool!"); 343 throw OrthancException(ErrorCode_InternalError, "Wrong tool!");
341 } 344 }
342 } 345 }
343 } 346 }
344 default: 347 default:
345 return NULL; 348 return FlexiblePointerTrackerPtr();
346 } 349 }
347 } 350 }
348 351
349 352
350 TrackerSampleApp::TrackerSampleApp(MessageBroker& broker) : IObserver(broker) 353 TrackerSampleApp::TrackerSampleApp(MessageBroker& broker) : IObserver(broker)
351 , scene_(broker)
352 , currentTool_(GuiTool_Rotate) 354 , currentTool_(GuiTool_Rotate)
353 { 355 {
354 scene_.RegisterObserverCallback( 356 controller_ = ViewportControllerPtr(new ViewportController(broker));
355 new Callable<TrackerSampleApp, Scene2D::SceneTransformChanged> 357
358 controller_->RegisterObserverCallback(
359 new Callable<TrackerSampleApp, ViewportController::SceneTransformChanged>
356 (*this, &TrackerSampleApp::OnSceneTransformChanged)); 360 (*this, &TrackerSampleApp::OnSceneTransformChanged));
357 361
358 TEXTURE_2x2_1_ZINDEX = 1; 362 TEXTURE_2x2_1_ZINDEX = 1;
359 TEXTURE_1x1_ZINDEX = 2; 363 TEXTURE_1x1_ZINDEX = 2;
360 TEXTURE_2x2_2_ZINDEX = 3; 364 TEXTURE_2x2_2_ZINDEX = 3;
361 LINESET_1_ZINDEX = 4; 365 LINESET_1_ZINDEX = 4;
362 LINESET_2_ZINDEX = 5; 366 LINESET_2_ZINDEX = 5;
363 FLOATING_INFOTEXT_LAYER_ZINDEX = 6; 367 FLOATING_INFOTEXT_LAYER_ZINDEX = 6;
364 FIXED_INFOTEXT_LAYER_ZINDEX = 7; 368 FIXED_INFOTEXT_LAYER_ZINDEX = 7;
365
366
367 } 369 }
368 370
369 void TrackerSampleApp::PrepareScene() 371 void TrackerSampleApp::PrepareScene()
370 { 372 {
371 // Texture of 2x2 size 373 // Texture of 2x2 size
388 390
389 p[3] = 255; 391 p[3] = 255;
390 p[4] = 0; 392 p[4] = 0;
391 p[5] = 0; 393 p[5] = 0;
392 394
393 scene_.SetLayer(TEXTURE_2x2_1_ZINDEX, new ColorTextureSceneLayer(i)); 395 GetScene()->SetLayer(TEXTURE_2x2_1_ZINDEX, new ColorTextureSceneLayer(i));
394 396
395 std::auto_ptr<ColorTextureSceneLayer> l(new ColorTextureSceneLayer(i)); 397 std::auto_ptr<ColorTextureSceneLayer> l(new ColorTextureSceneLayer(i));
396 l->SetOrigin(-3, 2); 398 l->SetOrigin(-3, 2);
397 l->SetPixelSpacing(1.5, 1); 399 l->SetPixelSpacing(1.5, 1);
398 l->SetAngle(20.0 / 180.0 * M_PI); 400 l->SetAngle(20.0 / 180.0 * M_PI);
399 scene_.SetLayer(TEXTURE_2x2_2_ZINDEX, l.release()); 401 GetScene()->SetLayer(TEXTURE_2x2_2_ZINDEX, l.release());
400 } 402 }
401 403
402 // Texture of 1x1 size 404 // Texture of 1x1 size
403 { 405 {
404 Orthanc::Image i(Orthanc::PixelFormat_RGB24, 1, 1, false); 406 Orthanc::Image i(Orthanc::PixelFormat_RGB24, 1, 1, false);
409 p[2] = 0; 411 p[2] = 0;
410 412
411 std::auto_ptr<ColorTextureSceneLayer> l(new ColorTextureSceneLayer(i)); 413 std::auto_ptr<ColorTextureSceneLayer> l(new ColorTextureSceneLayer(i));
412 l->SetOrigin(-2, 1); 414 l->SetOrigin(-2, 1);
413 l->SetAngle(20.0 / 180.0 * M_PI); 415 l->SetAngle(20.0 / 180.0 * M_PI);
414 scene_.SetLayer(TEXTURE_1x1_ZINDEX, l.release()); 416 GetScene()->SetLayer(TEXTURE_1x1_ZINDEX, l.release());
415 } 417 }
416 418
417 // Some lines 419 // Some lines
418 { 420 {
419 std::auto_ptr<PolylineSceneLayer> layer(new PolylineSceneLayer); 421 std::auto_ptr<PolylineSceneLayer> layer(new PolylineSceneLayer);
441 chain.push_back(ScenePoint2D(-4, -4 + 2.0 * dy)); 443 chain.push_back(ScenePoint2D(-4, -4 + 2.0 * dy));
442 chain.push_back(ScenePoint2D(4, 2)); 444 chain.push_back(ScenePoint2D(4, 2));
443 layer->AddChain(chain, false); 445 layer->AddChain(chain, false);
444 446
445 layer->SetColor(0, 255, 255); 447 layer->SetColor(0, 255, 255);
446 scene_.SetLayer(LINESET_1_ZINDEX, layer.release()); 448 GetScene()->SetLayer(LINESET_1_ZINDEX, layer.release());
447 } 449 }
448 450
449 // Some text 451 // Some text
450 { 452 {
451 std::auto_ptr<TextSceneLayer> layer(new TextSceneLayer); 453 std::auto_ptr<TextSceneLayer> layer(new TextSceneLayer);
452 layer->SetText("Hello"); 454 layer->SetText("Hello");
453 scene_.SetLayer(LINESET_2_ZINDEX, layer.release()); 455 GetScene()->SetLayer(LINESET_2_ZINDEX, layer.release());
454 } 456 }
455 } 457 }
456 458
457 459
458 void TrackerSampleApp::DisableTracker() 460 void TrackerSampleApp::DisableTracker()
459 { 461 {
460 if (activeTracker_) 462 if (activeTracker_)
461 { 463 {
462 activeTracker_->Cancel(); 464 activeTracker_->Cancel();
463 activeTracker_ = NULL; 465 activeTracker_.reset();
464 } 466 }
465 } 467 }
466 468
467 void TrackerSampleApp::TakeScreenshot(const std::string& target, 469 void TrackerSampleApp::TakeScreenshot(const std::string& target,
468 unsigned int canvasWidth, 470 unsigned int canvasWidth,
469 unsigned int canvasHeight) 471 unsigned int canvasHeight)
470 { 472 {
471 CairoCompositor compositor(scene_, canvasWidth, canvasHeight); 473 CairoCompositor compositor(*GetScene(), canvasWidth, canvasHeight);
472 compositor.SetFont(0, Orthanc::EmbeddedResources::UBUNTU_FONT, FONT_SIZE_0, Orthanc::Encoding_Latin1); 474 compositor.SetFont(0, Orthanc::EmbeddedResources::UBUNTU_FONT, FONT_SIZE_0, Orthanc::Encoding_Latin1);
473 compositor.Refresh(); 475 compositor.Refresh();
474 476
475 Orthanc::ImageAccessor canvas; 477 Orthanc::ImageAccessor canvas;
476 compositor.GetCanvas().GetReadOnlyAccessor(canvas); 478 compositor.GetCanvas().GetReadOnlyAccessor(canvas);
484 486
485 487
486 FlexiblePointerTrackerPtr TrackerSampleApp::TrackerHitTest(const PointerEvent & e) 488 FlexiblePointerTrackerPtr TrackerSampleApp::TrackerHitTest(const PointerEvent & e)
487 { 489 {
488 // std::vector<MeasureToolPtr> measureTools_; 490 // std::vector<MeasureToolPtr> measureTools_;
489 return nullptr; 491 return FlexiblePointerTrackerPtr();
490 } 492 }
491 493
492 static void GLAPIENTRY 494 static void GLAPIENTRY
493 OpenGLMessageCallback(GLenum source, 495 OpenGLMessageCallback(GLenum source,
494 GLenum type, 496 GLenum type,
512 { 514 {
513 // False means we do NOT let Windows treat this as a legacy application 515 // False means we do NOT let Windows treat this as a legacy application
514 // that needs to be scaled 516 // that needs to be scaled
515 SdlOpenGLWindow window("Hello", 1024, 1024, false); 517 SdlOpenGLWindow window("Hello", 1024, 1024, false);
516 518
517 GetScene().FitContent(window.GetCanvasWidth(), window.GetCanvasHeight()); 519 controller_->FitContent(window.GetCanvasWidth(), window.GetCanvasHeight());
518 520
519 glEnable(GL_DEBUG_OUTPUT); 521 glEnable(GL_DEBUG_OUTPUT);
520 glDebugMessageCallback(OpenGLMessageCallback, 0); 522 glDebugMessageCallback(OpenGLMessageCallback, 0);
521 523
522 compositor_.reset(new OpenGLCompositor(window, GetScene())); 524 compositor_.reset(new OpenGLCompositor(window, *GetScene()));
523 525
524 compositor_->SetFont(0, Orthanc::EmbeddedResources::UBUNTU_FONT, 526 compositor_->SetFont(0, Orthanc::EmbeddedResources::UBUNTU_FONT,
525 FONT_SIZE_0, Orthanc::Encoding_Latin1); 527 FONT_SIZE_0, Orthanc::Encoding_Latin1);
526 compositor_->SetFont(1, Orthanc::EmbeddedResources::UBUNTU_FONT, 528 compositor_->SetFont(1, Orthanc::EmbeddedResources::UBUNTU_FONT,
527 FONT_SIZE_1, Orthanc::Encoding_Latin1); 529 FONT_SIZE_1, Orthanc::Encoding_Latin1);
562 } 564 }
563 HandleApplicationEvent(event); 565 HandleApplicationEvent(event);
564 } 566 }
565 SDL_Delay(1); 567 SDL_Delay(1);
566 } 568 }
569
570 // the following is paramount because the compositor holds a reference
571 // to the scene and we do not want this reference to become dangling
567 compositor_.reset(NULL); 572 compositor_.reset(NULL);
568 } 573 }
569 574
570 void TrackerSampleApp::SetInfoDisplayMessage( 575 void TrackerSampleApp::SetInfoDisplayMessage(
571 std::string key, std::string value) 576 std::string key, std::string value)