Visual Servoing Platform  version 3.6.1 under development (2025-02-18)
servoSimuAfma6FourPoints2DCamVelocity.cpp
1 /****************************************************************************
2  *
3  * ViSP, open source Visual Servoing Platform software.
4  * Copyright (C) 2005 - 2023 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 https://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 using 4 points with cartesian
33  * coordinates as visual feature.
34  *
35 *****************************************************************************/
36 
53 #include <visp3/core/vpConfig.h>
54 #include <visp3/core/vpDebug.h>
55 
56 #if defined(VISP_HAVE_THREADS) && defined(VISP_HAVE_DISPLAY) \
57  && (defined(VISP_HAVE_LAPACK) || defined(VISP_HAVE_EIGEN3) || defined(VISP_HAVE_OPENCV))
58 
59 // We need to use threading capabilities. Thus on Unix-like
60 // platforms, the libpthread third-party library need to be
61 // installed. On Windows, we use the native threading capabilities.
62 
63 #include <stdio.h>
64 #include <stdlib.h>
65 
66 #include <visp3/core/vpCameraParameters.h>
67 #include <visp3/core/vpHomogeneousMatrix.h>
68 #include <visp3/core/vpImage.h>
69 #include <visp3/core/vpImagePoint.h>
70 #include <visp3/core/vpIoTools.h>
71 #include <visp3/core/vpMath.h>
72 #include <visp3/core/vpMeterPixelConversion.h>
73 #include <visp3/gui/vpDisplayFactory.h>
74 #include <visp3/io/vpParseArgv.h>
75 #include <visp3/robot/vpSimulatorAfma6.h>
76 #include <visp3/visual_features/vpFeatureBuilder.h>
77 #include <visp3/visual_features/vpFeaturePoint.h>
78 #include <visp3/vs/vpServo.h>
79 
80 // List of allowed command line options
81 #define GETOPTARGS "cdh"
82 
83 #ifdef ENABLE_VISP_NAMESPACE
84 using namespace VISP_NAMESPACE_NAME;
85 #endif
86 
87 void usage(const char *name, const char *badparam);
88 bool getOptions(int argc, const char **argv, bool &click_allowed, bool &display);
89 
98 void usage(const char *name, const char *badparam)
99 {
100  fprintf(stdout, "\n\
101 Tests a control law with the following characteristics:\n\
102  - eye-in-hand control\n\
103  - articular velocity are computed\n\
104  - servo on 4 points,\n\
105  - internal and external camera view displays.\n\
106  \n\
107 SYNOPSIS\n\
108  %s [-c] [-d] [-h]\n",
109  name);
110 
111  fprintf(stdout, "\n\
112 OPTIONS: Default\n\
113  -c\n\
114  Disable the mouse click. Useful to automate the \n\
115  execution of this program without human intervention.\n\
116  \n\
117  -d \n\
118  Turn off the display.\n\
119  \n\
120  -h\n\
121  Print the help.\n");
122 
123  if (badparam)
124  fprintf(stdout, "\nERROR: Bad parameter [%s]\n", badparam);
125 }
138 bool getOptions(int argc, const char **argv, bool &click_allowed, bool &display)
139 {
140  const char *optarg_;
141  int c;
142  while ((c = vpParseArgv::parse(argc, argv, GETOPTARGS, &optarg_)) > 1) {
143 
144  switch (c) {
145  case 'c':
146  click_allowed = false;
147  break;
148  case 'd':
149  display = false;
150  break;
151  case 'h':
152  usage(argv[0], nullptr);
153  return false;
154  break;
155 
156  default:
157  usage(argv[0], optarg_);
158  return false;
159  break;
160  }
161  }
162 
163  if ((c == 1) || (c == -1)) {
164  // standalone param or error
165  usage(argv[0], nullptr);
166  std::cerr << "ERROR: " << std::endl;
167  std::cerr << " Bad argument " << optarg_ << std::endl << std::endl;
168  return false;
169  }
170 
171  return true;
172 }
173 
174 int main(int argc, const char **argv)
175 {
176 #if (VISP_CXX_STANDARD >= VISP_CXX_STANDARD_11)
177  std::shared_ptr<vpDisplay> displayInt;
178 #else
179  vpDisplay *displayInt = nullptr;
180 #endif
181  try {
182  bool opt_click_allowed = true;
183  bool opt_display = true;
184 
185  // Read the command line options
186  if (getOptions(argc, argv, opt_click_allowed, opt_display) == false) {
187  return EXIT_FAILURE;
188  }
189 
190  // We open two displays, one for the internal camera view, the other one for
191  // the external view, using either X11, GTK or GDI.
192  vpImage<unsigned char> Iint(480, 640, 255);
193 
194  if (opt_display) {
195  // open a display for the visualization
196 #if (VISP_CXX_STANDARD >= VISP_CXX_STANDARD_11)
197  displayInt = vpDisplayFactory::createDisplay(Iint, 700, 0, "Internal view");
198 #else
199  displayInt = vpDisplayFactory::allocateDisplay(Iint, 700, 0, "Internal view");
200 #endif
201  }
202 
203  vpServo task;
204 
205  std::cout << std::endl;
206  std::cout << "----------------------------------------------" << std::endl;
207  std::cout << " Test program for vpServo " << std::endl;
208  std::cout << " Eye-in-hand task control, articular velocity are computed" << std::endl;
209  std::cout << " Simulation " << std::endl;
210  std::cout << " task : servo 4 points " << std::endl;
211  std::cout << "----------------------------------------------" << std::endl;
212  std::cout << std::endl;
213 
214  // sets the initial camera location
215  vpHomogeneousMatrix cMo(-0.05, -0.05, 0.7, vpMath::rad(10), vpMath::rad(10), vpMath::rad(-30));
216 
217  // sets the point coordinates in the object frame
218  vpPoint point[4];
219  point[0].setWorldCoordinates(-0.045, -0.045, 0);
220  point[3].setWorldCoordinates(-0.045, 0.045, 0);
221  point[2].setWorldCoordinates(0.045, 0.045, 0);
222  point[1].setWorldCoordinates(0.045, -0.045, 0);
223 
224  // computes the point coordinates in the camera frame and its 2D
225  // coordinates
226  for (unsigned int i = 0; i < 4; i++)
227  point[i].track(cMo);
228 
229  // sets the desired position of the point
230  vpFeaturePoint p[4];
231  for (unsigned int i = 0; i < 4; i++)
232  vpFeatureBuilder::create(p[i], point[i]); // retrieve x,y and Z of the vpPoint structure
233 
234  // sets the desired position of the feature point s*
235  vpFeaturePoint pd[4];
236 
237  // Desired pose
239 
240  // Projection of the points
241  for (unsigned int i = 0; i < 4; i++)
242  point[i].track(cdMo);
243 
244  for (unsigned int i = 0; i < 4; i++)
245  vpFeatureBuilder::create(pd[i], point[i]);
246 
247  // define the task
248  // - we want an eye-in-hand control law
249  // - articular velocity are computed
252 
253  // we want to see a point on a point
254  for (unsigned int i = 0; i < 4; i++)
255  task.addFeature(p[i], pd[i]);
256 
257  // set the gain
258  task.setLambda(0.8);
259 
260  // Declaration of the robot
261  vpSimulatorAfma6 robot(opt_display);
262 
263  // Initialise the robot and especially the camera
266 
267  // Initialise the object for the display part*/
269 
270  // Initialise the position of the object relative to the pose of the
271  // robot's camera
272  robot.initialiseObjectRelativeToCamera(cMo);
273 
274  // Set the desired position (for the displaypart)
275  robot.setDesiredCameraPosition(cdMo);
276 
277  // Get the internal robot's camera parameters
278  vpCameraParameters cam;
279  robot.getCameraParameters(cam, Iint);
280 
281  if (opt_display) {
282  // Get the internal view
283  vpDisplay::display(Iint);
284  robot.getInternalView(Iint);
285  vpDisplay::flush(Iint);
286  }
287 
288  // Display task information
289  task.print();
290 
291  unsigned int iter = 0;
292  vpTRACE("\t loop");
293  while (iter++ < 500) {
294  std::cout << "---------------------------------------------" << iter << std::endl;
295  vpColVector v;
296 
297  // Get the Time at the beginning of the loop
298  double t = vpTime::measureTimeMs();
299 
300  // Get the current pose of the camera
301  cMo = robot.get_cMo();
302 
303  if (iter == 1) {
304  std::cout << "Initial robot position with respect to the object frame:\n";
305  cMo.print();
306  }
307 
308  // new point position
309  for (unsigned int i = 0; i < 4; i++) {
310  point[i].track(cMo);
311  // retrieve x,y and Z of the vpPoint structure
312  vpFeatureBuilder::create(p[i], point[i]);
313  }
314 
315  if (opt_display) {
316  // Get the internal view and display it
317  vpDisplay::display(Iint);
318  robot.getInternalView(Iint);
319  vpDisplay::flush(Iint);
320  }
321 
322  if (opt_display && opt_click_allowed && iter == 1) {
323  // suppressed for automate test
324  std::cout << "Click in the internal view window to continue..." << std::endl;
325  vpDisplay::getClick(Iint);
326  }
327 
328  // compute the control law
329  v = task.computeControlLaw();
330 
331  // send the camera velocity to the controller
333 
334  std::cout << "|| s - s* || " << (task.getError()).sumSquare() << std::endl;
335 
336  // The main loop has a duration of 10 ms at minimum
337  vpTime::wait(t, 10);
338  }
339 
340  // Display task information
341  task.print();
342 
343  std::cout << "Final robot position with respect to the object frame:\n";
344  cMo.print();
345 
346  if (opt_display && opt_click_allowed) {
347  // suppressed for automate test
348  std::cout << "Click in the internal view window to end..." << std::endl;
349  vpDisplay::getClick(Iint);
350  }
351 
352 #if (VISP_CXX_STANDARD < VISP_CXX_STANDARD_11)
353  if (display != nullptr) {
354  delete display;
355  }
356 #endif
357  return EXIT_SUCCESS;
358  }
359  catch (const vpException &e) {
360  std::cout << "Catch a ViSP exception: " << e << std::endl;
361 #if (VISP_CXX_STANDARD < VISP_CXX_STANDARD_11)
362  if (display != nullptr) {
363  delete display;
364  }
365 #endif
366  return EXIT_FAILURE;
367  }
368 #if (VISP_CXX_STANDARD < VISP_CXX_STANDARD_11)
369  if (display != nullptr) {
370  delete display;
371  }
372 #endif
373  return EXIT_SUCCESS;
374 }
375 #elif !(defined(VISP_HAVE_DISPLAY))
376 int main()
377 {
378  std::cout << "You do not have X11, or GDI (Graphical Device Interface) of OpenCV functionalities to display images..."
379  << std::endl;
380  std::cout << "Tip if you are on a unix-like system:" << std::endl;
381  std::cout << "- Install X11, configure again ViSP using cmake and build again this example" << std::endl;
382  std::cout << "Tip if you are on a windows-like system:" << std::endl;
383  std::cout << "- Install GDI, configure again ViSP using cmake and build again this example" << std::endl;
384  return EXIT_SUCCESS;
385 }
386 #elif !(defined(VISP_HAVE_LAPACK) || defined(VISP_HAVE_EIGEN3) || defined(VISP_HAVE_OPENCV))
387 int main()
388 {
389  std::cout << "Cannot run this example: install Lapack, Eigen3 or OpenCV" << std::endl;
390  return EXIT_SUCCESS;
391 }
392 #else
393 int main()
394 {
395  std::cout << "You do not have threading capabilities" << std::endl;
396  std::cout << "Tip:" << std::endl;
397  std::cout << "- Install pthread, configure again ViSP using cmake and build again this example" << std::endl;
398  return EXIT_SUCCESS;
399 }
400 #endif
@ TOOL_CCMOP
Definition: vpAfma6.h:127
Generic class defining intrinsic camera parameters.
@ perspectiveProjWithoutDistortion
Perspective projection without distortion model.
Implementation of column vector and the associated operations.
Definition: vpColVector.h:191
Class that defines generic functionalities for display.
Definition: vpDisplay.h:178
static bool getClick(const vpImage< unsigned char > &I, bool blocking=true)
static void display(const vpImage< unsigned char > &I)
static void flush(const vpImage< unsigned char > &I)
error that can be emitted by ViSP classes.
Definition: vpException.h:60
static void create(vpFeaturePoint &s, const vpCameraParameters &cam, const vpImagePoint &t)
Class that defines a 2D point visual feature which is composed by two parameters that are the cartes...
void track(const vpHomogeneousMatrix &cMo)
Implementation of an homogeneous matrix and operations on such kind of matrices.
static double rad(double deg)
Definition: vpMath.h:129
static bool parse(int *argcPtr, const char **argv, vpArgvInfo *argTable, int flags)
Definition: vpParseArgv.cpp:70
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:113
void setVelocity(const vpRobot::vpControlFrameType frame, const vpColVector &vel) VP_OVERRIDE
@ CAMERA_FRAME
Definition: vpRobot.h:84
@ STATE_VELOCITY_CONTROL
Initialize the velocity controller.
Definition: vpRobot.h:67
virtual vpRobotStateType setRobotState(const vpRobot::vpRobotStateType newState)
Definition: vpRobot.cpp:202
void setInteractionMatrixType(const vpServoIteractionMatrixType &interactionMatrixType, const vpServoInversionType &interactionMatrixInversion=PSEUDO_INVERSE)
Definition: vpServo.cpp:380
@ EYEINHAND_CAMERA
Definition: vpServo.h:161
void addFeature(vpBasicFeature &s_cur, vpBasicFeature &s_star, unsigned int select=vpBasicFeature::FEATURE_ALL)
Definition: vpServo.cpp:331
void print(const vpServo::vpServoPrintType display_level=ALL, std::ostream &os=std::cout)
Definition: vpServo.cpp:171
void setLambda(double c)
Definition: vpServo.h:991
void setServo(const vpServoType &servo_type)
Definition: vpServo.cpp:134
vpColVector getError() const
Definition: vpServo.h:515
vpColVector computeControlLaw()
Definition: vpServo.cpp:705
@ DESIRED
Definition: vpServo.h:208
std::shared_ptr< vpDisplay > createDisplay()
Return a smart pointer vpDisplay specialization if a GUI library is available or nullptr otherwise.
vpDisplay * allocateDisplay()
Return a newly allocated vpDisplay specialization if a GUI library is available or nullptr otherwise.
VISP_EXPORT int wait(double t0, double t)
VISP_EXPORT double measureTimeMs()