472 lines
15 KiB
C++
472 lines
15 KiB
C++
#include "result.h"
|
|
#include "ui_result.h"
|
|
#include <QTableWidgetItem>
|
|
#include <algorithm>
|
|
#include <boost/lexical_cast.hpp>
|
|
#include <iomanip> // setprecision
|
|
#include <iostream>
|
|
#include <math.h>
|
|
#include <qcolor.h>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
using std::cout;
|
|
using std::endl;
|
|
using std::string;
|
|
using std::vector;
|
|
|
|
Result::Result(DataBase * db, QWidget * parent)
|
|
: QWidget(parent), ui(new Ui::Result) {
|
|
ui->setupUi(this);
|
|
this->db = db;
|
|
|
|
// prepare dummy data
|
|
vector<std::string> header;
|
|
// dummy for now
|
|
this->rennid = 39;
|
|
|
|
// test data
|
|
header.push_back("Spalte 1");
|
|
header.push_back("Spalte 2");
|
|
vector<vector<int>> data;
|
|
vector<int> subData;
|
|
subData.push_back(1);
|
|
subData.push_back(2);
|
|
data.push_back(subData);
|
|
data.push_back(subData);
|
|
|
|
this->ui->tWResult->resizeColumnsToContents();
|
|
this->ui->tWResult->horizontalHeader()->setStretchLastSection(true);
|
|
this->ui->tWResult->verticalHeader()->setVisible(true);
|
|
// this->model->setHeaderData(0, Qt::Horizontal, "Test");
|
|
|
|
// connects
|
|
// this->ui->pbClose->clicked()
|
|
|
|
std::stringstream statement;
|
|
statement << "select date from rennen where id like "
|
|
<< boost::lexical_cast<string>(rennid);
|
|
|
|
try {
|
|
QString renndatum = this->db->getData2(statement.str(), 1).at(0).at(0);
|
|
this->setWindowTitle(renndatum);
|
|
} catch (std::exception & e) {
|
|
Q_UNUSED(e);
|
|
cout << "Renndatum konnt aus Datenbank nicht gelesen werden" << endl;
|
|
}
|
|
// clear stringstream
|
|
statement.str(std::string());
|
|
statement << "select minimumroundtime from rennen where id like "
|
|
<< boost::lexical_cast<string>(rennid);
|
|
|
|
try {
|
|
this->minimumTime =
|
|
this->db->getData2(statement.str(), 1).at(0).at(0).toInt();
|
|
|
|
} catch (std::exception & e) {
|
|
Q_UNUSED(e);
|
|
cout << "Minimalzeit pro Runde konnte aus Datenbank nicht gelesen "
|
|
"werden."
|
|
<< endl;
|
|
}
|
|
|
|
vector<string> Fahrernamen;
|
|
for (size_t i = 0; i < this->getFahrerIds(this->rennid).size(); i++) {
|
|
Fahrernamen.push_back(
|
|
this->getFahrerName(this->getFahrerIds(this->rennid).at(i)));
|
|
}
|
|
|
|
vector<int> AutoIds = this->getAutoIds(this->rennid);
|
|
|
|
this->ui->tWResult->setRowCount(static_cast<int>(AutoIds.size()) * 2 + 4);
|
|
this->ui->tWResult->setColumnCount(static_cast<int>(Fahrernamen.size()) +
|
|
4);
|
|
|
|
int row = 0;
|
|
int col = 0;
|
|
this->ui->tWResult->setItem(row, col, new QTableWidgetItem("Auto"));
|
|
row += 0;
|
|
col += 1;
|
|
|
|
this->ui->tWResult->setItem(row, col, new QTableWidgetItem("Bahn"));
|
|
col += 1;
|
|
for (string fahrername : Fahrernamen) {
|
|
this->ui->tWResult->setItem(
|
|
row, col, new QTableWidgetItem(QString::fromStdString(fahrername)));
|
|
col += 1;
|
|
}
|
|
this->ui->tWResult->setItem(row, col,
|
|
new QTableWidgetItem("Durchschnitt Auto"));
|
|
col += 1;
|
|
this->ui->tWResult->setItem(
|
|
row, col, new QTableWidgetItem("Durchschnitt Auto gesamt"));
|
|
this->ui->tWResult->resizeColumnsToContents();
|
|
row = 1;
|
|
col = 1;
|
|
|
|
for (size_t i = 0; i <= AutoIds.size(); i++) {
|
|
this->ui->tWResult->setItem(row, col, new QTableWidgetItem("Shell"));
|
|
row += 1;
|
|
this->ui->tWResult->setItem(row, col, new QTableWidgetItem("Dea"));
|
|
row += 1;
|
|
}
|
|
|
|
vector<string> AutoNamen;
|
|
for (size_t i = 0; i < AutoIds.size(); i++) {
|
|
AutoNamen.push_back(this->getAutoName(AutoIds.at(i)));
|
|
}
|
|
col = 0;
|
|
row = 1;
|
|
|
|
for (string autoname : AutoNamen) {
|
|
this->ui->tWResult->setItem(
|
|
row, col, new QTableWidgetItem(QString::fromStdString(autoname)));
|
|
row += 2;
|
|
}
|
|
this->ui->tWResult->setItem(row, col,
|
|
new QTableWidgetItem("Durchschnitt Person"));
|
|
row += 2;
|
|
this->ui->tWResult->setItem(
|
|
row, col, new QTableWidgetItem("Durchschnitt Person ges"));
|
|
|
|
row = 1;
|
|
col = 2;
|
|
vector<vector<float>> zeiten;
|
|
vector<float> subZeiten;
|
|
|
|
for (int fahrer : this->getFahrerIds(this->rennid)) {
|
|
|
|
for (int car : this->getAutoIds(this->rennid)) {
|
|
int shellmin = this->getMinimum(fahrer, 1, this->rennid, car,
|
|
this->minimumTime);
|
|
int deamin = this->getMinimum(fahrer, 2, this->rennid, car,
|
|
this->minimumTime);
|
|
|
|
subZeiten.push_back(static_cast<float>(shellmin) / 1000);
|
|
subZeiten.push_back(static_cast<float>(deamin) / 1000);
|
|
|
|
this->ui->tWResult->setItem(
|
|
row, col,
|
|
new QTableWidgetItem(QString::fromStdString(
|
|
this->myRound(static_cast<double>(shellmin) / 1000, 3))));
|
|
row += 1;
|
|
this->ui->tWResult->setItem(
|
|
row, col,
|
|
new QTableWidgetItem(QString::fromStdString(
|
|
this->myRound(static_cast<double>(deamin) / 1000, 3))));
|
|
row += 1;
|
|
}
|
|
zeiten.push_back(subZeiten);
|
|
subZeiten.clear();
|
|
|
|
col += 1;
|
|
row = 1;
|
|
}
|
|
|
|
// Durchschnitt Fahrer Shell und Dea
|
|
row = static_cast<int>(AutoNamen.size()) * 2 + 1;
|
|
col = 2;
|
|
for (size_t i = 0; i < Fahrernamen.size(); i++) {
|
|
vector<float> shellListe;
|
|
vector<float> dealiste;
|
|
for (size_t k = 0; k < zeiten.at(i).size(); k++) {
|
|
if (k % 2 == 0) {
|
|
shellListe.push_back(zeiten.at(i).at(k));
|
|
}
|
|
else {
|
|
dealiste.push_back(zeiten.at(i).at(k));
|
|
}
|
|
}
|
|
this->ui->tWResult->setItem(
|
|
row, col,
|
|
new QTableWidgetItem(QString::fromStdString(
|
|
this->myRound(this->meanVal(shellListe), 3))));
|
|
row += 1;
|
|
this->ui->tWResult->setItem(
|
|
row, col,
|
|
new QTableWidgetItem(QString::fromStdString(
|
|
this->myRound(this->meanVal(dealiste), 3))));
|
|
row -= 1;
|
|
col += 1;
|
|
shellListe.clear();
|
|
dealiste.clear();
|
|
}
|
|
|
|
// Durchschnitt Auto Shell und Dea
|
|
col = static_cast<int>(Fahrernamen.size()) + 2;
|
|
row = 1;
|
|
vector<float> durschnittAuto;
|
|
for (size_t i = 0; i < AutoIds.size() * 2; i++) { //*2 weil 2 Bahnen
|
|
|
|
for (size_t k = 0; k < Fahrernamen.size(); k++) {
|
|
durschnittAuto.push_back(zeiten.at(k).at(i));
|
|
}
|
|
this->ui->tWResult->setItem(
|
|
row, col,
|
|
new QTableWidgetItem(QString::fromStdString(
|
|
this->myRound(this->meanVal(durschnittAuto), 3))));
|
|
row += 1;
|
|
durschnittAuto.clear();
|
|
}
|
|
|
|
// Durchschnitt Fahrer ges
|
|
row = static_cast<int>(AutoIds.size()) * 2 + 3;
|
|
col = 2;
|
|
for (size_t i = 0; i < Fahrernamen.size(); i++) {
|
|
this->ui->tWResult->setItem(
|
|
row, col,
|
|
new QTableWidgetItem(QString::fromStdString(
|
|
this->myRound(this->meanVal(zeiten.at(i)), 3))));
|
|
col += 1;
|
|
}
|
|
|
|
// Durchschnitt Auto ges
|
|
col = static_cast<int>(Fahrernamen.size()) + 3;
|
|
row = 1;
|
|
for (size_t i = 0; i < AutoIds.size() * 2; i++) { //*2 weil 2 Bahnen
|
|
if (i % 2 == 0) {
|
|
vector<float> durschnittAuto;
|
|
for (size_t k = 0; k < Fahrernamen.size(); k++) {
|
|
durschnittAuto.push_back(zeiten.at(k).at(i));
|
|
durschnittAuto.push_back(zeiten.at(k).at(i + 1));
|
|
}
|
|
this->ui->tWResult->setItem(
|
|
row, col,
|
|
new QTableWidgetItem(QString::fromStdString(
|
|
this->myRound(this->meanVal(durschnittAuto), 3))));
|
|
row += 2;
|
|
durschnittAuto.clear();
|
|
}
|
|
}
|
|
|
|
// Minimum durchschnitt markieren
|
|
row = static_cast<int>(AutoIds.size()) * 2 + 3;
|
|
col = 2;
|
|
vector<float> avgList;
|
|
for (size_t i = 0; i < Fahrernamen.size(); i++) {
|
|
QString value = this->ui->tWResult->item(row, col)->text();
|
|
avgList.push_back(value.toFloat());
|
|
|
|
col += 1;
|
|
}
|
|
row = static_cast<int>(AutoIds.size()) * 2 + 3;
|
|
col = 2;
|
|
for (size_t i = 0; i < Fahrernamen.size(); i++) {
|
|
|
|
if (this->myMin(avgList) ==
|
|
this->ui->tWResult->item(row, col)->text().toFloat()) {
|
|
this->ui->tWResult->item(row, col)->setBackground(
|
|
QColor(118, 238, 0));
|
|
}
|
|
col += 1;
|
|
}
|
|
|
|
// minimum abs markieren
|
|
// minimum finden
|
|
vector<float> temp;
|
|
for (size_t i = 0; i < zeiten.size(); i++) {
|
|
temp.push_back(this->myMin(zeiten.at(i)));
|
|
}
|
|
float minimum = this->myMin(temp);
|
|
col = 2;
|
|
row = 1;
|
|
for (size_t i = 0; i < Fahrernamen.size(); i++) {
|
|
for (size_t k = 0; k < AutoIds.size() * 2; k++) {
|
|
|
|
// self.tWRennergebnis.item(row + k, col +
|
|
// i).setBackground(QtGui.QColor(255, 215, 0))
|
|
if (this->ui->tWResult->item(row + k, col + i)->text().toFloat() ==
|
|
minimum) {
|
|
this->ui->tWResult
|
|
->item(row + static_cast<int>(k), col + static_cast<int>(i))
|
|
->setBackground(QColor(255, 215, 0));
|
|
}
|
|
}
|
|
}
|
|
this->ui->tWResult->resizeColumnsToContents();
|
|
this->ui->tWResult->horizontalHeader()->setStretchLastSection(true);
|
|
}
|
|
|
|
Result::~Result() {
|
|
cout << "result closed" << endl;
|
|
}
|
|
|
|
template <typename T> T Result::myMin(vector<T> vec) {
|
|
T min;
|
|
if (vec.size() > 0) {
|
|
min = vec.at(0);
|
|
}
|
|
else {
|
|
return 9999;
|
|
}
|
|
for (T minItr : vec) {
|
|
if (min > minItr) {
|
|
min = minItr;
|
|
}
|
|
}
|
|
return min;
|
|
}
|
|
|
|
template <typename T> double Result::meanVal(vector<T> vec) {
|
|
T sum = std::accumulate(vec.begin(), vec.end(), 0.0);
|
|
double mean = static_cast<double>(sum) / vec.size();
|
|
return mean;
|
|
}
|
|
|
|
string Result::myRound(double x, int d = 0) {
|
|
std::stringstream stream;
|
|
stream << std::fixed << std::setprecision(d) << x;
|
|
return stream.str();
|
|
}
|
|
void Result::closeWindow() {
|
|
this->close();
|
|
}
|
|
|
|
vector<int> Result::getFahrerIds(int rennid) {
|
|
std::stringstream statement;
|
|
statement << "select id_fahrer from zeiten where id_rennen like "
|
|
<< boost::lexical_cast<string>(rennid) << " group by id_fahrer";
|
|
|
|
vector<int> vecToRet;
|
|
try {
|
|
vector<vector<QString>> ret = this->db->getData2(statement.str(), 1);
|
|
for (size_t i = 0; i < ret.size(); i++) {
|
|
string strValue = ret.at(i).at(0).toStdString();
|
|
vecToRet.push_back(boost::lexical_cast<int>(strValue));
|
|
}
|
|
return vecToRet;
|
|
} catch (std::exception & e) {
|
|
Q_UNUSED(e);
|
|
cout << "FahrerIds konnten nicht aus Datenbank gelesen "
|
|
"werden."
|
|
<< endl;
|
|
}
|
|
return vecToRet;
|
|
}
|
|
|
|
vector<int> Result::getAutoIds(int rennid) {
|
|
std::stringstream statement;
|
|
statement << "select id_auto from zeiten where id_rennen like "
|
|
<< boost::lexical_cast<string>(rennid) << " group by id_auto";
|
|
vector<vector<QString>> ret = this->db->getData2(statement.str(), 1);
|
|
|
|
vector<int> vecToRet;
|
|
try {
|
|
vector<vector<QString>> ret = this->db->getData2(statement.str(), 1);
|
|
for (size_t i = 0; i < ret.size(); i++) {
|
|
string strValue = ret.at(i).at(0).toStdString();
|
|
vecToRet.push_back(boost::lexical_cast<int>(strValue));
|
|
}
|
|
return vecToRet;
|
|
} catch (std::exception & e) {
|
|
Q_UNUSED(e);
|
|
cout << "AutoIds konnten nicht aus Datenbank gelesen werden." << endl;
|
|
}
|
|
return vecToRet;
|
|
}
|
|
|
|
int Result::getMinimum(int fahrerId, int bahnId, int rennId, int autoid,
|
|
int minTime) {
|
|
std::stringstream statement;
|
|
statement << "select zeit from Zeiten where id_rennen like "
|
|
<< boost::lexical_cast<string>(rennId) << " and id_fahrer like "
|
|
<< boost::lexical_cast<string>(fahrerId) << " and id_auto like "
|
|
<< boost::lexical_cast<string>(autoid) << " and id_bahn like "
|
|
<< boost::lexical_cast<string>(bahnId);
|
|
|
|
try {
|
|
vector<vector<QString>> res = this->db->getData2(statement.str(), 1);
|
|
// filter impossible values
|
|
vector<int> validTimes;
|
|
for (size_t i = 0; i < res.size(); i++) {
|
|
int timeToCompare = res.at(i).at(0).toInt();
|
|
if (timeToCompare >= minTime) {
|
|
validTimes.push_back(timeToCompare);
|
|
}
|
|
}
|
|
if (validTimes.size() > 0) {
|
|
std::vector<int>::iterator result =
|
|
std::min_element(validTimes.begin(), validTimes.end());
|
|
return *result;
|
|
}
|
|
else {
|
|
return 9999;
|
|
}
|
|
|
|
} catch (std::exception & e) {
|
|
Q_UNUSED(e);
|
|
cout << "Minimalzeit konnte aus Datenbank nicht gelesen "
|
|
"werden."
|
|
<< endl;
|
|
}
|
|
return 9999;
|
|
}
|
|
|
|
float Result::getMean(int fahrerid, int bahnid, int rennid) {
|
|
vector<int> autoids = this->getAutoIds(rennid);
|
|
vector<int> avg;
|
|
|
|
for (int car : autoids) {
|
|
avg.push_back(
|
|
this->getMinimum(fahrerid, bahnid, rennid, car, this->minimumTime));
|
|
}
|
|
int sum = std::accumulate(avg.begin(), avg.end(), 0);
|
|
float floatAvg = 9999;
|
|
if (avg.size() > 0) {
|
|
floatAvg = static_cast<float>(sum) / static_cast<int>(avg.size());
|
|
cout << "avg:" << floatAvg << endl;
|
|
return floatAvg;
|
|
}
|
|
return 9999;
|
|
}
|
|
string Result::getFahrerName(int id) {
|
|
std::stringstream statement;
|
|
statement << "select name from fahrer where id like "
|
|
<< boost::lexical_cast<string>(id);
|
|
vector<vector<QString>> result = this->db->getData2(statement.str(), 1);
|
|
if (result.size() > 0) {
|
|
try {
|
|
return result.at(0).at(0).toStdString();
|
|
|
|
} catch (std::exception & e) {
|
|
Q_UNUSED(e);
|
|
cout << "Fehler beim Lesen vom Fahrernamen." << endl;
|
|
return "Leer";
|
|
}
|
|
}
|
|
return "Leer";
|
|
}
|
|
|
|
string Result::getAutoName(int id) {
|
|
std::stringstream statement;
|
|
statement << "select date from Rennen where id like "
|
|
<< boost::lexical_cast<string>(this->rennid);
|
|
string renndatum;
|
|
try {
|
|
QString qstrRenndatum =
|
|
this->db->getData2(statement.str(), 1).at(0).at(0);
|
|
renndatum = qstrRenndatum.toStdString();
|
|
|
|
} catch (std::exception & e) {
|
|
Q_UNUSED(e);
|
|
cout << "Renndatum konnte nicht gelesen werden." << endl;
|
|
return "nix";
|
|
}
|
|
|
|
try {
|
|
// clear stringstream
|
|
statement.str(std::string());
|
|
statement << "select name from Autokonfiguration where "
|
|
"id_auto like "
|
|
<< boost::lexical_cast<string>(id) << " and seit < '"
|
|
<< renndatum << "' order by seit DESC limit 1";
|
|
|
|
QString name = this->db->getData2(statement.str(), 1).at(0).at(0);
|
|
return name.toStdString();
|
|
} catch (std::exception & e) {
|
|
Q_UNUSED(e);
|
|
}
|
|
|
|
return "name";
|
|
}
|