Visual Servoing Platform version 3.6.0
Loading...
Searching...
No Matches
vpDisplay_uchar.cpp
1/****************************************************************************
2 *
3 * ViSP, open source Visual Servoing Platform software.
4 * Copyright (C) 2005 - 2023 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 https://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*****************************************************************************/
35
36#include <visp3/core/vpDisplay.h>
37
38#include "vpDisplay_impl.h"
39
40//************************************************************************
41// Modifications done in this file should be reported in all vpDisplay_*.cpp
42// files that implement other types (unsigned char, vpRGB, vpRGBa)
43//************************************************************************
44
48void vpDisplay::close(vpImage<unsigned char> &I) { vp_display_close(I); }
49
59 const vpColor &color, unsigned int w, unsigned int h, unsigned int thickness)
60{
61 vp_display_display_arrow(I, ip1, ip2, color, w, h, thickness);
62}
63
74void vpDisplay::displayArrow(const vpImage<unsigned char> &I, int i1, int j1, int i2, int j2, const vpColor &color,
75 unsigned int w, unsigned int h, unsigned int thickness)
76{
77 vp_display_display_arrow(I, i1, j1, i2, j2, color, w, h, thickness);
78}
79
94 const vpCameraParameters &cam, double size, const vpColor &color, unsigned int thickness)
95{
96 vp_display_display_camera(I, cMo, cam, size, color, thickness);
97}
98
112void vpDisplay::displayCharString(const vpImage<unsigned char> &I, const vpImagePoint &ip, const char *string,
113 const vpColor &color)
114{
115 vp_display_display_char_string(I, ip, string, color);
116}
117
131void vpDisplay::displayCharString(const vpImage<unsigned char> &I, int i, int j, const char *string,
132 const vpColor &color)
133{
134 vp_display_display_char_string(I, i, j, string, color);
135}
136
149 const vpColor &color, bool fill, unsigned int thickness)
150{
151 vp_display_display_circle(I, circle.getCenter(), static_cast<unsigned int>(circle.getRadius()), color, fill, thickness);
152}
153
166void vpDisplay::displayCircle(const vpImage<unsigned char> &I, const vpImagePoint &center, unsigned int radius,
167 const vpColor &color, bool fill, unsigned int thickness)
168{
169 vp_display_display_circle(I, center, radius, color, fill, thickness);
170}
171
184void vpDisplay::displayCircle(const vpImage<unsigned char> &I, int i, int j, unsigned int radius, const vpColor &color,
185 bool fill, unsigned int thickness)
186{
187 vp_display_display_circle(I, i, j, radius, color, fill, thickness);
188}
189
198void vpDisplay::displayCross(const vpImage<unsigned char> &I, const vpImagePoint &ip, unsigned int size,
199 const vpColor &color, unsigned int thickness)
200{
201 vp_display_display_cross(I, ip, size, color, thickness);
202}
203
212void vpDisplay::displayCross(const vpImage<unsigned char> &I, int i, int j, unsigned int size, const vpColor &color,
213 unsigned int thickness)
214{
215 vp_display_display_cross(I, i, j, size, color, thickness);
216}
217
226 const vpColor &color, unsigned int thickness)
227{
228 vp_display_display_dot_line(I, ip1, ip2, color, thickness);
229}
230
239void vpDisplay::displayDotLine(const vpImage<unsigned char> &I, int i1, int j1, int i2, int j2, const vpColor &color,
240 unsigned int thickness)
241{
242 vp_display_display_dot_line(I, i1, j1, i2, j2, color, thickness);
243}
244
254void vpDisplay::displayDotLine(const vpImage<unsigned char> &I, const std::vector<vpImagePoint> &ips,
255 bool closeTheShape, const vpColor &color, unsigned int thickness)
256{
257 if (ips.size() <= 1)
258 return;
259
260 for (size_t i = 0; i < ips.size() - 1; i++)
261 vp_display_display_dot_line(I, ips[i], ips[i + 1], color, thickness);
262
263 if (closeTheShape)
264 vp_display_display_dot_line(I, ips.front(), ips.back(), color, thickness);
265}
266
276void vpDisplay::displayDotLine(const vpImage<unsigned char> &I, const std::list<vpImagePoint> &ips, bool closeTheShape,
277 const vpColor &color, unsigned int thickness)
278{
279 if (ips.size() <= 1)
280 return;
281
282 std::list<vpImagePoint>::const_iterator it = ips.begin();
283
284 vpImagePoint ip_prev = *(it++);
285 for (; it != ips.end(); ++it) {
286 if (vpImagePoint::distance(ip_prev, *it) > 1) {
287 vp_display_display_dot_line(I, ip_prev, *it, color, thickness);
288 ip_prev = *it;
289 }
290 }
291
292 if (closeTheShape) {
293 vp_display_display_dot_line(I, ips.front(), ips.back(), color, thickness);
294 }
295}
296
333void vpDisplay::displayEllipse(const vpImage<unsigned char> &I, const vpImagePoint &center, const double &coef1,
334 const double &coef2, const double &coef3, bool use_normalized_centered_moments,
335 const vpColor &color, unsigned int thickness, bool display_center, bool display_arc)
336{
337 vpDisplay::displayEllipse(I, center, coef1, coef2, coef3, 0., 2 * M_PI, use_normalized_centered_moments, color,
338 thickness, display_center, display_arc);
339}
340
380void vpDisplay::displayEllipse(const vpImage<unsigned char> &I, const vpImagePoint &center, const double &coef1,
381 const double &coef2, const double &coef3, const double &smallalpha,
382 const double &highalpha, bool use_normalized_centered_moments, const vpColor &color,
383 unsigned int thickness, bool display_center, bool display_arc)
384{
385 vp_display_display_ellipse(I, center, coef1, coef2, coef3, smallalpha, highalpha, use_normalized_centered_moments,
386 color, thickness, display_center, display_arc);
387}
388
407 const vpCameraParameters &cam, double size, const vpColor &color, unsigned int thickness,
408 const vpImagePoint &offset, const std::string &frameName, const vpColor &textColor, const vpImagePoint &textOffset)
409{
410 vp_display_display_frame(I, cMo, cam, size, color, thickness, offset, frameName, textColor, textOffset);
411}
412
423 const vpColor &color, unsigned int thickness, bool segment)
424{
425 displayLine(I, static_cast<int>(ip1.get_i()), static_cast<int>(ip1.get_j()), static_cast<int>(ip2.get_i()),
426 static_cast<int>(ip2.get_j()), color, thickness, segment);
427}
428
439void vpDisplay::displayLine(const vpImage<unsigned char> &I, int i1, int j1, int i2, int j2, const vpColor &color,
440 unsigned int thickness, bool segment)
441{
442 if (segment) {
443 vp_display_display_line(I, i1, j1, i2, j2, color, thickness);
444 }
445 else {
446 // line equation in image: i = a * j + b
447 double delta_j = static_cast<double>(j2) - static_cast<double>(j1);
448 double delta_i = static_cast<double>(i2) - static_cast<double>(i1);
449 // Test if horizontal line
450 if (std::fabs(delta_i) <= std::numeric_limits<double>::epsilon()) {
451 vp_display_display_line(I, i1, 0, i1, (I.getWidth() - 1), color, thickness);
452 }
453 // Test if vertical line
454 else if (std::fabs(delta_j) <= std::numeric_limits<double>::epsilon()) {
455 vp_display_display_line(I, 0, j1, (I.getHeight() - 1), j1, color, thickness);
456 }
457 else {
458 double a = delta_i / delta_j;
459 double b = static_cast<double>(i1) - a * static_cast<double>(j1);
460 std::vector<vpImagePoint> vip; // Image points that intersect image borders
461 // Test intersection with vertical line j=0
462 vpImagePoint ip_left(b, 0);
463 if (ip_left.get_i() >= 0. && ip_left.get_i() <= (I.getHeight() - 1.)) {
464 vip.push_back(ip_left);
465 }
466 // Test intersection with vertical line j=width-1
467 vpImagePoint ip_right(a * (I.getWidth() - 1) + b, I.getWidth() - 1.);
468 if (ip_right.get_i() >= 0. && ip_right.get_i() <= (I.getHeight() - 1.)) {
469 vip.push_back(ip_right);
470 }
471 if (vip.size() == 2) {
472 vp_display_display_line(I, vip[0], vip[1], color, thickness);
473 return;
474 }
475 // Test intersection with horizontal line i=0
476 vpImagePoint ip_top(0, -b / a);
477 if (ip_top.get_j() >= 0. && ip_top.get_j() <= (I.getWidth() - 1.)) {
478 vip.push_back(ip_top);
479 }
480 if (vip.size() == 2) {
481 vp_display_display_line(I, vip[0], vip[1], color, thickness);
482 return;
483 }
484 // Test intersection with horizontal line i=height-1
485 vpImagePoint ip_bottom(I.getHeight() - 1., (I.getHeight() - 1. - b) / a);
486 if (ip_bottom.get_j() >= 0. && ip_bottom.get_j() <= (I.getWidth() - 1.)) {
487 vip.push_back(ip_bottom);
488 }
489 if (vip.size() == 2) {
490 vp_display_display_line(I, vip[0], vip[1], color, thickness);
491 return;
492 }
493 }
494 }
495}
496
505void vpDisplay::displayLine(const vpImage<unsigned char> &I, const std::vector<vpImagePoint> &ips, bool closeTheShape,
506 const vpColor &color, unsigned int thickness)
507{
508 if (ips.size() <= 1)
509 return;
510
511 for (size_t i = 0; i < ips.size() - 1; i++)
512 vp_display_display_line(I, ips[i], ips[i + 1], color, thickness);
513
514 if (closeTheShape)
515 vp_display_display_line(I, ips.front(), ips.back(), color, thickness);
516}
517
526void vpDisplay::displayLine(const vpImage<unsigned char> &I, const std::list<vpImagePoint> &ips, bool closeTheShape,
527 const vpColor &color, unsigned int thickness)
528{
529 if (ips.size() <= 1)
530 return;
531
532 std::list<vpImagePoint>::const_iterator it = ips.begin();
533
534 vpImagePoint ip_prev = *(it++);
535 for (; it != ips.end(); ++it) {
536 if (vpImagePoint::distance(ip_prev, *it) > 1) {
537 vp_display_display_line(I, ip_prev, *it, color, thickness);
538 ip_prev = *it;
539 }
540 }
541
542 if (closeTheShape) {
543 vp_display_display_line(I, ips.front(), ips.back(), color, thickness);
544 }
545}
546
555 unsigned int thickness)
556{
557 vp_display_display_point(I, ip, color, thickness);
558}
559
567void vpDisplay::displayPoint(const vpImage<unsigned char> &I, int i, int j, const vpColor &color,
568 unsigned int thickness)
569{
570 vp_display_display_point(I, i, j, color, thickness);
571}
572
581void vpDisplay::displayPolygon(const vpImage<unsigned char> &I, const std::vector<vpImagePoint> &vip,
582 const vpColor &color, unsigned int thickness, bool closed)
583{
584 vp_display_display_polygon(I, vip, color, thickness, closed);
585}
586
603void vpDisplay::displayRectangle(const vpImage<unsigned char> &I, const vpImagePoint &topLeft, unsigned int width,
604 unsigned int height, const vpColor &color, bool fill, unsigned int thickness)
605{
606 vp_display_display_rectangle(I, topLeft, width, height, color, fill, thickness);
607}
608
623void vpDisplay::displayRectangle(const vpImage<unsigned char> &I, int i, int j, unsigned int width, unsigned int height,
624 const vpColor &color, bool fill, unsigned int thickness)
625{
626 vp_display_display_rectangle(I, i, j, width, height, color, fill, thickness);
627}
628
644void vpDisplay::displayRectangle(const vpImage<unsigned char> &I, const vpRect &rectangle, const vpColor &color,
645 bool fill, unsigned int thickness)
646{
647 vp_display_display_rectangle(I, rectangle, color, fill, thickness);
648}
649
663void vpDisplay::displayRectangle(const vpImage<unsigned char> &I, const vpImagePoint &center, float angle,
664 unsigned int width, unsigned int height, const vpColor &color, unsigned int thickness)
665{
666 vp_display_display_rectangle(I, center, angle, width, height, color, thickness);
667}
668
686 const vpImagePoint &bottomRight, const vpColor &color, bool fill,
687 unsigned int thickness)
688{
689 vp_display_display_rectangle(I, topLeft, bottomRight, color, fill, thickness);
690}
691
705void vpDisplay::displayRectangle(const vpImage<unsigned char> &I, unsigned int i, unsigned int j, float angle,
706 unsigned int width, unsigned int height, const vpColor &color, unsigned int thickness)
707{
708 vp_display_display_rectangle(I, i, j, angle, width, height, color, thickness);
709}
710
723void vpDisplay::displayText(const vpImage<unsigned char> &I, const vpImagePoint &ip, const std::string &s,
724 const vpColor &color)
725{
726 vp_display_display_text(I, ip, s, color);
727}
728
741void vpDisplay::displayText(const vpImage<unsigned char> &I, int i, int j, const std::string &s, const vpColor &color)
742{
743 vp_display_display_text(I, i, j, s, color);
744}
745
775void vpDisplay::flush(const vpImage<unsigned char> &I) { vp_display_flush(I); }
776
786void vpDisplay::flushROI(const vpImage<unsigned char> &I, const vpRect &roi) { vp_display_flush_roi(I, roi); }
787
799void vpDisplay::display(const vpImage<unsigned char> &I) { vp_display_display(I); }
800
805void vpDisplay::displayROI(const vpImage<unsigned char> &I, const vpRect &roi) { vp_display_display_roi(I, roi); }
806
824bool vpDisplay::getClick(const vpImage<unsigned char> &I, bool blocking) { return vp_display_get_click(I, blocking); }
825
845{
846 return vp_display_get_click(I, ip, blocking);
847}
848
870 bool blocking)
871{
872 return vp_display_get_click(I, ip, button, blocking);
873}
874
892{
893 vpImagePoint ip;
894 return vpDisplay::getClick(I, ip, button, blocking);
895}
896
918 bool blocking)
919{
920 return vp_display_get_click_up(I, ip, button, blocking);
921}
922
940{
941 vpImagePoint ip;
942 return vpDisplay::getClickUp(I, ip, button, blocking);
943}
944
1029{
1030 return vp_display_get_keyboard_event(I, blocking);
1031}
1032
1119bool vpDisplay::getKeyboardEvent(const vpImage<unsigned char> &I, std::string &key, bool blocking)
1120{
1121 return vp_display_get_keyboard_event(I, key, blocking);
1122}
1123
1210bool vpDisplay::getKeyboardEvent(const vpImage<unsigned char> &I, char *key, bool blocking)
1211{
1212 return vp_display_get_keyboard_event(I, key, blocking);
1213}
1214
1225{
1226 return vp_display_get_pointer_motion_event(I, ip);
1227}
1228
1239{
1240 return vp_display_get_pointer_position(I, ip);
1241}
1242
1253{
1254 vp_display_set_background(I, color);
1255}
1256
1270void vpDisplay::setFont(const vpImage<unsigned char> &I, const std::string &fontname)
1271{
1272 vp_display_set_font(I, fontname);
1273}
1274
1282void vpDisplay::setTitle(const vpImage<unsigned char> &I, const std::string &windowtitle)
1283{
1284 vp_display_set_title(I, windowtitle);
1285}
1286
1298{
1299 vp_display_set_window_position(I, winx, winy);
1300}
1301
1310{
1311 return vp_display_get_down_scaling_factor(I);
1312}
Generic class defining intrinsic camera parameters.
Class to define RGB colors available for display functionalities.
Definition vpColor.h:152
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 void displayCircle(const vpImage< unsigned char > &I, const vpImageCircle &circle, const vpColor &color, bool fill=false, unsigned int thickness=1)
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 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), const std::string &frameName="", const vpColor &textColor=vpColor::black, const vpImagePoint &textOffset=vpImagePoint(15, 15))
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 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:231
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 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 circle in an image.
float getRadius() const
vpImagePoint getCenter() const
Class that defines a 2D point in an image. This class is useful for image processing and stores only ...
double get_j() const
static double distance(const vpImagePoint &iP1, const vpImagePoint &iP2)
double get_i() const
Definition of the vpImage class member functions.
Definition vpImage.h:135
unsigned int getWidth() const
Definition vpImage.h:242
unsigned int getHeight() const
Definition vpImage.h:184
Defines a rectangle in the plane.
Definition vpRect.h:76