Visual Servoing Platform version 3.6.0
Loading...
Searching...
No Matches
testGenericTracker.cpp

Regression test for MBT.

Regression test for MBT.

/****************************************************************************
*
* ViSP, open source Visual Servoing Platform software.
* Copyright (C) 2005 - 2023 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 https://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:
* Regression test for MBT.
*
*****************************************************************************/
#include <cstdlib>
#include <iostream>
#include <visp3/core/vpConfig.h>
#if defined(VISP_HAVE_MODULE_MBT) && \
(defined(VISP_HAVE_LAPACK) || defined(VISP_HAVE_EIGEN3) || defined(VISP_HAVE_OPENCV))
#if (VISP_CXX_STANDARD >= VISP_CXX_STANDARD_11)
#include <type_traits>
#endif
#include <visp3/core/vpFont.h>
#include <visp3/core/vpImageDraw.h>
#include <visp3/core/vpIoTools.h>
#include <visp3/gui/vpDisplayD3D.h>
#include <visp3/gui/vpDisplayGDI.h>
#include <visp3/gui/vpDisplayGTK.h>
#include <visp3/gui/vpDisplayOpenCV.h>
#include <visp3/gui/vpDisplayX.h>
#include <visp3/io/vpImageIo.h>
#include <visp3/io/vpParseArgv.h>
#include <visp3/mbt/vpMbGenericTracker.h>
#define GETOPTARGS "i:dsclt:e:DmCh"
namespace
{
void usage(const char *name, const char *badparam)
{
fprintf(stdout, "\n\
Regression test for vpGenericTracker.\n\
\n\
SYNOPSIS\n\
%s [-i <test image path>] [-c] [-d] [-s] [-h] [-l] \n\
[-t <tracker type>] [-e <last frame index>] [-D] [-m] [-C]\n",
name);
fprintf(stdout, "\n\
OPTIONS: \n\
-i <input image path> \n\
Set image input path.\n\
These images come from ViSP-images-x.y.z.tar.gz available \n\
on the ViSP website.\n\
Setting the VISP_INPUT_IMAGE_PATH environment\n\
variable produces the same behavior than using\n\
this option.\n\
\n\
-d \n\
Turn off the display.\n\
\n\
-s \n\
If display is turn off, tracking results are saved in a video folder.\n\
\n\
-c\n\
Disable the mouse click. Useful to automate the \n\
execution of this program without human intervention.\n\
\n\
-t <tracker type>\n\
Set tracker type (<1 (Edge)>, <2 (KLT)>, <3 (both)>) for color sensor.\n\
\n\
-l\n\
Use the scanline for visibility tests.\n\
\n\
-e <last frame index>\n\
Specify the index of the last frame. Once reached, the tracking is stopped.\n\
\n\
-D \n\
Use depth.\n\
\n\
-m \n\
Set a tracking mask.\n\
\n\
-C \n\
Use color images.\n\
\n\
-h \n\
Print the help.\n\n");
if (badparam)
fprintf(stdout, "\nERROR: Bad parameter [%s]\n", badparam);
}
bool getOptions(int argc, const char **argv, std::string &ipath, bool &click_allowed, bool &display, bool &save,
bool &useScanline, int &trackerType, int &lastFrame, bool &use_depth, bool &use_mask,
bool &use_color_image)
{
const char *optarg_;
int c;
while ((c = vpParseArgv::parse(argc, argv, GETOPTARGS, &optarg_)) > 1) {
switch (c) {
case 'i':
ipath = optarg_;
break;
case 'c':
click_allowed = false;
break;
case 'd':
display = false;
break;
case 's':
save = true;
break;
case 'l':
useScanline = true;
break;
case 't':
trackerType = atoi(optarg_);
break;
case 'e':
lastFrame = atoi(optarg_);
break;
case 'D':
use_depth = true;
break;
case 'm':
use_mask = true;
break;
case 'C':
use_color_image = true;
break;
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;
}
template <typename Type>
bool read_data(const std::string &input_directory, int cpt, const vpCameraParameters &cam_depth, vpImage<Type> &I,
vpImage<uint16_t> &I_depth, std::vector<vpColVector> &pointcloud, vpHomogeneousMatrix &cMo)
{
#if (VISP_CXX_STANDARD >= VISP_CXX_STANDARD_11)
static_assert(std::is_same<Type, unsigned char>::value || std::is_same<Type, vpRGBa>::value,
"Template function supports only unsigned char and vpRGBa images!");
#endif
#if VISP_HAVE_DATASET_VERSION >= 0x030600
std::string ext("png");
#else
std::string ext("pgm");
#endif
char buffer[FILENAME_MAX];
snprintf(buffer, FILENAME_MAX, std::string(input_directory + "/Images/Image_%04d." + ext).c_str(), cpt);
std::string image_filename = buffer;
snprintf(buffer, FILENAME_MAX, std::string(input_directory + "/Depth/Depth_%04d.bin").c_str(), cpt);
std::string depth_filename = buffer;
snprintf(buffer, FILENAME_MAX, std::string(input_directory + "/CameraPose/Camera_%03d.txt").c_str(), cpt);
std::string pose_filename = buffer;
if (!vpIoTools::checkFilename(image_filename) || !vpIoTools::checkFilename(depth_filename) ||
!vpIoTools::checkFilename(pose_filename))
return false;
vpImageIo::read(I, image_filename);
unsigned int depth_width = 0, depth_height = 0;
std::ifstream file_depth(depth_filename.c_str(), std::ios::in | std::ios::binary);
if (!file_depth.is_open())
return false;
vpIoTools::readBinaryValueLE(file_depth, depth_height);
vpIoTools::readBinaryValueLE(file_depth, depth_width);
I_depth.resize(depth_height, depth_width);
pointcloud.resize(depth_height * depth_width);
const float depth_scale = 0.000030518f;
for (unsigned int i = 0; i < I_depth.getHeight(); i++) {
for (unsigned int j = 0; j < I_depth.getWidth(); j++) {
vpIoTools::readBinaryValueLE(file_depth, I_depth[i][j]);
double x = 0.0, y = 0.0, Z = I_depth[i][j] * depth_scale;
vpPixelMeterConversion::convertPoint(cam_depth, j, i, x, y);
vpColVector pt3d(4, 1.0);
pt3d[0] = x * Z;
pt3d[1] = y * Z;
pt3d[2] = Z;
pointcloud[i * I_depth.getWidth() + j] = pt3d;
}
}
std::ifstream file_pose(pose_filename.c_str());
if (!file_pose.is_open()) {
return false;
}
for (unsigned int i = 0; i < 4; i++) {
for (unsigned int j = 0; j < 4; j++) {
file_pose >> cMo[i][j];
}
}
return true;
}
void convert(const vpImage<vpRGBa> &src, vpImage<vpRGBa> &dst) { dst = src; }
void convert(const vpImage<unsigned char> &src, vpImage<vpRGBa> &dst) { vpImageConvert::convert(src, dst); }
template <typename Type>
bool run(const std::string &input_directory, bool opt_click_allowed, bool opt_display, bool useScanline,
int trackerType_image, int opt_lastFrame, bool use_depth, bool use_mask, bool save)
{
#if (VISP_CXX_STANDARD >= VISP_CXX_STANDARD_11)
static_assert(std::is_same<Type, unsigned char>::value || std::is_same<Type, vpRGBa>::value,
"Template function supports only unsigned char and vpRGBa images!");
#endif
// Initialise a display
#if defined(VISP_HAVE_X11)
vpDisplayX display1, display2;
#elif defined(VISP_HAVE_GDI)
vpDisplayGDI display1, display2;
#elif defined(HAVE_OPENCV_HIGHGUI)
vpDisplayOpenCV display1, display2;
#elif defined(VISP_HAVE_D3D9)
vpDisplayD3D display1, display2;
#elif defined(VISP_HAVE_GTK)
vpDisplayGTK display1, display2;
#else
opt_display = false;
#endif
std::vector<int> tracker_type(2);
tracker_type[0] = trackerType_image;
vpMbGenericTracker tracker(tracker_type);
std::string configFileCam1 = input_directory + std::string("/Config/chateau.xml");
std::string configFileCam2 = input_directory + std::string("/Config/chateau_depth.xml");
std::cout << "Load config file for camera 1: " << configFileCam1 << std::endl;
std::cout << "Load config file for camera 2: " << configFileCam2 << std::endl;
tracker.loadConfigFile(configFileCam1, configFileCam2);
#if 0
// Corresponding parameters manually set to have an example code
{
vpCameraParameters cam_color, cam_depth;
cam_color.initPersProjWithoutDistortion(700.0, 700.0, 320.0, 240.0);
cam_depth.initPersProjWithoutDistortion(700.0, 700.0, 320.0, 240.0);
tracker.setCameraParameters(cam_color, cam_depth);
}
// Edge
vpMe me;
me.setMaskSize(5);
me.setMaskNumber(180);
me.setRange(8);
me.setThreshold(5);
me.setMu1(0.5);
me.setMu2(0.5);
tracker.setMovingEdge(me);
// Klt
#if defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
tracker.setKltMaskBorder(5);
klt.setMaxFeatures(10000);
klt.setWindowSize(5);
klt.setQuality(0.01);
klt.setBlockSize(3);
tracker.setKltOpencv(klt);
#endif
// Depth
tracker.setAngleAppear(vpMath::rad(85.0));
tracker.setNearClippingDistance(0.01);
tracker.setFarClippingDistance(2.0);
#endif
#ifdef VISP_HAVE_COIN3D
tracker.loadModel(input_directory + "/Models/chateau.wrl", input_directory + "/Models/chateau.cao");
#else
tracker.loadModel(input_directory + "/Models/chateau.cao", input_directory + "/Models/chateau.cao");
#endif
T[0][0] = -1;
T[0][3] = -0.2;
T[1][1] = 0;
T[1][2] = 1;
T[1][3] = 0.12;
T[2][1] = 1;
T[2][2] = 0;
T[2][3] = -0.15;
tracker.loadModel(input_directory + "/Models/cube.cao", false, T);
vpCameraParameters cam_color, cam_depth;
tracker.getCameraParameters(cam_color, cam_depth);
tracker.setDisplayFeatures(true);
tracker.setScanLineVisibilityTest(useScanline);
std::map<int, std::pair<double, double> > map_thresh;
// Take the highest thresholds between all CI machines
#ifdef VISP_HAVE_COIN3D
useScanline ? std::pair<double, double>(0.005, 3.9) : std::pair<double, double>(0.007, 3.9);
#if defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
useScanline ? std::pair<double, double>(0.007, 1.9) : std::pair<double, double>(0.007, 1.8);
useScanline ? std::pair<double, double>(0.005, 3.7) : std::pair<double, double>(0.006, 3.4);
#endif
useScanline ? std::pair<double, double>(0.003, 1.7) : std::pair<double, double>(0.002, 0.8);
#if defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
std::pair<double, double>(0.002, 0.3);
useScanline ? std::pair<double, double>(0.002, 1.8) : std::pair<double, double>(0.002, 0.7);
#endif
#else
useScanline ? std::pair<double, double>(0.008, 2.3) : std::pair<double, double>(0.007, 2.1);
#if defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
useScanline ? std::pair<double, double>(0.006, 1.7) : std::pair<double, double>(0.005, 1.4);
useScanline ? std::pair<double, double>(0.004, 1.2) : std::pair<double, double>(0.004, 1.2);
#endif
useScanline ? std::pair<double, double>(0.002, 0.7) : std::pair<double, double>(0.001, 0.4);
#if defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
std::pair<double, double>(0.002, 0.3);
useScanline ? std::pair<double, double>(0.001, 0.5) : std::pair<double, double>(0.001, 0.4);
#endif
#endif
vpImage<Type> I, I_depth;
vpImage<uint16_t> I_depth_raw;
std::vector<vpColVector> pointcloud;
int cpt_frame = 1;
if (!read_data(input_directory, cpt_frame, cam_depth, I, I_depth_raw, pointcloud, cMo_truth)) {
std::cerr << "Cannot read first frame!" << std::endl;
return EXIT_FAILURE;
}
const double roi_step = 7.0;
const double roi_step2 = 6.0;
if (use_mask) {
mask = false;
for (unsigned int i = (unsigned int)(I.getRows() / roi_step);
i < (unsigned int)(I.getRows() * roi_step2 / roi_step); i++) {
for (unsigned int j = (unsigned int)(I.getCols() / roi_step);
j < (unsigned int)(I.getCols() * roi_step2 / roi_step); j++) {
mask[i][j] = true;
}
}
tracker.setMask(mask);
}
vpImageConvert::createDepthHistogram(I_depth_raw, I_depth);
vpImage<vpRGBa> results(I.getHeight(), I.getWidth() + I_depth.getWidth());
vpImage<vpRGBa> resultsColor(I.getHeight(), I.getWidth());
vpImage<vpRGBa> resultsDepth(I_depth.getHeight(), I_depth.getWidth());
if (save) {
}
if (opt_display) {
#ifdef VISP_HAVE_DISPLAY
display1.init(I, 0, 0, "Image");
display2.init(I_depth, (int)I.getWidth(), 0, "Depth");
#endif
}
vpHomogeneousMatrix depth_M_color;
depth_M_color[0][3] = -0.05;
tracker.setCameraTransformationMatrix("Camera2", depth_M_color);
tracker.initFromPose(I, cMo_truth);
vpFont font(24);
bool click = false, quit = false, correct_accuracy = true;
std::vector<double> vec_err_t, vec_err_tu;
std::vector<double> time_vec;
while (read_data(input_directory, cpt_frame, cam_depth, I, I_depth_raw, pointcloud, cMo_truth) && !quit &&
(opt_lastFrame > 0 ? (int)cpt_frame <= opt_lastFrame : true)) {
vpImageConvert::createDepthHistogram(I_depth_raw, I_depth);
if (opt_display) {
}
else if (save) {
convert(I, resultsColor);
convert(I_depth, resultsDepth);
}
double t = vpTime::measureTimeMs();
std::map<std::string, const vpImage<Type> *> mapOfImages;
mapOfImages["Camera1"] = &I;
std::map<std::string, const std::vector<vpColVector> *> mapOfPointclouds;
mapOfPointclouds["Camera2"] = &pointcloud;
std::map<std::string, unsigned int> mapOfWidths, mapOfHeights;
if (!use_depth) {
mapOfWidths["Camera2"] = 0;
mapOfHeights["Camera2"] = 0;
}
else {
mapOfWidths["Camera2"] = I_depth.getWidth();
mapOfHeights["Camera2"] = I_depth.getHeight();
}
tracker.track(mapOfImages, mapOfPointclouds, mapOfWidths, mapOfHeights);
vpHomogeneousMatrix cMo = tracker.getPose();
time_vec.push_back(t);
if (opt_display) {
tracker.display(I, I_depth, cMo, depth_M_color * cMo, cam_color, cam_depth, vpColor::red, 3);
vpDisplay::displayFrame(I, cMo, cam_depth, 0.05, vpColor::none, 3);
vpDisplay::displayFrame(I_depth, depth_M_color * cMo, cam_depth, 0.05, vpColor::none, 3);
std::stringstream ss;
ss << "Frame: " << cpt_frame;
vpDisplay::displayText(I_depth, 20, 20, ss.str(), vpColor::red);
ss.str("");
ss << "Nb features: " << tracker.getError().getRows();
vpDisplay::displayText(I_depth, 40, 20, ss.str(), vpColor::red);
}
else if (save) {
std::map<std::string, std::vector<std::vector<double> > > mapOfModels;
std::map<std::string, unsigned int> mapOfW;
mapOfW["Camera1"] = I.getWidth();
mapOfW["Camera2"] = I.getHeight();
std::map<std::string, unsigned int> mapOfH;
mapOfH["Camera1"] = I_depth.getWidth();
mapOfH["Camera2"] = I_depth.getHeight();
std::map<std::string, vpHomogeneousMatrix> mapOfcMos;
mapOfcMos["Camera1"] = cMo;
mapOfcMos["Camera2"] = depth_M_color * cMo;
std::map<std::string, vpCameraParameters> mapOfCams;
mapOfCams["Camera1"] = cam_color;
mapOfCams["Camera2"] = cam_depth;
tracker.getModelForDisplay(mapOfModels, mapOfW, mapOfH, mapOfcMos, mapOfCams);
for (std::map<std::string, std::vector<std::vector<double> > >::const_iterator it = mapOfModels.begin();
it != mapOfModels.end(); ++it) {
for (size_t i = 0; i < it->second.size(); i++) {
// test if it->second[i][0] = 0
if (std::fabs(it->second[i][0]) <= std::numeric_limits<double>::epsilon()) {
vpImageDraw::drawLine(it->first == "Camera1" ? resultsColor : resultsDepth,
vpImagePoint(it->second[i][1], it->second[i][2]),
vpImagePoint(it->second[i][3], it->second[i][4]), vpColor::red, 3);
}
}
}
std::map<std::string, std::vector<std::vector<double> > > mapOfFeatures;
tracker.getFeaturesForDisplay(mapOfFeatures);
for (std::map<std::string, std::vector<std::vector<double> > >::const_iterator it = mapOfFeatures.begin();
it != mapOfFeatures.end(); ++it) {
for (size_t i = 0; i < it->second.size(); i++) {
if (std::fabs(it->second[i][0]) <=
std::numeric_limits<double>::epsilon()) { // test it->second[i][0] = 0 for ME
if (std::fabs(it->second[i][3]) <= std::numeric_limits<double>::epsilon()) { // test it->second[i][3] = 0
color = vpColor::green;
}
else if (std::fabs(it->second[i][3] - 1) <=
std::numeric_limits<double>::epsilon()) { // test it->second[i][3] = 1
color = vpColor::blue;
}
else if (std::fabs(it->second[i][3] - 2) <=
std::numeric_limits<double>::epsilon()) { // test it->second[i][3] = 2
color = vpColor::purple;
}
else if (std::fabs(it->second[i][3] - 3) <=
std::numeric_limits<double>::epsilon()) { // test it->second[i][3] = 3
color = vpColor::red;
}
else if (std::fabs(it->second[i][3] - 4) <=
std::numeric_limits<double>::epsilon()) { // test it->second[i][3] = 4
color = vpColor::cyan;
}
vpImageDraw::drawCross(it->first == "Camera1" ? resultsColor : resultsDepth,
vpImagePoint(it->second[i][1], it->second[i][2]), 3, color, 1);
}
else if (std::fabs(it->second[i][0] - 1) <=
std::numeric_limits<double>::epsilon()) { // test it->second[i][0] = 1 for KLT
vpImageDraw::drawCross(it->first == "Camera1" ? resultsColor : resultsDepth,
vpImagePoint(it->second[i][1], it->second[i][2]), 10, vpColor::red, 1);
}
}
}
// Computation time
std::ostringstream oss;
oss << "Tracking time: " << t << " ms";
font.drawText(resultsColor, oss.str(), vpImagePoint(20, 20), vpColor::red);
}
vpPoseVector pose_est(cMo);
vpPoseVector pose_truth(cMo_truth);
vpColVector t_est(3), t_truth(3);
vpColVector tu_est(3), tu_truth(3);
for (unsigned int i = 0; i < 3; i++) {
t_est[i] = pose_est[i];
t_truth[i] = pose_truth[i];
tu_est[i] = pose_est[i + 3];
tu_truth[i] = pose_truth[i + 3];
}
vpColVector t_err = t_truth - t_est, tu_err = tu_truth - tu_est;
const double t_thresh =
map_thresh[!use_depth ? trackerType_image : trackerType_image | vpMbGenericTracker::DEPTH_DENSE_TRACKER].first;
const double tu_thresh =
map_thresh[!use_depth ? trackerType_image : trackerType_image | vpMbGenericTracker::DEPTH_DENSE_TRACKER].second;
double t_err2 = sqrt(t_err.sumSquare()), tu_err2 = vpMath::deg(sqrt(tu_err.sumSquare()));
vec_err_t.push_back(t_err2);
vec_err_tu.push_back(tu_err2);
if (!use_mask && (t_err2 > t_thresh || tu_err2 > tu_thresh)) { // no accuracy test with mask
std::cerr << "Pose estimated exceeds the threshold (t_thresh = " << t_thresh << " ; tu_thresh = " << tu_thresh
<< ")!" << std::endl;
std::cout << "t_err: " << t_err2 << " ; tu_err: " << tu_err2 << std::endl;
correct_accuracy = false;
}
if (opt_display) {
if (use_mask) {
vpRect roi(vpImagePoint(I.getRows() / roi_step, I.getCols() / roi_step),
vpImagePoint(I.getRows() * roi_step2 / roi_step, I.getCols() * roi_step2 / roi_step));
}
vpDisplay::flush(I_depth);
}
else if (save) {
char buffer[FILENAME_MAX];
std::ostringstream oss;
oss << "results/image_%04d.png";
snprintf(buffer, FILENAME_MAX, oss.str().c_str(), cpt_frame);
results.insert(resultsColor, vpImagePoint());
results.insert(resultsDepth, vpImagePoint(0, resultsColor.getWidth()));
vpImageIo::write(results, buffer);
}
if (opt_display && opt_click_allowed) {
if (vpDisplay::getClick(I, button, click)) {
switch (button) {
quit = !click;
break;
click = !click;
break;
default:
break;
}
}
}
cpt_frame++;
}
if (!time_vec.empty())
std::cout << "Computation time, Mean: " << vpMath::getMean(time_vec)
<< " ms ; Median: " << vpMath::getMedian(time_vec) << " ms ; Std: " << vpMath::getStdev(time_vec) << " ms"
<< std::endl;
if (!vec_err_t.empty())
std::cout << "Max translation error: " << *std::max_element(vec_err_t.begin(), vec_err_t.end()) << std::endl;
if (!vec_err_tu.empty())
std::cout << "Max thetau error: " << *std::max_element(vec_err_tu.begin(), vec_err_tu.end()) << std::endl;
std::cout << "Test result: " << (correct_accuracy ? "success" : "failure") << std::endl;
return correct_accuracy ? EXIT_SUCCESS : EXIT_FAILURE;
}
} // namespace
int main(int argc, const char *argv [])
{
try {
std::string env_ipath;
std::string opt_ipath = "";
bool opt_click_allowed = true;
bool opt_display = true;
bool opt_save = false;
bool useScanline = false;
int trackerType_image = vpMbGenericTracker::EDGE_TRACKER;
#if defined(__mips__) || defined(__mips) || defined(mips) || defined(__MIPS__)
// To avoid Debian test timeout
int opt_lastFrame = 5;
#else
int opt_lastFrame = -1;
#endif
bool use_depth = false;
bool use_mask = false;
bool use_color_image = false;
// Get the visp-images-data package path or VISP_INPUT_IMAGE_PATH
// environment variable value
// Read the command line options
if (!getOptions(argc, argv, opt_ipath, opt_click_allowed, opt_display, opt_save, useScanline, trackerType_image,
opt_lastFrame, use_depth, use_mask, use_color_image)) {
return EXIT_FAILURE;
}
#if ! (defined(VISP_HAVE_MODULE_KLT) && defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO))
if (trackerType_image == 2 || trackerType_image == 3) {
std::cout << "Using klt tracker is not possible without OpenCV imgproc and video modules." << std::endl;
std::cout << "Use rather command line option -t 1 to use edges." << std::endl;
return EXIT_SUCCESS;
}
#endif
std::cout << "trackerType_image: " << trackerType_image << std::endl;
std::cout << "useScanline: " << useScanline << std::endl;
std::cout << "use_depth: " << use_depth << std::endl;
std::cout << "use_mask: " << use_mask << std::endl;
std::cout << "use_color_image: " << use_color_image << std::endl;
#ifdef VISP_HAVE_COIN3D
std::cout << "COIN3D available." << std::endl;
#endif
#if !defined(VISP_HAVE_MODULE_KLT) || (!defined(VISP_HAVE_OPENCV) || (VISP_HAVE_OPENCV_VERSION < 0x020100))
if (trackerType_image & 2) {
std::cout << "KLT features cannot be used: ViSP is not built with "
"KLT module or OpenCV is not available.\nTest is not run."
<< std::endl;
return EXIT_SUCCESS;
}
#endif
// Test if an input path is set
if (opt_ipath.empty() && env_ipath.empty()) {
usage(argv[0], NULL);
std::cerr << std::endl << "ERROR:" << std::endl;
std::cerr << " Use -i <visp image path> option or set VISP_INPUT_IMAGE_PATH " << std::endl
<< " environment variable to specify the location of the " << std::endl
<< " image path where test images are located." << std::endl
<< std::endl;
return EXIT_FAILURE;
}
std::string input_directory =
vpIoTools::createFilePath(!opt_ipath.empty() ? opt_ipath : env_ipath, "mbt-depth/Castle-simu");
if (!vpIoTools::checkDirectory(input_directory)) {
std::cerr << "ViSP-images does not contain the folder: " << input_directory << "!" << std::endl;
return EXIT_SUCCESS;
}
if (use_color_image) {
return run<vpRGBa>(input_directory, opt_click_allowed, opt_display, useScanline, trackerType_image, opt_lastFrame,
use_depth, use_mask, opt_save);
}
else {
return run<unsigned char>(input_directory, opt_click_allowed, opt_display, useScanline, trackerType_image,
opt_lastFrame, use_depth, use_mask, opt_save);
}
std::cout << "Test succeed" << std::endl;
return EXIT_SUCCESS;
}
catch (const vpException &e) {
std::cout << "Catch an exception: " << e << std::endl;
return EXIT_FAILURE;
}
}
#elif !(defined(VISP_HAVE_LAPACK) || defined(VISP_HAVE_EIGEN3) || defined(VISP_HAVE_OPENCV))
int main()
{
std::cout << "Cannot run this example: install Lapack, Eigen3 or OpenCV" << std::endl;
return EXIT_SUCCESS;
}
#else
int main()
{
std::cout << "Enable MBT module (VISP_HAVE_MODULE_MBT) to launch this test." << std::endl;
return EXIT_SUCCESS;
}
#endif
unsigned int getRows() const
Definition vpArray2D.h:290
Generic class defining intrinsic camera parameters.
void initPersProjWithoutDistortion(double px, double py, double u0, double v0)
Implementation of column vector and the associated operations.
double sumSquare() const
Class to define RGB colors available for display functionalities.
Definition vpColor.h:152
static const vpColor red
Definition vpColor.h:211
static const vpColor cyan
Definition vpColor.h:220
static const vpColor none
Definition vpColor.h:223
static const vpColor blue
Definition vpColor.h:217
static const vpColor purple
Definition vpColor.h:222
static const vpColor yellow
Definition vpColor.h:219
static const vpColor green
Definition vpColor.h:214
Display for windows using Direct3D 3rd party. Thus to enable this class Direct3D should be installed....
Display for windows using GDI (available on any windows 32 platform).
The vpDisplayGTK allows to display image using the GTK 3rd party library. Thus to enable this class G...
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:132
void init(vpImage< unsigned char > &I, int win_x=-1, int win_y=-1, const std::string &win_title="")
static bool getClick(const vpImage< unsigned char > &I, bool blocking=true)
static void display(const vpImage< unsigned char > &I)
static void displayFrame(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, double size, const vpColor &color=vpColor::none, unsigned int thickness=1, const vpImagePoint &offset=vpImagePoint(0, 0), const std::string &frameName="", const vpColor &textColor=vpColor::black, const vpImagePoint &textOffset=vpImagePoint(15, 15))
static void flush(const vpImage< unsigned char > &I)
static void displayRectangle(const vpImage< unsigned char > &I, const vpImagePoint &topLeft, unsigned int width, unsigned int height, const vpColor &color, bool fill=false, unsigned int thickness=1)
static void displayText(const vpImage< unsigned char > &I, const vpImagePoint &ip, const std::string &s, const vpColor &color)
error that can be emitted by ViSP classes.
Definition vpException.h:59
Font drawing functions for image.
Definition vpFont.h:54
bool drawText(vpImage< unsigned char > &I, const std::string &text, const vpImagePoint &position, unsigned char color) const
Definition vpFont.cpp:2634
Implementation of an homogeneous matrix and operations on such kind of matrices.
static void createDepthHistogram(const vpImage< uint16_t > &src_depth, vpImage< vpRGBa > &dest_rgba)
static void convert(const vpImage< unsigned char > &src, vpImage< vpRGBa > &dest)
static void drawLine(vpImage< unsigned char > &I, const vpImagePoint &ip1, const vpImagePoint &ip2, unsigned char color, unsigned int thickness=1)
static void drawCross(vpImage< unsigned char > &I, const vpImagePoint &ip, unsigned int size, unsigned char color, unsigned int thickness=1)
static void read(vpImage< unsigned char > &I, const std::string &filename, int backend=IO_DEFAULT_BACKEND)
static void write(const vpImage< unsigned char > &I, const std::string &filename, int backend=IO_DEFAULT_BACKEND)
Class that defines a 2D point in an image. This class is useful for image processing and stores only ...
Definition of the vpImage class member functions.
Definition vpImage.h:135
unsigned int getWidth() const
Definition vpImage.h:242
void resize(unsigned int h, unsigned int w)
resize the image : Image initialization
Definition vpImage.h:795
void insert(const vpImage< Type > &src, const vpImagePoint &topLeft)
Definition vpImage.h:1361
unsigned int getCols() const
Definition vpImage.h:175
unsigned int getHeight() const
Definition vpImage.h:184
unsigned int getRows() const
Definition vpImage.h:214
static std::string getViSPImagesDataPath()
static bool checkFilename(const std::string &filename)
static void readBinaryValueLE(std::ifstream &file, int16_t &short_value)
static bool checkDirectory(const std::string &dirname)
static std::string createFilePath(const std::string &parent, const std::string &child)
static void makeDirectory(const std::string &dirname)
Wrapper for the KLT (Kanade-Lucas-Tomasi) feature tracker implemented in OpenCV. Thus to enable this ...
Definition vpKltOpencv.h:73
void setBlockSize(int blockSize)
void setQuality(double qualityLevel)
void setHarrisFreeParameter(double harris_k)
void setMaxFeatures(int maxCount)
void setMinDistance(double minDistance)
void setWindowSize(int winSize)
void setPyramidLevels(int pyrMaxLevel)
static double rad(double deg)
Definition vpMath.h:116
static double getMedian(const std::vector< double > &v)
Definition vpMath.cpp:314
static double getStdev(const std::vector< double > &v, bool useBesselCorrection=false)
Definition vpMath.cpp:345
static double getMean(const std::vector< double > &v)
Definition vpMath.cpp:294
static double deg(double rad)
Definition vpMath.h:106
Real-time 6D object pose tracking using its CAD model.
virtual void setCameraParameters(const vpCameraParameters &camera)
virtual void getPose(vpHomogeneousMatrix &cMo) const
virtual std::vector< std::vector< double > > getFeaturesForDisplay()
virtual void setDisplayFeatures(bool displayF)
virtual void setKltMaskBorder(const unsigned int &e)
virtual std::vector< std::vector< double > > getModelForDisplay(unsigned int width, unsigned int height, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, bool displayFullModel=false)
virtual void setAngleAppear(const double &a)
virtual void setDepthNormalSamplingStep(unsigned int stepX, unsigned int stepY)
virtual void setNearClippingDistance(const double &dist)
virtual void initFromPose(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cMo)
virtual void getCameraParameters(vpCameraParameters &camera) const
virtual void setAngleDisappear(const double &a)
virtual void setDepthNormalPclPlaneEstimationMethod(int method)
virtual void setMovingEdge(const vpMe &me)
virtual void setScanLineVisibilityTest(const bool &v)
virtual void setDepthNormalPclPlaneEstimationRansacMaxIter(int maxIter)
virtual void setDepthNormalPclPlaneEstimationRansacThreshold(double threshold)
virtual void setDepthDenseSamplingStep(unsigned int stepX, unsigned int stepY)
virtual void setKltOpencv(const vpKltOpencv &t)
virtual void getClipping(unsigned int &clippingFlag1, unsigned int &clippingFlag2) const
virtual void setFarClippingDistance(const double &dist)
virtual void setClipping(const unsigned int &flags)
virtual void loadConfigFile(const std::string &configFile, bool verbose=true)
virtual void setCameraTransformationMatrix(const std::string &cameraName, const vpHomogeneousMatrix &cameraTransformationMatrix)
virtual void loadModel(const std::string &modelFile, bool verbose=false, const vpHomogeneousMatrix &T=vpHomogeneousMatrix())
virtual vpColVector getError() const
virtual void setMask(const vpImage< bool > &mask)
virtual void setDepthNormalFeatureEstimationMethod(const vpMbtFaceDepthNormal::vpFeatureEstimationType &method)
virtual void display(const vpImage< unsigned char > &I, const vpHomogeneousMatrix &cMo, const vpCameraParameters &cam, const vpColor &col, unsigned int thickness=1, bool displayFullModel=false)
virtual void track(const vpImage< unsigned char > &I)
Definition vpMe.h:122
void setMu1(const double &mu_1)
Definition vpMe.h:353
void setSampleStep(const double &s)
Definition vpMe.h:390
void setRange(const unsigned int &r)
Definition vpMe.h:383
void setLikelihoodThresholdType(const vpLikelihoodThresholdType likelihood_threshold_type)
Definition vpMe.h:445
void setMaskSize(const unsigned int &a)
Definition vpMe.cpp:452
void setMu2(const double &mu_2)
Definition vpMe.h:360
@ NORMALIZED_THRESHOLD
Easy-to-use normalized likelihood threshold corresponding to the minimal luminance contrast to consid...
Definition vpMe.h:132
void setMaskNumber(const unsigned int &a)
Definition vpMe.cpp:445
void setThreshold(const double &t)
Definition vpMe.h:435
static bool parse(int *argcPtr, const char **argv, vpArgvInfo *argTable, int flags)
static void convertPoint(const vpCameraParameters &cam, const double &u, const double &v, double &x, double &y)
Implementation of a pose vector and operations on poses.
Defines a rectangle in the plane.
Definition vpRect.h:76
VISP_EXPORT double measureTimeMs()