vpDisplay_rgba.cpp

/****************************************************************************
 *
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2022 by Inria. All rights reserved.
 *
 * This software is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * See http://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at visp@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Description:
 * Display implementation.
 *
 *****************************************************************************/
 
#include <visp3/core/vpDisplay.h>
 
#include "vpDisplay_impl.h"
 
//************************************************************************
// Modifications done in this file should be reported in all vpDisplay_*.cpp
// files that implement other types (unsigned char, vpRGB, vpRGBa)
//************************************************************************
 
void vpDisplay::close(vpImage<vpRGBa> &I) { vp_display_close(I); }
 
void vpDisplay::displayArrow(const vpImage<vpRGBa> &I, const vpImagePoint &ip1, const vpImagePoint &ip2,
                             const vpColor &color, unsigned int w, unsigned int h, unsigned int thickness)
{
  vp_display_display_arrow(I, ip1, ip2, color, w, h, thickness);
}
 
void vpDisplay::displayArrow(const vpImage<vpRGBa> &I, int i1, int j1, int i2, int j2, const vpColor &color,
                             unsigned int w, unsigned int h, unsigned int thickness)
{
  vp_display_display_arrow(I, i1, j1, i2, j2, color, w, h, thickness);
}
 
void vpDisplay::displayCamera(const vpImage<vpRGBa> &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam,
                              double size, const vpColor &color, unsigned int thickness)
{
  vp_display_display_camera(I, cMo, cam, size, color, thickness);
}
 
void vpDisplay::displayCharString(const vpImage<vpRGBa> &I, const vpImagePoint &ip, const char *string,
                                  const vpColor &color)
{
  vp_display_display_char_string(I, ip, string, color);
}
 
void vpDisplay::displayCharString(const vpImage<vpRGBa> &I, int i, int j, const char *string, const vpColor &color)
{
  vp_display_display_char_string(I, i, j, string, color);
}
 
void vpDisplay::displayCircle(const vpImage<vpRGBa> &I, const vpImagePoint &center, unsigned int radius,
                              const vpColor &color, bool fill, unsigned int thickness)
{
  vp_display_display_circle(I, center, radius, color, fill, thickness);
}
 
void vpDisplay::displayCircle(const vpImage<vpRGBa> &I, int i, int j, unsigned int radius, const vpColor &color,
                              bool fill, unsigned int thickness)
{
  vp_display_display_circle(I, i, j, radius, color, fill, thickness);
}
 
void vpDisplay::displayCross(const vpImage<vpRGBa> &I, const vpImagePoint &ip, unsigned int size, const vpColor &color,
                             unsigned int thickness)
{
  vp_display_display_cross(I, ip, size, color, thickness);
}
 
void vpDisplay::displayCross(const vpImage<vpRGBa> &I, int i, int j, unsigned int size, const vpColor &color,
                             unsigned int thickness)
{
  vp_display_display_cross(I, i, j, size, color, thickness);
}
 
void vpDisplay::displayDotLine(const vpImage<vpRGBa> &I, const vpImagePoint &ip1, const vpImagePoint &ip2,
                               const vpColor &color, unsigned int thickness)
{
  vp_display_display_dot_line(I, ip1, ip2, color, thickness);
}
 
void vpDisplay::displayDotLine(const vpImage<vpRGBa> &I, int i1, int j1, int i2, int j2, const vpColor &color,
                               unsigned int thickness)
{
  vp_display_display_dot_line(I, i1, j1, i2, j2, color, thickness);
}
 
void vpDisplay::displayDotLine(const vpImage<vpRGBa> &I, const std::vector<vpImagePoint> &ips, bool closeTheShape,
                               const vpColor &color, unsigned int thickness)
{
  if (ips.size() <= 1)
    return;
 
  for (size_t i = 0; i < ips.size() - 1; i++)
    vp_display_display_dot_line(I, ips[i], ips[i + 1], color, thickness);
 
  if (closeTheShape)
    vp_display_display_dot_line(I, ips.front(), ips.back(), color, thickness);
}
 
