Visual Servoing Platform version 3.5.0
servoSimuPoint2DCamVelocity2.cpp
1/****************************************************************************
2 *
3 * ViSP, open source Visual Servoing Platform software.
4 * Copyright (C) 2005 - 2019 by Inria. All rights reserved.
5 *
6 * This software is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 * See the file LICENSE.txt at the root directory of this source
11 * distribution for additional information about the GNU GPL.
12 *
13 * For using ViSP with software that can not be combined with the GNU
14 * GPL, please contact Inria about acquiring a ViSP Professional
15 * Edition License.
16 *
17 * See http://visp.inria.fr for more information.
18 *
19 * This software was developed at:
20 * Inria Rennes - Bretagne Atlantique
21 * Campus Universitaire de Beaulieu
22 * 35042 Rennes Cedex
23 * France
24 *
25 * If you have questions regarding the use of this file, please contact
26 * Inria at visp@inria.fr
27 *
28 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
29 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
30 *
31 * Description:
32 * Simulation of a 2D visual servoing on a point.
33 *
34 * Authors:
35 * Eric Marchand
36 * Fabien Spindler
37 *
38 *****************************************************************************/
39
56#include <stdio.h>
57#include <stdlib.h>
58
59#include <visp3/core/vpHomogeneousMatrix.h>
60#include <visp3/core/vpMath.h>
61#include <visp3/io/vpParseArgv.h>
62#include <visp3/robot/vpSimulatorCamera.h>
63#include <visp3/visual_features/vpFeatureBuilder.h>
64#include <visp3/visual_features/vpFeaturePoint.h>
65#include <visp3/vs/vpServo.h>
66
67// List of allowed command line options
68#define GETOPTARGS "h"
69
70void usage(const char *name, const char *badparam);
71bool getOptions(int argc, const char **argv);
72
81void usage(const char *name, const char *badparam)
82{
83 fprintf(stdout, "\n\
84Simulation of a 2D visual servoing on a point:\n\
85- eye-in-hand control law,\n\
86- articular velocity are computed,\n\
87- without display.\n\
88\n\
89SYNOPSIS\n\
90 %s [-h]\n", name);
91
92 fprintf(stdout, "\n\
93OPTIONS: Default\n\
94\n\
95 -h\n\
96 Print the help.\n");
97
98 if (badparam)
99 fprintf(stdout, "\nERROR: Bad parameter [%s]\n", badparam);
100}
101
112bool getOptions(int argc, const char **argv)
113{
114 const char *optarg_;
115 int c;
116 while ((c = vpParseArgv::parse(argc, argv, GETOPTARGS, &optarg_)) > 1) {
117
118 switch (c) {
119 case 'h':
120 usage(argv[0], NULL);
121 return false;
122
123 default:
124 usage(argv[0], optarg_);
125 return false;
126 }
127 }
128
129 if ((c == 1) || (c == -1)) {
130 // standalone param or error
131 usage(argv[0], NULL);
132 std::cerr << "ERROR: " << std::endl;
133 std::cerr << " Bad argument " << optarg_ << std::endl << std::endl;
134 return false;
135 }
136
137 return true;
138}
139
140int main(int argc, const char **argv)
141{
142#if (defined(VISP_HAVE_LAPACK) || defined(VISP_HAVE_EIGEN3) || defined(VISP_HAVE_OPENCV))
143 try {
144 // Read the command line options
145 if (getOptions(argc, argv) == false) {
146 exit(-1);
147 }
148
149 vpServo task;
150 vpSimulatorCamera robot;
151
152 std::cout << std::endl;
153 std::cout << "-------------------------------------------------------" << std::endl;
154 std::cout << " Test program for vpServo " << std::endl;
155 std::cout << " Eye-in-hand task control, articular velocity are computed" << std::endl;
156 std::cout << " Simulation " << std::endl;
157 std::cout << " task : servo a point " << std::endl;
158 std::cout << "-------------------------------------------------------" << std::endl;
159 std::cout << std::endl;
160
161 // sets the initial camera location
163 cMo[0][3] = 0.1;
164 cMo[1][3] = 0.2;
165 cMo[2][3] = 2;
166 // Compute the position of the object in the world frame
167 vpHomogeneousMatrix wMc, wMo;
168 robot.getPosition(wMc);
169 wMo = wMc * cMo;
170
171 // sets the point coordinates in the world frame
172 vpPoint point(0, 0, 0);
173
174 // computes the point coordinates in the camera frame and its 2D
175 // coordinates
176 point.track(cMo);
177
178 // sets the current position of the visual feature
180 vpFeatureBuilder::create(p, point); // retrieve x,y and Z of the vpPoint structure
181
182 // sets the desired position of the visual feature
184 pd.buildFrom(0, 0, 1);
185
186 // define the task
187 // - we want an eye-in-hand control law
188 // - articular velocity are computed
191
192 // Set the position of the end-effector frame in the camera frame
194 vpVelocityTwistMatrix cVe(cMe);
195 task.set_cVe(cVe);
196
197 // Set the Jacobian (expressed in the end-effector frame)
198 vpMatrix eJe;
199 robot.get_eJe(eJe);
200 task.set_eJe(eJe);
201
202 // we want to see a point on a point
203 task.addFeature(p, pd);
204
205 // set the gain
206 task.setLambda(1);
207 // Display task information
208 task.print();
209
210 unsigned int iter = 0;
211 // loop
212 while (iter++ < 100) {
213 std::cout << "---------------------------------------------" << iter << std::endl;
214 vpColVector v;
215
216 // Set the Jacobian (expressed in the end-effector frame)
217 // since q is modified eJe is modified
218 robot.get_eJe(eJe);
219 task.set_eJe(eJe);
220
221 // get the robot position
222 robot.getPosition(wMc);
223 // Compute the position of the object frame in the camera frame
224 cMo = wMc.inverse() * wMo;
225
226 // new point position
227 point.track(cMo);
228 vpFeatureBuilder::create(p, point); // retrieve x,y and Z of the vpPoint structure
229 pd.buildFrom(0, 0, 1); // Since vpServo::MEAN interaction matrix is
230 // used, we need to update the desired feature at
231 // each iteration
232
233 // compute the control law
234 v = task.computeControlLaw();
235
236 // send the camera velocity to the controller
238
239 std::cout << "|| s - s* || = " << (task.getError()).sumSquare() << std::endl;
240 }
241
242 // Display task information
243 task.print();
244 return EXIT_SUCCESS;
245 } catch (const vpException &e) {
246 std::cout << "Catch a ViSP exception: " << e << std::endl;
247 return EXIT_FAILURE;
248 }
249#else
250 (void)argc;
251 (void)argv;
252 std::cout << "Cannot run this example: install Lapack, Eigen3 or OpenCV" << std::endl;
253 return EXIT_SUCCESS;
254#endif
255}
Implementation of column vector and the associated operations.
Definition: vpColVector.h:131
error that can be emited by ViSP classes.
Definition: vpException.h:72
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)
Implementation of an homogeneous matrix and operations on such kind of matrices.
vpHomogeneousMatrix inverse() const
Implementation of a matrix and operations on matrices.
Definition: vpMatrix.h:154
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:82
void setVelocity(const vpRobot::vpControlFrameType frame, const vpColVector &vel)
void get_eJe(vpMatrix &eJe)
@ CAMERA_FRAME
Definition: vpRobot.h:82
void setInteractionMatrixType(const vpServoIteractionMatrixType &interactionMatrixType, const vpServoInversionType &interactionMatrixInversion=PSEUDO_INVERSE)
Definition: vpServo.cpp:567
@ EYEINHAND_L_cVe_eJe
Definition: vpServo.h:159
void set_cVe(const vpVelocityTwistMatrix &cVe_)
Definition: vpServo.h:448
void print(const vpServo::vpServoPrintType display_level=ALL, std::ostream &os=std::cout)
Definition: vpServo.cpp:306
void setLambda(double c)
Definition: vpServo.h:404
void set_eJe(const vpMatrix &eJe_)
Definition: vpServo.h:506
void setServo(const vpServoType &servo_type)
Definition: vpServo.cpp:218
vpColVector getError() const
Definition: vpServo.h:278
vpColVector computeControlLaw()
Definition: vpServo.cpp:929
@ MEAN
Definition: vpServo.h:190
void addFeature(vpBasicFeature &s, vpBasicFeature &s_star, unsigned int select=vpBasicFeature::FEATURE_ALL)
Definition: vpServo.cpp:490
Class that defines the simplest robot: a free flying camera.