Visual Servoing Platform version 3.5.0
testRobotViper850Pose.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 * Test for Afma 6 dof robot.
33 *
34 * Authors:
35 * Fabien Spindler
36 *
37 *****************************************************************************/
38
49#include <iostream>
50#include <visp3/blob/vpDot.h>
51#include <visp3/core/vpCameraParameters.h>
52#include <visp3/core/vpConfig.h>
53#include <visp3/core/vpDebug.h>
54#include <visp3/core/vpImage.h>
55#include <visp3/core/vpPixelMeterConversion.h>
56#include <visp3/core/vpPoint.h>
57#include <visp3/gui/vpDisplayGTK.h>
58#include <visp3/gui/vpDisplayOpenCV.h>
59#include <visp3/gui/vpDisplayX.h>
60#include <visp3/robot/vpRobotViper850.h>
61#include <visp3/sensor/vp1394TwoGrabber.h>
62#include <visp3/vision/vpPose.h>
63#if defined(VISP_HAVE_VIPER850) && defined(VISP_HAVE_DC1394)
64
65int main()
66{
67 try {
68 // Create an image B&W container
70
71 // Create a firewire grabber based on libdc1394-2.x
72 bool reset = false;
73 vp1394TwoGrabber g(reset);
74
75 // Grab an image from the firewire camera
76 g.acquire(I);
77
78// Create an image viewer for the image
79#ifdef VISP_HAVE_X11
80 vpDisplayX display(I, 100, 100, "Current image");
81#elif defined(VISP_HAVE_OPENCV)
82 vpDisplayOpenCV display(I, 100, 100, "Current image");
83#elif defined(VISP_HAVE_GTK)
84 vpDisplayGTK display(I, 100, 100, "Current image");
85#endif
86
87 // Display the image
90
91 // Define a squared target
92 // The target is made of 4 planar points (square dim = 0.077m)
93 double sdim = 0.077; // square width and height
94 vpPoint target[4];
95 // Set the point world coordinates (x,y,z) in the object frame
96 // o ----> x
97 // |
98 // |
99 // \/
100 // y
101 target[0].setWorldCoordinates(-sdim / 2., -sdim / 2., 0);
102 target[1].setWorldCoordinates(sdim / 2., -sdim / 2., 0);
103 target[2].setWorldCoordinates(sdim / 2., sdim / 2., 0);
104 target[3].setWorldCoordinates(-sdim / 2., sdim / 2., 0);
105
106 // Image processing to extract the 2D coordinates in sub-pixels of the 4
107 // points from the image acquired by the camera
108 // Creation of 4 trackers
109 vpDot dot[4];
110 vpImagePoint cog;
111 for (int i = 0; i < 4; i++) {
112 dot[i].setGraphics(true); // to display the tracking results
113 std::cout << "Click on dot " << i << std::endl;
114 dot[i].initTracking(I);
115 // The tracker computes the sub-pixels coordinates in the image
116 // i ----> u
117 // |
118 // |
119 // \/
120 // v
121 std::cout << " Coordinates: " << dot[i].getCog() << std::endl;
122 // Flush the tracking results in the viewer
124 }
125
126 // Create an intrinsic camera parameters structure
128
129 // Create a robot access
130 vpRobotViper850 robot;
131
132 // Load the end-effector to camera frame transformation obtained
133 // using a camera intrinsic model with distortion
135
136 // Get the intrinsic camera parameters associated to the image
137 robot.getCameraParameters(cam, I);
138
139 // Using the camera parameters, compute the perspective projection
140 // (transform the dot sub-pixel coordinates into coordinates in the camera
141 // frame in meter)
142 for (int i = 0; i < 4; i++) {
143 double x = 0, y = 0; // coordinates of the dots in the camera frame
144 // c ----> x
145 // |
146 // |
147 // \/
148 // y
149 // pixel to meter conversion
150 cog = dot[i].getCog();
152 target[i].set_x(x);
153 target[i].set_y(y);
154 }
155
156 // From now, in target[i], we have the 3D coordinates of a point in the
157 // object frame, and their correspondances in the camera frame. We can now
158 // compute the pose cMo between the camera and the object.
159 vpPose pose;
160 // Add the 4 points to compute the pose
161 for (int i = 0; i < 4; i++) {
162 pose.addPoint(target[i]);
163 }
164 // Create an homogeneous matrix for the camera to object transformation
165 // computed just bellow
168 vpRxyzVector r;
169 // Compute the pose: initialisation is done by Lagrange method, and the
170 // final pose is computed by the more accurate Virtual Visual Servoing
171 // method.
173
174 std::cout << "Pose cMo: " << std::endl << cMo;
175 cMo.extract(R);
176 r.buildFrom(R);
177 std::cout << " rotation: " << vpMath::deg(r[0]) << " " << vpMath::deg(r[1]) << " " << vpMath::deg(r[2]) << " deg"
178 << std::endl
179 << std::endl;
180
181 // Get the robot position in the reference frame
183 vpColVector p; // position x,y,z,rx,ry,rz
184 robot.getPosition(vpRobotViper850::REFERENCE_FRAME, p);
185 std::cout << "Robot pose in reference frame: " << p << std::endl;
187 t[0] = p[0];
188 t[1] = p[1];
189 t[2] = p[2];
190 r[0] = p[3];
191 r[1] = p[4];
192 r[2] = p[5];
193 R.buildFrom(r);
194 rMc.buildFrom(t, R);
195 std::cout << "Pose rMc: " << std::endl << rMc;
196 rMc.extract(R);
197 r.buildFrom(R);
198 std::cout << " rotation: " << vpMath::deg(r[0]) << " " << vpMath::deg(r[1]) << " " << vpMath::deg(r[2]) << " deg"
199 << std::endl
200 << std::endl;
201
202 robot.getPosition(vpRobotViper850::ARTICULAR_FRAME, p);
203 std::cout << "Robot pose in articular: " << p << std::endl;
204
205 robot.get_fMc(p, rMc);
206 std::cout << "Pose rMc from MGD: " << std::endl << rMc;
207 rMc.extract(R);
208 r.buildFrom(R);
209 std::cout << " rotation: " << vpMath::deg(r[0]) << " " << vpMath::deg(r[1]) << " " << vpMath::deg(r[2]) << " deg"
210 << std::endl
211 << std::endl;
212
214 rMo = rMc * cMo;
215 std::cout << "Pose rMo = rMc * cMo: " << std::endl << rMo;
216 rMo.extract(R);
217 r.buildFrom(R);
218 std::cout << " rotation: " << vpMath::deg(r[0]) << " " << vpMath::deg(r[1]) << " " << vpMath::deg(r[2]) << " deg"
219 << std::endl
220 << std::endl;
221
222 } catch (const vpException &e) {
223 std::cout << "Catch an exception: " << e << std::endl;
224 }
225 return 0;
226}
227#else
228int main()
229{
230 std::cout << "Sorry, test not valid. You should have an Viper850 robot..." << std::endl;
231 return 0;
232}
233
234#endif
Class for firewire ieee1394 video devices using libdc1394-2.x api.
Generic class defining intrinsic camera parameters.
Implementation of column vector and the associated operations.
Definition: vpColVector.h:131
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:135
static void display(const vpImage< unsigned char > &I)
static void flush(const vpImage< unsigned char > &I)
This tracker is meant to track a dot (connected pixels with same gray level) on a vpImage.
Definition: vpDot.h:116
void initTracking(const vpImage< unsigned char > &I)
Definition: vpDot.cpp:635
void setGraphics(bool activate)
Definition: vpDot.h:361
vpImagePoint getCog() const
Definition: vpDot.h:247
error that can be emited by ViSP classes.
Definition: vpException.h:72
Implementation of an homogeneous matrix and operations on such kind of matrices.
void buildFrom(const vpTranslationVector &t, const vpRotationMatrix &R)
void extract(vpRotationMatrix &R) const
Class that defines a 2D point in an image. This class is useful for image processing and stores only ...
Definition: vpImagePoint.h:88
static double deg(double rad)
Definition: vpMath.h:103
static void convertPoint(const vpCameraParameters &cam, const double &u, const double &v, double &x, double &y)
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 set_x(double x)
Set the point x coordinate in the image plane.
Definition: vpPoint.cpp:511
void setWorldCoordinates(double oX, double oY, double oZ)
Definition: vpPoint.cpp:113
void set_y(double y)
Set the point y coordinate in the image plane.
Definition: vpPoint.cpp:513
Class used for pose computation from N points (pose from point only). Some of the algorithms implemen...
Definition: vpPose.h:81
void addPoint(const vpPoint &P)
Definition: vpPose.cpp:149
@ LAGRANGE_VIRTUAL_VS
Definition: vpPose.h:99
bool computePose(vpPoseMethodType method, vpHomogeneousMatrix &cMo, bool(*func)(const vpHomogeneousMatrix &)=NULL)
Definition: vpPose.cpp:374
@ REFERENCE_FRAME
Definition: vpRobot.h:76
@ ARTICULAR_FRAME
Definition: vpRobot.h:78
Implementation of a rotation matrix and operations on such kind of matrices.
vpRotationMatrix buildFrom(const vpHomogeneousMatrix &M)
Implementation of a rotation vector as Euler angle minimal representation.
Definition: vpRxyzVector.h:184
vpRxyzVector buildFrom(const vpRotationMatrix &R)
Class that consider the case of a translation vector.
static const vpToolType defaultTool
Default tool attached to the robot end effector.
Definition: vpViper850.h:137