tracking_KL.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#include "vision-precomp.h"  // Precompiled headers
 
#include <mrpt/system/memory.h>
#include <mrpt/vision/tracking.h>
#include <mrpt/vision/CFeatureExtraction.h>
 
// Universal include for all versions of OpenCV
#include <mrpt/otherlibs/do_opencv_includes.h>
 
#if HAVE_ALLOCA_H
#include <alloca.h>
#endif
 
using namespace mrpt;
using namespace mrpt::vision;
using namespace mrpt::img;
using namespace std;
 
/** Track a set of features from old_img -> new_img using sparse optimal flow
  *(classic KL method)
  *  Optional parameters that can be passed in "extra_params":
  *             - "window_width"  (Default=15)
  *             - "window_height" (Default=15)
  *
  *  \sa OpenCV's method cvCalcOpticalFlowPyrLK
  */
template <typename FEATLIST>
void CFeatureTracker_KL::trackFeatures_impl_templ(
        const CImage& old_img, const CImage& new_img, FEATLIST& featureList)
{
        MRPT_START
 
#if MRPT_HAS_OPENCV
        const unsigned int window_width =
                extra_params.getWithDefaultVal("window_width", 15);
        const unsigned int window_height =
                extra_params.getWithDefaultVal("window_height", 15);
 
        const int LK_levels = extra_params.getWithDefaultVal("LK_levels", 3);
        const int LK_max_iters = extra_params.getWithDefaultVal("LK_max_iters", 10);
        const int LK_epsilon = extra_params.getWithDefaultVal("LK_epsilon", 0.1);
        const float LK_max_tracking_error =
                extra_params.getWithDefaultVal("LK_max_tracking_error", 150.0f);
 
        // Both images must be of the same size
        ASSERT_(
                old_img.getWidth() == new_img.getWidth() &&
                old_img.getHeight() == new_img.getHeight());
 
        const size_t img_width = old_img.getWidth();
        const size_t img_height = old_img.getHeight();
 
        const size_t nFeatures = featureList.size();  // Number of features
 
        // Grayscale images
        const CImage prev_gray(old_img, FAST_REF_OR_CONVERT_TO_GRAY);
        const CImage cur_gray(new_img, FAST_REF_OR_CONVERT_TO_GRAY);
 
        // Array conversion MRPT->OpenCV
        if (nFeatures > 0)
        {
                CvPoint2D32f* points[2];
 
                points[0] = reinterpret_cast<CvPoint2D32f*>(
                        mrpt_alloca(sizeof(CvPoint2D32f) * nFeatures));
                points[1] = reinterpret_cast<CvPoint2D32f*>(
                        mrpt_alloca(sizeof(CvPoint2D32f) * nFeatures));
 
                std::vector<char> status(nFeatures);
 
                for (size_t i = 0; i < nFeatures; ++i)
                {
                        points[0][i].x = featureList.getFeatureX(i);
                        points[0][i].y = featureList.getFeatureY(i);
                }  // end for
 
                // local scope for auxiliary variables around cvCalcOpticalFlowPyrLK()
                const IplImage* prev_gray_ipl = prev_gray.getAs<IplImage>();
                const IplImage* cur_gray_ipl = cur_gray.getAs<IplImage>();
 
                // Pyramids
                // JL: It seems that cache'ing the pyramids of previous images doesn't
                // really improve the efficiency (!?!?)
                IplImage* pPyr = nullptr;
                IplImage* cPyr = nullptr;
 
                int flags = 0;
 
                float* track_error =
                        reinterpret_cast<float*>(mrpt_alloca(sizeof(float) * nFeatures));
 
                cvCalcOpticalFlowPyrLK(
                        prev_gray_ipl, cur_gray_ipl, pPyr, cPyr, &points[0][0],
                        &points[1][0], nFeatures, cvSize(window_width, window_height),
                        LK_levels, &status[0], track_error,
                        cvTermCriteria(
                                CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, LK_max_iters, LK_epsilon),
                        flags);
 
                cvReleaseImage(&pPyr);
                cvReleaseImage(&cPyr);
 
                for (size_t i = 0; i < nFeatures; ++i)
                {
                        const bool trck_err_too_large =
                                track_error[i] > LK_max_tracking_error;
 
                        if (status[i] == 1 && !trck_err_too_large && points[1][i].x > 0 &&
                                points[1][i].y > 0 && points[1][i].x < img_width &&
                                points[1][i].y < img_height)
                        {
                                // Feature could be tracked
                                featureList.setFeatureXf(i, points[1][i].x);
                                featureList.setFeatureYf(i, points[1][i].y);
                                featureList.setTrackStatus(i, status_TRACKED);
                        }  // end if
                        else  // Feature could not be tracked
                        {
                                featureList.setFeatureX(i, -1);
                                featureList.setFeatureY(i, -1);
                                featureList.setTrackStatus(
                                        i, trck_err_too_large ? status_LOST : status_OOB);
                        }  // end else
                }  // end for
 
                mrpt_alloca_free(points[0]);
                mrpt_alloca_free(points[1]);
                mrpt_alloca_free(track_error);
 
                // In case it needs to rebuild a kd-tree or whatever
                featureList.mark_as_outdated();
        }
 
#else
        THROW_EXCEPTION("The MRPT has been compiled with MRPT_HAS_OPENCV=0 !");
#endif
 
        MRPT_END
}  // end trackFeatures
 
void CFeatureTracker_KL::trackFeatures_impl(
        const CImage& old_img, const CImage& new_img, CFeatureList& featureList)
{
        trackFeatures_impl_templ<CFeatureList>(old_img, new_img, featureList);
}
 
void CFeatureTracker_KL::trackFeatures_impl(
        const CImage& old_img, const CImage& new_img,
        TSimpleFeatureList& featureList)
{
        trackFeatures_impl_templ<TSimpleFeatureList>(old_img, new_img, featureList);
}
 
void CFeatureTracker_KL::trackFeatures_impl(
        const CImage& old_img, const CImage& new_img,
        TSimpleFeaturefList& featureList)
{
        trackFeatures_impl_templ<TSimpleFeaturefList>(
                old_img, new_img, featureList);
}