vpKltOpencv.h

/*
 * 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:
 * Wrapper for the KLT (Kanade-Lucas-Tomasi) feature tracker implemented
 * with opencv.
 */
 
#ifndef _vpKltOpencv_h_
#define _vpKltOpencv_h_
 
#include <visp3/core/vpColor.h>
#include <visp3/core/vpConfig.h>
#include <visp3/core/vpImage.h>
 
#if defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_HIGHGUI) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
 
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/video/tracking.hpp>
 
BEGIN_VISP_NAMESPACE
class VISP_EXPORT vpKltOpencv
{
public:
  vpKltOpencv();
  vpKltOpencv(const vpKltOpencv &copy);
  virtual ~vpKltOpencv();
 
  void addFeature(const float &x, const float &y);
 
  void addFeature(const long &id, const float &x, const float &y);
 
  void addFeature(const cv::Point2f &f);
 
  void display(const vpImage<unsigned char> &I, const vpColor &color = vpColor::red, unsigned int thickness = 1) const;
  static void display(const vpImage<unsigned char> &I, const std::vector<cv::Point2f> &features,
                      const vpColor &color = vpColor::green, unsigned int thickness = 1);
  static void display(const vpImage<vpRGBa> &I, const std::vector<cv::Point2f> &features,
                      const vpColor &color = vpColor::green, unsigned int thickness = 1);
  static void display(const vpImage<unsigned char> &I, const std::vector<cv::Point2f> &features,
                        const std::vector<long> &featuresid, const vpColor &color = vpColor::green,
                        unsigned int thickness = 1);
  static void display(const vpImage<vpRGBa> &I, const std::vector<cv::Point2f> &features,
                      const std::vector<long> &featuresid, const vpColor &color = vpColor::green,
                      unsigned int thickness = 1);
 
  int getBlockSize() const { return m_blockSize; }
  void getFeature(const int &index, long &id, float &x, float &y) const;
  std::vector<cv::Point2f> getFeatures() const { return m_points[1]; }
  // CvPoint2D32f* getFeatures() const {return features;}
  std::vector<long> getFeaturesId() const { return m_points_id; }
  // long* getFeaturesId() const {return featuresid;}
  double getHarrisFreeParameter() const { return m_harris_k; }
  // bool *getListOfLostFeature() const { return lostDuringTrack; }
  int getMaxFeatures() const { return m_maxCount; }
  double getMinDistance() const { return m_minDistance; }
  int getNbFeatures() const { return (int)m_points[1].size(); }
  int getNbPrevFeatures() const { return (int)m_points[0].size(); }
  // void getPrevFeature(int index, int &id, float &x, float &y) const;
  std::vector<cv::Point2f> getPrevFeatures() const { return m_points[0]; }
  // CvPoint2D32f* getPrevFeatures() const {return prev_features;}
  // long* getPrevFeaturesId() const {return prev_featuresid;}
  int getPyramidLevels() const { return m_pyrMaxLevel; }
  double getQuality() const { return m_qualityLevel; }
  int getWindowSize() const { return m_winSize; }
 
  void initTracking(const cv::Mat &I, const cv::Mat &mask = cv::Mat());
 
  void initTracking(const cv::Mat &I, const std::vector<cv::Point2f> &pts);
 
  void initTracking(const cv::Mat &I, const std::vector<cv::Point2f> &pts, const std::vector<long> &ids);
 
  vpKltOpencv &operator=(const vpKltOpencv &copy);
 
  void track(const cv::Mat &I);
 
  void setBlockSize(int blockSize) { m_blockSize = blockSize; }
 
  void setHarrisFreeParameter(double harris_k) { m_harris_k = harris_k; }
 
  void setInitialGuess(const std::vector<cv::Point2f> &guess_pts);
 
  void setInitialGuess(const std::vector<cv::Point2f> &init_pts, const std::vector<cv::Point2f> &guess_pts,
                       const std::vector<long> &fid);
  void setMaxFeatures(int maxCount) { m_maxCount = maxCount; }
 
  void setMinDistance(double minDistance) { m_minDistance = minDistance; }
 
  void setMinEigThreshold(double minEigThreshold) { m_minEigThreshold = minEigThreshold; }
 
  void setPyramidLevels(int pyrMaxLevel) { m_pyrMaxLevel = pyrMaxLevel; }
 
  void setQuality(double qualityLevel) { m_qualityLevel = qualityLevel; }
 
  void setTrackerId(int tid) { (void)tid; }
 
  void setUseHarris(int useHarrisDetector) { m_useHarrisDetector = useHarrisDetector; }
 
  void setWindowSize(int winSize) { m_winSize = winSize; }
 
  void suppressFeature(const int &index);
 
protected:
  cv::Mat m_gray; 
  cv::Mat m_prevGray; 
  std::vector<cv::Point2f> m_points[2]; 
  std::vector<long> m_points_id;        
  int m_maxCount; 
  cv::TermCriteria m_termcrit; 
  int m_winSize; 
  double m_qualityLevel; 
  double m_minDistance; 
  double m_minEigThreshold; 
  double m_harris_k; 
  int m_blockSize; 
  int m_useHarrisDetector; 
  int m_pyrMaxLevel; 
  long m_next_points_id; 
  bool m_initial_guess; 
};
END_VISP_NAMESPACE
#endif
#endif