vpKltOpencv.h

/*
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2024 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 VP_KLT_OPENCV_H
#define VP_KLT_OPENCV_H
 
#include <visp3/core/vpConfig.h>
 
#if defined(HAVE_OPENCV_HIGHGUI) && defined(HAVE_OPENCV_IMGPROC) && defined(HAVE_OPENCV_VIDEO)
 
#include <visp3/core/vpColor.h>
#include <visp3/core/vpImage.h>
 
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/video/tracking.hpp>
 
#if defined(VISP_HAVE_NLOHMANN_JSON)
#include VISP_NLOHMANN_JSON(json.hpp)
#endif
 
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 static_cast<int>(m_points[1].size()); }
  int getNbPrevFeatures() const { return static_cast<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);
 
#ifdef VISP_HAVE_NLOHMANN_JSON
  friend void to_json(nlohmann::json &j, const vpKltOpencv &array);
  friend void from_json(const nlohmann::json &j, vpKltOpencv &array);
#endif
 
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; 
};
 
#ifdef VISP_HAVE_NLOHMANN_JSON
inline void to_json(nlohmann::json &j, const vpKltOpencv &klt)
{
  j = nlohmann::json {
      {"maxFeatures", klt.getMaxFeatures()},
      {"windowSize", klt.getWindowSize()},
      {"quality", klt.getQuality()},
      {"minDistance", klt.getMinDistance()},
      {"useHarris", klt.m_useHarrisDetector},
      {"harris", klt.getHarrisFreeParameter()},
      {"blockSize", klt.getBlockSize()},
      {"pyramidLevels", klt.getPyramidLevels()}
  };
}
 
inline void from_json(const nlohmann::json &j, vpKltOpencv &klt)
{
  klt.setMaxFeatures(j.value("maxFeatures", 10000));
  klt.setWindowSize(j.value("windowSize", 5));
  klt.setQuality(j.value("quality", 0.01));
  klt.setMinDistance(j.value("minDistance", 5));
  klt.setUseHarris(j.value("useHarris", 1));
  klt.setHarrisFreeParameter(j.value("harris", 0.01));
  klt.setBlockSize(j.value("blockSize", 3));
  klt.setPyramidLevels(j.value("pyramidLevels", 3));
}
#endif
 
END_VISP_NAMESPACE
#endif
#endif