ViSP  2.6.2
servoSimuPoint2DCamVelocity2.cpp

Servo a point:

wrt. servoSimuPoint2DCamVelocity1.cpp only the type of control law is modified. This illustrates the need for Jacobian update and Twist transformation matrix initialization.

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

/****************************************************************************
*
* $Id: servoSimuPoint2DCamVelocity2.cpp 2503 2010-02-16 18:55:01Z fspindle $
*
* This file is part of the ViSP software.
* Copyright (C) 2005 - 2012 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
* ("GPL") version 2 as published by the Free Software Foundation.
* 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 http://www.irisa.fr/lagadic/visp/visp.html for more information.
*
* This software was developed at:
* INRIA Rennes - Bretagne Atlantique
* Campus Universitaire de Beaulieu
* 35042 Rennes Cedex
* France
* http://www.irisa.fr/lagadic
*
* If you have questions regarding the use of this file, please contact
* INRIA at visp@inria.fr
*
* This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
* WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
*
* Description:
* Simulation of a 2D visual servoing on a point.
*
* Authors:
* Eric Marchand
* Fabien Spindler
*
*****************************************************************************/
#include <visp/vpMath.h>
#include <visp/vpHomogeneousMatrix.h>
#include <visp/vpFeaturePoint.h>
#include <visp/vpPoint.h>
#include <visp/vpServo.h>
#include <visp/vpRobotCamera.h>
#include <visp/vpDebug.h>
#include <visp/vpFeatureBuilder.h>
#include <visp/vpParseArgv.h>
#include <stdlib.h>
#include <stdio.h>
// List of allowed command line options
#define GETOPTARGS "h"
void usage(const char *name, const char *badparam)
{
fprintf(stdout, "\n\
Simulation of a 2D visual servoing on a point:\n\
- eye-in-hand control law,\n\
- articular velocity are computed,\n\
- without display.\n\
\n\
SYNOPSIS\n\
%s [-h]\n", name);
fprintf(stdout, "\n\
OPTIONS: Default\n\
\n\
-h\n\
Print the help.\n");
if (badparam)
fprintf(stdout, "\nERROR: Bad parameter [%s]\n", badparam);
}
bool getOptions(int argc, const char **argv)
{
const char *optarg;
int c;
while ((c = vpParseArgv::parse(argc, argv, GETOPTARGS, &optarg)) > 1) {
switch (c) {
case 'h': usage(argv[0], NULL); return false; break;
default:
usage(argv[0], optarg);
return false; break;
}
}
if ((c == 1) || (c == -1)) {
// standalone param or error
usage(argv[0], NULL);
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)
{
// Read the command line options
if (getOptions(argc, argv) == false) {
exit (-1);
}
vpServo task ;
vpRobotCamera robot ;
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 a point " << std::endl ;
std::cout << "-------------------------------------------------------" << std::endl ;
std::cout << std::endl ;
vpTRACE("sets the initial camera location " ) ;
vpHomogeneousMatrix cMo ;
cMo[0][3] = 0.1 ;
cMo[1][3] = 0.2 ;
cMo[2][3] = 2 ;
robot.setPosition(cMo) ;
vpTRACE("sets the point coordinates in the world frame " ) ;
vpPoint point ;
point.setWorldCoordinates(0,0,0) ;
vpTRACE("project : computes the point coordinates in the camera frame and its 2D coordinates" ) ;
point.track(cMo) ;
vpTRACE("sets the current position of the visual feature ") ;
vpFeaturePoint p ;
vpFeatureBuilder::create(p,point) ; //retrieve x,y and Z of the vpPoint structure
vpTRACE("sets the desired position of the visual feature ") ;
vpFeaturePoint pd ;
pd.buildFrom(0,0,1) ;
vpTRACE("define the task") ;
vpTRACE("\t we want an eye-in-hand control law") ;
vpTRACE("\t articular velocity are computed") ;
task.setServo(vpServo::EYEINHAND_L_cVe_eJe) ;
task.setInteractionMatrixType(vpServo::MEAN) ;
vpTRACE("Set the position of the camera in the end-effector frame ") ;
vpHomogeneousMatrix cMe ;
vpVelocityTwistMatrix cVe(cMe) ;
task.set_cVe(cVe) ;
vpTRACE("Set the Jacobian (expressed in the end-effector frame)") ;
vpMatrix eJe ;
robot.get_eJe(eJe) ;
task.set_eJe(eJe) ;
vpTRACE("\t we want to see a point on a point..") ;
task.addFeature(p,pd) ;
vpTRACE("\t set the gain") ;
task.setLambda(1) ;
vpTRACE("Display task information " ) ;
task.print() ;
unsigned int iter=0 ;
vpTRACE("\t loop") ;
while(iter++<100)
{
std::cout << "---------------------------------------------" << iter <<std::endl ;
vpColVector v ;
if (iter==1)
{
vpTRACE("Set the Jacobian (expressed in the end-effector frame)") ;
vpTRACE("since q is modified eJe is modified") ;
}
robot.get_eJe(eJe) ;
task.set_eJe(eJe) ;
if (iter==1) vpTRACE("\t\t get the robot position ") ;
robot.getPosition(cMo) ;
if (iter==1) vpTRACE("\t\t new point position ") ;
point.track(cMo) ;
vpFeatureBuilder::create(p,point) ; //retrieve x,y and Z of the vpPoint structure
if (iter==1) vpTRACE("\t\t compute the control law ") ;
v = task.computeControlLaw() ;
if (iter==1)
{
vpTRACE("Display task information " ) ;
task.print() ;
}
if (iter==1) vpTRACE("\t\t send the camera velocity to the controller ") ;
robot.setVelocity(vpRobot::CAMERA_FRAME, v) ;
vpTRACE("\t\t || s - s* || ") ;
std::cout << ( task.getError() ).sumSquare() <<std::endl ; ;
}
vpTRACE("Display task information " ) ;
task.print() ;
task.kill();
}