void vpDisplay::displayDotLine(const vpImage<vpRGBa> &I, const std::list<vpImagePoint> &ips, bool closeTheShape,
                               const vpColor &color, unsigned int thickness)
{
  if (ips.size() <= 1)
    return;
 
  std::list<vpImagePoint>::const_iterator it = ips.begin();
 
  vpImagePoint ip_prev = *(it++);
  for (; it != ips.end(); ++it) {
    if (vpImagePoint::distance(ip_prev, *it) > 1) {
      vp_display_display_dot_line(I, ip_prev, *it, color, thickness);
      ip_prev = *it;
    }
  }
 
  if (closeTheShape) {
    vp_display_display_dot_line(I, ips.front(), ips.back(), color, thickness);
  }
}
 
void vpDisplay::displayEllipse(const vpImage<vpRGBa> &I, const vpImagePoint &center, const double &coef1,
                               const double &coef2, const double &coef3, bool use_normalized_centered_moments,
                               const vpColor &color, unsigned int thickness, bool display_center, bool display_arc)
{
  vpDisplay::displayEllipse(I, center, coef1, coef2, coef3, 0., 2 * M_PI, use_normalized_centered_moments, color,
                            thickness, display_center, display_arc);
}
 
void vpDisplay::displayEllipse(const vpImage<vpRGBa> &I, const vpImagePoint &center, const double &coef1,
                               const double &coef2, const double &coef3, const double &smallalpha,
                               const double &highalpha, bool use_normalized_centered_moments, const vpColor &color,
                               unsigned int thickness, bool display_center, bool display_arc)
{
  vp_display_display_ellipse(I, center, coef1, coef2, coef3, smallalpha, highalpha, use_normalized_centered_moments,
                             color, thickness, display_center, display_arc);
}
 
void vpDisplay::displayFrame(const vpImage<vpRGBa> &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam,
                             double size, const vpColor &color, unsigned int thickness, const vpImagePoint &offset,
                             const std::string& frameName, const vpColor& textColor, const vpImagePoint& textOffset)
{
  vp_display_display_frame(I, cMo, cam, size, color, thickness, offset, frameName, textColor, textOffset);
}
 
void vpDisplay::displayLine(const vpImage<vpRGBa> &I, const vpImagePoint &ip1, const vpImagePoint &ip2,
                            const vpColor &color, unsigned int thickness, bool segment)
{
  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);
}
 
void vpDisplay::displayLine(const vpImage<vpRGBa> &I, int i1, int j1, int i2, int j2, const vpColor &color,
                            unsigned int thickness, bool segment)
{
  if (segment) {
    vp_display_display_line(I, i1, j1, i2, j2, color, thickness);
  } else {
    // line equation in image: i = a * j + b
    double delta_j = static_cast<double>(j2) - static_cast<double>(j1);
    double delta_i = static_cast<double>(i2) - static_cast<double>(i1);
    // Test if horizontal line
    if (std::fabs(delta_i) <= std::numeric_limits<double>::epsilon()) {
      vp_display_display_line(I, i1, 0, i1, (I.getWidth() - 1), color, thickness);
    }
    // Test if vertical line
    else if (std::fabs(delta_j) <= std::numeric_limits<double>::epsilon()) {
      vp_display_display_line(I, 0, j1, (I.getHeight() - 1), j1, color, thickness);
    } else {
      double a = delta_i / delta_j;
      double b = static_cast<double>(i1) - a * static_cast<double>(j1);
      std::vector<vpImagePoint> vip; // Image points that intersect image borders
      // Test intersection with vertical line j=0
      vpImagePoint ip_left(b, 0);
      if (ip_left.get_i() >= 0. && ip_left.get_i() <= (I.getHeight() - 1.)) {
        vip.push_back(ip_left);
      }
      // Test intersection with vertical line j=width-1
      vpImagePoint ip_right(a * (I.getWidth() - 1) + b, I.getWidth() - 1.);
      if (ip_right.get_i() >= 0. && ip_right.get_i() <= (I.getHeight() - 1.)) {
        vip.push_back(ip_right);
      }
      if (vip.size() == 2) {
        vp_display_display_line(I, vip[0], vip[1], color, thickness);
        return;
      }
      // Test intersection with horizontal line i=0
      vpImagePoint ip_top(0, -b / a);
      if (ip_top.get_j() >= 0. && ip_top.get_j() <= (I.getWidth() - 1.)) {
        vip.push_back(ip_top);
      }
      if (vip.size() == 2) {
        vp_display_display_line(I, vip[0], vip[1], color, thickness);
        return;
      }
      // Test intersection with horizontal line i=height-1
      vpImagePoint ip_bottom(I.getHeight() - 1., (I.getHeight() - 1. - b) / a);
      if (ip_bottom.get_j() >= 0. && ip_bottom.get_j() <= (I.getWidth() - 1.)) {
        vip.push_back(ip_bottom);
      }
      if (vip.size() == 2) {
        vp_display_display_line(I, vip[0], vip[1], color, thickness);
        return;
      }
    }
  }
}
 
