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 <QList>
#include <QMap>
#include <QObject>
#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
 
  QElapsedTimer *timer; 
  bool 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;
 
  int param_n;                            
  int param_maxArea;                      
  int param_minArea;                      
  int param_spot;                         
  double param_len;                       
  double param_angle;                     
  double param_area;                      
  double param_perimeter;                 
  double param_lo;                        
  double param_to;                        
  int param_thresh;                       
  double param_nBackground;               
  int param_methodBackground;             
  int param_methodRegistrationBackground; 
  int param_registration;                 
  int param_x1;                           
  int param_y1;                           
  int param_x2;                           
  int param_y2;                           
  int param_kernelSize;                   
  int param_kernelType;                   
  int param_morphOperation;               
  QMap<QString, QString> parameters;      
 public:
  Tracking() = default;
  Tracking(string path, string background, int startImage = 0, int stopImage = -1);
  Tracking(string path, UMat background, int startImage = 0, int stopImage = -1);
  Tracking(const Tracking &) = delete;
  Tracking &operator=(const Tracking &) = delete;
  ~Tracking();
 
  Point2d curvatureCenter(const Point3d &tail, const Point3d &head) const;
  double curvature(Point2d center, const Mat &image) const;
  static double modul(double angle);
  double divide(double a, double b) const;
  static double angleDifference(double alpha, double beta);
  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;
  UMat backgroundExtraction(VideoReader &video, int n, const int method, const int registrationMethod) const;
  void registration(UMat imageReference, UMat &frame, int method) const;
  void binarisation(UMat &frame, char backgroundColor, int value) 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 bool exportTrackingResult(const QString path, QSqlDatabase db);
  static bool importTrackingResult(const QString path, QSqlDatabase db);
 
  UMat m_binaryFrame;                
  UMat m_visuFrame;                  
  vector<vector<Point3d>> m_out;     
  vector<vector<Point3d>> m_outPrev; 
 public slots:
  virtual void startProcess();
  void updatingParameters(const QMap<QString, QString> &);
  virtual void imageProcessing();
 
 signals:
  void progress(int) const;
 
  void backgroundProgress(int) const;
 
  void finishedProcessFrame() const;
 
  void finished() const;
 
  void forceFinished(QString message) const;
 
  void statistic(long long int time) const;
};
 
#endif