Mercurial > hg > orthanc-stone

comparison Samples/Sdl/TrackerSample.cpp @ 644:f939f449482c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Ongoing tracker work.
author Benjamin Golinvaux <bgo@osimis.io>
date Fri, 10 May 2019 16:15:55 +0200
parents 500c3f70b6c2
children 1e9ed656318e
comparison
equal deleted inserted replaced
634:6a144a45b2d8 644:f939f449482c
16 * 16 *
17 * You should have received a copy of the GNU Affero General Public License 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/>. 18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 **/ 19 **/
20 20
21 #include "TrackerSampleApp.h"
21 22
22 // From Stone 23 // From Stone
23 #include "../../Applications/Sdl/SdlOpenGLWindow.h" 24 #include "../../Applications/Sdl/SdlOpenGLWindow.h"
24 #include "../../Framework/Scene2D/CairoCompositor.h" 25 #include "../../Framework/Scene2D/CairoCompositor.h"
25 #include "../../Framework/Scene2D/ColorTextureSceneLayer.h" 26 #include "../../Framework/Scene2D/ColorTextureSceneLayer.h"
26 #include "../../Framework/Scene2D/OpenGLCompositor.h" 27 #include "../../Framework/Scene2D/OpenGLCompositor.h"
27 #include "../../Framework/Scene2D/PanSceneTracker.h"
28 #include "../../Framework/Scene2D/RotateSceneTracker.h"
29 #include "../../Framework/Scene2D/Scene2D.h"
30 #include "../../Framework/Scene2D/ZoomSceneTracker.h"
31 #include "../../Framework/StoneInitialization.h" 28 #include "../../Framework/StoneInitialization.h"
32 29
33 // From Orthanc framework
34 #include <Core/Logging.h> 30 #include <Core/Logging.h>
35 #include <Core/OrthancException.h> 31 #include <Core/OrthancException.h>
36 #include <Core/Images/Image.h> 32
37 #include <Core/Images/ImageProcessing.h>
38 #include <Core/Images/PngWriter.h>
39 33
40 #include <boost/shared_ptr.hpp> 34 #include <boost/shared_ptr.hpp>
41 #include <boost/weak_ptr.hpp> 35 #include <boost/weak_ptr.hpp>
42 36
43 #include <SDL.h> 37 #include <SDL.h>
44 #include <stdio.h> 38 #include <stdio.h>
45
46
47 // to be moved into Stone
48 #include "../Common/MeasureTrackers.h"
49 #include "../Common/MeasureCommands.h"
50 39
51 /* 40 /*
52 TODO: 41 TODO:
53 42
54 - to decouple the trackers from the sample, we need to supply them with 43 - to decouple the trackers from the sample, we need to supply them with
60 */ 49 */
61 50
62 51
63 using namespace Orthanc; 52 using namespace Orthanc;
64 using namespace OrthancStone; 53 using namespace OrthancStone;
65
66 namespace OrthancStone
67 {
68 enum GuiTool
69 {
70 GuiTool_Rotate = 0,
71 GuiTool_Pan,
72 GuiTool_Zoom,
73 GuiTool_LineMeasure,
74 GuiTool_CircleMeasure,
75 GuiTool_AngleMeasure,
76 GuiTool_EllipseMeasure,
77 GuiTool_LAST
78 };
79
80 const char* MeasureToolToString(size_t i)
81 {
82 static const char* descs[] = {
83 "GuiTool_Rotate",
84 "GuiTool_Pan",
85 "GuiTool_Zoom",
86 "GuiTool_LineMeasure",
87 "GuiTool_CircleMeasure",
88 "GuiTool_AngleMeasure",
89 "GuiTool_EllipseMeasure",
90 "GuiTool_LAST"
91 };
92 if (i >= GuiTool_LAST)
93 {
94 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError, "Wrong tool index");
95 }
96 return descs[i];
97 }
98 }
99
100 class TrackerSampleApp
101 {
102 public:
103 // 12 because.
104 TrackerSampleApp() : currentTool_(GuiTool_Rotate)
105 {
106 TEXTURE_2x2_1_ZINDEX = 1;
107 TEXTURE_1x1_ZINDEX = 2;
108 TEXTURE_2x2_2_ZINDEX = 3;
109 LINESET_1_ZINDEX = 4;
110 LINESET_2_ZINDEX = 5;
111 INFOTEXT_LAYER_ZINDEX = 6;
112 }
113 void PrepareScene();
114 void Run();
115
116 private:
117 Scene2D& GetScene()
118 {
119 return scene_;
120 }
121
122 void SelectNextTool()
123 {
124 currentTool_ = static_cast<GuiTool>(currentTool_ + 1);
125 if (currentTool_ == GuiTool_LAST)
126 currentTool_ = static_cast<GuiTool>(0);;
127 printf("Current tool is now: %s\n", MeasureToolToString(currentTool_));
128 }
129
130 void HandleApplicationEvent(
131 const OpenGLCompositor& compositor,
132 const SDL_Event& event,
133 std::auto_ptr<IPointerTracker>& activeTracker);
134
135 IPointerTracker* TrackerSampleApp::TrackerHitTest(const PointerEvent& e);
136
137 IPointerTracker* CreateSuitableTracker(
138 const SDL_Event& event,
139 const PointerEvent& e,
140 const OpenGLCompositor& compositor);
141
142 void TakeScreenshot(
143 const std::string& target,
144 unsigned int canvasWidth,
145 unsigned int canvasHeight);
146
147 /**
148 This adds the command at the top of the undo stack
149 */
150 void Commit(TrackerCommandPtr cmd);
151 void Undo();
152 void Redo();
153
154 private:
155 static const unsigned int FONT_SIZE = 32;
156
157 std::vector<TrackerCommandPtr> undoStack_;
158
159 // we store the measure tools here so that they don't get deleted
160 std::vector<MeasureToolPtr> measureTools_;
161
162 //static const int LAYER_POSITION = 150;
163 #if 0
164 int TEXTURE_2x2_1_ZINDEX = 12;
165 int TEXTURE_1x1_ZINDEX = 13;
166 int TEXTURE_2x2_2_ZINDEX = 14;
167 int LINESET_1_ZINDEX = 50;
168 int LINESET_2_ZINDEX = 100;
169 int INFOTEXT_LAYER_ZINDEX = 150;
170 #else
171 int TEXTURE_2x2_1_ZINDEX;
172 int TEXTURE_1x1_ZINDEX;
173 int TEXTURE_2x2_2_ZINDEX;
174 int LINESET_1_ZINDEX;
175 int LINESET_2_ZINDEX;
176 int INFOTEXT_LAYER_ZINDEX;
177 #endif
178 Scene2D scene_;
179 GuiTool currentTool_;
180 };
181
182
183 void TrackerSampleApp::PrepareScene()
184 {
185 // Texture of 2x2 size
186 {
187 Orthanc::Image i(Orthanc::PixelFormat_RGB24, 2, 2, false);
188
189 uint8_t *p = reinterpret_cast<uint8_t*>(i.GetRow(0));
190 p[0] = 255;
191 p[1] = 0;
192 p[2] = 0;
193
194 p[3] = 0;
195 p[4] = 255;
196 p[5] = 0;
197
198 p = reinterpret_cast<uint8_t*>(i.GetRow(1));
199 p[0] = 0;
200 p[1] = 0;
201 p[2] = 255;
202
203 p[3] = 255;
204 p[4] = 0;
205 p[5] = 0;
206
207 scene_.SetLayer(TEXTURE_2x2_1_ZINDEX, new ColorTextureSceneLayer(i));
208
209 std::auto_ptr<ColorTextureSceneLayer> l(new ColorTextureSceneLayer(i));
210 l->SetOrigin(-3, 2);
211 l->SetPixelSpacing(1.5, 1);
212 l->SetAngle(20.0 / 180.0 * M_PI);
213 scene_.SetLayer(TEXTURE_2x2_2_ZINDEX, l.release());
214 }
215
216 // Texture of 1x1 size
217 {
218 Orthanc::Image i(Orthanc::PixelFormat_RGB24, 1, 1, false);
219
220 uint8_t *p = reinterpret_cast<uint8_t*>(i.GetRow(0));
221 p[0] = 255;
222 p[1] = 0;
223 p[2] = 0;
224
225 std::auto_ptr<ColorTextureSceneLayer> l(new ColorTextureSceneLayer(i));
226 l->SetOrigin(-2, 1);
227 l->SetAngle(20.0 / 180.0 * M_PI);
228 scene_.SetLayer(TEXTURE_1x1_ZINDEX, l.release());
229 }
230
231 // Some lines
232 {
233 std::auto_ptr<PolylineSceneLayer> layer(new PolylineSceneLayer);
234
235 layer->SetThickness(1);
236
237 PolylineSceneLayer::Chain chain;
238 chain.push_back(ScenePoint2D(0 - 0.5, 0 - 0.5));
239 chain.push_back(ScenePoint2D(0 - 0.5, 2 - 0.5));
240 chain.push_back(ScenePoint2D(2 - 0.5, 2 - 0.5));
241 chain.push_back(ScenePoint2D(2 - 0.5, 0 - 0.5));
242 layer->AddChain(chain, true);
243
244 chain.clear();
245 chain.push_back(ScenePoint2D(-5, -5));
246 chain.push_back(ScenePoint2D(5, -5));
247 chain.push_back(ScenePoint2D(5, 5));
248 chain.push_back(ScenePoint2D(-5, 5));
249 layer->AddChain(chain, true);
250
251 double dy = 1.01;
252 chain.clear();
253 chain.push_back(ScenePoint2D(-4, -4));
254 chain.push_back(ScenePoint2D(4, -4 + dy));
255 chain.push_back(ScenePoint2D(-4, -4 + 2.0 * dy));
256 chain.push_back(ScenePoint2D(4, 2));
257 layer->AddChain(chain, false);
258
259 layer->SetColor(0, 255, 255);
260 scene_.SetLayer(LINESET_1_ZINDEX, layer.release());
261 }
262
263 // Some text
264 {
265 std::auto_ptr<TextSceneLayer> layer(new TextSceneLayer);
266 layer->SetText("Hello");
267 scene_.SetLayer(LINESET_2_ZINDEX, layer.release());
268 }
269 }
270
271
272 void TrackerSampleApp::TakeScreenshot(const std::string& target,
273 unsigned int canvasWidth,
274 unsigned int canvasHeight)
275 {
276 // Take a screenshot, then save it as PNG file
277 CairoCompositor compositor(scene_, canvasWidth, canvasHeight);
278 compositor.SetFont(0, Orthanc::EmbeddedResources::UBUNTU_FONT, FONT_SIZE, Orthanc::Encoding_Latin1);
279 compositor.Refresh();
280
281 Orthanc::ImageAccessor canvas;
282 compositor.GetCanvas().GetReadOnlyAccessor(canvas);
283
284 Orthanc::Image png(Orthanc::PixelFormat_RGB24, canvas.GetWidth(), canvas.GetHeight(), false);
285 Orthanc::ImageProcessing::Convert(png, canvas);
286
287 Orthanc::PngWriter writer;
288 writer.WriteToFile(target, png);
289 }
290
291
292 IPointerTracker* TrackerSampleApp::TrackerHitTest(const PointerEvent& e)
293 {
294 // std::vector<MeasureToolPtr> measureTools_;
295 return nullptr;
296 }
297
298 IPointerTracker* TrackerSampleApp::CreateSuitableTracker(
299 const SDL_Event& event,
300 const PointerEvent& e,
301 const OpenGLCompositor& compositor)
302 {
303 switch (event.button.button)
304 {
305 case SDL_BUTTON_MIDDLE:
306 return new PanSceneTracker(scene_, e);
307
308 case SDL_BUTTON_RIGHT:
309 return new ZoomSceneTracker(
310 scene_, e, compositor.GetCanvasHeight());
311
312 case SDL_BUTTON_LEFT:
313 {
314 // TODO: we need to iterate on the set of measuring tool and perform
315 // a hit test to check if a tracker needs to be created for edition.
316 // Otherwise, depending upon the active tool, we might want to create
317 // a "measuring tool creation" tracker
318
319 // TODO: if there are conflicts, we should prefer a tracker that
320 // pertains to the type of measuring tool currently selected (TBD?)
321 IPointerTracker* hitTestTracker = TrackerHitTest(e);
322
323 if (hitTestTracker != NULL)
324 {
325 return hitTestTracker;
326 }
327 else
328 {
329 switch (currentTool_)
330 {
331 case GuiTool_Rotate:
332 return new RotateSceneTracker(scene_, e);
333 case GuiTool_LineMeasure:
334 return new CreateLineMeasureTracker(
335 scene_, undoStack_, measureTools_, e);
336 //case GuiTool_AngleMeasure:
337 // return new AngleMeasureTracker(scene_, measureTools_, undoStack_, e);
338 //case GuiTool_CircleMeasure:
339 // return new CircleMeasureTracker(scene_, measureTools_, undoStack_, e);
340 //case GuiTool_EllipseMeasure:
341 // return new EllipseMeasureTracker(scene_, measureTools_, undoStack_, e);
342 default:
343 throw OrthancException(ErrorCode_InternalError, "Wrong tool!");
344 }
345 }
346 }
347 default:
348 return NULL;
349 }
350 }
351
352 void TrackerSampleApp::HandleApplicationEvent(
353 const OpenGLCompositor& compositor,
354 const SDL_Event& event,
355 std::auto_ptr<IPointerTracker>& activeTracker)
356 {
357 if (event.type == SDL_MOUSEMOTION)
358 {
359 int scancodeCount = 0;
360 const uint8_t* keyboardState = SDL_GetKeyboardState(&scancodeCount);
361
362 if (activeTracker.get() == NULL &&
363 SDL_SCANCODE_LCTRL < scancodeCount &&
364 keyboardState[SDL_SCANCODE_LCTRL])
365 {
366 // The "left-ctrl" key is down, while no tracker is present
367
368 PointerEvent e;
369 e.AddPosition(compositor.GetPixelCenterCoordinates(event.button.x, event.button.y));
370
371 ScenePoint2D p = e.GetMainPosition().Apply(scene_.GetCanvasToSceneTransform());
372
373 char buf[64];
374 sprintf(buf, "(%0.02f,%0.02f)", p.GetX(), p.GetY());
375
376 if (scene_.HasLayer(INFOTEXT_LAYER_ZINDEX))
377 {
378 TextSceneLayer& layer =
379 dynamic_cast<TextSceneLayer&>(scene_.GetLayer(INFOTEXT_LAYER_ZINDEX));
380 layer.SetText(buf);
381 layer.SetPosition(p.GetX(), p.GetY());
382 }
383 else
384 {
385 std::auto_ptr<TextSceneLayer> layer(new TextSceneLayer);
386 layer->SetColor(0, 255, 0);
387 layer->SetText(buf);
388 layer->SetBorder(20);
389 layer->SetAnchor(BitmapAnchor_BottomCenter);
390 layer->SetPosition(p.GetX(), p.GetY());
391 scene_.SetLayer(INFOTEXT_LAYER_ZINDEX, layer.release());
392 }
393 }
394 else
395 {
396 scene_.DeleteLayer(INFOTEXT_LAYER_ZINDEX);
397 }
398 }
399 else if (event.type == SDL_MOUSEBUTTONDOWN)
400 {
401 PointerEvent e;
402 e.AddPosition(compositor.GetPixelCenterCoordinates(event.button.x, event.button.y));
403
404 activeTracker.reset(CreateSuitableTracker(event, e, compositor));
405 }
406 else if (event.type == SDL_KEYDOWN &&
407 event.key.repeat == 0 /* Ignore key bounce */)
408 {
409 switch (event.key.keysym.sym)
410 {
411 case SDLK_s:
412 scene_.FitContent(compositor.GetCanvasWidth(),
413 compositor.GetCanvasHeight());
414 break;
415
416 case SDLK_c:
417 TakeScreenshot(
418 "screenshot.png",
419 compositor.GetCanvasWidth(),
420 compositor.GetCanvasHeight());
421 break;
422
423 default:
424 break;
425 }
426 }
427 }
428 54
429 55
430 static void GLAPIENTRY 56 static void GLAPIENTRY
431 OpenGLMessageCallback(GLenum source, 57 OpenGLMessageCallback(GLenum source,
432 GLenum type, 58 GLenum type,
444 } 70 }
445 } 71 }
446 72
447 bool g_stopApplication = false; 73 bool g_stopApplication = false;
448 74
449 void TrackerSampleApp::Run() 75 void Run(TrackerSampleApp* app)
450 { 76 {
451 SdlOpenGLWindow window("Hello", 1024, 768); 77 SdlOpenGLWindow window("Hello", 1024, 768);
452 78
453 scene_.FitContent(window.GetCanvasWidth(), window.GetCanvasHeight()); 79 app->GetScene().FitContent(window.GetCanvasWidth(), window.GetCanvasHeight());
454 80
455 glEnable(GL_DEBUG_OUTPUT); 81 glEnable(GL_DEBUG_OUTPUT);
456 glDebugMessageCallback(OpenGLMessageCallback, 0); 82 glDebugMessageCallback(OpenGLMessageCallback, 0);
457 83
458 OpenGLCompositor compositor(window, scene_); 84 OpenGLCompositor compositor(window, app->GetScene());
459 compositor.SetFont(0, Orthanc::EmbeddedResources::UBUNTU_FONT, 85 compositor.SetFont(0, Orthanc::EmbeddedResources::UBUNTU_FONT,
460 FONT_SIZE, Orthanc::Encoding_Latin1); 86 FONT_SIZE, Orthanc::Encoding_Latin1);
461 87
462 // this will either be empty or contain the current tracker, if any
463 std::auto_ptr<IPointerTracker> tracker;
464
465
466 while (!g_stopApplication) 88 while (!g_stopApplication)
467 { 89 {
468 compositor.Refresh(); 90 compositor.Refresh();
469 91
470 SDL_Event event; 92 SDL_Event event;
473 if (event.type == SDL_QUIT) 95 if (event.type == SDL_QUIT)
474 { 96 {
475 g_stopApplication = true; 97 g_stopApplication = true;
476 break; 98 break;
477 } 99 }
478 else if (event.type == SDL_MOUSEMOTION)
479 {
480 if (tracker.get() != NULL)
481 {
482 PointerEvent e;
483 e.AddPosition(compositor.GetPixelCenterCoordinates(event.button.x, event.button.y));
484 LOG(TRACE) << "event.button.x = " << event.button.x << " " <<
485 "event.button.y = " << event.button.y;
486 tracker->Update(e);
487 }
488 }
489 else if (event.type == SDL_MOUSEBUTTONUP)
490 {
491 if (tracker.get() != NULL)
492 {
493 tracker->Release();
494 tracker.reset(NULL);
495 }
496 }
497 else if (event.type == SDL_WINDOWEVENT && 100 else if (event.type == SDL_WINDOWEVENT &&
498 event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED) 101 event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
499 { 102 {
500 tracker.reset(NULL); 103 app->DisableTracker(); // was: tracker.reset(NULL);
501 compositor.UpdateSize(); 104 compositor.UpdateSize();
502 } 105 }
503 else if (event.type == SDL_KEYDOWN && 106 else if (event.type == SDL_KEYDOWN &&
504 event.key.repeat == 0 /* Ignore key bounce */) 107 event.key.repeat == 0 /* Ignore key bounce */)
505 { 108 {
510 break; 113 break;
511 114
512 case SDLK_q: 115 case SDLK_q:
513 g_stopApplication = true; 116 g_stopApplication = true;
514 break; 117 break;
515
516 case SDLK_t:
517 SelectNextTool();
518 break;
519
520 default: 118 default:
521 break; 119 break;
522 } 120 }
523 } 121 }
524 HandleApplicationEvent(compositor, event, tracker); 122 app->HandleApplicationEvent(compositor, event);
525 } 123 }
526 SDL_Delay(1); 124 SDL_Delay(1);
527 } 125 }
528 } 126 }
529 127
535 **/ 133 **/
536 int main(int argc, char* argv[]) 134 int main(int argc, char* argv[])
537 { 135 {
538 StoneInitialize(); 136 StoneInitialize();
539 Orthanc::Logging::EnableInfoLevel(true); 137 Orthanc::Logging::EnableInfoLevel(true);
138 Orthanc::Logging::EnableTraceLevel(true);
139
540 140
541 try 141 try
542 { 142 {
543 TrackerSampleApp app; 143 TrackerSampleApp app;
544 app.PrepareScene(); 144 app.PrepareScene();
545 app.Run(); 145 Run(&app);
546 } 146 }
547 catch (Orthanc::OrthancException& e) 147 catch (Orthanc::OrthancException& e)
548 { 148 {
549 LOG(ERROR) << "EXCEPTION: " << e.What(); 149 LOG(ERROR) << "EXCEPTION: " << e.What();
550 } 150 }