Visual Servoing Platform  version 3.4.0
manServo4PointsDisplay.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 visual servoing with display.
33  *
34  * Authors:
35  * Eric Marchand
36  * Fabien Spindler
37  *
38  *****************************************************************************/
39 
50 #include <visp3/core/vpConfig.h>
51 #include <visp3/core/vpDebug.h>
52 
53 #if defined(VISP_HAVE_X11) || defined(VISP_HAVE_GTK) || defined(VISP_HAVE_GDI) || defined(VISP_HAVE_OPENCV)
54 
55 #include <visp3/core/vpCameraParameters.h>
56 #include <visp3/core/vpImage.h>
57 #include <visp3/core/vpImageConvert.h>
58 #include <visp3/core/vpTime.h>
59 #include <visp3/gui/vpDisplayGDI.h>
60 #include <visp3/gui/vpDisplayGTK.h>
61 #include <visp3/gui/vpDisplayOpenCV.h>
62 #include <visp3/gui/vpDisplayX.h>
63 
64 #include <visp3/core/vpHomogeneousMatrix.h>
65 #include <visp3/core/vpIoTools.h>
66 #include <visp3/core/vpMath.h>
67 #include <visp3/robot/vpSimulatorCamera.h>
68 #include <visp3/vision/vpPose.h>
69 #include <visp3/visual_features/vpFeatureBuilder.h>
70 #include <visp3/visual_features/vpFeaturePoint.h>
71 #include <visp3/vs/vpServo.h>
72 #include <visp3/vs/vpServoDisplay.h>
73 
74 int main()
75 {
76  try {
78  // sets the initial camera location
79  vpHomogeneousMatrix cMo(0.3, 0.2, 3, vpMath::rad(0), vpMath::rad(0), vpMath::rad(40));
80  vpHomogeneousMatrix wMo; // Set to identity
81  vpHomogeneousMatrix wMc; // Camera position in the world frame
82 
84  // initialize the robot
85  vpSimulatorCamera robot;
86  robot.setSamplingTime(0.04); // 40ms
87  wMc = wMo * cMo.inverse();
88  robot.setPosition(wMc);
89 
90  // initialize the camera parameters
91  vpCameraParameters cam(800, 800, 240, 180);
92 
93  // Image definition
94  unsigned int height = 360;
95  unsigned int width = 480;
96  vpImage<unsigned char> I(height, width);
97 
98 // Display initialization
99 #if defined(VISP_HAVE_X11)
100  vpDisplayX disp;
101 #elif defined(VISP_HAVE_GTK)
102  vpDisplayGTK disp;
103 #elif defined(VISP_HAVE_GDI)
104  vpDisplayGDI disp;
105 #elif defined(VISP_HAVE_OPENCV)
106  vpDisplayOpenCV disp;
107 #endif
108 
109 #if defined(VISP_HAVE_X11) || defined(VISP_HAVE_GTK) || defined(VISP_HAVE_GDI) || defined(VISP_HAVE_OPENCV)
110  disp.init(I, 100, 100, "Simulation display");
111 #endif
112 
114  // Desired visual features initialization
115 
116  // sets the points coordinates in the object frame (in meter)
117  vpPoint point[4];
118  point[0].setWorldCoordinates(-0.1, -0.1, 0);
119  point[1].setWorldCoordinates(0.1, -0.1, 0);
120  point[2].setWorldCoordinates(0.1, 0.1, 0);
121  point[3].setWorldCoordinates(-0.1, 0.1, 0);
122 
123  // sets the desired camera location
124  vpHomogeneousMatrix cMo_d(0, 0, 1, 0, 0, 0);
125 
126  // computes the 3D point coordinates in the camera frame and its 2D
127  // coordinates
128  for (int i = 0; i < 4; i++)
129  point[i].project(cMo_d);
130 
131  // creates the associated features
132  vpFeaturePoint pd[4];
133  for (int i = 0; i < 4; i++)
134  vpFeatureBuilder::create(pd[i], point[i]);
135 
137  // Current visual features initialization
138 
139  // computes the 3D point coordinates in the camera frame and its 2D
140  // coordinates
141  for (int i = 0; i < 4; i++)
142  point[i].project(cMo);
143 
144  // creates the associated features
145  vpFeaturePoint p[4];
146  for (int i = 0; i < 4; i++)
147  vpFeatureBuilder::create(p[i], point[i]);
148 
150  // Task defintion
151  vpServo task;
152  // we want an eye-in-hand control law ;
155 
156  // Set the position of the end-effector frame in the camera frame as identity
158  vpVelocityTwistMatrix cVe(cMe);
159  task.set_cVe(cVe);
160  // Set the Jacobian (expressed in the end-effector frame)
161  vpMatrix eJe;
162  robot.get_eJe(eJe);
163  task.set_eJe(eJe);
164 
165  // we want to see a point on a point
166  for (int i = 0; i < 4; i++)
167  task.addFeature(p[i], pd[i]);
168  // Set the gain
169  task.setLambda(1.0);
170  // Print the current information about the task
171  task.print();
172 
174  // The control loop
175  int k = 0;
176  while (k++ < 200) {
177  double t = vpTime::measureTimeMs();
178 
179  // Display the image background
181 
182  // Update the current features
183  for (int i = 0; i < 4; i++) {
184  point[i].project(cMo);
185  vpFeatureBuilder::create(p[i], point[i]);
186  }
187 
188  // Display the task features (current and desired)
189  vpServoDisplay::display(task, cam, I);
190  vpDisplay::flush(I);
191 
192  // Update the robot Jacobian
193  robot.get_eJe(eJe);
194  task.set_eJe(eJe);
195 
196  // Compute the control law
197  vpColVector v = task.computeControlLaw();
198 
199  // Send the computed velocity to the robot and compute the new robot
200  // position
202  wMc = robot.getPosition();
203  cMo = wMc.inverse() * wMo;
204 
205  // Print the current information about the task
206  task.print();
207 
208  // Wait 40 ms
209  vpTime::wait(t, 40);
210  }
211  return EXIT_SUCCESS;
212  } catch (const vpException &e) {
213  std::cout << "Catch an exception: " << e << std::endl;
214  return EXIT_FAILURE;
215  }
216 }
217 
218 #else
219 int main()
220 {
221  std::cout << "You do not have X11, GTK, or OpenCV, or GDI (Graphical Device Interface) functionalities to display images..." << std::endl;
222  std::cout << "Tip if you are on a unix-like system:" << std::endl;
223  std::cout << "- Install X11, configure again ViSP using cmake and build again this example" << std::endl;
224  std::cout << "Tip if you are on a windows-like system:" << std::endl;
225  std::cout << "- Install GDI, configure again ViSP using cmake and build again this example" << std::endl;
226  return EXIT_SUCCESS;
227 }
228 #endif
Generic class defining intrinsic camera parameters.
Implementation of column vector and the associated operations.
Definition: vpColVector.h:131
Display for windows using GDI (available on any windows 32 platform).
Definition: vpDisplayGDI.h:129
The vpDisplayGTK allows to display image using the GTK 3rd party library. Thus to enable this class G...
Definition: vpDisplayGTK.h:135
The vpDisplayOpenCV allows to display image using the OpenCV library. Thus to enable this class OpenC...
Use the X11 console to display images on unix-like OS. Thus to enable this class X11 should be instal...
Definition: vpDisplayX.h:151
void init(vpImage< unsigned char > &I, int winx=-1, int winy=-1, const std::string &title="")
Definition: vpDisplayX.cpp:252
static void display(const vpImage< unsigned char > &I)
static void flush(const vpImage< unsigned char > &I)
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...
Implementation of an homogeneous matrix and operations on such kind of matrices.
vpHomogeneousMatrix inverse() const
static double rad(double deg)
Definition: vpMath.h:110
Implementation of a matrix and operations on matrices.
Definition: vpMatrix.h:154
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 setWorldCoordinates(double oX, double oY, double oZ)
Definition: vpPoint.cpp:113
void setVelocity(const vpRobot::vpControlFrameType frame, const vpColVector &vel)
void get_eJe(vpMatrix &eJe)
@ ARTICULAR_FRAME
Definition: vpRobot.h:78
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: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
@ PSEUDO_INVERSE
Definition: vpServo.h:202
vpColVector computeControlLaw()
Definition: vpServo.cpp:929
@ DESIRED
Definition: vpServo.h:186
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.
VISP_EXPORT int wait(double t0, double t)
VISP_EXPORT double measureTimeMs()