text: #ifndef MAINWINDOW_H
  #define MAINWINDOW_H
  
  #include <QMainWindow>
  #include <vector>
  
  #include "common/FileHandler.h"
  #include "common/TimeHandler.h"
  
  #include "widget/WidgetCapture.h"
  #include "widget/CaptureReport.h"
  
  #include "module/QT/Map/MapJSHandler.h"
  
  namespace evaluation
  {
  
  struct gpsTime
  {
  	gpsTime()
  	{
  		this->week = 0;
  		this->second = 0;
  	}
  	gpsTime(int week, double second)
  	{
  		this->week = week;
  		this->second = second;
  	}
  
  	void operator += (int second)
  	{
  		this->second += second;
  		while(this->second > SECS_PER_WEEK)
  		{
  			this->second -= SECS_PER_WEEK;
  			this->week++;
  		}
  	}
  
  	bool operator <(gpsTime &other)
  	{
  		if(this->week < other.week)
  		{
  			return true;
  		}
  		else if(this->week == other.week)
  		{
  			if(this->second <= other.second)
  			{
  				return true;
  			}
  			else
  			{
  				return false;
  			}
  		}
  		else
  		{
  			return false;
  		}
  	}
  	int week;
  	double second;
  };
  struct camera
  {
  	std::string path;
  	int imageCount;
  	double timeStart;
  	double timeEnd;
  	std::vector<int> error;
  };
  
  struct lidarData
  {
  	std::string info;
  	gpsTime timeStart;
  	gpsTime timeEnd;
  	bool error;
  	double secondStart;
  	double secondEnd;
  };
  struct lidar
  {
  	std::string path;
  	std::string dataPath;
  	std::vector<lidarData> dataList;
  	std::string telePath;
  
  	gpsTime timeStart;
  	gpsTime timeEnd;
  
  	int minDiff;
  	int maxDiff;
  	double avgDiff;
  	std::vector<double> error;
  };
  
  struct ins
  {
  	std::string name;
  	int markCount;
  
  	gpsTime timeStart;
  	gpsTime timeEnd;
  
  	double distanceOffset;
  
  	int minSVs;
  	int maxSVs;
  	double avgSVs;
  
  	double minAccuracy;
  	double maxAccuracy;
  	double avgAccuracy;
  
  	double minDiff;
  	double maxDiff;
  	double avgDiff;
  	std::vector<double> error;
  };
  
  struct CaptureHW
  {
  	std::string name;
  	std::vector<evaluation::camera> camList;
  	std::vector<evaluation::lidar> lidarList;
  
  	std::string thumb;
  	int thumbCount;
  };
  
  struct Round
  {
  	std::string path;
  	evaluation::ins ins;
  	std::vector<evaluation::CaptureHW> captureList;
  };
  }
  
  namespace Ui {
  class MainWindow;
  }
  
  class MainWindow : public QMainWindow
  {
  	Q_OBJECT
  
  public:
  	explicit MainWindow(QWidget *parent = 0);
  	~MainWindow();
  
  private:
  	void checkINS(QString folderPath);
  	void checkMeta(QString folderPath);
  	void checkCamera();
  	void checkLidar();
  	void checkCapture(evaluation::CaptureHW *capture);
  	void showReport();
  
  private slots:
  	void on_pb_select_round_clicked();
  
  	void on_pb_apply_round_clicked();
  
  	void on_checkBox_clicked(bool checked);
  
  	void on_pb_check_ins_clicked();
  
  	void on_pb_check_metadata_clicked();
  
  	void on_pb_evaluation_clicked();
  
  	void on_pb_clear_capture_clicked();
  
  
  private slots:
  	void recvLoading(bool on, QString info);
  	void recvReporting();
  	void addJSObject();
  
  	void on_pb_result_copy_clicked();
  
  	void on_pb_lidar_play_clicked(bool checked);
  
  	void on_hor_slider_lidar_sliderReleased();
  
  	void on_hor_slider_lidar_sliderPressed();
  
  signals:
  	void sendChecked(bool);
  	void sendLoading(bool on, QString info);
  	void sendReporting();
  private:
  	Ui::MainWindow *ui;
  	QMovie *_loaderImg;
  
  	std::string _roundPath;
  	std::vector<WidgetCapture *> _captureWidgets;
  	std::vector<CaptureReport *> _captureReports;
  
  	std::vector<std::string> _capturePathList;
  	QString _insPath;
  	QString _metaPath;
  	evaluation::Round _round;
  	MapJSHandler _naverMapHandler;
  };
  
  #endif // MAINWINDOW_H
  