vpDisplay_rgba.cpp

#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::displayEllipse(const vpImage<vpRGBa> &I, const vpImagePoint &center,
                               const double &coef1, const double &coef2, const double &coef3,
                               bool use_centered_moments, const vpColor &color, unsigned int thickness)
{
  vpDisplay::displayEllipse(I, center, coef1, coef2, coef3, 0., vpMath::rad(360), use_centered_moments, color, thickness);
}

void vpDisplay::displayEllipse(const vpImage<vpRGBa> &I, const vpImagePoint &center,
                               const double &coef1, const double &coef2, const double &coef3,
                               const double &theta1, const double &theta2, bool use_centered_moments,
                               const vpColor &color, unsigned int thickness)
{
  vp_display_display_ellipse(I, center, coef1, coef2, coef3, theta1, theta2, use_centered_moments, color, thickness);
}

void
vpDisplay::displayFrame(const vpImage<vpRGBa> &I, const vpHomogeneousMatrix &cMo,
                        const vpCameraParameters &cam, double size, const vpColor &color,
                        unsigned int thickness, vpImagePoint offset)
{
  vp_display_display_frame(I, cMo, cam, size, color, thickness, offset);
}

void vpDisplay::displayLine(const vpImage<vpRGBa> &I, const vpImagePoint &ip1, const vpImagePoint &ip2,
                            const vpColor &color,  unsigned int thickness )
{
  vp_display_display_line(I, ip1, ip2, color, thickness);
}

void vpDisplay::displayLine(const vpImage<vpRGBa> &I, int i1, int j1, int i2, int j2,
                            const vpColor &color, unsigned int thickness )
{
  vp_display_display_line(I, i1, j1, i2, j2, 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)
{
  vp_display_display_polygon(I, vip, color, thickness);
}

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);
}