void vpDisplay::displayLine(const vpImage<vpRGBa> &I, const std::vector<vpImagePoint> &ips, bool closeTheShape,
                            const vpColor &color, unsigned int thickness)
{
  if (ips.size() <= 1)
    return;
 
  for (size_t i = 0; i < ips.size() - 1; i++)
    vp_display_display_line(I, ips[i], ips[i + 1], color, thickness);
 
  if (closeTheShape)
    vp_display_display_line(I, ips.front(), ips.back(), color, thickness);
}
 
void vpDisplay::displayLine(const vpImage<vpRGBa> &I, const std::list<vpImagePoint> &ips, bool closeTheShape,
                            const vpColor &color, unsigned int thickness)
{
  if (ips.size() <= 1)
    return;
 
  std::list<vpImagePoint>::const_iterator it = ips.begin();
 
  vpImagePoint ip_prev = *(it++);
  for (; it != ips.end(); ++it) {
    if (vpImagePoint::distance(ip_prev, *it) > 1) {
      vp_display_display_line(I, ip_prev, *it, color, thickness);
      ip_prev = *it;
    }
  }
 
  if (closeTheShape) {
    vp_display_display_line(I, ips.front(), ips.back(), color, thickness);
  }
}
 
void vpDisplay::displayPoint(const vpImage<vpRGBa> &I, const vpImagePoint &ip, const vpColor &color,
                             unsigned int thickness)
{
  vp_display_display_point(I, ip, color, thickness);
}
 
void vpDisplay::displayPoint(const vpImage<vpRGBa> &I, int i, int j, const vpColor &color, unsigned int thickness)
{
  vp_display_display_point(I, i, j, color, thickness);
}
 
void vpDisplay::displayPolygon(const vpImage<vpRGBa> &I, const std::vector<vpImagePoint> &vip, const vpColor &color,
                               unsigned int thickness, bool closed)
{
  vp_display_display_polygon(I, vip, color, thickness, closed);
}
 
void vpDisplay::displayRectangle(const vpImage<vpRGBa> &I, const vpImagePoint &topLeft, unsigned int width,
                                 unsigned int height, const vpColor &color, bool fill, unsigned int thickness)
{
  vp_display_display_rectangle(I, topLeft, width, height, color, fill, thickness);
}
 
void vpDisplay::displayRectangle(const vpImage<vpRGBa> &I, int i, int j, unsigned int width, unsigned int height,
                                 const vpColor &color, bool fill, unsigned int thickness)
{
  vp_display_display_rectangle(I, i, j, width, height, color, fill, thickness);
}
 
void vpDisplay::displayRectangle(const vpImage<vpRGBa> &I, const vpRect &rectangle, const vpColor &color, bool fill,
                                 unsigned int thickness)
{
  vp_display_display_rectangle(I, rectangle, color, fill, thickness);
}
 
void vpDisplay::displayRectangle(const vpImage<vpRGBa> &I, const vpImagePoint &center, float angle, unsigned int width,
                                 unsigned int height, const vpColor &color, unsigned int thickness)
{
  vp_display_display_rectangle(I, center, angle, width, height, color, thickness);
}
 
void vpDisplay::displayRectangle(const vpImage<vpRGBa> &I, const vpImagePoint &topLeft, const vpImagePoint &bottomRight,
                                 const vpColor &color, bool fill, unsigned int thickness)
{
  vp_display_display_rectangle(I, topLeft, bottomRight, color, fill, thickness);
}
 
