mirror of
https://github.com/GoldenCheetah/GoldenCheetah.git
synced 2026-02-14 08:38:45 +00:00
809 lines
26 KiB
C++
809 lines
26 KiB
C++
/*
|
|
* Copyright (c) 2006 Sean C. Rhea (srhea@srhea.net)
|
|
*
|
|
* This program 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.
|
|
*
|
|
* This program 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 this program; if not, write to the Free Software Foundation, Inc., 51
|
|
* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include "Zones.h"
|
|
#include "CpintPlot.h"
|
|
#include <assert.h>
|
|
#include <unistd.h>
|
|
#include <QDebug>
|
|
#include <qwt_data.h>
|
|
#include <qwt_legend.h>
|
|
#include <qwt_plot_curve.h>
|
|
#include <qwt_plot_grid.h>
|
|
#include "RideItem.h"
|
|
#include "LogTimeScaleDraw.h"
|
|
#include "LogTimeScaleEngine.h"
|
|
#include "RideFile.h"
|
|
#include "Season.h"
|
|
|
|
CpintPlot::CpintPlot(QString p) :
|
|
progress(NULL),
|
|
needToScanRides(true),
|
|
path(p),
|
|
thisCurve(NULL),
|
|
CPCurve(NULL),
|
|
grid(NULL),
|
|
zones(NULL)
|
|
{
|
|
insertLegend(new QwtLegend(), QwtPlot::BottomLegend);
|
|
setCanvasBackground(Qt::white);
|
|
setAxisTitle(yLeft, "Average Power (watts)");
|
|
setAxisTitle(xBottom, "Interval Length");
|
|
setAxisScaleDraw(xBottom, new LogTimeScaleDraw);
|
|
setAxisScaleEngine(xBottom, new LogTimeScaleEngine);
|
|
setAxisScale(xBottom, 1.0 / 60.0, 60);
|
|
|
|
grid = new QwtPlotGrid();
|
|
grid->enableX(false);
|
|
QPen gridPen;
|
|
gridPen.setStyle(Qt::DotLine);
|
|
grid->setPen(gridPen);
|
|
grid->attach(this);
|
|
|
|
allCurves= QList <QwtPlotCurve *>::QList();
|
|
allZoneLabels= QList <QwtPlotMarker *>::QList();
|
|
}
|
|
|
|
struct cpi_file_info {
|
|
QString file, inname, outname;
|
|
};
|
|
|
|
QString
|
|
ride_filename_to_cpi_filename(const QString filename)
|
|
{
|
|
return (QFileInfo(filename).completeBaseName() + ".cpi");
|
|
}
|
|
|
|
static void
|
|
cpi_files_to_update(const QDir &dir, QList<cpi_file_info> &result)
|
|
{
|
|
QStringList filenames = RideFileFactory::instance().listRideFiles(dir);
|
|
QListIterator<QString> i(filenames);
|
|
while (i.hasNext()) {
|
|
const QString &filename = i.next();
|
|
if (RideFileFactory::instance().rideFileRegExp().exactMatch(filename)) {
|
|
QString inname = dir.absoluteFilePath(filename);
|
|
QString outname =
|
|
dir.absoluteFilePath(ride_filename_to_cpi_filename(filename));
|
|
QFileInfo ifi(inname), ofi(outname);
|
|
if (!ofi.exists() || (ofi.lastModified() < ifi.lastModified())) {
|
|
cpi_file_info info;
|
|
info.file = filename;
|
|
info.inname = inname;
|
|
info.outname = outname;
|
|
result.append(info);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
struct cpint_point
|
|
{
|
|
double secs;
|
|
int watts;
|
|
cpint_point(double s, int w) : secs(s), watts(w) {}
|
|
};
|
|
|
|
struct cpint_data {
|
|
QStringList errors;
|
|
QList<cpint_point> points;
|
|
int rec_int_ms;
|
|
cpint_data() : rec_int_ms(0) {}
|
|
};
|
|
|
|
static void
|
|
update_cpi_file(const cpi_file_info *info, QProgressDialog *progress,
|
|
double &progress_sum, double progress_max)
|
|
{
|
|
QFile file(info->inname);
|
|
QStringList errors;
|
|
RideFile *rideFile =
|
|
RideFileFactory::instance().openRideFile(file, errors);
|
|
if (! rideFile)
|
|
return;
|
|
cpint_data data;
|
|
data.rec_int_ms = (int) round(rideFile->recIntSecs() * 1000.0);
|
|
foreach (const RideFilePoint *p, rideFile->dataPoints()) {
|
|
double secs = round(p->secs * 1000.0) / 1000;
|
|
if (secs > 0)
|
|
data.points.append(cpint_point(secs, (int) round(p->watts)));
|
|
}
|
|
delete rideFile;
|
|
|
|
FILE *out = fopen(info->outname.toAscii().constData(), "w");
|
|
assert(out);
|
|
|
|
int total_secs = (int) ceil(data.points.back().secs);
|
|
|
|
// don't allow data more than one week
|
|
#define SECONDS_PER_WEEK 7 * 24 * 60 * 60
|
|
if (total_secs > SECONDS_PER_WEEK) {
|
|
fclose(out);
|
|
return;
|
|
}
|
|
|
|
|
|
QVector <double> ride_bests(total_secs + 1); // was calloc'ed array (unfreed?), changed djconnel
|
|
|
|
// initialize ride_bests
|
|
for (int i = 0; i < ride_bests.size(); i ++)
|
|
ride_bests[i] = 0.0;
|
|
|
|
bool canceled = false;
|
|
int progress_count = 0;
|
|
for (int i = 0; i < data.points.size() - 1; ++i) {
|
|
cpint_point *p = &data.points[i];
|
|
double sum = 0.0;
|
|
double prev_secs = p->secs;
|
|
for (int j = i + 1; j < data.points.size(); ++j) {
|
|
cpint_point *q = &data.points[j];
|
|
if (++progress_count % 1000 == 0) {
|
|
double x = (progress_count + progress_sum)
|
|
/ progress_max * 1000.0;
|
|
// Use min() just in case math is wrong...
|
|
int n = qMin((int) round(x), 1000);
|
|
progress->setValue(n);
|
|
QCoreApplication::processEvents();
|
|
if (progress->wasCanceled()) {
|
|
canceled = true;
|
|
goto done;
|
|
}
|
|
}
|
|
sum += data.rec_int_ms / 1000.0 * q->watts;
|
|
double dur_secs = q->secs - p->secs;
|
|
double avg = sum / dur_secs;
|
|
int dur_secs_top = (int) floor(dur_secs);
|
|
int dur_secs_bot =
|
|
qMax((int) floor(dur_secs - data.rec_int_ms / 1000.0), 0);
|
|
for (int k = dur_secs_top; k > dur_secs_bot; --k) {
|
|
if (ride_bests[k] < avg)
|
|
ride_bests[k] = avg;
|
|
}
|
|
prev_secs = q->secs;
|
|
}
|
|
}
|
|
|
|
// avoid decreasing work with increasing duration
|
|
{
|
|
double maxwork = 0.0;
|
|
for (int i = 1; i <= total_secs; ++i) {
|
|
// note index is being used here in lieu of time, as the index
|
|
// is assumed to be proportional to time
|
|
double work = ride_bests[i] * i;
|
|
if (maxwork > work)
|
|
ride_bests[i] = round(maxwork / i);
|
|
else
|
|
maxwork = work;
|
|
if (ride_bests[i] != 0)
|
|
fprintf(out, "%6.3f %3.0f\n", i / 60.0, round(ride_bests[i]));
|
|
}
|
|
}
|
|
|
|
done:
|
|
fclose(out);
|
|
if (canceled)
|
|
unlink(info->outname.toAscii().constData());
|
|
progress_sum += progress_count;
|
|
}
|
|
|
|
QDate
|
|
cpi_filename_to_date(const QString filename) {
|
|
QRegExp rx(".*([0-9][0-9][0-9][0-9])_([0-9][0-9])_([0-9][0-9])"
|
|
"_([0-9][0-9])_([0-9][0-9])_([0-9][0-9])\\.cpi$");
|
|
if (rx.exactMatch(filename)) {
|
|
assert(rx.numCaptures() == 6);
|
|
QDate date = QDate(rx.cap(1).toInt(),
|
|
rx.cap(2).toInt(),
|
|
rx.cap(3).toInt());
|
|
if (!date.isValid())
|
|
return QDate();
|
|
else
|
|
return date;
|
|
}
|
|
else
|
|
return QDate(); // return value was 1 Jan: changed to null
|
|
}
|
|
|
|
static int
|
|
read_one(const char *inname, QVector<double> &bests, QVector<QDate> &bestDates, QHash <QString, bool> *cpiDataInBests)
|
|
{
|
|
FILE *in = fopen(inname, "r");
|
|
if (!in)
|
|
return -1;
|
|
int lineno = 1;
|
|
char line[40];
|
|
|
|
while (fgets(line, sizeof(line), in) != NULL) {
|
|
double mins;
|
|
int watts;
|
|
if (sscanf(line, "%lf %d\n", &mins, &watts) != 2) {
|
|
fprintf(stderr, "Bad match on line %d: %s", lineno, line);
|
|
exit(1);
|
|
}
|
|
int secs = (int) round(mins * 60.0);
|
|
if (secs >= bests.size()) {
|
|
bests.resize(secs + 1);
|
|
bestDates.resize(secs + 1);
|
|
}
|
|
if (bests[secs] < watts){
|
|
bests[secs] = watts;
|
|
bestDates[secs] = cpi_filename_to_date(QString(inname));
|
|
|
|
// mark the filename as having contributed to the bests
|
|
// Note this contribution may subsequently be over-written, so
|
|
// for example the first file scanned will always be tagged.
|
|
if (cpiDataInBests)
|
|
(*cpiDataInBests)[inname] = true;
|
|
}
|
|
++lineno;
|
|
}
|
|
fclose(in);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
read_cpi_file(const QDir &dir, const QFileInfo &raw, QVector<double> &bests, QVector<QDate> &bestDates, QHash <QString, bool> *cpiDataInBests)
|
|
{
|
|
QString inname = dir.absoluteFilePath(raw.completeBaseName() + ".cpi");
|
|
return read_one(inname.toAscii().constData(), bests, bestDates, cpiDataInBests);
|
|
}
|
|
|
|
// extract critical power parameters which match the given curve
|
|
// model: maximal power = cp (1 + tau / [t + t0]), where t is the
|
|
// duration of the effort, and t, cp and tau are model parameters
|
|
// the basic critical power model is t0 = 0, but non-zero has
|
|
// been discussed in the literature
|
|
// it is assumed duration = index * seconds
|
|
void
|
|
CpintPlot::deriveCPParameters()
|
|
{
|
|
// bounds on anaerobic interval in minutes
|
|
const double t1 = USE_T0_IN_CP_MODEL ? 0.25 : 1;
|
|
const double t2 = 6;
|
|
|
|
// bounds on aerobic interval in minutes
|
|
const double t3 = 10;
|
|
const double t4 = 60;
|
|
|
|
// bounds of these time valus in the data
|
|
int i1, i2, i3, i4;
|
|
|
|
// find the indexes associated with the bounds
|
|
// the first point must be at least the minimum for the anaerobic interval, or quit
|
|
for (i1 = 0; i1 < 60 * t1; i1++)
|
|
if (i1 + 1 >= bests.size())
|
|
return;
|
|
// the second point is the maximum point suitable for anaerobicly dominated efforts.
|
|
for (i2 = i1; i2 + 1 <= 60 * t2; i2++)
|
|
if (i2 + 1 >= bests.size())
|
|
return;
|
|
// the third point is the beginning of the minimum duration for aerobic efforts
|
|
for (i3 = i2; i3 < 60 * t3; i3++)
|
|
if (i3 + 1 >= bests.size())
|
|
return;
|
|
for (i4 = i3; i4 + 1 <= 60 * t4; i4++)
|
|
if (i4 + 1 >= bests.size())
|
|
break;
|
|
|
|
// initial estimate of tau
|
|
if (tau == 0)
|
|
tau = 1;
|
|
|
|
// initial estimate of cp (if not already available)
|
|
if (cp == 0)
|
|
cp = 300;
|
|
|
|
// initial estimate of t0: start small to maximize sensitivity to data
|
|
t0 = 0;
|
|
|
|
// lower bound on tau
|
|
const double tau_min = 0.5;
|
|
|
|
// convergence delta for tau
|
|
const double tau_delta_max = 1e-4;
|
|
const double t0_delta_max = 1e-4;
|
|
|
|
// previous loop value of tau and t0
|
|
double tau_prev;
|
|
double t0_prev;
|
|
|
|
// maximum number of loops
|
|
const int max_loops = 100;
|
|
|
|
// loop to convergence
|
|
int iteration = 0;
|
|
do {
|
|
if (iteration ++ > max_loops) {
|
|
fprintf(stderr, "maximum number of loops %d exceeded in cp model extraction\n", max_loops);
|
|
break;
|
|
}
|
|
|
|
// record the previous version of tau, for convergence
|
|
tau_prev = tau;
|
|
t0_prev = t0;
|
|
|
|
// estimate cp, given tau
|
|
int i;
|
|
cp = 0;
|
|
for (i = i3; i <= i4; i++) {
|
|
double cpn = bests[i] / (1 + tau / (t0 + i / 60.0));
|
|
if (cp < cpn)
|
|
cp = cpn;
|
|
}
|
|
|
|
// if cp = 0; no valid data; give up
|
|
if (cp == 0.0)
|
|
return;
|
|
|
|
// estimate tau, given cp
|
|
tau = tau_min;
|
|
for (i = i1; i <= i2; i++) {
|
|
double taun = (bests[i] / cp - 1) * (i / 60.0 + t0) - t0;
|
|
if (tau < taun)
|
|
tau = taun;
|
|
}
|
|
|
|
// update t0 if we're using that model
|
|
#if USE_T0_IN_CP_MODEL
|
|
t0 = tau / (bests[1] / cp - 1) - 1 / 60.0;
|
|
#endif
|
|
|
|
} while ((fabs(tau - tau_prev) > tau_delta_max) ||
|
|
(fabs(t0 - t0_prev) > t0_delta_max)
|
|
);
|
|
}
|
|
|
|
void
|
|
CpintPlot::plot_CP_curve(CpintPlot *thisPlot, // the plot we're currently displaying
|
|
double cp,
|
|
double tau,
|
|
double t0)
|
|
{
|
|
// detach the CP curve if it exists
|
|
if (CPCurve)
|
|
CPCurve->detach();
|
|
|
|
// if there's no cp, then there's nothing to do
|
|
if (cp <= 0)
|
|
return;
|
|
|
|
// populate curve data with a CP curve
|
|
const int curve_points = 100;
|
|
double tmin = USE_T0_IN_CP_MODEL ? 1.0/60 : tau;
|
|
double tmax = 180.0;
|
|
QVector<double> cp_curve_power(curve_points);
|
|
QVector<double> cp_curve_time(curve_points);
|
|
int i;
|
|
|
|
for (i = 0; i < curve_points; i ++) {
|
|
double x = (double) i / (curve_points - 1);
|
|
double t = pow(tmax, x) * pow(tmin, 1-x);
|
|
cp_curve_time[i] = t;
|
|
cp_curve_power[i] = cp * (1 + tau / (t + t0));
|
|
}
|
|
|
|
// generate a plot
|
|
QString curve_title;
|
|
#if USE_T0_IN_CP_MODEL
|
|
curve_title.sprintf("CP=%.1f W; AWC/CP=%.2f m; t0=%.1f s", cp, tau, 60 * t0);
|
|
#else
|
|
curve_title.sprintf("CP=%.1f W; AWC/CP=%.2f m", cp, tau);
|
|
#endif
|
|
|
|
CPCurve = new QwtPlotCurve(curve_title);
|
|
CPCurve->setRenderHint(QwtPlotItem::RenderAntialiased);
|
|
QPen *pen = new QPen(Qt::red);
|
|
pen->setWidth(2.0);
|
|
pen->setStyle(Qt::DashLine);
|
|
CPCurve->setPen(*pen);
|
|
CPCurve->setData(cp_curve_time.data(), cp_curve_power.data(), curve_points);
|
|
CPCurve->attach(thisPlot);
|
|
delete pen;
|
|
}
|
|
|
|
void
|
|
CpintPlot::clear_CP_Curves()
|
|
{
|
|
// unattach any existing shading curves and reset the list
|
|
if (allCurves.size()) {
|
|
QListIterator<QwtPlotCurve *> i(allCurves);
|
|
while (i.hasNext()) {
|
|
QwtPlotCurve *curve = i.next();
|
|
if (curve) {
|
|
curve->detach();
|
|
delete curve;
|
|
}
|
|
}
|
|
allCurves.clear();
|
|
}
|
|
|
|
// now delete any labels
|
|
if (allZoneLabels.size()) {
|
|
QListIterator<QwtPlotMarker *> i(allZoneLabels);
|
|
while (i.hasNext()) {
|
|
QwtPlotMarker *label = i.next();
|
|
if (label) {
|
|
label->detach();
|
|
delete label;
|
|
}
|
|
}
|
|
allZoneLabels.clear();
|
|
}
|
|
}
|
|
|
|
void
|
|
CpintPlot::plot_allCurve(CpintPlot *thisPlot,
|
|
int n_values,
|
|
const double *power_values)
|
|
{
|
|
clear_CP_Curves();
|
|
|
|
QVector<double> time_values(n_values);
|
|
// generate an array of time values
|
|
for (int t = 1; t <= n_values; t++)
|
|
time_values[t - 1] = t / 60.0;
|
|
|
|
// generate zones from derived CP value
|
|
if (cp > 0) {
|
|
QList <int> power_zone;
|
|
int n_zones = (*zones)->lowsFromCP(&power_zone, (int) int(cp));
|
|
|
|
QList <int> n_zone;
|
|
|
|
// the lowest zone goes to zero power, so mark its start at the last data point
|
|
n_zone.append(n_values - 1);
|
|
|
|
// start the search at the next-to-lowest zone
|
|
int z = 1;
|
|
|
|
// search the maximal power curve to extract the zone times
|
|
for (int i = n_values; i-- > 0;) {
|
|
// if we reach the beginning of the curve OR if we hit a zone boundary, we're done with the present zone
|
|
if ((i == 0) || (power_values[i] > power_zone[z])) {
|
|
n_zone.append(
|
|
(z == n_zones) ?
|
|
0 :
|
|
(
|
|
(
|
|
(i == n_values - 1) ||
|
|
(abs(power_values[i] - power_zone[z]) < abs(power_zone[z] - power_values[i + 1]))
|
|
) ?
|
|
i :
|
|
i + 1
|
|
)
|
|
);
|
|
|
|
// draw curves for the zone we're leaving, if it spans any segments
|
|
if (n_zone[z - 1] > n_zone[z]) {
|
|
// define the individual code segments. Note in the old code with a single segment, it was
|
|
// part of the class. This curve is not a protected member of the class. djconnel Apr2009
|
|
QwtPlotCurve *curve;
|
|
curve =
|
|
new QwtPlotCurve((*zones)->getDefaultZoneName(z - 1));
|
|
curve->setRenderHint(QwtPlotItem::RenderAntialiased);
|
|
QPen *pen = new QPen(zoneColor(z - 1, n_zones));
|
|
pen->setWidth(2.0);
|
|
curve->setPen(*pen);
|
|
curve->attach(thisPlot);
|
|
QColor brush_color = zoneColor(z - 1, n_zones);
|
|
brush_color.setAlpha(64);
|
|
curve->setBrush(brush_color); // brush fills below the line
|
|
curve->setData(time_values.data() + n_zone[z],
|
|
power_values + n_zone[z],
|
|
n_zone[z - 1] - n_zone[z] + 1);
|
|
delete pen;
|
|
|
|
// add the curve to the list
|
|
allCurves.append(curve);
|
|
|
|
// render a colored label on the zone
|
|
QwtText text((*zones)->getDefaultZoneName(z - 1));
|
|
text.setFont(QFont("Helvetica",24, QFont::Bold));
|
|
QColor text_color = zoneColor(z - 1, n_zones);
|
|
text_color.setAlpha(128);
|
|
text.setColor(text_color);
|
|
QwtPlotMarker *label_mark;
|
|
label_mark = new QwtPlotMarker();
|
|
|
|
// place the text in the geometric mean in time, at a decent power
|
|
label_mark->setValue(sqrt(time_values[n_zone[z-1]] * time_values[n_zone[z]]),
|
|
(power_values[n_zone[z-1]] + power_values[n_zone[z]]) / 5);
|
|
label_mark->setLabel(text);
|
|
label_mark->attach(thisPlot);
|
|
allZoneLabels.append(label_mark);
|
|
}
|
|
|
|
if (z < n_zones)
|
|
fprintf(stderr, "zone %s: %d watts, index = %d\n",
|
|
(*zones)->getDefaultZoneName(z).toAscii().constData(),
|
|
power_zone[z],
|
|
n_zone[z]);
|
|
|
|
// if we're to the smallest time, we're done
|
|
if (i == 0)
|
|
break;
|
|
|
|
// increment zone number
|
|
if (z < n_zones)
|
|
z ++;
|
|
|
|
// if we're to the final zone, just jump to the beginning of the plot: we're done
|
|
if (z == n_zones)
|
|
i = 1;
|
|
|
|
// else, we've got to recheck this point for the next zone
|
|
else
|
|
i ++;
|
|
}
|
|
}
|
|
}
|
|
// no zones available: just plot the curve without zones
|
|
else {
|
|
QwtPlotCurve *curve;
|
|
curve = new QwtPlotCurve("maximal power");
|
|
curve->setRenderHint(QwtPlotItem::RenderAntialiased);
|
|
QPen *pen = new QPen(Qt::red);
|
|
pen->setWidth(2.0);
|
|
curve->setPen(*pen);
|
|
QColor brush_color = Qt::red;
|
|
brush_color.setAlpha(64);
|
|
curve->setBrush(brush_color); // brush fills below the line
|
|
curve->setData(time_values.data(),
|
|
power_values,
|
|
n_values);
|
|
curve->attach(thisPlot);
|
|
delete pen;
|
|
allCurves.append(curve);
|
|
}
|
|
|
|
// set the x-axis to span the time of the all-time curve, starting at 1 second
|
|
thisPlot->setAxisScale(thisPlot->xBottom,
|
|
1.0 / 60,
|
|
time_values[n_values - 1]);
|
|
|
|
// set the y-axis to go from zero to the maximum power, rounded up to nearest 100 watts
|
|
thisPlot->setAxisScale(thisPlot->yLeft,
|
|
0,
|
|
100 * ceil( power_values[0] / 100 ));
|
|
|
|
}
|
|
|
|
void
|
|
CpintPlot::calculate(RideItem *rideItem)
|
|
{
|
|
QString fileName = rideItem->fileName;
|
|
QDateTime dateTime = rideItem->dateTime;
|
|
QDir dir(path);
|
|
QFileInfo file(fileName);
|
|
zones = rideItem->zones;
|
|
|
|
if (needToScanRides) {
|
|
bests.clear();
|
|
bestDates.clear();
|
|
cpiDataInBests.clear();
|
|
if (CPCurve) {
|
|
CPCurve->detach();
|
|
CPCurve = NULL;
|
|
}
|
|
|
|
fflush(stderr);
|
|
bool aborted = false;
|
|
QList<cpi_file_info> to_update;
|
|
cpi_files_to_update(dir, to_update);
|
|
double progress_max = 0.0;
|
|
if (!to_update.empty()) {
|
|
QListIterator<cpi_file_info> i(to_update);
|
|
while (i.hasNext()) {
|
|
const cpi_file_info &info = i.next();
|
|
QFile file(info.inname);
|
|
QStringList errors;
|
|
RideFile *rideFile =
|
|
RideFileFactory::instance().openRideFile(file, errors);
|
|
if (rideFile) {
|
|
double x = rideFile->dataPoints().size();
|
|
progress_max += x * (x + 1.0) / 2.0;
|
|
delete rideFile;
|
|
}
|
|
}
|
|
}
|
|
progress = new QProgressDialog(
|
|
QString(tr("Computing critical power intervals.\n"
|
|
"This may take a while.\n")),
|
|
tr("Abort"), 0, 1000, this);
|
|
double progress_sum = 0.0;
|
|
int endingOffset = progress->labelText().size();
|
|
if (!to_update.empty()) {
|
|
QListIterator<cpi_file_info> i(to_update);
|
|
int count = 1;
|
|
while (i.hasNext()) {
|
|
const cpi_file_info &info = i.next();
|
|
QString existing = progress->labelText();
|
|
existing.chop(progress->labelText().size() - endingOffset);
|
|
progress->setLabelText(
|
|
existing + QString(tr("Processing %1...")).arg(info.file));
|
|
progress->setValue(count++);
|
|
update_cpi_file(&info, progress, progress_sum, progress_max);
|
|
QCoreApplication::processEvents();
|
|
if (progress->wasCanceled()) {
|
|
aborted = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!aborted) {
|
|
QString existing = progress->labelText();
|
|
existing.chop(progress->labelText().size() - endingOffset);
|
|
QStringList filters;
|
|
filters << "*.cpi";
|
|
QStringList list = dir.entryList(filters, QDir::Files, QDir::Name);
|
|
list = filterForSeason(list, startDate, endDate);
|
|
progress->setLabelText(
|
|
existing + tr("Aggregating over all files."));
|
|
progress->setRange(0, list.size());
|
|
progress->setValue(0);
|
|
progress->show();
|
|
QListIterator<QString> i(list);
|
|
while (i.hasNext()) {
|
|
const QString &filename = i.next();
|
|
QString path = dir.absoluteFilePath(filename);
|
|
read_one(path.toAscii().constData(), bests, bestDates, &cpiDataInBests);
|
|
progress->setValue(progress->value() + 1);
|
|
QCoreApplication::processEvents();
|
|
if (progress->wasCanceled()) {
|
|
aborted = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!aborted && bests.size()) {
|
|
int maxNonZero = 0;
|
|
|
|
// check that total work doesn't decrease with time
|
|
double maxwork = 0.0;
|
|
|
|
for (int i = 0; i < bests.size(); ++i) {
|
|
// record the date associated with each point's CPI file,
|
|
if (bests[i] > 0)
|
|
maxNonZero = i;
|
|
|
|
// note index is being used here in lieu of time, as the index
|
|
// is assumed to be proportional to time
|
|
double work = bests[i] * i;
|
|
if ((i > 0) && (maxwork > work)) {
|
|
bests[i] = round(maxwork / i);
|
|
bestDates[i] = bestDates[i - 1];
|
|
}
|
|
else
|
|
maxwork = work;
|
|
}
|
|
|
|
// derive CP model
|
|
if (bests.size() > 1) {
|
|
// cp model parameters
|
|
cp = 0;
|
|
tau = 0;
|
|
t0 = 0;
|
|
|
|
// calculate CP model from all-time best data
|
|
deriveCPParameters();
|
|
plot_CP_curve(this, cp, tau, t0);
|
|
|
|
plot_allCurve(this, maxNonZero - 1, bests.constData() + 1);
|
|
}
|
|
needToScanRides = false;
|
|
}
|
|
delete progress;
|
|
progress = NULL;
|
|
}
|
|
|
|
if (!needToScanRides) {
|
|
if (thisCurve)
|
|
delete thisCurve;
|
|
thisCurve = NULL;
|
|
QVector<double> bests;
|
|
QVector<QDate> bestDates;
|
|
if ((read_cpi_file(dir, file, bests, bestDates, NULL) == 0) && bests.size()) {
|
|
QVector<double> timeArray(bests.size());
|
|
int maxNonZero = 0;
|
|
for (int i = 0; i < bests.size(); ++i) {
|
|
timeArray[i] = i / 60.0;
|
|
if (bests[i] > 0) maxNonZero = i;
|
|
}
|
|
if (maxNonZero > 1) {
|
|
thisCurve = new QwtPlotCurve(
|
|
dateTime.toString("ddd MMM d, yyyy h:mm AP"));
|
|
thisCurve->setRenderHint(QwtPlotItem::RenderAntialiased);
|
|
QPen *pen = new QPen(Qt::black);
|
|
pen->setWidth(2.0);
|
|
thisCurve->setPen(QPen(Qt::black));
|
|
thisCurve->attach(this);
|
|
thisCurve->setData(timeArray.data() + 1, bests.constData() + 1,
|
|
maxNonZero - 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
replot();
|
|
}
|
|
|
|
// delete a CPI file
|
|
bool
|
|
CpintPlot::deleteCpiFile(QString filename)
|
|
{
|
|
// first, get ride of the file
|
|
if (! QFile::remove(filename))
|
|
return false;
|
|
|
|
// now check to see if this file contributed to the bests
|
|
// in the current implementation a false means it does
|
|
// not contribute, but a true only means it at one time
|
|
// contributed (may not in the end).
|
|
if (cpiDataInBests.contains(filename)) {
|
|
if (cpiDataInBests[filename])
|
|
needToScanRides = true;
|
|
cpiDataInBests.remove(filename);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void
|
|
CpintPlot::showGrid(int state)
|
|
{
|
|
assert(state != Qt::PartiallyChecked);
|
|
grid->setVisible(state == Qt::Checked);
|
|
replot();
|
|
}
|
|
|
|
QStringList
|
|
CpintPlot::filterForSeason(QStringList cpints, QDate startDate, QDate endDate)
|
|
{
|
|
QString cpi;
|
|
QDate cpiDate;
|
|
QStringListIterator cpis(cpints);
|
|
QStringList returnList;
|
|
|
|
//Check to see if no date was assigned.
|
|
QDate nilDate;
|
|
if(startDate == nilDate)
|
|
return cpints;
|
|
|
|
while (cpis.hasNext())
|
|
{
|
|
cpi = cpis.next();
|
|
cpiDate = cpi_filename_to_date(cpi);
|
|
if(cpiDate > startDate && cpiDate < endDate)
|
|
returnList << cpi;
|
|
|
|
}
|
|
return returnList;
|
|
}
|
|
|
|
void
|
|
CpintPlot::setStartDate(QDate _startDate)
|
|
{
|
|
startDate = _startDate;
|
|
}
|
|
|
|
void
|
|
CpintPlot::setEndDate(QDate _endDate)
|
|
{
|
|
endDate = _endDate;
|
|
}
|