mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2024-11-30 22:20:21 +00:00
Code Issues Projects Releases Packages Wiki Activity
subsurface/profile-widget/diveprofileitem.cpp
Berthold Stoeger efc89b9d9c profile: use dynamic distances between labels on chart 
Use variable intervals for printing temperature and heart
beat labels. Obviously, so that the labels don't become
sparse on zooming, but also to make them not too crowded
on mobile / small screens.

This doesn't work for depth labels, because these labels
use data provided from the profile.c core that doesn't
know about the size of the chart.

Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2021-12-17 11:54:23 -08:00

790 lines
25 KiB
C++
Raw Blame History

// SPDX-License-Identifier: GPL-2.0
#include "profile-widget/diveprofileitem.h"
#include "qt-models/diveplotdatamodel.h"
#include "profile-widget/divecartesianaxis.h"
#include "profile-widget/divetextitem.h"
#include "profile-widget/animationfunctions.h"
#include "core/profile.h"
#include "qt-models/diveplannermodel.h"
#include "core/qthelper.h"
#include "core/settings/qPrefTechnicalDetails.h"
#include "core/settings/qPrefLog.h"
#include "libdivecomputer/parser.h"
#include "profile-widget/profilewidget2.h"
AbstractProfilePolygonItem::AbstractProfilePolygonItem(const DivePlotDataModel &model, const DiveCartesianAxis &horizontal, int hColumn,
const DiveCartesianAxis &vertical, int vColumn, double dpr) :
hAxis(horizontal), vAxis(vertical), dataModel(model), hDataColumn(hColumn), vDataColumn(vColumn), dpr(dpr), from(0), to(0)
{
setCacheMode(DeviceCoordinateCache);
}
void AbstractProfilePolygonItem::clear()
{
setPolygon(QPolygonF());
qDeleteAll(texts);
texts.clear();
}
static std::pair<double,double> clip(double x1, double y1, double x2, double y2, double x)
{
double rel = fabs(x2 - x1) > 1e-10 ? (x - x1) / (x2 - x1) : 0.5;
return { x, (y2 - y1) * rel + y1 };
}
void AbstractProfilePolygonItem::clipStart(double &x, double &y, double next_x, double next_y) const
{
if (x < hAxis.minimum())
std::tie(x, y) = clip(x, y, next_x, next_y, hAxis.minimum());
}
void AbstractProfilePolygonItem::clipStop(double &x, double &y, double prev_x, double prev_y) const
{
if (x > hAxis.maximum())
std::tie(x, y) = clip(prev_x, prev_y, x, y, hAxis.maximum());
}
std::pair<double, double> AbstractProfilePolygonItem::getPoint(int i) const
{
double x = dataModel.index(i, hDataColumn).data().toReal();
double y = dataModel.index(i, vDataColumn).data().toReal();
// Do clipping of first and last value
if (i == from && i < to) {
double next_x = dataModel.index(i+1, hDataColumn).data().toReal();
double next_y = dataModel.index(i+1, vDataColumn).data().toReal();
clipStart(x, y, next_x, next_y);
}
if (i == to - 1 && i > 0) {
double prev_x = dataModel.index(i-1, hDataColumn).data().toReal();
double prev_y = dataModel.index(i-1, vDataColumn).data().toReal();
clipStop(x, y, prev_x, prev_y);
}
return { x, y };
}
void AbstractProfilePolygonItem::makePolygon(int fromIn, int toIn)
{
from = fromIn;
to = toIn;
// Calculate the polygon. This is the polygon that will be painted on screen
// on the ::paint method. Here we calculate the correct position of the points
// regarting our cartesian plane ( made by the hAxis and vAxis ), the QPolygonF
// is an array of QPointF's, so we basically get the point from the model, convert
// to our coordinates, store. no painting is done here.
QPolygonF poly;
for (int i = from; i < to; i++) {
auto [horizontalValue, verticalValue] = getPoint(i);
if (i == from) {
QPointF point(hAxis.posAtValue(horizontalValue), vAxis.posAtValue(0.0));
poly.append(point);
}
QPointF point(hAxis.posAtValue(horizontalValue), vAxis.posAtValue(verticalValue));
poly.append(point);
if (i == to - 1) {
QPointF point(hAxis.posAtValue(horizontalValue), vAxis.posAtValue(0.0));
poly.append(point);
}
}
setPolygon(poly);
qDeleteAll(texts);
texts.clear();
}
DiveProfileItem::DiveProfileItem(const DivePlotDataModel &model, const DiveCartesianAxis &hAxis, int hColumn,
const DiveCartesianAxis &vAxis, int vColumn, double dpr) :
AbstractProfilePolygonItem(model, hAxis, hColumn, vAxis, vColumn, dpr),
show_reported_ceiling(0), reported_ceiling_in_red(0)
{
}
void DiveProfileItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
if (polygon().isEmpty())
return;
painter->save();
// This paints the Polygon + Background. I'm setting the pen to QPen() so we don't get a black line here,
// after all we need to plot the correct velocities colors later.
setPen(Qt::NoPen);
QGraphicsPolygonItem::paint(painter, option, widget);
// Here we actually paint the boundaries of the Polygon using the colors that the model provides.
// Those are the speed colors of the dives.
QPen pen;
pen.setCosmetic(true);
pen.setWidth(2);
QPolygonF poly = polygon();
// This paints the colors of the velocities.
for (int i = from + 1; i < to; i++) {
QModelIndex colorIndex = dataModel.index(i, DivePlotDataModel::COLOR);
pen.setBrush(QBrush(colorIndex.data(Qt::BackgroundRole).value<QColor>()));
painter->setPen(pen);
if (i - from < poly.count() - 1)
painter->drawLine(poly[i - from], poly[i - from + 1]);
}
painter->restore();
}
void DiveProfileItem::replot(const dive *d, int from, int to, bool in_planner)
{
makePolygon(from, to);
if (polygon().isEmpty())
return;
show_reported_ceiling = prefs.dcceiling;
reported_ceiling_in_red = prefs.redceiling;
profileColor = dataModel.data().waypoint_above_ceiling ? QColor(Qt::red)
: getColor(DEPTH_BOTTOM);
/* Show any ceiling we may have encountered */
if (prefs.dcceiling && !prefs.redceiling) {
QPolygonF p = polygon();
plot_data *entry = dataModel.data().entry + to - 1;
for (int i = to - 1; i >= from; i--, entry--) {
if (!entry->in_deco) {
/* not in deco implies this is a safety stop, no ceiling */
p.append(QPointF(hAxis.posAtValue(entry->sec), vAxis.posAtValue(0)));
} else {
p.append(QPointF(hAxis.posAtValue(entry->sec), vAxis.posAtValue(qMin(entry->stopdepth, entry->depth))));
}
}
setPolygon(p);
}
// This is the blueish gradient that the Depth Profile should have.
// It's a simple QLinearGradient with 2 stops, starting from top to bottom.
QLinearGradient pat(0, polygon().boundingRect().top(), 0, polygon().boundingRect().bottom());
pat.setColorAt(1, profileColor);
pat.setColorAt(0, getColor(DEPTH_TOP));
setBrush(QBrush(pat));
int last = -1;
for (int i = from; i < to; i++) {
struct plot_data *pd = dataModel.data().entry;
struct plot_data *entry = pd + i;
// "min/max" are the 9-minute window min/max indices
struct plot_data *min_entry = pd + entry->min;
struct plot_data *max_entry = pd + entry->max;
if (entry->depth < 2000)
continue;
if ((entry == max_entry) && entry->depth / 100 != last) {
plot_depth_sample(entry, Qt::AlignHCenter | Qt::AlignBottom, getColor(SAMPLE_DEEP));
last = entry->depth / 100;
}
if ((entry == min_entry) && entry->depth / 100 != last) {
plot_depth_sample(entry, Qt::AlignHCenter | Qt::AlignTop, getColor(SAMPLE_SHALLOW));
last = entry->depth / 100;
}
if (entry->depth != last)
last = -1;
}
}
void DiveProfileItem::plot_depth_sample(struct plot_data *entry, QFlags<Qt::AlignmentFlag> flags, const QColor &color)
{
DiveTextItem *item = new DiveTextItem(dpr, 1.0, flags, this);
item->set(get_depth_string(entry->depth, true), color);
item->setPos(hAxis.posAtValue(entry->sec), vAxis.posAtValue(entry->depth));
texts.append(item);
}
DiveHeartrateItem::DiveHeartrateItem(const DivePlotDataModel &model, const DiveCartesianAxis &hAxis, int hColumn,
const DiveCartesianAxis &vAxis, int vColumn, double dpr) :
AbstractProfilePolygonItem(model, hAxis, hColumn, vAxis, vColumn, dpr)
{
QPen pen;
pen.setBrush(QBrush(getColor(::HR_PLOT)));
pen.setCosmetic(true);
pen.setWidth(1);
setPen(pen);
}
void DiveHeartrateItem::replot(const dive *, int fromIn, int toIn, bool)
{
from = fromIn;
to = toIn;
int last = -300, last_printed_hr = 0;
struct sec_hr {
int sec;
int hr;
} hist[3] = {};
std::vector<sec_hr> textItems;
qDeleteAll(texts);
texts.clear();
// Ignore empty values. a heart rate of 0 would be a bad sign.
QPolygonF poly;
int interval = vAxis.getMinLabelDistance(hAxis);
for (int i = from; i < to; i++) {
auto [sec_double, hr_double] = getPoint(i);
int hr = lrint(hr_double);
if (!hr)
continue;
int sec = lrint(sec_double);
QPointF point(hAxis.posAtValue(sec_double), vAxis.posAtValue(hr_double));
poly.append(point);
if (hr == hist[2].hr)
// same as last one, no point in looking at printing
continue;
hist[0] = hist[1];
hist[1] = hist[2];
hist[2].sec = sec;
hist[2].hr = hr;
// don't print a HR
// if it's not a local min / max
// if it's been less a full label interval and less than a 20 beats change OR
// if it's been less than half a label interval OR if the change from the
// last print is less than 10 beats
// to test min / max requires three points, so we now look at the
// previous one
sec = hist[1].sec;
hr = hist[1].hr;
if ((hist[0].hr < hr && hr < hist[2].hr) ||
(hist[0].hr > hr && hr > hist[2].hr) ||
((sec < last + interval) && (abs(hr - last_printed_hr) < 20)) ||
(sec < last + interval / 2) ||
(abs(hr - last_printed_hr) < 10))
continue;
last = sec;
textItems.push_back({ sec, hr });
last_printed_hr = hr;
}
setPolygon(poly);
for (size_t i = 0; i < textItems.size(); ++i) {
auto [sec, hr] = textItems[i];
createTextItem(sec, hr, i == textItems.size() - 1);
}
}
void DiveHeartrateItem::createTextItem(int sec, int hr, bool last)
{
int flags = last ? Qt::AlignLeft | Qt::AlignBottom :
Qt::AlignRight | Qt::AlignBottom;
DiveTextItem *text = new DiveTextItem(dpr, 0.7, flags, this);
text->set(QString("%1").arg(hr), getColor(HR_TEXT));
text->setPos(QPointF(hAxis.posAtValue(sec), vAxis.posAtValue(hr)));
texts.append(text);
}
void DiveHeartrateItem::paint(QPainter *painter, const QStyleOptionGraphicsItem*, QWidget*)
{
if (polygon().isEmpty())
return;
painter->save();
painter->setPen(pen());
painter->drawPolyline(polygon());
painter->restore();
}
DiveTemperatureItem::DiveTemperatureItem(const DivePlotDataModel &model, const DiveCartesianAxis &hAxis, int hColumn,
const DiveCartesianAxis &vAxis, int vColumn, double dpr) :
AbstractProfilePolygonItem(model, hAxis, hColumn, vAxis, vColumn, dpr)
{
QPen pen;
pen.setBrush(QBrush(getColor(::TEMP_PLOT)));
pen.setCosmetic(true);
pen.setWidth(2);
setPen(pen);
}
void DiveTemperatureItem::replot(const dive *, int fromIn, int toIn, bool)
{
from = fromIn;
to = toIn;
double last = -300.0, last_printed_temp = 0.0, last_valid_temp = 0.0, sec = 0.0;
std::vector<std::pair<int, int>> textItems;
qDeleteAll(texts);
texts.clear();
// Ignore empty values. things do not look good with '0' as temperature in kelvin...
QPolygonF poly;
int interval = vAxis.getMinLabelDistance(hAxis);
for (int i = from; i < to; i++) {
auto [sec, mkelvin] = getPoint(i);
if (mkelvin < 1.0)
continue;
QPointF point(hAxis.posAtValue(sec), vAxis.posAtValue(mkelvin));
poly.append(point);
last_valid_temp = sec;
/* don't print a temperature
* if it's been less than a full label interval and less than a 2K change OR
* if it's been less than a half label interval OR if the change from the
* last print is less than .4K (and therefore less than 1F) */
if (((sec < last + interval) && (fabs(mkelvin - last_printed_temp) < 2000.0)) ||
(sec < last + interval / 2) ||
(fabs(mkelvin - last_printed_temp) < 400.0))
continue;
last = sec;
if (mkelvin > 200000.0)
textItems.push_back({ static_cast<int>(sec), static_cast<int>(mkelvin) });
last_printed_temp = mkelvin;
}
setPolygon(poly);
/* print the end temperature, if it's different or if the
* last temperature print has been more than a quarter of the
* dive back */
if (last_valid_temp > 200000.0 &&
((fabs(last_valid_temp - last_printed_temp) > 500.0) || (last < 0.75 * sec))) {
textItems.push_back({ static_cast<int>(sec), static_cast<int>(last_valid_temp) });
}
for (size_t i = 0; i < textItems.size(); ++i) {
auto [sec, mkelvin] = textItems[i];
createTextItem(sec, mkelvin, i == textItems.size() - 1);
}
}
void DiveTemperatureItem::createTextItem(int sec, int mkelvin, bool last)
{
temperature_t temp;
temp.mkelvin = mkelvin;
int flags = last ? Qt::AlignLeft | Qt::AlignBottom :
Qt::AlignRight | Qt::AlignBottom;
DiveTextItem *text = new DiveTextItem(dpr, 0.8, flags, this);
text->set(get_temperature_string(temp, true), getColor(TEMP_TEXT));
text->setPos(QPointF(hAxis.posAtValue(sec), vAxis.posAtValue(mkelvin)));
texts.append(text);
}
void DiveTemperatureItem::paint(QPainter *painter, const QStyleOptionGraphicsItem*, QWidget*)
{
if (polygon().isEmpty())
return;
painter->save();
painter->setPen(pen());
painter->drawPolyline(polygon());
painter->restore();
}
DiveMeanDepthItem::DiveMeanDepthItem(const DivePlotDataModel &model, const DiveCartesianAxis &hAxis, int hColumn,
const DiveCartesianAxis &vAxis, int vColumn, double dpr) :
AbstractProfilePolygonItem(model, hAxis, hColumn, vAxis, vColumn, dpr)
{
QPen pen;
pen.setBrush(QBrush(getColor(::HR_AXIS)));
pen.setCosmetic(true);
pen.setWidth(2);
setPen(pen);
}
// Apparently, there can be samples without mean depth? If not, remove these functions.
std::pair<double,double> DiveMeanDepthItem::getMeanDepth(int i) const
{
for ( ; i >= 0; --i) {
const plot_data &entry = dataModel.data().entry[i];
if (entry.running_sum > 0)
return { static_cast<double>(entry.sec),
static_cast<double>(entry.running_sum) / entry.sec };
}
return { 0.0, 0.0 };
}
std::pair<double,double> DiveMeanDepthItem::getNextMeanDepth(int first) const
{
int last = dataModel.data().nr;
for (int i = first + 1; i < last; ++i) {
const plot_data &entry = dataModel.data().entry[i];
if (entry.running_sum > 0)
return { static_cast<double>(entry.sec),
static_cast<double>(entry.running_sum) / entry.sec };
}
return getMeanDepth(first);
}
void DiveMeanDepthItem::replot(const dive *, int fromIn, int toIn, bool)
{
from = fromIn;
to = toIn;
double prevSec = 0.0, prevMeanDepth = 0.0;
QPolygonF poly;
for (int i = from; i < to; i++) {
auto [sec, meanDepth] = getMeanDepth(i);
// Ignore empty values
if (meanDepth == 0)
continue;
if (i == from && i < to) {
auto [sec2, meanDepth2] = getNextMeanDepth(i);
if (meanDepth2 > 0.0)
clipStart(sec, meanDepth, sec2, meanDepth2);
}
if (i == to - 1 && i > 0)
clipStop(sec, meanDepth, prevSec, prevMeanDepth);
QPointF point(hAxis.posAtValue(sec), vAxis.posAtValue(meanDepth));
poly.append(point);
prevSec = sec;
prevMeanDepth = meanDepth;
}
setPolygon(poly);
if (prevMeanDepth > 0.0)
createTextItem(prevSec, prevMeanDepth);
}
void DiveMeanDepthItem::paint(QPainter *painter, const QStyleOptionGraphicsItem*, QWidget*)
{
if (polygon().isEmpty())
return;
painter->save();
painter->setPen(pen());
painter->drawPolyline(polygon());
painter->restore();
}
void DiveMeanDepthItem::createTextItem(double lastSec, double lastMeanDepth)
{
qDeleteAll(texts);
texts.clear();
DiveTextItem *text = new DiveTextItem(dpr, 0.8, Qt::AlignRight | Qt::AlignTop, this);
text->set(get_depth_string(lrint(lastMeanDepth), true), getColor(TEMP_TEXT));
text->setPos(QPointF(hAxis.posAtValue(lastSec) + dpr, vAxis.posAtValue(lastMeanDepth)));
texts.append(text);
}
void DiveGasPressureItem::replot(const dive *d, int fromIn, int toIn, bool in_planner)
{
from = fromIn;
to = toIn;
const struct plot_info *pInfo = &dataModel.data();
std::vector<int> plotted_cyl(pInfo->nr_cylinders, false);
std::vector<double> last_plotted(pInfo->nr_cylinders, 0.0);
std::vector<Segment> act_segments(pInfo->nr_cylinders);
QPolygonF boundingPoly;
segments.clear();
for (int i = from; i < to; i++) {
const struct plot_data *entry = pInfo->entry + i;
for (int cyl = 0; cyl < pInfo->nr_cylinders; cyl++) {
double mbar = static_cast<double>(get_plot_pressure(pInfo, i, cyl));
double time = static_cast<double>(entry->sec);
if (mbar < 1.0)
continue;
if (i == from && i < to - 1) {
double mbar2 = static_cast<double>(get_plot_pressure(pInfo, i+1, cyl));
double time2 = static_cast<double>(entry[1].sec);
if (mbar2 < 1.0)
continue;
clipStart(time, mbar, time2, mbar2);
}
if (i == to - 1 && i > from) {
double mbar2 = static_cast<double>(get_plot_pressure(pInfo, i-1, cyl));
double time2 = static_cast<double>(entry[-1].sec);
if (mbar2 < 1.0)
continue;
clipStop(time, mbar, time2, mbar2);
}
QPointF point(hAxis.posAtValue(time), vAxis.posAtValue(mbar));
boundingPoly.push_back(point);
QColor color;
if (!in_planner) {
if (entry->sac)
color = getSacColor(entry->sac, d->sac);
else
color = MED_GRAY_HIGH_TRANS;
} else {
if (mbar < 0.0)
color = MAGENTA;
else
color = getPressureColor(entry->density);
}
if (!act_segments[cyl].polygon.empty()) {
/* Have we used this cylinder in the last two minutes? Continue */
if (time - act_segments[cyl].last.time <= 2*60) {
act_segments[cyl].polygon.push_back({ point, color });
act_segments[cyl].last.time = time;
act_segments[cyl].last.pressure = mbar;
continue;
}
/* Finish the previous one, start a new one */
act_segments[cyl].cyl = cyl;
segments.push_back(std::move(act_segments[cyl]));
act_segments[cyl] = Segment();
}
plotted_cyl[cyl] = true;
act_segments[cyl].polygon.push_back({ point, color });
act_segments[cyl].last.time = time;
act_segments[cyl].last.pressure = mbar;
if (act_segments[cyl].first.pressure == 0.0) {
act_segments[cyl].first.time = time;
act_segments[cyl].first.pressure = mbar;
}
}
}
for (int cyl = 0; cyl < pInfo->nr_cylinders; cyl++) {
if (act_segments[cyl].polygon.empty())
continue;
act_segments[cyl].cyl = cyl;
segments.push_back(std::move(act_segments[cyl]));
}
setPolygon(boundingPoly);
qDeleteAll(texts);
texts.clear();
// These are offset values used to print the gas labels and pressures on a
// dive profile at appropriate Y-coordinates. We alternate aligning the
// label and the gas pressure above and under the pressure line.
// The values are historical, and we could try to pick the over/under
// depending on whether this pressure is higher or lower than the average.
// Right now it's just strictly alternating when you have multiple gas
// pressures.
QFlags<Qt::AlignmentFlag> alignVar = Qt::AlignTop;
std::vector<QFlags<Qt::AlignmentFlag>> align(pInfo->nr_cylinders);
double labelHeight = DiveTextItem::fontHeight(dpr, 1.0);
for (const Segment &segment: segments) {
// Magic Y offset depending on whether we're aliging
// the top of the text or the bottom of the text to
// the pressure line.
double value_y_offset = -0.5 * dpr;
double label_y_offset = alignVar & Qt::AlignTop ? labelHeight : -labelHeight;
gasmix gas = get_cylinder(d, segment.cyl)->gasmix;
plotPressureValue(segment.first.pressure, segment.first.time, alignVar, value_y_offset);
plotGasValue(segment.first.pressure, segment.first.time, gas, alignVar, label_y_offset);
// For each cylinder, on right hand side of the curve, write cylinder pressure
plotPressureValue(segment.last.pressure, segment.last.time, alignVar | Qt::AlignLeft, value_y_offset);
/* Alternate alignment as we see cylinder use.. */
alignVar ^= Qt::AlignTop | Qt::AlignBottom;
}
}
void DiveGasPressureItem::plotPressureValue(double mbar, double sec, QFlags<Qt::AlignmentFlag> align, double pressure_offset)
{
const char *unit;
int pressure = get_pressure_units(lrint(mbar), &unit);
DiveTextItem *text = new DiveTextItem(dpr, 1.0, align, this);
text->set(QString("%1%2").arg(pressure).arg(unit), getColor(PRESSURE_TEXT));
text->setPos(hAxis.posAtValue(sec), vAxis.posAtValue(mbar) + pressure_offset);
texts.push_back(text);
}
void DiveGasPressureItem::plotGasValue(double mbar, double sec, struct gasmix gasmix, QFlags<Qt::AlignmentFlag> align, double gasname_offset)
{
QString gas = get_gas_string(gasmix);
DiveTextItem *text = new DiveTextItem(dpr, 1.0, align, this);
text->set(gas, getColor(PRESSURE_TEXT));
text->setPos(hAxis.posAtValue(sec), vAxis.posAtValue(mbar) + gasname_offset);
texts.push_back(text);
}
void DiveGasPressureItem::paint(QPainter *painter, const QStyleOptionGraphicsItem*, QWidget*)
{
if (polygon().isEmpty())
return;
QPen pen;
pen.setCosmetic(true);
pen.setWidth(2);
painter->save();
for (const Segment &segment: segments) {
for (size_t i = 1; i < segment.polygon.size(); i++) {
pen.setBrush(segment.polygon[i].col);
painter->setPen(pen);
painter->drawLine(segment.polygon[i - 1].pos, segment.polygon[i].pos);
}
}
painter->restore();
}
DiveCalculatedCeiling::DiveCalculatedCeiling(const DivePlotDataModel &model, const DiveCartesianAxis &hAxis, int hColumn,
const DiveCartesianAxis &vAxis, int vColumn, double dpr) :
AbstractProfilePolygonItem(model, hAxis, hColumn, vAxis, vColumn, dpr)
{
}
void DiveCalculatedCeiling::replot(const dive *d, int from, int to, bool in_planner)
{
makePolygon(from, to);
QLinearGradient pat(0, polygon().boundingRect().top(), 0, polygon().boundingRect().bottom());
pat.setColorAt(0, getColor(CALC_CEILING_SHALLOW));
pat.setColorAt(1, getColor(CALC_CEILING_DEEP));
setPen(QPen(QBrush(Qt::NoBrush), 0));
setBrush(pat);
}
void DiveCalculatedCeiling::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
if (polygon().isEmpty())
return;
QGraphicsPolygonItem::paint(painter, option, widget);
}
DiveCalculatedTissue::DiveCalculatedTissue(const DivePlotDataModel &model, const DiveCartesianAxis &hAxis, int hColumn,
const DiveCartesianAxis &vAxis, int vColumn, double dpr) :
DiveCalculatedCeiling(model, hAxis, hColumn, vAxis, vColumn, dpr)
{
}
DiveReportedCeiling::DiveReportedCeiling(const DivePlotDataModel &model, const DiveCartesianAxis &hAxis, int hColumn,
const DiveCartesianAxis &vAxis, int vColumn, double dpr) :
AbstractProfilePolygonItem(model, hAxis, hColumn, vAxis, vColumn, dpr)
{
}
std::pair<double,double> DiveReportedCeiling::getTimeValue(int i) const
{
const plot_data &entry = dataModel.data().entry[i];
int value = entry.in_deco && entry.stopdepth ? std::min(entry.stopdepth, entry.depth) : 0;
return { static_cast<double>(entry.sec), static_cast<double>(value) };
}
std::pair<double, double> DiveReportedCeiling::getPoint(int i) const
{
auto [x,y] = getTimeValue(i);
if (i == from && i < to) {
auto [next_x, next_y] = getTimeValue(i + 1);
clipStart(x, y, next_x, next_y);
}
if (i == to - 1 && i > 0) {
auto [prev_x, prev_y] = getTimeValue(i - 1);
clipStop(x, y, prev_x, prev_y);
}
return { x, y };
}
void DiveReportedCeiling::replot(const dive *, int fromIn, int toIn, bool)
{
from = fromIn;
to = toIn;
QPolygonF p;
for (int i = from; i < to; i++) {
auto [sec, value] = getPoint(i);
if (i == from)
p.append(QPointF(hAxis.posAtValue(sec), vAxis.posAtValue(0.0)));
p.append(QPointF(hAxis.posAtValue(sec), vAxis.posAtValue(value)));
if (i == to - 1)
p.append(QPointF(hAxis.posAtValue(sec), vAxis.posAtValue(0)));
}
setPolygon(p);
QLinearGradient pat(0, p.boundingRect().top(), 0, p.boundingRect().bottom());
// does the user want the ceiling in "surface color" or in red?
if (prefs.redceiling) {
pat.setColorAt(0, getColor(CEILING_SHALLOW));
pat.setColorAt(1, getColor(CEILING_DEEP));
} else {
pat.setColorAt(0, getColor(BACKGROUND_TRANS));
pat.setColorAt(1, getColor(BACKGROUND_TRANS));
}
setPen(QPen(QBrush(Qt::NoBrush), 0));
setBrush(pat);
}
void DiveReportedCeiling::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
if (polygon().isEmpty())
return;
QGraphicsPolygonItem::paint(painter, option, widget);
}
void PartialPressureGasItem::replot(const dive *, int fromIn, int toIn, bool)
{
from = fromIn;
to = toIn;
QPolygonF poly;
QPolygonF alertpoly;
alertPolygons.clear();
double threshold_min = 100.0; // yes, a ridiculous high partial pressure
double threshold_max = 0.0;
if (thresholdPtrMax)
threshold_max = *thresholdPtrMax;
if (thresholdPtrMin)
threshold_min = *thresholdPtrMin;
bool inAlertFragment = false;
for (int i = from; i < to; i++) {
auto [time, value] = getPoint(i);
QPointF point(hAxis.posAtValue(time), vAxis.posAtValue(value));
poly.push_back(point);
if (thresholdPtrMax && value >= threshold_max) {
if (inAlertFragment) {
alertPolygons.back().push_back(point);
} else {
alertpoly.clear();
alertpoly.push_back(point);
alertPolygons.append(alertpoly);
inAlertFragment = true;
}
} else if (thresholdPtrMin && value <= threshold_min) {
if (inAlertFragment) {
alertPolygons.back().push_back(point);
} else {
alertpoly.clear();
alertpoly.push_back(point);
alertPolygons.append(alertpoly);
inAlertFragment = true;
}
} else {
inAlertFragment = false;
}
}
setPolygon(poly);
}
void PartialPressureGasItem::paint(QPainter *painter, const QStyleOptionGraphicsItem*, QWidget*)
{
const qreal pWidth = 0.0;
painter->save();
painter->setPen(QPen(normalColor, pWidth));
painter->drawPolyline(polygon());
QPolygonF poly;
painter->setPen(QPen(alertColor, pWidth));
Q_FOREACH (const QPolygonF &poly, alertPolygons)
painter->drawPolyline(poly);
painter->restore();
}
void PartialPressureGasItem::setThresholdSettingsKey(const double *prefPointerMin, const double *prefPointerMax)
{
thresholdPtrMin = prefPointerMin;
thresholdPtrMax = prefPointerMax;
}
PartialPressureGasItem::PartialPressureGasItem(const DivePlotDataModel &model, const DiveCartesianAxis &hAxis, int hColumn,
const DiveCartesianAxis &vAxis, int vColumn, double dpr) :
AbstractProfilePolygonItem(model, hAxis, hColumn, vAxis, vColumn, dpr),
thresholdPtrMin(NULL),
thresholdPtrMax(NULL)
{
}
void PartialPressureGasItem::setColors(const QColor &normal, const QColor &alert)
{
normalColor = normal;
alertColor = alert;
}
Reference in a new issue View git blame Copy permalink