Visual Servoing Platform  version 3.6.1 under development (2024-05-21)

Simulation of a 2D visual servoing:Simulation of a 2D visual servoing:

Interaction matrix is computed as the mean of the current and desired interaction matrix.

* ViSP, open source Visual Servoing Platform software.
* Copyright (C) 2005 - 2023 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 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
* This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
* Description:
* Simulation of a 2D visual servoing using 4 points as visual feature.
#include <iostream>
#include <visp3/core/vpConfig.h>
#if (defined(VISP_HAVE_X11) || defined(VISP_HAVE_GTK) || defined(VISP_HAVE_GDI) || defined(VISP_HAVE_OPENCV)) && \
(defined(VISP_HAVE_LAPACK) || defined(VISP_HAVE_EIGEN3) || defined(VISP_HAVE_OPENCV))
#include <stdio.h>
#include <stdlib.h>
#include <visp3/core/vpCameraParameters.h>
#include <visp3/core/vpHomogeneousMatrix.h>
#include <visp3/core/vpImage.h>
#include <visp3/core/vpMath.h>
#include <visp3/gui/vpDisplayGDI.h>
#include <visp3/gui/vpDisplayGTK.h>
#include <visp3/gui/vpDisplayOpenCV.h>
#include <visp3/gui/vpDisplayX.h>
#include <visp3/gui/vpProjectionDisplay.h>
#include <visp3/io/vpParseArgv.h>
#include <visp3/robot/vpSimulatorCamera.h>
#include <visp3/visual_features/vpFeatureBuilder.h>
#include <visp3/visual_features/vpFeaturePoint.h>
#include <visp3/vs/vpServo.h>
#include <visp3/vs/vpServoDisplay.h>
// List of allowed command line options
#define GETOPTARGS "cdh"
void usage(const char *name, const char *badparam);
bool getOptions(int argc, const char **argv, bool &click_allowed, bool &display);
void usage(const char *name, const char *badparam)
fprintf(stdout, "\n\
Tests a control law with the following characteristics:\n\
- eye-in-hand control\n\
- articular velocity are computed\n\
- servo on 4 points,\n\
- internal and external camera view displays.\n\
%s [-c] [-d] [-h]\n",
fprintf(stdout, "\n\
OPTIONS: Default\n\
Disable the mouse click. Useful to automate the \n\
execution of this program without human intervention.\n\
-d \n\
Turn off the display.\n\
Print the help.\n");
if (badparam)
fprintf(stdout, "\nERROR: Bad parameter [%s]\n", badparam);
bool getOptions(int argc, const char **argv, bool &click_allowed, bool &display)
const char *optarg_;
int c;
while ((c = vpParseArgv::parse(argc, argv, GETOPTARGS, &optarg_)) > 1) {
switch (c) {
case 'c':
click_allowed = false;
case 'd':
display = false;
case 'h':
usage(argv[0], nullptr);
return false;
usage(argv[0], optarg_);
return false;
if ((c == 1) || (c == -1)) {
// standalone param or error
usage(argv[0], nullptr);
std::cerr << "ERROR: " << std::endl;
std::cerr << " Bad argument " << optarg_ << std::endl << std::endl;
return false;
return true;
int main(int argc, const char **argv)
try {
bool opt_click_allowed = true;
bool opt_display = true;
// Read the command line options
if (getOptions(argc, argv, opt_click_allowed, opt_display) == false) {
// We open two displays, one for the internal camera view, the other one for
// the external view, using either X11, GTK or GDI.
#if defined(VISP_HAVE_X11)
vpDisplayX displayInt;
vpDisplayX displayExt;
#elif defined(VISP_HAVE_GTK)
vpDisplayGTK displayInt;
vpDisplayGTK displayExt;
#elif defined(VISP_HAVE_GDI)
vpDisplayGDI displayInt;
vpDisplayGDI displayExt;
#elif defined(HAVE_OPENCV_HIGHGUI)
vpDisplayOpenCV displayInt;
vpDisplayOpenCV displayExt;
// open a display for the visualization
vpImage<unsigned char> Iint(300, 300, 0);
vpImage<unsigned char> Iext(300, 300, 0);
if (opt_display) {
displayInt.init(Iint, 0, 0, "Internal view");
displayExt.init(Iext, 330, 000, "External view");
vpProjectionDisplay externalview;
double px = 500, py = 500;
double u0 = 150, v0 = 160;
vpCameraParameters cam(px, py, u0, v0);
vpServo task;
std::cout << std::endl;
std::cout << "----------------------------------------------" << std::endl;
std::cout << " Test program for vpServo " << std::endl;
std::cout << " Eye-in-hand task control, articular velocity are computed" << std::endl;
std::cout << " Simulation " << std::endl;
std::cout << " task : servo 4 points " << std::endl;
std::cout << "----------------------------------------------" << std::endl;
std::cout << std::endl;
// sets the initial camera location
vpHomogeneousMatrix cMo(-0.1, -0.1, 1, vpMath::rad(40), vpMath::rad(10), vpMath::rad(60));
// Compute the position of the object in the world frame
wMo = wMc * cMo;
vpHomogeneousMatrix cextMo(0, 0, 2, 0, 0, 0); // vpMath::rad(40), vpMath::rad(10), vpMath::rad(60));
// sets the point coordinates in the object frame
vpPoint point[4];
point[0].setWorldCoordinates(-0.1, -0.1, 0);
point[1].setWorldCoordinates(0.1, -0.1, 0);
point[2].setWorldCoordinates(0.1, 0.1, 0);
point[3].setWorldCoordinates(-0.1, 0.1, 0);
for (unsigned i = 0; i < 4; i++)
// computes the point coordinates in the camera frame and its 2D
// coordinates
for (unsigned i = 0; i < 4; i++)
// sets the desired position of the point
for (unsigned i = 0; i < 4; i++)
vpFeatureBuilder::create(p[i], point[i]); // retrieve x,y and Z of the vpPoint structure
// sets the desired position of the feature point s*
pd[0].buildFrom(-0.1, -0.1, 1);
pd[1].buildFrom(0.1, -0.1, 1);
pd[2].buildFrom(0.1, 0.1, 1);
pd[3].buildFrom(-0.1, 0.1, 1);
// define the task
// - we want an eye-in-hand control law
// - articular velocity are computed
// Set the position of the end-effector frame in the camera frame as identity
// Set the Jacobian (expressed in the end-effector frame
vpMatrix eJe;
// we want to see a point on a point
for (unsigned i = 0; i < 4; i++)
task.addFeature(p[i], pd[i]);
// set the gain
// Display task information
unsigned int iter = 0;
// loop
while (iter++ < 200) {
std::cout << "---------------------------------------------" << iter << std::endl;
// Set the Jacobian (expressed in the end-effector frame)
// since q is modified eJe is modified
// get the robot position
// Compute the position of the object frame in the camera frame
cMo = wMc.inverse() * wMo;
// update new point position and corresponding features
for (unsigned i = 0; i < 4; i++) {
// retrieve x,y and Z of the vpPoint structure
vpFeatureBuilder::create(p[i], point[i]);
// since vpServo::MEAN interaction matrix is used, we need also to
// update the desired features at each iteration
pd[0].buildFrom(-0.1, -0.1, 1);
pd[1].buildFrom(0.1, -0.1, 1);
pd[2].buildFrom(0.1, 0.1, 1);
pd[3].buildFrom(-0.1, 0.1, 1);
if (opt_display) {
vpServoDisplay::display(task, cam, Iint);
externalview.display(Iext, cextMo, cMo, cam, vpColor::green);
// compute the control law
v = task.computeControlLaw();
// send the camera velocity to the controller
std::cout << "|| s - s* || = " << (task.getError()).sumSquare() << std::endl;
// Display task information
std::cout << "Final robot position with respect to the object frame:\n";
if (opt_display && opt_click_allowed) {
vpDisplay::displayText(Iint, 20, 20, "Click to quit...", vpColor::white);
} catch (const vpException &e) {
std::cout << "Catch a ViSP exception: " << e << std::endl;
#elif !(defined(VISP_HAVE_LAPACK) || defined(VISP_HAVE_EIGEN3) || defined(VISP_HAVE_OPENCV))
int main()
std::cout << "Cannot run this example: install Lapack, Eigen3 or OpenCV" << std::endl;
int main()
std::cout << "You do not have X11, or GTK, or GDI (Graphical Device Interface) functionalities to display images..."
<< std::endl;
std::cout << "Tip if you are on a unix-like system:" << std::endl;
std::cout << "- Install X11, configure again ViSP using cmake and build again this example" << std::endl;
std::cout << "Tip if you are on a windows-like system:" << std::endl;
std::cout << "- Install GDI, configure again ViSP using cmake and build again this example" << std::endl;
Generic class defining intrinsic camera parameters.
Implementation of column vector and the associated operations.
Definition: vpColVector.h:163
static const vpColor white
Definition: vpColor.h:206
static const vpColor green
Definition: vpColor.h:214
Display for windows using GDI (available on any windows 32 platform).
Definition: vpDisplayGDI.h:128
The vpDisplayGTK allows to display image using the GTK 3rd party library. Thus to enable this class G...
Definition: vpDisplayGTK.h:128
The vpDisplayOpenCV allows to display image using the OpenCV library. Thus to enable this class OpenC...
Use the X11 console to display images on unix-like OS. Thus to enable this class X11 should be instal...
Definition: vpDisplayX.h:128
void init(vpImage< unsigned char > &I, int win_x=-1, int win_y=-1, const std::string &win_title="") vp_override
static bool getClick(const vpImage< unsigned char > &I, bool blocking=true)
static void display(const vpImage< unsigned char > &I)
static void flush(const vpImage< unsigned char > &I)
static void displayText(const vpImage< unsigned char > &I, const vpImagePoint &ip, const std::string &s, const vpColor &color)
error that can be emitted by ViSP classes.
Definition: vpException.h:59
static void create(vpFeaturePoint &s, const vpCameraParameters &cam, const vpDot &d)
Class that defines a 2D point visual feature which is composed by two parameters that are the cartes...
void buildFrom(double x, double y, double Z)
void track(const vpHomogeneousMatrix &cMo)
Implementation of an homogeneous matrix and operations on such kind of matrices.
vpHomogeneousMatrix inverse() const
static double rad(double deg)
Definition: vpMath.h:127
Implementation of a matrix and operations on matrices.
Definition: vpMatrix.h:146
static bool parse(int *argcPtr, const char **argv, vpArgvInfo *argTable, int flags)
Definition: vpParseArgv.cpp:69
Class that defines a 3D point in the object frame and allows forward projection of a 3D point in the ...
Definition: vpPoint.h:77
void setWorldCoordinates(double oX, double oY, double oZ)
Definition: vpPoint.cpp:110
interface with the image for feature display
void display(vpImage< unsigned char > &I, const vpHomogeneousMatrix &cextMo, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, const vpColor &color, const bool &displayTraj=false, unsigned int thickness=1)
void insert(vpForwardProjection &fp)
void get_eJe(vpMatrix &eJe) vp_override
void setVelocity(const vpRobot::vpControlFrameType frame, const vpColVector &vel) vp_override
Definition: vpRobot.h:82
static void display(const vpServo &s, const vpCameraParameters &cam, const vpImage< unsigned char > &I, vpColor currentColor=vpColor::green, vpColor desiredColor=vpColor::red, unsigned int thickness=1)
void setInteractionMatrixType(const vpServoIteractionMatrixType &interactionMatrixType, const vpServoInversionType &interactionMatrixInversion=PSEUDO_INVERSE)
Definition: vpServo.cpp:378
Definition: vpServo.h:162
void addFeature(vpBasicFeature &s_cur, vpBasicFeature &s_star, unsigned int select=vpBasicFeature::FEATURE_ALL)
Definition: vpServo.cpp:329
void set_cVe(const vpVelocityTwistMatrix &cVe_)
Definition: vpServo.h:1028
void print(const vpServo::vpServoPrintType display_level=ALL, std::ostream &os=std::cout)
Definition: vpServo.cpp:169
void setLambda(double c)
Definition: vpServo.h:976
void set_eJe(const vpMatrix &eJe_)
Definition: vpServo.h:1091
void setServo(const vpServoType &servo_type)
Definition: vpServo.cpp:132
vpColVector getError() const
Definition: vpServo.h:504
vpColVector computeControlLaw()
Definition: vpServo.cpp:703
Definition: vpServo.h:208
Class that defines the simplest robot: a free flying camera.
void display(vpImage< unsigned char > &I, const std::string &title)
Display a gray-scale image.