tracking.h

/*
This file is part of Fast Track.
 
    FastTrack 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 3 of the License, or
    (at your option) any later version.
 
    FastTrack is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with FastTrack.  If not, see <https://www.gnu.org/licenses/>.
*/
 
#ifndef TRACKING_H
#define TRACKING_H
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <QDate>
#include <QDebug>
#include <QDir>
#include <QDirIterator>
#include <QElapsedTimer>
#include <QFile>
#include <QFileInfo>
#include <QHash>
#include <QList>
#include <QObject>
#include <QProgressBar>
#include <QRandomGenerator>
#include <QSharedPointer>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QString>
#include <QTextStream>
#include <QThread>
#include <QTimer>
#include <QVector>
#include <algorithm>
#include <fstream>
#include <iostream>
#include <numeric>
#include <opencv2/calib3d.hpp>
#include <opencv2/core/types.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/video/tracking.hpp>
#include <stdexcept>
#include <string>
#include <tuple>
#include <utility>
#include "opencv2/features2d/features2d.hpp"
#include "videoreader.h"
 
using namespace cv;
using namespace std;
 
class Tracking : public QObject {
  Q_OBJECT
 
  QSharedPointer<QElapsedTimer> m_timer; 
 
  bool m_statusBinarisation; 
 
  string m_path;           
  string m_backgroundPath; 
  UMat m_background;       
  int m_displayTime;       
  QString m_savingPath;    
 
  VideoReader *video;
  int m_im;                   
  QString m_error;            
  int m_startImage;           
  int m_stopImage;            
  Rect m_ROI;                 
  QFile m_logFile;            
  vector<cv::String> m_files; 
  vector<int> m_id;           
  vector<int> m_lost;         
  int m_idMax;
  bool m_isMorph;                       
  QHash<QString, QString> m_parameters; 
 
 public:
  explicit Tracking(QWidget *parent = nullptr) : QObject(parent){};
  Tracking(const string &path, const string &background, int startImage = 0, int stopImage = -1);
  Tracking(const string &path, const UMat &background, int startImage = 0, int stopImage = -1);
  Tracking(const Tracking &) = delete;
  Tracking &operator=(const Tracking &T) = delete;
  Tracking &operator=(Tracking &&T) = delete;
  Tracking(Tracking &&T) = delete;
  ~Tracking();
 
  const QString connectionName;
  Point2d curvatureCenter(const Point3d &tail, const Point3d &head) const;
  double curvature(Point2d center, const Mat &image) const;
  double divide(double a, double b) const;
  bool objectDirection(const UMat &image, vector<double> &information) const;
  vector<double> objectInformation(const UMat &image) const;
  vector<Point3d> reassignment(const vector<Point3d> &past, const vector<Point3d> &input, const vector<int> &assignment) const;
  vector<vector<Point3d>> objectPosition(const UMat &frame, int minSize, int maxSize) const;
  vector<int> costFunc(const vector<vector<Point3d>> &prevPos, const vector<vector<Point3d>> &pos, double LENGHT, double ANGLE, double LO, double AREA, double PERIMETER) const;
  void cleaning(const vector<int> &occluded, vector<int> &lostCounter, vector<int> &id, vector<vector<Point3d>> &input, double param_maximalTime) const;
  vector<Point3d> prevision(vector<Point3d> past, vector<Point3d> present) const;
  vector<int> findOcclusion(vector<int> assignment) const;
  static double modul(double angle);
  static double angleDifference(double alpha, double beta);
  static UMat backgroundExtraction(VideoReader &video, int n, const int method, const int registrationMethod);
  static void registration(UMat imageReference, UMat &frame, int method);
  static void binarisation(UMat &frame, char backgroundColor, int value);
  static bool exportTrackingResult(const QString &path, const QSqlDatabase &db);
  static bool importTrackingResult(const QString &path, QSqlDatabase db);
 
  UMat m_binaryFrame;                
  vector<vector<Point3d>> m_out;     
  vector<vector<Point3d>> m_outPrev; 
 
 public slots:
  virtual void startProcess();
  void updatingParameters(const QHash<QString, QString> &);
  virtual void imageProcessing();
 
 signals:
  void progress(int);

  void backgroundProgress(int);

  void finishedProcessFrame();

  void finished();

  void forceFinished(QString message);

  void statistic(long long int time);
};
 
#endif