Visual Servoing Platform version 3.5.0
vpDisplay_rgba.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<vpRGBa> &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<vpRGBa> &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 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<vpRGBa> &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<vpRGBa> &I, int i, int j, const char *string, const vpColor &color)
135{
136 vp_display_display_char_string(I, i, j, string, color);
137}
138
151void vpDisplay::displayCircle(const vpImage<vpRGBa> &I, const vpImagePoint &center, unsigned int radius,
152 const vpColor &color, bool fill, unsigned int thickness)
153{
154 vp_display_display_circle(I, center, radius, color, fill, thickness);
155}
156
169void vpDisplay::displayCircle(const vpImage<vpRGBa> &I, int i, int j, unsigned int radius, const vpColor &color,
170 bool fill, unsigned int thickness)
171{
172 vp_display_display_circle(I, i, j, radius, color, fill, thickness);
173}
174
183void vpDisplay::displayCross(const vpImage<vpRGBa> &I, const vpImagePoint &ip, unsigned int size, const vpColor &color,
184 unsigned int thickness)
185{
186 vp_display_display_cross(I, ip, size, color, thickness);
187}
188
197void vpDisplay::displayCross(const vpImage<vpRGBa> &I, int i, int j, unsigned int size, const vpColor &color,
198 unsigned int thickness)
199{
200 vp_display_display_cross(I, i, j, size, color, thickness);
201}
202
211 const vpColor &color, unsigned int thickness)
212{
213 vp_display_display_dot_line(I, ip1, ip2, color, thickness);
214}
215
224void vpDisplay::displayDotLine(const vpImage<vpRGBa> &I, int i1, int j1, int i2, int j2, const vpColor &color,
225 unsigned int thickness)
226{
227 vp_display_display_dot_line(I, i1, j1, i2, j2, color, thickness);
228}
229
239void vpDisplay::displayDotLine(const vpImage<vpRGBa> &I, const std::vector<vpImagePoint> &ips, bool closeTheShape,
240 const vpColor &color, unsigned int thickness)
241{
242 if (ips.size() <= 1)
243 return;
244
245 for (size_t i = 0; i < ips.size() - 1; i++)
246 vp_display_display_dot_line(I, ips[i], ips[i + 1], color, thickness);
247
248 if (closeTheShape)
249 vp_display_display_dot_line(I, ips.front(), ips.back(), color, thickness);
250}
251
261void vpDisplay::displayDotLine(const vpImage<vpRGBa> &I, const std::list<vpImagePoint> &ips, bool closeTheShape,
262 const vpColor &color, unsigned int thickness)
263{
264 if (ips.size() <= 1)
265 return;
266
267 std::list<vpImagePoint>::const_iterator it = ips.begin();
268
269 vpImagePoint ip_prev = *(it++);
270 for (; it != ips.end(); ++it) {
271 if (vpImagePoint::distance(ip_prev, *it) > 1) {
272 vp_display_display_dot_line(I, ip_prev, *it, color, thickness);
273 ip_prev = *it;
274 }
275 }
276
277 if (closeTheShape) {
278 vp_display_display_dot_line(I, ips.front(), ips.back(), color, thickness);
279 }
280}
281
318void vpDisplay::displayEllipse(const vpImage<vpRGBa> &I, const vpImagePoint &center, const double &coef1,
319 const double &coef2, const double &coef3, bool use_normalized_centered_moments,
320 const vpColor &color, unsigned int thickness, bool display_center, bool display_arc)
321{
322 vpDisplay::displayEllipse(I, center, coef1, coef2, coef3, 0., 2 * M_PI, use_normalized_centered_moments, color,
323 thickness, display_center, display_arc);
324}
325
365void vpDisplay::displayEllipse(const vpImage<vpRGBa> &I, const vpImagePoint &center, const double &coef1,
366 const double &coef2, const double &coef3, const double &smallalpha, const double &highalpha,
367 bool use_normalized_centered_moments, const vpColor &color, unsigned int thickness,
368 bool display_center, bool display_arc)
369{
370 vp_display_display_ellipse(I, center, coef1, coef2, coef3, smallalpha, highalpha, use_normalized_centered_moments,
371 color, thickness, display_center, display_arc);
372}
373
390 double size, const vpColor &color, unsigned int thickness, const vpImagePoint &offset)
391{
392 vp_display_display_frame(I, cMo, cam, size, color, thickness, offset);
393}
394
405 const vpColor &color, unsigned int thickness, bool segment)
406{
407 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);
408}
409
420void vpDisplay::displayLine(const vpImage<vpRGBa> &I, int i1, int j1, int i2, int j2, const vpColor &color,
421 unsigned int thickness, bool segment)
422{
423 if (segment) {
424 vp_display_display_line(I, i1, j1, i2, j2, color, thickness);
425 }
426 else {
427 // line equation in image: i = a * j + b
428 double delta_j = static_cast<double>(j2) - static_cast<double>(j1);
429 double delta_i = static_cast<double>(i2) - static_cast<double>(i1);
430 // Test if horizontal line
431 if (std::fabs(delta_i) <= std::numeric_limits<double>::epsilon()) {
432 vp_display_display_line(I, i1, 0, i1, (I.getWidth()-1), color, thickness);
433 }
434 // Test if vertical line
435 else if (std::fabs(delta_j) <= std::numeric_limits<double>::epsilon()) {
436 vp_display_display_line(I, 0, j1, (I.getHeight()-1), j1, color, thickness);
437 }
438 else {
439 double a = delta_i / delta_j;
440 double b = static_cast<double>(i1) - a * static_cast<double>(j1);
441 std::vector<vpImagePoint> vip; // Image points that intersect image borders
442 // Test intersection with vertical line j=0
443 vpImagePoint ip_left(b, 0);
444 if (ip_left.get_i() >= 0. && ip_left.get_i() <= (I.getHeight()-1.)) {
445 vip.push_back(ip_left);
446 }
447 // Test intersection with vertical line j=width-1
448 vpImagePoint ip_right(a*(I.getWidth()-1)+b, I.getWidth()-1.);
449 if (ip_right.get_i() >= 0. && ip_right.get_i() <= (I.getHeight()-1.)) {
450 vip.push_back(ip_right);
451 }
452 if (vip.size() == 2) {
453 vp_display_display_line(I, vip[0], vip[1], color, thickness);
454 return;
455 }
456 // Test intersection with horizontal line i=0
457 vpImagePoint ip_top(0, -b/a);
458 if (ip_top.get_j() >= 0. && ip_top.get_j() <= (I.getWidth()-1.)) {
459 vip.push_back(ip_top);
460 }
461 if (vip.size() == 2) {
462 vp_display_display_line(I, vip[0], vip[1], color, thickness);
463 return;
464 }
465 // Test intersection with horizontal line i=height-1
466 vpImagePoint ip_bottom(I.getHeight()-1., (I.getHeight()-1. - b)/a);
467 if (ip_bottom.get_j() >= 0. && ip_bottom.get_j() <= (I.getWidth()-1.)) {
468 vip.push_back(ip_bottom);
469 }
470 if (vip.size() == 2) {
471 vp_display_display_line(I, vip[0], vip[1], color, thickness);
472 return;
473 }
474 }
475 }
476}
477
487void vpDisplay::displayLine(const vpImage<vpRGBa> &I, const std::vector<vpImagePoint> &ips, bool closeTheShape,
488 const vpColor &color, unsigned int thickness)
489{
490 if (ips.size() <= 1)
491 return;
492
493 for (size_t i = 0; i < ips.size() - 1; i++)
494 vp_display_display_line(I, ips[i], ips[i + 1], color, thickness);
495
496 if (closeTheShape)
497 vp_display_display_line(I, ips.front(), ips.back(), color, thickness);
498}
499
509void vpDisplay::displayLine(const vpImage<vpRGBa> &I, const std::list<vpImagePoint> &ips, bool closeTheShape,
510 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
537void vpDisplay::displayPoint(const vpImage<vpRGBa> &I, const vpImagePoint &ip, const vpColor &color,
538 unsigned int thickness)
539{
540 vp_display_display_point(I, ip, color, thickness);
541}
542
550void vpDisplay::displayPoint(const vpImage<vpRGBa> &I, int i, int j, const vpColor &color, unsigned int thickness)
551{
552 vp_display_display_point(I, i, j, color, thickness);
553}
554
563void vpDisplay::displayPolygon(const vpImage<vpRGBa> &I, const std::vector<vpImagePoint> &vip, const vpColor &color,
564 unsigned int thickness, bool closed)
565{
566 vp_display_display_polygon(I, vip, color, thickness, closed);
567}
568
585void vpDisplay::displayRectangle(const vpImage<vpRGBa> &I, const vpImagePoint &topLeft, unsigned int width,
586 unsigned int height, const vpColor &color, bool fill, unsigned int thickness)
587{
588 vp_display_display_rectangle(I, topLeft, width, height, color, fill, thickness);
589}
590
605void vpDisplay::displayRectangle(const vpImage<vpRGBa> &I, int i, int j, unsigned int width, unsigned int height,
606 const vpColor &color, bool fill, unsigned int thickness)
607{
608 vp_display_display_rectangle(I, i, j, width, height, color, fill, thickness);
609}
610
626void vpDisplay::displayRectangle(const vpImage<vpRGBa> &I, const vpRect &rectangle, const vpColor &color, bool fill,
627 unsigned int thickness)
628{
629 vp_display_display_rectangle(I, rectangle, color, fill, thickness);
630}
631
645void vpDisplay::displayRectangle(const vpImage<vpRGBa> &I, const vpImagePoint &center, float angle, unsigned int width,
646 unsigned int height, const vpColor &color, unsigned int thickness)
647{
648 vp_display_display_rectangle(I, center, angle, width, height, color, thickness);
649}
650
667void vpDisplay::displayRectangle(const vpImage<vpRGBa> &I, const vpImagePoint &topLeft, const vpImagePoint &bottomRight,
668 const vpColor &color, bool fill, unsigned int thickness)
669{
670 vp_display_display_rectangle(I, topLeft, bottomRight, color, fill, thickness);
671}
672
686void vpDisplay::displayRectangle(const vpImage<vpRGBa> &I, unsigned int i, unsigned int j, float angle,
687 unsigned int width, unsigned int height, const vpColor &color, unsigned int thickness)
688{
689 vp_display_display_rectangle(I, i, j, angle, width, height, color, thickness);
690}
691
704void vpDisplay::displayText(const vpImage<vpRGBa> &I, const vpImagePoint &ip, const std::string &s,
705 const vpColor &color)
706{
707 vp_display_display_text(I, ip, s, color);
708}
709
722void vpDisplay::displayText(const vpImage<vpRGBa> &I, int i, int j, const std::string &s, const vpColor &color)
723{
724 vp_display_display_text(I, i, j, s, color);
725}
726
756void vpDisplay::flush(const vpImage<vpRGBa> &I) { vp_display_flush(I); }
757
767void vpDisplay::flushROI(const vpImage<vpRGBa> &I, const vpRect &roi) { vp_display_flush_roi(I, roi); }
768
780void vpDisplay::display(const vpImage<vpRGBa> &I) { vp_display_display(I); }
781
786void vpDisplay::displayROI(const vpImage<vpRGBa> &I, const vpRect &roi) { vp_display_display_roi(I, roi); }
787
805bool vpDisplay::getClick(const vpImage<vpRGBa> &I, bool blocking) { return vp_display_get_click(I, blocking); }
806
825bool vpDisplay::getClick(const vpImage<vpRGBa> &I, vpImagePoint &ip, bool blocking)
826{
827 return vp_display_get_click(I, ip, blocking);
828}
829
851 bool blocking)
852{
853 return vp_display_get_click(I, ip, button, blocking);
854}
855
873{
874 vpImagePoint ip;
875 return vpDisplay::getClick(I, ip, button, blocking);
876}
877
899 bool blocking)
900{
901 return vp_display_get_click_up(I, ip, button, blocking);
902}
903
921{
922 vpImagePoint ip;
923 return vpDisplay::getClickUp(I, ip, button, blocking);
924}
925
1009{
1010 return vp_display_get_keyboard_event(I, blocking);
1011}
1012
1099bool vpDisplay::getKeyboardEvent(const vpImage<vpRGBa> &I, std::string &key, bool blocking)
1100{
1101 return vp_display_get_keyboard_event(I, key, blocking);
1102}
1103
1190bool vpDisplay::getKeyboardEvent(const vpImage<vpRGBa> &I, char *key, bool blocking)
1191{
1192 return vp_display_get_keyboard_event(I, key, blocking);
1193}
1194
1205{
1206 return vp_display_get_pointer_motion_event(I, ip);
1207}
1208
1219{
1220 return vp_display_get_pointer_position(I, ip);
1221}
1222
1232void vpDisplay::setBackground(const vpImage<vpRGBa> &I, const vpColor &color) { vp_display_set_background(I, color); }
1233
1247void vpDisplay::setFont(const vpImage<vpRGBa> &I, const std::string &fontname) { vp_display_set_font(I, fontname); }
1248
1256void vpDisplay::setTitle(const vpImage<vpRGBa> &I, const std::string &windowtitle)
1257{
1258 vp_display_set_title(I, windowtitle);
1259}
1260
1271void vpDisplay::setWindowPosition(const vpImage<vpRGBa> &I, int winx, int winy)
1272{
1273 vp_display_set_window_position(I, winx, winy);
1274}
1275
1285unsigned int vpDisplay::getDownScalingFactor(const vpImage<vpRGBa> &I) { return vp_display_get_down_scaling_factor(I); }
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