void vpDisplay::displayRectangle(const vpImage<vpRGBa> &I, unsigned int i, unsigned int j, float angle,
                                 unsigned int width, unsigned int height, const vpColor &color, unsigned int thickness)
{
  vp_display_display_rectangle(I, i, j, angle, width, height, color, thickness);
}
 
void vpDisplay::displayText(const vpImage<vpRGBa> &I, const vpImagePoint &ip, const std::string &s,
                            const vpColor &color)
{
  vp_display_display_text(I, ip, s, color);
}
 
void vpDisplay::displayText(const vpImage<vpRGBa> &I, int i, int j, const std::string &s, const vpColor &color)
{
  vp_display_display_text(I, i, j, s, color);
}
 
void vpDisplay::flush(const vpImage<vpRGBa> &I) { vp_display_flush(I); }
 
void vpDisplay::flushROI(const vpImage<vpRGBa> &I, const vpRect &roi) { vp_display_flush_roi(I, roi); }
 
void vpDisplay::display(const vpImage<vpRGBa> &I) { vp_display_display(I); }
 
void vpDisplay::displayROI(const vpImage<vpRGBa> &I, const vpRect &roi) { vp_display_display_roi(I, roi); }
 
bool vpDisplay::getClick(const vpImage<vpRGBa> &I, bool blocking) { return vp_display_get_click(I, blocking); }
 
bool vpDisplay::getClick(const vpImage<vpRGBa> &I, vpImagePoint &ip, bool blocking)
{
  return vp_display_get_click(I, ip, blocking);
}
 
bool vpDisplay::getClick(const vpImage<vpRGBa> &I, vpImagePoint &ip, vpMouseButton::vpMouseButtonType &button,
                         bool blocking)
{
  return vp_display_get_click(I, ip, button, blocking);
}
 
bool vpDisplay::getClick(const vpImage<vpRGBa> &I, vpMouseButton::vpMouseButtonType &button, bool blocking)
{
  vpImagePoint ip;
  return vpDisplay::getClick(I, ip, button, blocking);
}
 
bool vpDisplay::getClickUp(const vpImage<vpRGBa> &I, vpImagePoint &ip, vpMouseButton::vpMouseButtonType &button,
                           bool blocking)
{
  return vp_display_get_click_up(I, ip, button, blocking);
}
 
bool vpDisplay::getClickUp(const vpImage<vpRGBa> &I, vpMouseButton::vpMouseButtonType &button, bool blocking)
{
  vpImagePoint ip;
  return vpDisplay::getClickUp(I, ip, button, blocking);
}
 
bool vpDisplay::getKeyboardEvent(const vpImage<vpRGBa> &I, bool blocking)
{
  return vp_display_get_keyboard_event(I, blocking);
}
 
bool vpDisplay::getKeyboardEvent(const vpImage<vpRGBa> &I, std::string &key, bool blocking)
{
  return vp_display_get_keyboard_event(I, key, blocking);
}
 
bool vpDisplay::getKeyboardEvent(const vpImage<vpRGBa> &I, char *key, bool blocking)
{
  return vp_display_get_keyboard_event(I, key, blocking);
}
 
bool vpDisplay::getPointerMotionEvent(const vpImage<vpRGBa> &I, vpImagePoint &ip)
{
  return vp_display_get_pointer_motion_event(I, ip);
}
 
bool vpDisplay::getPointerPosition(const vpImage<vpRGBa> &I, vpImagePoint &ip)
{
  return vp_display_get_pointer_position(I, ip);
}
 
void vpDisplay::setBackground(const vpImage<vpRGBa> &I, const vpColor &color) { vp_display_set_background(I, color); }
 
void vpDisplay::setFont(const vpImage<vpRGBa> &I, const std::string &fontname) { vp_display_set_font(I, fontname); }
 
void vpDisplay::setTitle(const vpImage<vpRGBa> &I, const std::string &windowtitle)
{
  vp_display_set_title(I, windowtitle);
}
 
void vpDisplay::setWindowPosition(const vpImage<vpRGBa> &I, int winx, int winy)
{
  vp_display_set_window_position(I, winx, winy);
}
 
unsigned int vpDisplay::getDownScalingFactor(const vpImage<vpRGBa> &I) { return vp_display_get_down_scaling_factor(I); }