Visual Servoing Platform  version 3.3.0
servoMomentImage.cpp

Example of moment-based visual servoing with Images

/****************************************************************************
*
* 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 http://visp.inria.fr 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 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:
* Example of visual servoing with moments using an image as object
* container
*
* Authors:
* Filip Novotny
* Manikandan.B
*****************************************************************************/
#define PRINT_CONDITION_NUMBER
#include <iostream>
#include <visp3/core/vpCameraParameters.h>
#include <visp3/core/vpConfig.h>
#include <visp3/core/vpDebug.h>
#include <visp3/core/vpHomogeneousMatrix.h>
#include <visp3/core/vpIoTools.h>
#include <visp3/core/vpMath.h>
#include <visp3/core/vpMomentCommon.h>
#include <visp3/core/vpMomentDatabase.h>
#include <visp3/core/vpMomentObject.h>
#include <visp3/core/vpPlane.h>
#include <visp3/core/vpPoseVector.h>
#include <visp3/gui/vpDisplayGDI.h>
#include <visp3/gui/vpDisplayGTK.h>
#include <visp3/gui/vpDisplayOpenCV.h>
#include <visp3/gui/vpDisplayX.h>
#include <visp3/gui/vpPlot.h>
#include <visp3/robot/vpImageSimulator.h>
#include <visp3/robot/vpSimulatorCamera.h>
#include <visp3/visual_features/vpFeatureBuilder.h>
#include <visp3/visual_features/vpFeatureMomentCommon.h>
#include <visp3/visual_features/vpFeaturePoint.h>
#include <visp3/vs/vpServo.h>
#if !defined(_WIN32) && !defined(VISP_HAVE_PTHREAD)
// Robot simulator used in this example is not available
int main()
{
std::cout << "Can't run this example since vpSimulatorAfma6 capability is "
"not available."
<< std::endl;
std::cout << "You should install pthread third-party library." << std::endl;
return EXIT_SUCCESS;
}
// No display available
#elif !defined(VISP_HAVE_X11) && !defined(VISP_HAVE_OPENCV) && !defined(VISP_HAVE_GDI) && !defined(VISP_HAVE_D3D9) && \
!defined(VISP_HAVE_GTK)
int main()
{
std::cout << "Can't run this example since no display capability is available." << std::endl;
std::cout << "You should install one of the following third-party library: "
"X11, OpenCV, GDI, GTK."
<< std::endl;
return EXIT_SUCCESS;
}
#else
// setup robot parameters
void paramRobot();
// update moment objects and interface
void refreshScene(vpMomentObject &obj);
// initialize scene in the interface
void initScene();
// initialize the moment features
void initFeatures();
void execute(unsigned int nbIter); // launch the simulation
void setInteractionMatrixType(vpServo::vpServoIteractionMatrixType type);
double error();
void planeToABC(vpPlane &pl, double &A, double &B, double &C);
void paramRobot();
void init_visp_plot(vpPlot &);
int main()
{
try {
// intial pose
vpHomogeneousMatrix cMo(-0.1, -0.1, 1.5, -vpMath::rad(20), -vpMath::rad(20), -vpMath::rad(30));
// Desired pose
// init the simulation
init(cMo, cdMo);
execute(1500);
return EXIT_SUCCESS;
} catch (const vpException &e) {
std::cout << "Catch an exception: " << e << std::endl;
return EXIT_FAILURE;
}
}
// init the right display
#if defined VISP_HAVE_X11
vpDisplayX displayInt;
#elif defined VISP_HAVE_OPENCV
vpDisplayOpenCV displayInt;
#elif defined VISP_HAVE_GDI
vpDisplayGDI displayInt;
#elif defined VISP_HAVE_D3D9
vpDisplayD3D displayInt;
#elif defined VISP_HAVE_GTK
vpDisplayGTK displayInt;
#endif
// start and destination positioning matrices
vpSimulatorCamera robot; // robot used in this simulation
vpImage<vpRGBa> Iint(480, 640, 0); // internal image used for interface
// display
vpServo task; // servoing task
vpCameraParameters cam; // robot camera parameters
double _error; // current error
vpImageSimulator imsim; // image simulator used to simulate the
// perspective-projection camera
// several images used in the simulation
vpImage<unsigned char> cur_img(480, 640, 0);
vpImage<unsigned char> src_img(480, 640, 0);
vpImage<unsigned char> dst_img(480, 640, 0);
vpImage<vpRGBa> start_img(480, 640, 0);
vpServo::vpServoIteractionMatrixType interaction_type; // current or desired
// source and destination objects for moment manipulation
// moment sets and their corresponding features
vpMomentCommon *moments;
vpMomentCommon *momentsDes;
vpFeatureMomentCommon *featureMoments;
vpFeatureMomentCommon *featureMomentsDes;
using namespace std;
void initScene()
{
for (int i = 0; i < 4; i++)
X[i].resize(3);
X[0][0] = -0.2;
X[0][1] = -0.1;
X[0][2] = 0;
X[1][0] = 0.2;
X[1][1] = -0.1;
X[1][2] = 0;
X[2][0] = 0.2;
X[2][1] = 0.1;
X[2][2] = 0;
X[3][0] = -0.2;
X[3][1] = 0.1;
X[3][2] = 0;
// init source and destination images
vpImage<unsigned char> tmp_img(480, 640, 255);
vpImage<vpRGBa> tmp_start_img(480, 640, vpRGBa(255, 0, 0));
vpImageSimulator imsim_start;
imsim_start.init(tmp_start_img, X);
imsim_start.setCameraPosition(cdMo);
imsim_start.getImage(start_img, cam);
imsim.init(tmp_img, X);
imsim.setCameraPosition(cMo);
imsim.getImage(src_img, cam);
src.fromImage(src_img, 128, cam);
imsim.setCameraPosition(cdMo);
imsim.getImage(dst_img, cam);
dst.fromImage(dst_img, 128, cam);
}
void refreshScene(vpMomentObject &obj)
{
cur_img = 0;
imsim.setCameraPosition(cMo);
imsim.getImage(cur_img, cam);
obj.fromImage(cur_img, 128, cam);
}
void init(vpHomogeneousMatrix &_cMo, vpHomogeneousMatrix &_cdMo)
{
cMo = _cMo; // init source matrix
cdMo = _cdMo; // init destination matrix
interaction_type = vpServo::CURRENT; // use interaction matrix for current position
displayInt.init(Iint, 700, 0, "Visual servoing with moments");
paramRobot(); // set up robot parameters
initScene(); // initialize graphical scene (for interface)
initFeatures(); // initialize moment features
}
void initFeatures()
{
// A,B,C parameters of source and destination plane
double A;
double B;
double C;
double Ad;
double Bd;
double Cd;
// init main object: using moments up to order 5
// Initializing values from regular plane (with ax+by+cz=d convention)
vpPlane pl;
pl.setABCD(0, 0, 1.0, 0);
pl.changeFrame(cMo);
planeToABC(pl, A, B, C);
pl.setABCD(0, 0, 1.0, 0);
pl.changeFrame(cdMo);
planeToABC(pl, Ad, Bd, Cd);
// extracting initial position (actually we only care about Zdst)
cdMo.extract(vec);
// don't need to be specific, vpMomentCommon automatically loads
// Xg,Yg,An,Ci,Cj,Alpha moments
vpMomentCommon::getAlpha(dst), vec[2], true);
vpMomentCommon::getAlpha(dst), vec[2], true);
// same thing with common features
featureMoments = new vpFeatureMomentCommon(*moments);
featureMomentsDes = new vpFeatureMomentCommon(*momentsDes);
moments->updateAll(src);
momentsDes->updateAll(dst);
featureMoments->updateAll(A, B, C);
featureMomentsDes->updateAll(Ad, Bd, Cd);
// setup the interaction type
task.setInteractionMatrixType(interaction_type);
task.addFeature(featureMoments->getFeatureGravityNormalized(), featureMomentsDes->getFeatureGravityNormalized());
task.addFeature(featureMoments->getFeatureAn(), featureMomentsDes->getFeatureAn());
// the moments are different in case of a symmetric object
task.addFeature(featureMoments->getFeatureCInvariant(), featureMomentsDes->getFeatureCInvariant(),
(1 << 10) | (1 << 11));
task.addFeature(featureMoments->getFeatureAlpha(), featureMomentsDes->getFeatureAlpha());
task.setLambda(1.);
}
void execute(unsigned int nbIter)
{
vpPlot ViSP_plot;
init_visp_plot(ViSP_plot); // Initialize plot object
// init main object: using moments up to order 6
// setting object type (disrete, continuous[form polygon])
vpTRACE("Display task information ");
task.print();
unsigned int iter = 0;
vpHomogeneousMatrix wMo; // Set to identity
vpHomogeneousMatrix wMc; // Camera position in the world frame
wMc = wMo * cMo.inverse();
robot.setPosition(wMc);
float sampling_time = 0.010f; // Sampling period in seconds
robot.setSamplingTime(sampling_time);
// For plotting
vpPoseVector currentpose;
vpColVector err_features;
while (iter++ < nbIter) {
double t = vpTime::measureTimeMs();
// get the cMo
wMc = robot.getPosition();
cMo = wMc.inverse() * wMo;
currentpose.buildFrom(cMo); // For plot
// setup the plane in A,B,C style
vpPlane pl;
double A, B, C;
pl.setABCD(0, 0, 1.0, 0);
pl.changeFrame(cMo);
planeToABC(pl, A, B, C);
// track points, draw points and add refresh our object
refreshScene(obj);
// this is the most important thing to do: update our moments
moments->updateAll(obj);
// and update our features. Do it in that order. Features need to use the
// information computed by moments
featureMoments->updateAll(A, B, C);
// some graphics again
imsim.setCameraPosition(cMo);
Iint = start_img;
imsim.getImage(Iint, cam);
if (iter == 1)
v = task.computeControlLaw();
// pilot robot using position control. The displacement is t*v with t=10ms
// step robot.setPosition(vpRobot::CAMERA_FRAME,0.01*v);
err_features = task.error;
std::cout << " || s - s* || = " << task.error.sumSquare() << std::endl;
vpTime::wait(t, sampling_time * 1000); // Wait 10 ms
ViSP_plot.plot(0, iter, v);
ViSP_plot.plot(1, iter, currentpose); // Plot the velocities
ViSP_plot.plot(2, iter, err_features); // cMo as translations and theta_u
_error = (task.getError()).sumSquare();
#if defined(PRINT_CONDITION_NUMBER)
/*
* Condition number of interaction matrix
*/
vpMatrix Linteraction = task.L;
vpMatrix tmpry, U;
vpColVector singularvals;
Linteraction.svd(singularvals, tmpry);
double condno = static_cast<double>(singularvals.getMaxValue() / singularvals.getMinValue());
std::cout << "Condition Number: " << condno << std::endl;
#endif
}
task.kill();
vpTRACE("\n\nClick in the internal view window to end...");
delete moments;
delete momentsDes;
delete featureMoments;
delete featureMomentsDes;
}
void setInteractionMatrixType(vpServo::vpServoIteractionMatrixType type) { interaction_type = type; }
double error() { return _error; }
void planeToABC(vpPlane &pl, double &A, double &B, double &C)
{
if (fabs(pl.getD()) < std::numeric_limits<double>::epsilon()) {
std::cout << "Invalid position:" << std::endl;
std::cout << cMo << std::endl;
std::cout << "Cannot put plane in the form 1/Z=Ax+By+C." << std::endl;
throw vpException(vpException::divideByZeroError, "invalid position!");
}
A = -pl.getA() / pl.getD();
B = -pl.getB() / pl.getD();
C = -pl.getC() / pl.getD();
}
void paramRobot() { cam = vpCameraParameters(640, 480, 320, 240); }
void init_visp_plot(vpPlot &ViSP_plot)
{
/* -------------------------------------
* Initialize ViSP Plotting
* -------------------------------------
*/
const unsigned int NbGraphs = 3; // No. of graphs
const unsigned int NbCurves_in_graph[NbGraphs] = {6, 6, 6}; // Curves in each graph
ViSP_plot.init(NbGraphs, 800, 800, 10, 10, "Visual Servoing results...");
vpColor Colors[6] = {// Colour for s1, s2, s3, in 1st plot
for (unsigned int p = 0; p < NbGraphs; p++) {
ViSP_plot.initGraph(p, NbCurves_in_graph[p]);
for (unsigned int c = 0; c < NbCurves_in_graph[p]; c++)
ViSP_plot.setColor(p, c, Colors[c]);
}
ViSP_plot.setTitle(0, "Robot velocities");
ViSP_plot.setLegend(0, 0, "v_x");
ViSP_plot.setLegend(0, 1, "v_y");
ViSP_plot.setLegend(0, 2, "v_z");
ViSP_plot.setLegend(0, 3, "w_x");
ViSP_plot.setLegend(0, 4, "w_y");
ViSP_plot.setLegend(0, 5, "w_z");
ViSP_plot.setTitle(1, "Camera pose cMo");
ViSP_plot.setLegend(1, 0, "tx");
ViSP_plot.setLegend(1, 1, "ty");
ViSP_plot.setLegend(1, 2, "tz");
ViSP_plot.setLegend(1, 3, "tu_x");
ViSP_plot.setLegend(1, 4, "tu_y");
ViSP_plot.setLegend(1, 5, "tu_z");
ViSP_plot.setTitle(2, "Error in visual features: ");
ViSP_plot.setLegend(2, 0, "x_n");
ViSP_plot.setLegend(2, 1, "y_n");
ViSP_plot.setLegend(2, 2, "a_n");
ViSP_plot.setLegend(2, 3, "sx");
ViSP_plot.setLegend(2, 4, "sy");
ViSP_plot.setLegend(2, 5, "alpha");
}
#endif
vpDisplayX
Use the X11 console to display images on unix-like OS. Thus to enable this class X11 should be instal...
Definition: vpDisplayX.h:149
vpException::divideByZeroError
Division by zero.
Definition: vpException.h:93
vpServo::error
vpColVector error
Definition: vpServo.h:548
vpMomentObject::DENSE_FULL_OBJECT
Definition: vpMomentObject.h:225
vpFeatureMomentCommon
This class allows to access common vpFeatureMoments in a pre-filled database.
Definition: vpFeatureMomentCommon.h:225
vpServo::kill
void kill()
Definition: vpServo.cpp:191
vpTime::wait
VISP_EXPORT int wait(double t0, double t)
Definition: vpTime.cpp:172
vpMomentObject::setType
void setType(vpObjectType input_type)
Definition: vpMomentObject.h:293
vpPlot::setColor
void setColor(unsigned int graphNum, unsigned int curveNum, vpColor color)
Definition: vpPlot.cpp:260
vpColor::orange
static const vpColor orange
Definition: vpColor.h:188
vpServo::CURRENT
Definition: vpServo.h:185
vpImageSimulator::setInterpolationType
void setInterpolationType(const vpInterpolationType interplt)
Definition: vpImageSimulator.h:230
vpMath::rad
static double rad(double deg)
Definition: vpMath.h:107
vpServo::L
vpMatrix L
Interaction matrix.
Definition: vpServo.h:543
vpCameraParameters
Generic class defining intrinsic camera parameters.
Definition: vpCameraParameters.h:232
vpMomentCommon::updateAll
void updateAll(vpMomentObject &object)
Definition: vpMomentCommon.cpp:125
vpFeatureMomentCommon::getFeatureAlpha
vpFeatureMomentAlpha & getFeatureAlpha()
Definition: vpFeatureMomentCommon.h:243
vpImageSimulator::setCameraPosition
void setCameraPosition(const vpHomogeneousMatrix &cMt)
Definition: vpImageSimulator.cpp:967
vpMomentCommon
This class initializes and allows access to commonly used moments.
Definition: vpMomentCommon.h:103
vpServo::setLambda
void setLambda(double c)
Definition: vpServo.h:405
vpSimulatorCamera::setPosition
void setPosition(const vpHomogeneousMatrix &wMc)
Definition: vpSimulatorCamera.cpp:241
vpArray2D::getMaxValue
Type getMaxValue() const
Definition: vpArray2D.h:912
vpServo::EYEINHAND_CAMERA
Definition: vpServo.h:158
vpDisplayGDI
Display for windows using GDI (available on any windows 32 platform).
Definition: vpDisplayGDI.h:127
vpPlot::init
void init(unsigned int nbGraph, unsigned int height=700, unsigned int width=700, int x=-1, int y=-1, const std::string &title="")
Definition: vpPlot.cpp:99
vpImageSimulator::init
void init(const vpImage< unsigned char > &I, vpColVector *X)
Definition: vpImageSimulator.cpp:1080
vpRGBa
Definition: vpRGBa.h:65
vpTranslationVector
Class that consider the case of a translation vector.
Definition: vpTranslationVector.h:118
vpImageSimulator
Class which enables to project an image in the 3D space and get the view of a virtual camera.
Definition: vpImageSimulator.h:141
vpColor::purple
static const vpColor purple
Definition: vpColor.h:189
vpArray2D::getMinValue
Type getMinValue() const
Definition: vpArray2D.h:895
vpDisplayD3D
Display for windows using Direct3D 3rd party. Thus to enable this class Direct3D should be installed....
Definition: vpDisplayD3D.h:105
vpSimulatorCamera
Class that defines the simplest robot: a free flying camera.
Definition: vpSimulatorCamera.h:106
vpColVector
Implementation of column vector and the associated operations.
Definition: vpColVector.h:129
vpHomogeneousMatrix::extract
void extract(vpRotationMatrix &R) const
Definition: vpHomogeneousMatrix.cpp:550
vpColor::cyan
static const vpColor cyan
Definition: vpColor.h:187
vpDisplayOpenCV
The vpDisplayOpenCV allows to display image using the OpenCV library. Thus to enable this class OpenC...
Definition: vpDisplayOpenCV.h:140
vpMatrix
Implementation of a matrix and operations on matrices.
Definition: vpMatrix.h:163
vpServo::setServo
void setServo(const vpServoType &servo_type)
Definition: vpServo.cpp:222
vpPlane::setABCD
void setABCD(double a, double b, double c, double d)
Definition: vpPlane.h:89
vpTime::measureTimeMs
VISP_EXPORT double measureTimeMs()
Definition: vpTime.cpp:125
vpSimulatorCamera::getPosition
vpHomogeneousMatrix getPosition() const
Definition: vpSimulatorCamera.cpp:118
vpColor::green
static const vpColor green
Definition: vpColor.h:181
vpPlot::setLegend
void setLegend(unsigned int graphNum, unsigned int curveNum, const std::string &legend)
Definition: vpPlot.cpp:546
vpFeatureMomentCommon::getFeatureGravityNormalized
vpFeatureMomentGravityCenterNormalized & getFeatureGravityNormalized()
Definition: vpFeatureMomentCommon.h:265
vpServo::print
void print(const vpServo::vpServoPrintType display_level=ALL, std::ostream &os=std::cout)
Definition: vpServo.cpp:312
vpMomentObject::fromImage
void fromImage(const vpImage< unsigned char > &image, unsigned char threshold, const vpCameraParameters &cam)
Definition: vpMomentObject.cpp:288
vpDisplay::display
static void display(const vpImage< unsigned char > &I)
Definition: vpDisplay_uchar.cpp:739
vpDisplayGTK
The vpDisplayGTK allows to display image using the GTK 3rd party library. Thus to enable this class G...
Definition: vpDisplayGTK.h:136
vpPlane::getB
double getB() const
Definition: vpPlane.h:103
vpPoseVector
Implementation of a pose vector and operations on poses.
Definition: vpPoseVector.h:150
vpPoseVector::buildFrom
vpPoseVector buildFrom(double tx, double ty, double tz, double tux, double tuy, double tuz)
Definition: vpPoseVector.cpp:180
vpServo::getError
vpColVector getError() const
Definition: vpServo.h:281
vpFeatureMomentCommon::updateAll
void updateAll(double A, double B, double C)
Definition: vpFeatureMomentCommon.cpp:73
vpImageSimulator::BILINEAR_INTERPOLATION
Definition: vpImageSimulator.h:146
vpPlane::getC
double getC() const
Definition: vpPlane.h:105
vpRobot::CAMERA_FRAME
Definition: vpRobot.h:81
vpMomentCommon::getMu3
static std::vector< double > getMu3(vpMomentObject &object)
Definition: vpMomentCommon.cpp:198
vpServo::addFeature
void addFeature(vpBasicFeature &s, vpBasicFeature &s_star, unsigned int select=vpBasicFeature::FEATURE_ALL)
Definition: vpServo.cpp:496
vpDisplayX::init
void init(vpImage< unsigned char > &I, int winx=-1, int winy=-1, const std::string &title="")
Definition: vpDisplayX.cpp:251
vpPlot::setTitle
void setTitle(unsigned int graphNum, const std::string &title)
Definition: vpPlot.cpp:497
vpMomentObject
Class for generic objects.
Definition: vpMomentObject.h:218
vpPlane::getD
double getD() const
Definition: vpPlane.h:107
vpPlane
This class defines the container for a plane geometrical structure.
Definition: vpPlane.h:57
vpPlane::changeFrame
void changeFrame(const vpHomogeneousMatrix &cMo)
Definition: vpPlane.cpp:353
vpServo::setInteractionMatrixType
void setInteractionMatrixType(const vpServoIteractionMatrixType &interactionMatrixType, const vpServoInversionType &interactionMatrixInversion=PSEUDO_INVERSE)
Definition: vpServo.cpp:573
vpPlot::plot
void plot(unsigned int graphNum, unsigned int curveNum, double x, double y)
Definition: vpPlot.cpp:285
vpImageSimulator::getImage
void getImage(vpImage< unsigned char > &I, const vpCameraParameters &cam)
Definition: vpImageSimulator.cpp:188
vpColor::blue
static const vpColor blue
Definition: vpColor.h:184
vpServo
Definition: vpServo.h:149
vpServo::vpServoIteractionMatrixType
vpServoIteractionMatrixType
Definition: vpServo.h:184
vpServo::computeControlLaw
vpColVector computeControlLaw()
Definition: vpServo.cpp:934
vpDisplay::flush
static void flush(const vpImage< unsigned char > &I)
Definition: vpDisplay_uchar.cpp:715
vpColVector::sumSquare
double sumSquare() const
Definition: vpColVector.cpp:1522
vpRobotSimulator::setSamplingTime
virtual void setSamplingTime(const double &delta_t)
Definition: vpRobotSimulator.h:90
vpHomogeneousMatrix::inverse
vpHomogeneousMatrix inverse() const
Definition: vpHomogeneousMatrix.cpp:640
vpImage< vpRGBa >
vpPlot::initGraph
void initGraph(unsigned int graphNum, unsigned int curveNbr)
Definition: vpPlot.cpp:205
vpDisplay::getClick
static bool getClick(const vpImage< unsigned char > &I, bool blocking=true)
Definition: vpDisplay_uchar.cpp:764
vpColor
Class to define colors available for display functionnalities.
Definition: vpColor.h:118
vpHomogeneousMatrix
Implementation of an homogeneous matrix and operations on such kind of matrices.
Definition: vpHomogeneousMatrix.h:148
vpMomentCommon::getSurface
static double getSurface(vpMomentObject &object)
Definition: vpMomentCommon.cpp:148
vpSimulatorCamera::setVelocity
void setVelocity(const vpRobot::vpControlFrameType frame, const vpColVector &vel)
Definition: vpSimulatorCamera.cpp:197
vpTRACE
#define vpTRACE
Definition: vpDebug.h:415
vpFeatureMomentCommon::getFeatureCInvariant
vpFeatureMomentCInvariant & getFeatureCInvariant()
Definition: vpFeatureMomentCommon.h:261
vpException
error that can be emited by ViSP classes.
Definition: vpException.h:70
vpPlot
This class enables real time drawing of 2D or 3D graphics. An instance of the class open a window whi...
Definition: vpPlot.h:114
vpMatrix::svd
void svd(vpColVector &w, vpMatrix &V)
Definition: vpMatrix.cpp:2065
vpColor::red
static const vpColor red
Definition: vpColor.h:178
vpMomentCommon::getAlpha
static double getAlpha(vpMomentObject &object)
Definition: vpMomentCommon.cpp:175
vpFeatureMomentCommon::getFeatureAn
vpFeatureMomentAreaNormalized & getFeatureAn()
Definition: vpFeatureMomentCommon.h:248
vpPlane::getA
double getA() const
Definition: vpPlane.h:101