Visual Servoing Platform  version 3.5.1 under development (2022-10-03)

Example of eye-in-hand control law. We control here a real robot, the Viper S650 robot (arm with 6 degrees of freedom). The velocity is computed in camera frame. The inverse jacobian that converts cartesian velocities in joint velocities is implemented in the robot low level controller. Visual features are the image coordinates of 4 points. The target is made of 4 dots arranged as a 10cm by 10cm square.The device used to acquire images is a Realsense SR300 device.

Camera extrinsic (eMc) parameters are read from SR300-eMc.cnf file located besides this code.

Camera intrinsic parameters are retrieved from the Realsense SDK.

* ViSP, open source Visual Servoing Platform software.
* Copyright (C) 2005 - 2019 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:
* tests the control law
* eye-in-hand control
* velocity computed in the camera frame
* Authors:
* Fabien Spindler
#include <fstream>
#include <iostream>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <visp3/core/vpConfig.h>
#if defined(VISP_HAVE_VIPER650) && defined(VISP_HAVE_REALSENSE) && defined(VISP_HAVE_X11)
#include <visp3/blob/vpDot2.h>
#include <visp3/core/vpHomogeneousMatrix.h>
#include <visp3/core/vpIoTools.h>
#include <visp3/core/vpPoint.h>
#include <visp3/gui/vpDisplayX.h>
#include <visp3/robot/vpRobotViper650.h>
#include <visp3/sensor/vpRealSense.h>
#include <visp3/vision/vpPose.h>
#include <visp3/visual_features/vpFeatureBuilder.h>
#include <visp3/visual_features/vpFeaturePoint.h>
#include <visp3/vs/vpServo.h>
#include <visp3/vs/vpServoDisplay.h>
#define L 0.05 // to deal with a 10cm by 10cm square
void compute_pose(std::vector<vpPoint> &point, std::vector<vpDot2> &dot, vpCameraParameters cam,
vpHomogeneousMatrix cMo_dementhon; // computed pose with dementhon method
vpHomogeneousMatrix cMo_lagrange; // computed pose with lagrange method
vpPose pose;
for (size_t i = 0; i < point.size(); i++) {
double x = 0, y = 0;
vpImagePoint cog = dot[i].getCog();
y); // pixel to meter conversion
point[i].set_x(x); // projection perspective p
if (init == true) {
pose.computePose(vpPose::DEMENTHON, cMo_dementhon);
// Compute and return the residual expressed in meter for the pose matrix
double residual_dementhon = pose.computeResidual(cMo_dementhon);
pose.computePose(vpPose::LAGRANGE, cMo_lagrange);
double residual_lagrange = pose.computeResidual(cMo_lagrange);
// Select the best pose to initialize the lowe pose computation
if (residual_lagrange < residual_dementhon)
cMo = cMo_lagrange;
cMo = cMo_dementhon;
int main()
// Log file creation in /tmp/$USERNAME/log.dat
// This file contains by line:
// - the 6 computed camera velocities (m/s, rad/s) to achieve the task
// - the 6 mesured joint velocities (m/s, rad/s)
// - the 6 mesured joint positions (m, rad)
// - the 8 values of s - s*
std::string username;
// Get the user login name
// Create a log filename to save velocities...
std::string logdirname;
logdirname = "/tmp/" + username;
// Test if the output path exist. If no try to create it
if (vpIoTools::checkDirectory(logdirname) == false) {
try {
// Create the dirname
} catch (...) {
std::cerr << std::endl << "ERROR:" << std::endl;
std::cerr << " Cannot create " << logdirname << std::endl;
return (-1);
std::string logfilename;
logfilename = logdirname + "/log.dat";
// Open the log file name
std::ofstream flog(logfilename.c_str());
try {
// Load the end-effector to camera frame transformation from SR300-eMc.cnf
// file
robot.init(vpRobotViper650::TOOL_CUSTOM, "./SR300-eMc.cnf");
std::cout << "Camera extrinsic parameters (eMc): \n" << eMc << std::endl;
vpServo task;
// Enable the RealSense device to acquire only color images with size
// 640x480
g.setEnableStream(rs::stream::color, true);
g.setEnableStream(rs::stream::depth, false);
g.setEnableStream(rs::stream::infrared, false);
g.setEnableStream(rs::stream::infrared2, false);
g.setStreamSettings(rs::stream::color, vpRealSense::vpRsStreamParams(640, 480, rs::format::rgba8, 30));;
// Update camera parameters
std::cout << "Camera intrinsic parameters: \n" << cam << std::endl;
vpDisplayX display(I, 100, 100, "Current image");
std::vector<vpDot2> dot(4);
std::cout << "Click on the 4 dots clockwise starting from upper/left dot..." << std::endl;
for (size_t i = 0; i < dot.size(); i++) {
vpImagePoint cog = dot[i].getCog();
// Sets the current position of the visual feature
for (size_t i = 0; i < dot.size(); i++)
vpFeatureBuilder::create(p[i], cam, dot[i]); // retrieve x,y of the vpFeaturePoint structure
// Set the position of the square target in a frame which origin is
// centered in the middle of the square
std::vector<vpPoint> point(4);
point[0].setWorldCoordinates(-L, -L, 0);
point[1].setWorldCoordinates(L, -L, 0);
point[2].setWorldCoordinates(L, L, 0);
point[3].setWorldCoordinates(-L, L, 0);
// Compute target initial pose
compute_pose(point, dot, cam, cMo, true);
std::cout << "Initial camera pose (cMo): \n" << cMo << std::endl;
// Initialise a desired pose to compute s*, the desired 2D point features
vpHomogeneousMatrix cMo_d(vpTranslationVector(0, 0, 0.5), // tz = 0.5 meter
vpRotationMatrix()); // no rotation
// Sets the desired position of the 2D visual feature
// Compute the desired position of the features from the desired pose
for (int i = 0; i < 4; i++) {
vpColVector cP, p;
point[i].changeFrame(cMo_d, cP);
point[i].projection(cP, p);
// We want to see a point on a point
for (size_t i = 0; i < dot.size(); i++)
task.addFeature(p[i], pd[i]);
// Set the proportional gain
// Define the task
// - we want an eye-in-hand control law
// - camera velocities are computed
// Initialise the velocity control of the robot
std::cout << "\nHit CTRL-C or click in the image to stop the loop...\n" << std::flush;
for (;;) {
// Acquire a new image from the camera
// Display this image
try {
// For each point...
for (size_t i = 0; i < dot.size(); i++) {
// Achieve the tracking of the dot in the image
// Display a green cross at the center of gravity position in the
// image
vpImagePoint cog = dot[i].getCog();
} catch (...) {
std::cout << "Error detected while tracking visual features.." << std::endl;
// During the servo, we compute the pose using a non linear method. For
// the initial pose used in the non linear minimisation we use the pose
// computed at the previous iteration.
compute_pose(point, dot, cam, cMo, false);
for (size_t i = 0; i < dot.size(); i++) {
// Update the point feature from the dot location
vpFeatureBuilder::create(p[i], cam, dot[i]);
// Set the feature Z coordinate from the pose
point[i].changeFrame(cMo, cP);
// Compute the visual servoing skew vector
// Display the current and desired feature points in the image display
vpServoDisplay::display(task, cam, I);
// Apply the computed joint velocities to the robot
// Save velocities applied to the robot in the log file
// v[0], v[1], v[2] correspond to camera translation velocities in m/s
// v[3], v[4], v[5] correspond to camera rotation velocities in rad/s
flog << v[0] << " " << v[1] << " " << v[2] << " " << v[3] << " " << v[4] << " " << v[5] << " ";
// Get the measured joint velocities of the robot
// Save measured joint velocities of the robot in the log file:
// - qvel[0], qvel[1], qvel[2] correspond to measured joint translation
// velocities in m/s
// - qvel[3], qvel[4], qvel[5] correspond to measured joint rotation
// velocities in rad/s
flog << qvel[0] << " " << qvel[1] << " " << qvel[2] << " " << qvel[3] << " " << qvel[4] << " " << qvel[5] << " ";
// Get the measured joint positions of the robot
robot.getPosition(vpRobot::ARTICULAR_FRAME, q);
// Save measured joint positions of the robot in the log file
// - q[0], q[1], q[2] correspond to measured joint translation
// positions in m
// - q[3], q[4], q[5] correspond to measured joint rotation
// positions in rad
flog << q[0] << " " << q[1] << " " << q[2] << " " << q[3] << " " << q[4] << " " << q[5] << " ";
// Save feature error (s-s*) for the 4 feature points. For each feature
// point, we have 2 errors (along x and y axis). This error is
// expressed in meters in the camera frame
flog << task.getError() << std::endl;
vpDisplay::displayText(I, 10, 10, "Click to quit...", vpColor::red);
if (vpDisplay::getClick(I, false))
// Flush the display
// std::cout << "\t\t || s - s* || = " << ( task.getError()
// ).sumSquare() << std::endl;
std::cout << "Display task information: " << std::endl;
flog.close(); // Close the log file
} catch (const vpException &e) {
flog.close(); // Close the log file
std::cout << "Catch an exception: " << e.getMessage() << std::endl;
int main()
std::cout << "You do not have an Viper 650 robot connected to your computer..." << std::endl;
Generic class defining intrinsic camera parameters.
Implementation of column vector and the associated operations.
Definition: vpColVector.h:131
static const vpColor red
Definition: vpColor.h:217
static const vpColor blue
Definition: vpColor.h:223
static const vpColor green
Definition: vpColor.h:220
Use the X11 console to display images on unix-like OS. Thus to enable this class X11 should be instal...
Definition: vpDisplayX.h:135
static bool getClick(const vpImage< unsigned char > &I, bool blocking=true)
static void display(const vpImage< unsigned char > &I)
static void displayCross(const vpImage< unsigned char > &I, const vpImagePoint &ip, unsigned int size, const vpColor &color, unsigned int thickness=1)
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 emited by ViSP classes.
Definition: vpException.h:72
const char * getMessage() const
Definition: vpException.cpp:87
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 set_y(double y)
void set_x(double x)
void set_Z(double Z)
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:89
void init(unsigned int h, unsigned int w, Type value)
Definition: vpImage.h:631
static bool checkDirectory(const std::string &dirname)
Definition: vpIoTools.cpp:418
static std::string getUserName()
Definition: vpIoTools.cpp:314
static void makeDirectory(const std::string &dirname)
Definition: vpIoTools.cpp:568
static void convertPoint(const vpCameraParameters &cam, const double &u, const double &v, double &x, double &y)
Class used for pose computation from N points (pose from point only). Some of the algorithms implemen...
Definition: vpPose.h:90
void addPoint(const vpPoint &P)
Definition: vpPose.cpp:148
Definition: vpPose.h:95
Definition: vpPose.h:94
Definition: vpPose.h:96
double computeResidual(const vpHomogeneousMatrix &cMo) const
Compute and return the sum of squared residuals expressed in meter^2 for the pose matrix cMo.
Definition: vpPose.cpp:335
bool computePose(vpPoseMethodType method, vpHomogeneousMatrix &cMo, bool(*func)(const vpHomogeneousMatrix &)=NULL)
Definition: vpPose.cpp:373
void setStreamSettings(const rs::stream &stream, const rs::preset &preset)
vpCameraParameters getCameraParameters(const rs::stream &stream, vpCameraParameters::vpCameraParametersProjType type=vpCameraParameters::perspectiveProjWithDistortion) const
void acquire(std::vector< vpColVector > &pointcloud)
void setEnableStream(const rs::stream &stream, bool status)
void setVelocity(const vpRobot::vpControlFrameType frame, const vpColVector &vel)
void getVelocity(const vpRobot::vpControlFrameType frame, vpColVector &velocity)
Control of Irisa's Viper S650 robot named Viper650.
Definition: vpRobot.h:79
Definition: vpRobot.h:83
Initialize the velocity controller.
Definition: vpRobot.h:67
virtual vpRobotStateType setRobotState(const vpRobot::vpRobotStateType newState)
Definition: vpRobot.cpp:201
Implementation of a rotation matrix and operations on such kind of matrices.
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:564
Definition: vpServo.h:155
void print(const vpServo::vpServoPrintType display_level=ALL, std::ostream &os=std::cout)
Definition: vpServo.cpp:303
void setLambda(double c)
Definition: vpServo.h:404
void setServo(const vpServoType &servo_type)
Definition: vpServo.cpp:215
vpColVector getError() const
Definition: vpServo.h:278
Definition: vpServo.h:202
vpColVector computeControlLaw()
Definition: vpServo.cpp:926
Definition: vpServo.h:182
void addFeature(vpBasicFeature &s, vpBasicFeature &s_star, unsigned int select=vpBasicFeature::FEATURE_ALL)
Definition: vpServo.cpp:487
Class that consider the case of a translation vector.