Visual Servoing Platform  version 3.6.1 under development (2024-06-23)

Visual servoing experiment on 4 points with a visualization from the camera and from an external view using vpSimulator.

* 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 visual servoing with visualization.
#include <visp3/core/vpConfig.h>
#include <visp3/core/vpDebug.h>
#if (defined(VISP_HAVE_COIN3D_AND_GUI))
#include <visp3/ar/vpSimulator.h>
#include <visp3/core/vpCameraParameters.h>
#include <visp3/core/vpImage.h>
#include <visp3/core/vpTime.h>
#include <visp3/core/vpHomogeneousMatrix.h>
#include <visp3/core/vpIoTools.h>
#include <visp3/core/vpMath.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>
using namespace VISP_NAMESPACE_NAME;
static void *mainLoop(void *_simu)
// pointer copy of the vpSimulator instance
vpSimulator *simu = static_cast<vpSimulator *>(_simu);
// Simulation initialization
// sets the initial camera location
vpHomogeneousMatrix cMo(-0.3, -0.2, 3, vpMath::rad(0), vpMath::rad(0), vpMath::rad(40));
vpHomogeneousMatrix wMo; // Set to identity
vpHomogeneousMatrix wMc; // Camera position in the world frame
// Initialize the robot
robot.setSamplingTime(0.04); // 40ms
wMc = wMo * cMo.inverse();
// Send the robot position to the visualizator
// Initialize the camera parameters
// Desired visual features initialization
// sets the points coordinates in the object frame (in meter)
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);
// sets the desired camera location
vpHomogeneousMatrix cMo_d(0, 0, 1, 0, 0, 0);
// computes the 3D point coordinates in the camera frame and its 2D
// coordinates
for (int i = 0; i < 4; i++)
// creates the associated features
for (int i = 0; i < 4; i++)
vpFeatureBuilder::create(pd[i], point[i]);
// Current visual features initialization
// computes the 3D point coordinates in the camera frame and its 2D
// coordinates
for (int i = 0; i < 4; i++)
// creates the associated features
for (int i = 0; i < 4; i++)
vpFeatureBuilder::create(p[i], point[i]);
// Task defintion
vpServo task;
// we want an eye-in-hand control law ;
// 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 (int i = 0; i < 4; i++)
task.addFeature(p[i], pd[i]);
// Set the gain
// Print the current information about the task
// The control loop
int k = 0;
while (k++ < 200) {
double t = vpTime::measureTimeMs();
// Update the current features
for (int i = 0; i < 4; i++) {
vpFeatureBuilder::create(p[i], point[i]);
// Update the robot Jacobian
// Compute the control law
// Send the computed velocity to the robot and compute the new robot
// position
wMc = robot.getPosition();
cMo = wMc.inverse() * wMo;
// Send the robot position to the visualizator
// Print the current information about the task
// Wait 40 ms
vpTime::wait(t, 40);
void *a = nullptr;
return a;
// return (void *);
int main()
try {
// Internal view initialization : view from the robot camera
simu.initInternalViewer(480, 360);
// External view initialization : view from an external camera
simu.initExternalViewer(300, 300);
// Inernal camera parameters initialization
vpCameraParameters cam(800, 800, 240, 180);
// Get the visp-images-data package path or VISP_INPUT_IMAGE_PATH
// environment variable value
std::string ipath = vpIoTools::getViSPImagesDataPath();
std::string filename = "./4points.iv";
// Set the default input path
if (!ipath.empty())
filename = vpIoTools::createFilePath(ipath, "iv/4points.iv");
std::cout << "Load : " << filename << std::endl << "This file should be in the working directory" << std::endl;
// Run the main loop
// Run the simulator
catch (const vpException &e) {
std::cout << "Catch an exception: " << e << std::endl;
int main()
std::cout << "You do not have Coin3D and SoQT or SoWin or SoXt functionalities enabled..." << std::endl;
std::cout << "Tip:" << std::endl;
<< "- Install Coin3D and SoQT or SoWin or SoXt, configure ViSP again 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:171
error that can be emitted by ViSP classes.
Definition: vpException.h:60
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...
Implementation of an homogeneous matrix and operations on such kind of matrices.
vpHomogeneousMatrix inverse() const
static std::string getViSPImagesDataPath()
Definition: vpIoTools.cpp:1864
static std::string createFilePath(const std::string &parent, const std::string &child)
Definition: vpIoTools.cpp:2227
static double rad(double deg)
Definition: vpMath.h:129
Implementation of a matrix and operations on matrices.
Definition: vpMatrix.h:151
Class that defines a 3D point in the object frame and allows forward projection of a 3D point in the ...
Definition: vpPoint.h:79
void setWorldCoordinates(double oX, double oY, double oZ)
Definition: vpPoint.cpp:111
void get_eJe(vpMatrix &eJe) vp_override
void setVelocity(const vpRobot::vpControlFrameType frame, const vpColVector &vel) vp_override
Definition: vpRobot.h:80
void setInteractionMatrixType(const vpServoIteractionMatrixType &interactionMatrixType, const vpServoInversionType &interactionMatrixInversion=PSEUDO_INVERSE)
Definition: vpServo.cpp:380
Definition: vpServo.h:164
void addFeature(vpBasicFeature &s_cur, vpBasicFeature &s_star, unsigned int select=vpBasicFeature::FEATURE_ALL)
Definition: vpServo.cpp:331
void set_cVe(const vpVelocityTwistMatrix &cVe_)
Definition: vpServo.h:1030
void print(const vpServo::vpServoPrintType display_level=ALL, std::ostream &os=std::cout)
Definition: vpServo.cpp:171
void setLambda(double c)
Definition: vpServo.h:978
void set_eJe(const vpMatrix &eJe_)
Definition: vpServo.h:1093
void setServo(const vpServoType &servo_type)
Definition: vpServo.cpp:134
Definition: vpServo.h:231
vpColVector computeControlLaw()
Definition: vpServo.cpp:705
Definition: vpServo.h:204
Class that defines the simplest robot: a free flying camera.
Implementation of a simulator based on Coin3d (
Definition: vpSimulator.h:95
void load(const char *file_name)
load an iv file
void setInternalCameraParameters(vpCameraParameters &cam)
set internal camera parameters
virtual void mainLoop()
activate the mainloop
void getCameraParameters(vpCameraParameters &cam)
get the intrinsic parameters of the camera
Definition: vpSimulator.h:288
void initMainApplication()
perform some initialization in the main program thread
void initApplication(void *(*start_routine)(void *))
begin the main program
void setCameraPosition(vpHomogeneousMatrix &cMf)
set the camera position (from an homogeneous matrix)
void initExternalViewer(unsigned int nlig, unsigned int ncol)
initialize the external view
virtual void initInternalViewer(unsigned int nlig, unsigned int ncol)
initialize the camera view
void closeMainApplication()
vpImagePoint project(const vpCameraParameters &intrinsic_cam_params, const vpColVector &point)
VISP_EXPORT int wait(double t0, double t)
VISP_EXPORT double measureTimeMs()