Visual Servoing Platform version 3.5.0
vpDisplay_uchar.cpp
1/****************************************************************************
2 *
3 * ViSP, open source Visual Servoing Platform software.
4 * Copyright (C) 2005 - 2019 by Inria. All rights reserved.
5 *
6 * This software is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 * See the file LICENSE.txt at the root directory of this source
11 * distribution for additional information about the GNU GPL.
12 *
13 * For using ViSP with software that can not be combined with the GNU
14 * GPL, please contact Inria about acquiring a ViSP Professional
15 * Edition License.
16 *
17 * See http://visp.inria.fr for more information.
18 *
19 * This software was developed at:
20 * Inria Rennes - Bretagne Atlantique
21 * Campus Universitaire de Beaulieu
22 * 35042 Rennes Cedex
23 * France
24 *
25 * If you have questions regarding the use of this file, please contact
26 * Inria at visp@inria.fr
27 *
28 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
29 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
30 *
31 * Description:
32 * Display implementation.
33 *
34 * Authors:
35 * Fabien Spindler
36 *
37 *****************************************************************************/
38
39#include <visp3/core/vpDisplay.h>
40
41#include "vpDisplay_impl.h"
42
43//************************************************************************
44// Modifications done in this file should be reported in all vpDisplay_*.cpp
45// files that implement other types (unsigned char, vpRGB, vpRGBa)
46//************************************************************************
47
51void vpDisplay::close(vpImage<unsigned char> &I) { vp_display_close(I); }
52
62 const vpColor &color, unsigned int w, unsigned int h, unsigned int thickness)
63{
64 vp_display_display_arrow(I, ip1, ip2, color, w, h, thickness);
65}
66
77void vpDisplay::displayArrow(const vpImage<unsigned char> &I, int i1, int j1, int i2, int j2, const vpColor &color,
78 unsigned int w, unsigned int h, unsigned int thickness)
79{
80 vp_display_display_arrow(I, i1, j1, i2, j2, color, w, h, thickness);
81}
82
97 const vpCameraParameters &cam, double size, const vpColor &color, unsigned int thickness)
98{
99 vp_display_display_camera(I, cMo, cam, size, color, thickness);
100}
101
115void vpDisplay::displayCharString(const vpImage<unsigned char> &I, const vpImagePoint &ip, const char *string,
116 const vpColor &color)
117{
118 vp_display_display_char_string(I, ip, string, color);
119}
120
134void vpDisplay::displayCharString(const vpImage<unsigned char> &I, int i, int j, const char *string,
135 const vpColor &color)
136{
137 vp_display_display_char_string(I, i, j, string, color);
138}
139
152void vpDisplay::displayCircle(const vpImage<unsigned char> &I, const vpImagePoint &center, unsigned int radius,
153 const vpColor &color, bool fill, unsigned int thickness)
154{
155 vp_display_display_circle(I, center, radius, color, fill, thickness);
156}
157
170void vpDisplay::displayCircle(const vpImage<unsigned char> &I, int i, int j, unsigned int radius, const vpColor &color,
171 bool fill, unsigned int thickness)
172{
173 vp_display_display_circle(I, i, j, radius, color, fill, thickness);
174}
175
184void vpDisplay::displayCross(const vpImage<unsigned char> &I, const vpImagePoint &ip, unsigned int size,
185 const vpColor &color, unsigned int thickness)
186{
187 vp_display_display_cross(I, ip, size, color, thickness);
188}
189
198void vpDisplay::displayCross(const vpImage<unsigned char> &I, int i, int j, unsigned int size, const vpColor &color,
199 unsigned int thickness)
200{
201 vp_display_display_cross(I, i, j, size, color, thickness);
202}
203
212 const vpColor &color, unsigned int thickness)
213{
214 vp_display_display_dot_line(I, ip1, ip2, color, thickness);
215}
216
225void vpDisplay::displayDotLine(const vpImage<unsigned char> &I, int i1, int j1, int i2, int j2, const vpColor &color,
226 unsigned int thickness)
227{
228 vp_display_display_dot_line(I, i1, j1, i2, j2, color, thickness);
229}
230
240void vpDisplay::displayDotLine(const vpImage<unsigned char> &I, const std::vector<vpImagePoint> &ips,
241 bool closeTheShape, const vpColor &color, unsigned int thickness)
242{
243 if (ips.size() <= 1)
244 return;
245
246 for (size_t i = 0; i < ips.size() - 1; i++)
247 vp_display_display_dot_line(I, ips[i], ips[i + 1], color, thickness);
248
249 if (closeTheShape)
250 vp_display_display_dot_line(I, ips.front(), ips.back(), color, thickness);
251}
252
262void vpDisplay::displayDotLine(const vpImage<unsigned char> &I, const std::list<vpImagePoint> &ips,
263 bool closeTheShape, const vpColor &color, unsigned int thickness)
264{
265 if (ips.size() <= 1)
266 return;
267
268 std::list<vpImagePoint>::const_iterator it = ips.begin();
269
270 vpImagePoint ip_prev = *(it++);
271 for (; it != ips.end(); ++it) {
272 if (vpImagePoint::distance(ip_prev, *it) > 1) {
273 vp_display_display_dot_line(I, ip_prev, *it, color, thickness);
274 ip_prev = *it;
275 }
276 }
277
278 if (closeTheShape) {
279 vp_display_display_dot_line(I, ips.front(), ips.back(), color, thickness);
280 }
281}
282
319void vpDisplay::displayEllipse(const vpImage<unsigned char> &I, const vpImagePoint &center, const double &coef1,
320 const double &coef2, const double &coef3, bool use_normalized_centered_moments,
321 const vpColor &color, unsigned int thickness, bool display_center, bool display_arc)
322{
323 vpDisplay::displayEllipse(I, center, coef1, coef2, coef3, 0., 2 * M_PI, use_normalized_centered_moments, color,
324 thickness, display_center, display_arc);
325}
326
366void vpDisplay::displayEllipse(const vpImage<unsigned char> &I, const vpImagePoint &center, const double &coef1,
367 const double &coef2, const double &coef3, const double &smallalpha, const double &highalpha,
368 bool use_normalized_centered_moments, const vpColor &color, unsigned int thickness,
369 bool display_center, bool display_arc)
370{
371 vp_display_display_ellipse(I, center, coef1, coef2, coef3, smallalpha, highalpha, use_normalized_centered_moments, color,
372 thickness, display_center, display_arc);
373}
374
391 const vpCameraParameters &cam, double size, const vpColor &color, unsigned int thickness,
392 const vpImagePoint &offset)
393{
394 vp_display_display_frame(I, cMo, cam, size, color, thickness, offset);
395}
396
407 const vpColor &color, unsigned int thickness, bool segment)
408{
409 displayLine(I, static_cast<int>(ip1.get_i()), static_cast<int>(ip1.get_j()), static_cast<int>(ip2.get_i()), static_cast<int>(ip2.get_j()), color, thickness, segment);
410}
411
422void vpDisplay::displayLine(const vpImage<unsigned char> &I, int i1, int j1, int i2, int j2, const vpColor &color,
423 unsigned int thickness, bool segment)
424{
425 if (segment) {
426 vp_display_display_line(I, i1, j1, i2, j2, color, thickness);
427 }
428 else {
429 // line equation in image: i = a * j + b
430 double delta_j = static_cast<double>(j2) - static_cast<double>(j1);
431 double delta_i = static_cast<double>(i2) - static_cast<double>(i1);
432 // Test if horizontal line
433 if (std::fabs(delta_i) <= std::numeric_limits<double>::epsilon()) {
434 vp_display_display_line(I, i1, 0, i1, (I.getWidth()-1), color, thickness);
435 }
436 // Test if vertical line
437 else if (std::fabs(delta_j) <= std::numeric_limits<double>::epsilon()) {
438 vp_display_display_line(I, 0, j1, (I.getHeight()-1), j1, color, thickness);
439 }
440 else {
441 double a = delta_i / delta_j;
442 double b = static_cast<double>(i1) - a * static_cast<double>(j1);
443 std::vector<vpImagePoint> vip; // Image points that intersect image borders
444 // Test intersection with vertical line j=0
445 vpImagePoint ip_left(b, 0);
446 if (ip_left.get_i() >= 0. && ip_left.get_i() <= (I.getHeight()-1.)) {
447 vip.push_back(ip_left);
448 }
449 // Test intersection with vertical line j=width-1
450 vpImagePoint ip_right(a*(I.getWidth()-1)+b, I.getWidth()-1.);
451 if (ip_right.get_i() >= 0. && ip_right.get_i() <= (I.getHeight()-1.)) {
452 vip.push_back(ip_right);
453 }
454 if (vip.size() == 2) {
455 vp_display_display_line(I, vip[0], vip[1], color, thickness);
456 return;
457 }
458 // Test intersection with horizontal line i=0
459 vpImagePoint ip_top(0, -b/a);
460 if (ip_top.get_j() >= 0. && ip_top.get_j() <= (I.getWidth()-1.)) {
461 vip.push_back(ip_top);
462 }
463 if (vip.size() == 2) {
464 vp_display_display_line(I, vip[0], vip[1], color, thickness);
465 return;
466 }
467 // Test intersection with horizontal line i=height-1
468 vpImagePoint ip_bottom(I.getHeight()-1., (I.getHeight()-1. - b)/a);
469 if (ip_bottom.get_j() >= 0. && ip_bottom.get_j() <= (I.getWidth()-1.)) {
470 vip.push_back(ip_bottom);
471 }
472 if (vip.size() == 2) {
473 vp_display_display_line(I, vip[0], vip[1], color, thickness);
474 return;
475 }
476 }
477 }
478}
479
488void vpDisplay::displayLine(const vpImage<unsigned char> &I, const std::vector<vpImagePoint> &ips,
489 bool closeTheShape, const vpColor &color, unsigned int thickness)
490{
491 if (ips.size() <= 1)
492 return;
493
494 for (size_t i = 0; i < ips.size() - 1; i++)
495 vp_display_display_line(I, ips[i], ips[i + 1], color, thickness);
496
497 if (closeTheShape)
498 vp_display_display_line(I, ips.front(), ips.back(), color, thickness);
499}
500
509void vpDisplay::displayLine(const vpImage<unsigned char> &I, const std::list<vpImagePoint> &ips,
510 bool closeTheShape, const vpColor &color, unsigned int thickness)
511{
512 if (ips.size() <= 1)
513 return;
514
515 std::list<vpImagePoint>::const_iterator it = ips.begin();
516
517 vpImagePoint ip_prev = *(it++);
518 for (; it != ips.end(); ++it) {
519 if (vpImagePoint::distance(ip_prev, *it) > 1) {
520 vp_display_display_line(I, ip_prev, *it, color, thickness);
521 ip_prev = *it;
522 }
523 }
524
525 if (closeTheShape) {
526 vp_display_display_line(I, ips.front(), ips.back(), color, thickness);
527 }
528}
529
538 unsigned int thickness)
539{
540 vp_display_display_point(I, ip, color, thickness);
541}
542
550void vpDisplay::displayPoint(const vpImage<unsigned char> &I, int i, int j, const vpColor &color,
551 unsigned int thickness)
552{
553 vp_display_display_point(I, i, j, color, thickness);
554}
555
564void vpDisplay::displayPolygon(const vpImage<unsigned char> &I, const std::vector<vpImagePoint> &vip,
565 const vpColor &color, unsigned int thickness, bool closed)
566{
567 vp_display_display_polygon(I, vip, color, thickness, closed);
568}
569
586void vpDisplay::displayRectangle(const vpImage<unsigned char> &I, const vpImagePoint &topLeft, unsigned int width,
587 unsigned int height, const vpColor &color, bool fill, unsigned int thickness)
588{
589 vp_display_display_rectangle(I, topLeft, width, height, color, fill, thickness);
590}
591
606void vpDisplay::displayRectangle(const vpImage<unsigned char> &I, int i, int j, unsigned int width, unsigned int height,
607 const vpColor &color, bool fill, unsigned int thickness)
608{
609 vp_display_display_rectangle(I, i, j, width, height, color, fill, thickness);
610}
611
627void vpDisplay::displayRectangle(const vpImage<unsigned char> &I, const vpRect &rectangle, const vpColor &color,
628 bool fill, unsigned int thickness)
629{
630 vp_display_display_rectangle(I, rectangle, color, fill, thickness);
631}
632
646void vpDisplay::displayRectangle(const vpImage<unsigned char> &I, const vpImagePoint &center, float angle,
647 unsigned int width, unsigned int height, const vpColor &color, unsigned int thickness)
648{
649 vp_display_display_rectangle(I, center, angle, width, height, color, thickness);
650}
651
669 const vpImagePoint &bottomRight, const vpColor &color, bool fill,
670 unsigned int thickness)
671{
672 vp_display_display_rectangle(I, topLeft, bottomRight, color, fill, thickness);
673}
674
688void vpDisplay::displayRectangle(const vpImage<unsigned char> &I, unsigned int i, unsigned int j, float angle,
689 unsigned int width, unsigned int height, const vpColor &color, unsigned int thickness)
690{
691 vp_display_display_rectangle(I, i, j, angle, width, height, color, thickness);
692}
693
706void vpDisplay::displayText(const vpImage<unsigned char> &I, const vpImagePoint &ip, const std::string &s,
707 const vpColor &color)
708{
709 vp_display_display_text(I, ip, s, color);
710}
711
724void vpDisplay::displayText(const vpImage<unsigned char> &I, int i, int j, const std::string &s, const vpColor &color)
725{
726 vp_display_display_text(I, i, j, s, color);
727}
728
758void vpDisplay::flush(const vpImage<unsigned char> &I) { vp_display_flush(I); }
759
769void vpDisplay::flushROI(const vpImage<unsigned char> &I, const vpRect &roi) { vp_display_flush_roi(I, roi); }
770
782void vpDisplay::display(const vpImage<unsigned char> &I) { vp_display_display(I); }
783
788void vpDisplay::displayROI(const vpImage<unsigned char> &I, const vpRect &roi) { vp_display_display_roi(I, roi); }
789
807bool vpDisplay::getClick(const vpImage<unsigned char> &I, bool blocking) { return vp_display_get_click(I, blocking); }
808
828{
829 return vp_display_get_click(I, ip, blocking);
830}
831
853 bool blocking)
854{
855 return vp_display_get_click(I, ip, button, blocking);
856}
857
875{
876 vpImagePoint ip;
877 return vpDisplay::getClick(I, ip, button, blocking);
878}
879
901 bool blocking)
902{
903 return vp_display_get_click_up(I, ip, button, blocking);
904}
905
923{
924 vpImagePoint ip;
925 return vpDisplay::getClickUp(I, ip, button, blocking);
926}
927
1012{
1013 return vp_display_get_keyboard_event(I, blocking);
1014}
1015
1102bool vpDisplay::getKeyboardEvent(const vpImage<unsigned char> &I, std::string &key, bool blocking)
1103{
1104 return vp_display_get_keyboard_event(I, key, blocking);
1105}
1106
1193bool vpDisplay::getKeyboardEvent(const vpImage<unsigned char> &I, char *key, bool blocking)
1194{
1195 return vp_display_get_keyboard_event(I, key, blocking);
1196}
1197
1208{
1209 return vp_display_get_pointer_motion_event(I, ip);
1210}
1211
1222{
1223 return vp_display_get_pointer_position(I, ip);
1224}
1225
1236{
1237 vp_display_set_background(I, color);
1238}
1239
1253void vpDisplay::setFont(const vpImage<unsigned char> &I, const std::string &fontname)
1254{
1255 vp_display_set_font(I, fontname);
1256}
1257
1265void vpDisplay::setTitle(const vpImage<unsigned char> &I, const std::string &windowtitle)
1266{
1267 vp_display_set_title(I, windowtitle);
1268}
1269
1281{
1282 vp_display_set_window_position(I, winx, winy);
1283}
1284
1295{
1296 return vp_display_get_down_scaling_factor(I);
1297}
Generic class defining intrinsic camera parameters.
Class to define RGB colors available for display functionnalities.
Definition: vpColor.h:158
static void close(vpImage< unsigned char > &I)
static void setBackground(const vpImage< unsigned char > &I, const vpColor &color)
static bool getClick(const vpImage< unsigned char > &I, bool blocking=true)
static bool getKeyboardEvent(const vpImage< unsigned char > &I, bool blocking=true)
static void displayROI(const vpImage< unsigned char > &I, const vpRect &roi)
static void display(const vpImage< unsigned char > &I)
static void displayLine(const vpImage< unsigned char > &I, const vpImagePoint &ip1, const vpImagePoint &ip2, const vpColor &color, unsigned int thickness=1, bool segment=true)
static void displayEllipse(const vpImage< unsigned char > &I, const vpImagePoint &center, const double &coef1, const double &coef2, const double &coef3, bool use_normalized_centered_moments, const vpColor &color, unsigned int thickness=1, bool display_center=false, bool display_arc=false)
static void flushROI(const vpImage< unsigned char > &I, const vpRect &roi)
static bool getClickUp(const vpImage< unsigned char > &I, vpImagePoint &ip, vpMouseButton::vpMouseButtonType &button, bool blocking=true)
static void displayCross(const vpImage< unsigned char > &I, const vpImagePoint &ip, unsigned int size, const vpColor &color, unsigned int thickness=1)
static void displayCharString(const vpImage< unsigned char > &I, const vpImagePoint &ip, const char *string, const vpColor &color)
static void setTitle(const vpImage< unsigned char > &I, const std::string &windowtitle)
static void flush(const vpImage< unsigned char > &I)
static void displayArrow(const vpImage< unsigned char > &I, const vpImagePoint &ip1, const vpImagePoint &ip2, const vpColor &color=vpColor::white, unsigned int w=4, unsigned int h=2, unsigned int thickness=1)
static void displayPoint(const vpImage< unsigned char > &I, const vpImagePoint &ip, const vpColor &color, unsigned int thickness=1)
static void setFont(const vpImage< unsigned char > &I, const std::string &font)
static void displayDotLine(const vpImage< unsigned char > &I, const vpImagePoint &ip1, const vpImagePoint &ip2, const vpColor &color, unsigned int thickness=1)
static bool getPointerPosition(const vpImage< unsigned char > &I, vpImagePoint &ip)
static bool getPointerMotionEvent(const vpImage< unsigned char > &I, vpImagePoint &ip)
static void displayFrame(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, double size, const vpColor &color=vpColor::none, unsigned int thickness=1, const vpImagePoint &offset=vpImagePoint(0, 0))
static void displayCamera(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, double size, const vpColor &color, unsigned int thickness)
unsigned int getDownScalingFactor()
Definition: vpDisplay.h:235
static void displayRectangle(const vpImage< unsigned char > &I, const vpImagePoint &topLeft, unsigned int width, unsigned int height, const vpColor &color, bool fill=false, unsigned int thickness=1)
static void setWindowPosition(const vpImage< unsigned char > &I, int winx, int winy)
static void displayText(const vpImage< unsigned char > &I, const vpImagePoint &ip, const std::string &s, const vpColor &color)
static void displayCircle(const vpImage< unsigned char > &I, const vpImagePoint &center, unsigned int radius, const vpColor &color, bool fill=false, unsigned int thickness=1)
static void displayPolygon(const vpImage< unsigned char > &I, const std::vector< vpImagePoint > &vip, const vpColor &color, unsigned int thickness=1, bool closed=true)
Implementation of an homogeneous matrix and operations on such kind of matrices.
Class that defines a 2D point in an image. This class is useful for image processing and stores only ...
Definition: vpImagePoint.h:88
double get_j() const
Definition: vpImagePoint.h:214
static double distance(const vpImagePoint &iP1, const vpImagePoint &iP2)
double get_i() const
Definition: vpImagePoint.h:203
unsigned int getWidth() const
Definition: vpImage.h:246
unsigned int getHeight() const
Definition: vpImage.h:188
Defines a rectangle in the plane.
Definition: vpRect.h:80