mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2025-02-19 22:16:15 +00:00
Code Issues Projects Releases Packages Wiki Activity

profile: make plotdata::depth depth_t

Browse source 
A small drop in the bucket: more conversion to our unit types.

Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
This commit is contained in:
Berthold Stoeger 2024-12-14 17:09:05 +01:00 • committed by Michael Keller
parent 851e8bc5ee
commit 94a54d8e35
9 changed files with 97 additions and 104 deletions
Download patch file Download diff file Expand all files Collapse all files

2
core/gaspressures.cpp
View file

@ -280,7 +280,7 @@ static void fill_missing_tank_pressures(const struct dive *dive, struct plot_inf
static inline int calc_pressure_time(const struct dive *dive, const struct plot_data &a, const struct plot_data &b) static inline int calc_pressure_time(const struct dive *dive, const struct plot_data &a, const struct plot_data &b)
{ {
int time = b.sec - a.sec; int time = b.sec - a.sec;
depth_t depth { .mm = (a.depth + b.depth) / 2 }; depth_t depth = (a.depth + b.depth) / 2;
if (depth.mm <= SURFACE_THRESHOLD) if (depth.mm <= SURFACE_THRESHOLD)
return 0; return 0;

133
core/profile.cpp
View file

@ -46,13 +46,12 @@ static void dump_pi(const struct plot_info &pi)
pi.maxpressure, pi.mintemp, pi.maxtemp); pi.maxpressure, pi.mintemp, pi.maxtemp);
for (i = 0; i < pi.nr; i++) { for (i = 0; i < pi.nr; i++) {
struct plot_data &entry = pi.entry[i]; struct plot_data &entry = pi.entry[i];
depth_t depth { .mm = entry.depth };
printf(" entry[%d]:{cylinderindex:%d sec:%d pressure:{%d,%d}\n" printf(" entry[%d]:{cylinderindex:%d sec:%d pressure:{%d,%d}\n"
" time:%d:%02d temperature:%d depth:%d stopdepth:%d stoptime:%d ndl:%d smoothed:%d po2:%lf phe:%lf pn2:%lf sum-pp %lf}\n", " time:%d:%02d temperature:%d depth:%d stopdepth:%d stoptime:%d ndl:%d smoothed:%d po2:%lf phe:%lf pn2:%lf sum-pp %lf}\n",
i, entry.sensor[0], entry.sec, i, entry.sensor[0], entry.sec,
entry.pressure[0], entry.pressure[1], entry.pressure[0], entry.pressure[1],
entry.sec / 60, entry.sec % 60, entry.sec / 60, entry.sec % 60,
entry.temperature, entry.depth, entry.stopdepth, entry.stoptime, entry.ndl, entry.smoothed, entry.temperature, entry.depth.mm, entry.stopdepth.mm, entry.stoptime, entry.ndl, entry.smoothed,
entry.pressures.o2, entry.pressures.he, entry.pressures.n2, entry.pressures.o2, entry.pressures.he, entry.pressures.n2,
entry.pressures.o2 + entry.pressures.he + entry.pressures.n2); entry.pressures.o2 + entry.pressures.he + entry.pressures.n2);
} }
@ -123,7 +122,7 @@ static int get_local_sac(struct plot_info &pi, int idx1, int idx2, struct dive *
return 0; return 0;
/* Mean pressure in ATM */ /* Mean pressure in ATM */
depth_t depth {.mm = (entry1.depth + entry2.depth) / 2 }; depth_t depth = (entry1.depth + entry2.depth) / 2;
atm = dive->depth_to_atm(depth); atm = dive->depth_to_atm(depth);
cyl = dive->get_cylinder(index); cyl = dive->get_cylinder(index);
@ -167,23 +166,23 @@ static void analyze_plot_info(struct plot_info &pi)
/* Smoothing function: 5-point triangular smooth */ /* Smoothing function: 5-point triangular smooth */
for (size_t i = 2; i < pi.entry.size(); i++) { for (size_t i = 2; i < pi.entry.size(); i++) {
struct plot_data &entry = pi.entry[i]; struct plot_data &entry = pi.entry[i];
int depth; depth_t depth;
if (i + 2 < pi.entry.size()) { if (i + 2 < pi.entry.size()) {
depth = pi.entry[i-2].depth + 2 * pi.entry[i-1].depth + 3 * pi.entry[i].depth + 2 * pi.entry[i+1].depth + pi.entry[i+2].depth; depth = pi.entry[i-2].depth + pi.entry[i-1].depth * 2 + pi.entry[i].depth * 3 + pi.entry[i+1].depth * 2 + pi.entry[i+2].depth;
entry.smoothed = (depth + 4) / 9; entry.smoothed = (depth + 4_mm) / 9;
} }
/* vertical velocity in mm/sec */ /* vertical velocity in mm/sec */
/* Linus wants to smooth this - let's at least look at the samples that aren't FAST or CRAZY */ /* Linus wants to smooth this - let's at least look at the samples that aren't FAST or CRAZY */
if (pi.entry[i].sec - pi.entry[i-1].sec) { if (pi.entry[i].sec - pi.entry[i-1].sec) {
entry.speed = (pi.entry[i+0].depth - pi.entry[i-1].depth) / (pi.entry[i].sec - pi.entry[i-1].sec); entry.speed = (pi.entry[i+0].depth - pi.entry[i-1].depth).mm / (pi.entry[i].sec - pi.entry[i-1].sec);
entry.velocity = velocity(entry.speed); entry.velocity = velocity(entry.speed);
/* if our samples are short and we aren't too FAST*/ /* if our samples are short and we aren't too FAST*/
if (pi.entry[i].sec - pi.entry[i-1].sec < 15 && entry.velocity < FAST) { if (pi.entry[i].sec - pi.entry[i-1].sec < 15 && entry.velocity < FAST) {
int past = -2; int past = -2;
while (i + past > 0 && pi.entry[i].sec - pi.entry[i+past].sec < 15) while (i + past > 0 && pi.entry[i].sec - pi.entry[i+past].sec < 15)
past--; past--;
entry.velocity = velocity((pi.entry[i].depth - pi.entry[i+past].depth) / entry.velocity = velocity((pi.entry[i].depth - pi.entry[i+past].depth).mm /
(pi.entry[i].sec - pi.entry[i+past].sec)); (pi.entry[i].sec - pi.entry[i+past].sec));
} }
} else { } else {
@ -320,14 +319,14 @@ static plot_data &add_entry(struct plot_info &pi)
/* copy the previous entry (we know this exists), update time and depth /* copy the previous entry (we know this exists), update time and depth
* and zero out the sensor pressure (since this is a synthetic entry) * and zero out the sensor pressure (since this is a synthetic entry)
* increment the entry pointer and the count of synthetic entries. */ * increment the entry pointer and the count of synthetic entries. */
static void insert_entry(struct plot_info &pi, int time, int depth, int sac) static void insert_entry(struct plot_info &pi, int time, depth_t depth, int sac)
{ {
struct plot_data &entry = add_entry(pi); struct plot_data &entry = add_entry(pi);
struct plot_data &prev = pi.entry[pi.entry.size() - 2]; struct plot_data &prev = pi.entry[pi.entry.size() - 2];
entry = prev; entry = prev;
entry.sec = time; entry.sec = time;
entry.depth = depth; entry.depth = depth;
entry.running_sum = prev.running_sum + (time - prev.sec) * (depth + prev.depth) / 2; entry.running_sum = prev.running_sum + (time - prev.sec) * (depth + prev.depth).mm / 2;
entry.sac = sac; entry.sac = sac;
entry.ndl = -1; entry.ndl = -1;
entry.bearing = -1; entry.bearing = -1;
@ -355,7 +354,7 @@ static void populate_plot_entries(const struct dive *dive, const struct divecomp
pi.entry.resize(2); pi.entry.resize(2);
pi.pressures.resize(pi.nr_cylinders * 2); pi.pressures.resize(pi.nr_cylinders * 2);
int lastdepth = 0; depth_t lastdepth;
int lasttime = 0; int lasttime = 0;
int lasttemp = 0; int lasttemp = 0;
/* skip events at time = 0 */ /* skip events at time = 0 */
@ -365,7 +364,6 @@ static void populate_plot_entries(const struct dive *dive, const struct divecomp
for (const auto &sample: dc->samples) { for (const auto &sample: dc->samples) {
int time = sample.time.seconds; int time = sample.time.seconds;
int offset, delta; int offset, delta;
int depth = sample.depth.mm;
int sac = sample.sac.mliter; int sac = sample.sac.mliter;
/* Add intermediate plot entries if required */ /* Add intermediate plot entries if required */
@ -380,12 +378,12 @@ static void populate_plot_entries(const struct dive *dive, const struct divecomp
/* Add events if they are between plot entries */ /* Add events if they are between plot entries */
while (evit != dc->events.end() && static_cast<int>(evit->time.seconds) < lasttime + offset) { while (evit != dc->events.end() && static_cast<int>(evit->time.seconds) < lasttime + offset) {
insert_entry(pi, evit->time.seconds, interpolate(lastdepth, depth, evit->time.seconds - lasttime, delta), sac); insert_entry(pi, evit->time.seconds, interpolate(lastdepth, sample.depth, evit->time.seconds - lasttime, delta), sac);
++evit; ++evit;
} }
/* now insert the time interpolated entry */ /* now insert the time interpolated entry */
insert_entry(pi, lasttime + offset, interpolate(lastdepth, depth, offset, delta), sac); insert_entry(pi, lasttime + offset, interpolate(lastdepth, sample.depth, offset, delta), sac);
/* skip events that happened at this time */ /* skip events that happened at this time */
while (evit != dc->events.end() && static_cast<int>(evit->time.seconds) == lasttime + offset) while (evit != dc->events.end() && static_cast<int>(evit->time.seconds) == lasttime + offset)
@ -394,17 +392,17 @@ static void populate_plot_entries(const struct dive *dive, const struct divecomp
/* Add events if they are between plot entries */ /* Add events if they are between plot entries */
while (evit != dc->events.end() && static_cast<int>(evit->time.seconds) < time) { while (evit != dc->events.end() && static_cast<int>(evit->time.seconds) < time) {
insert_entry(pi, evit->time.seconds, interpolate(lastdepth, depth, evit->time.seconds - lasttime, delta), sac); insert_entry(pi, evit->time.seconds, interpolate(lastdepth, sample.depth, evit->time.seconds - lasttime, delta), sac);
++evit; ++evit;
} }
plot_data &entry = add_entry(pi); plot_data &entry = add_entry(pi);
plot_data &prev = pi.entry[pi.entry.size() - 2]; plot_data &prev = pi.entry[pi.entry.size() - 2];
entry.sec = time; entry.sec = time;
entry.depth = depth; entry.depth = sample.depth;
entry.running_sum = prev.running_sum + (time - prev.sec) * (depth + prev.depth) / 2; entry.running_sum = prev.running_sum + (time - prev.sec) * (sample.depth.mm + prev.depth.mm) / 2;
entry.stopdepth = sample.stopdepth.mm; entry.stopdepth = sample.stopdepth;
entry.stoptime = sample.stoptime.seconds; entry.stoptime = sample.stoptime.seconds;
entry.ndl = sample.ndl.seconds; entry.ndl = sample.ndl.seconds;
entry.tts = sample.tts.seconds; entry.tts = sample.tts.seconds;
@ -435,7 +433,7 @@ static void populate_plot_entries(const struct dive *dive, const struct divecomp
while (evit != dc->events.end() && static_cast<int>(evit->time.seconds) == time) while (evit != dc->events.end() && static_cast<int>(evit->time.seconds) == time)
++evit; ++evit;
lasttime = time; lasttime = time;
lastdepth = depth; lastdepth = entry.depth;
if (time > pi.maxtime) if (time > pi.maxtime)
break; break;
@ -446,7 +444,7 @@ static void populate_plot_entries(const struct dive *dive, const struct divecomp
int time = evit->time.seconds; int time = evit->time.seconds;
if (time > lasttime) { if (time > lasttime) {
insert_entry(pi, evit->time.seconds, 0, 0); insert_entry(pi, evit->time.seconds, 0_m, 0);
lasttime = time; lasttime = time;
} }
++evit; ++evit;
@ -492,7 +490,7 @@ static int sac_between(const struct dive *dive, const struct plot_info &pi, int
do { do {
const struct plot_data &entry = pi.entry[first]; const struct plot_data &entry = pi.entry[first];
const struct plot_data &next = pi.entry[first + 1]; const struct plot_data &next = pi.entry[first + 1];
depth_t depth { .mm = (entry.depth + next.depth) / 2 }; depth_t depth { .mm = (entry.depth.mm + next.depth.mm) / 2 };
int time = next.sec - entry.sec; int time = next.sec - entry.sec;
double atm = dive->depth_to_atm(depth); double atm = dive->depth_to_atm(depth);
@ -565,7 +563,7 @@ static void fill_sac(const struct dive *dive, struct plot_info &pi, int idx, con
const struct plot_data &entry = pi.entry[idx]; const struct plot_data &entry = pi.entry[idx];
const struct plot_data &prev = pi.entry[idx - 1]; const struct plot_data &prev = pi.entry[idx - 1];
if (prev.depth < SURFACE_THRESHOLD && entry.depth < SURFACE_THRESHOLD) if (prev.depth.mm < SURFACE_THRESHOLD && entry.depth.mm < SURFACE_THRESHOLD)
break; break;
if (prev.sec < time) if (prev.sec < time)
break; break;
@ -581,7 +579,7 @@ static void fill_sac(const struct dive *dive, struct plot_info &pi, int idx, con
while (++idx < pi.nr) { while (++idx < pi.nr) {
const struct plot_data &entry = pi.entry[last]; const struct plot_data &entry = pi.entry[last];
const struct plot_data &next = pi.entry[last + 1]; const struct plot_data &next = pi.entry[last + 1];
if (next.depth < SURFACE_THRESHOLD && entry.depth < SURFACE_THRESHOLD) if (next.depth.mm < SURFACE_THRESHOLD && entry.depth.mm < SURFACE_THRESHOLD)
break; break;
if (next.sec > time) if (next.sec > time)
break; break;
@ -766,18 +764,18 @@ static void calculate_ndl_tts(struct deco_state *ds, const struct dive *dive, st
const int time_stepsize = 60; const int time_stepsize = 60;
const depth_t deco_stepsize = m_or_ft(3, 10); const depth_t deco_stepsize = m_or_ft(3, 10);
/* at what depth is the current deco-step? */ /* at what depth is the current deco-step? */
depth_t ascent_depth { .mm = entry.depth }; depth_t ascent_depth = entry.depth;
int next_stop = round_up(deco_allowed_depth( depth_t next_stop { .mm = round_up(deco_allowed_depth(
tissue_tolerance_calc(ds, dive, dive->depth_to_bar(ascent_depth), in_planner), tissue_tolerance_calc(ds, dive, dive->depth_to_bar(ascent_depth), in_planner),
surface_pressure, dive, 1).mm, deco_stepsize.mm); surface_pressure, dive, 1).mm, deco_stepsize.mm)};
/* at what time should we give up and say that we got enuff NDL? */ /* at what time should we give up and say that we got enuff NDL? */
/* If iterating through a dive, entry.tts_calc needs to be reset */ /* If iterating through a dive, entry.tts_calc needs to be reset */
entry.tts_calc = 0; entry.tts_calc = 0;
/* If we don't have a ceiling yet, calculate ndl. Don't try to calculate /* If we don't have a ceiling yet, calculate ndl. Don't try to calculate
* a ndl for lower values than 3m it would take forever */ * a ndl for lower values than 3m it would take forever */
if (next_stop == 0) { if (next_stop.mm <= 0) {
if (entry.depth < 3000) { if (entry.depth.mm < 3000) {
entry.ndl = MAX_PROFILE_DECO; entry.ndl = MAX_PROFILE_DECO;
return; return;
} }
@ -798,23 +796,23 @@ static void calculate_ndl_tts(struct deco_state *ds, const struct dive *dive, st
entry.in_deco_calc = true; entry.in_deco_calc = true;
/* Add segments for movement to stopdepth */ /* Add segments for movement to stopdepth */
for (; ascent_depth.mm > next_stop; ascent_depth.mm -= ascent_s_per_step * ascent_velocity(ascent_depth, entry.running_sum / entry.sec, 0), entry.tts_calc += ascent_s_per_step) { for (; ascent_depth.mm > next_stop.mm; ascent_depth.mm -= ascent_s_per_step * ascent_velocity(ascent_depth, entry.running_sum / entry.sec, 0), entry.tts_calc += ascent_s_per_step) {
add_segment(ds, dive->depth_to_bar(ascent_depth), add_segment(ds, dive->depth_to_bar(ascent_depth),
gasmix, ascent_s_per_step, entry.o2pressure.mbar, divemode, prefs.decosac, in_planner); gasmix, ascent_s_per_step, entry.o2pressure.mbar, divemode, prefs.decosac, in_planner);
next_stop = round_up(deco_allowed_depth(tissue_tolerance_calc(ds, dive, dive->depth_to_bar(ascent_depth), in_planner), next_stop.mm = round_up(deco_allowed_depth(tissue_tolerance_calc(ds, dive, dive->depth_to_bar(ascent_depth), in_planner),
surface_pressure, dive, 1).mm, deco_stepsize.mm); surface_pressure, dive, 1).mm, deco_stepsize.mm);
} }
ascent_depth.mm = next_stop; ascent_depth = next_stop;
/* And how long is the current deco-step? */ /* And how long is the current deco-step? */
entry.stoptime_calc = 0; entry.stoptime_calc = 0;
entry.stopdepth_calc = next_stop; entry.stopdepth_calc = next_stop;
next_stop -= deco_stepsize.mm; next_stop -= deco_stepsize;
/* And how long is the total TTS */ /* And how long is the total TTS */
while (next_stop >= 0) { while (next_stop.mm >= 0) {
/* save the time for the first stop to show in the graph */ /* save the time for the first stop to show in the graph */
if (ascent_depth.mm == entry.stopdepth_calc) if (ascent_depth.mm == entry.stopdepth_calc.mm)
entry.stoptime_calc += time_stepsize; entry.stoptime_calc += time_stepsize;
entry.tts_calc += time_stepsize; entry.tts_calc += time_stepsize;
@ -823,13 +821,13 @@ static void calculate_ndl_tts(struct deco_state *ds, const struct dive *dive, st
add_segment(ds, dive->depth_to_bar(ascent_depth), add_segment(ds, dive->depth_to_bar(ascent_depth),
gasmix, time_stepsize, entry.o2pressure.mbar, divemode, prefs.decosac, in_planner); gasmix, time_stepsize, entry.o2pressure.mbar, divemode, prefs.decosac, in_planner);
if (deco_allowed_depth(tissue_tolerance_calc(ds, dive, dive->depth_to_bar(ascent_depth), in_planner), surface_pressure, dive, 1).mm <= next_stop) { if (deco_allowed_depth(tissue_tolerance_calc(ds, dive, dive->depth_to_bar(ascent_depth), in_planner), surface_pressure, dive, 1).mm <= next_stop.mm) {
/* move to the next stop and add the travel between stops */ /* move to the next stop and add the travel between stops */
for (; ascent_depth.mm > next_stop; ascent_depth.mm -= ascent_s_per_deco_step * ascent_velocity(ascent_depth, entry.running_sum / entry.sec, 0), entry.tts_calc += ascent_s_per_deco_step) for (; ascent_depth.mm > next_stop.mm; ascent_depth.mm -= ascent_s_per_deco_step * ascent_velocity(ascent_depth, entry.running_sum / entry.sec, 0), entry.tts_calc += ascent_s_per_deco_step)
add_segment(ds, dive->depth_to_bar(ascent_depth), add_segment(ds, dive->depth_to_bar(ascent_depth),
gasmix, ascent_s_per_deco_step, entry.o2pressure.mbar, divemode, prefs.decosac, in_planner); gasmix, ascent_s_per_deco_step, entry.o2pressure.mbar, divemode, prefs.decosac, in_planner);
ascent_depth.mm = next_stop; ascent_depth = next_stop;
next_stop -= deco_stepsize.mm; next_stop -= deco_stepsize;
} }
} }
} }
@ -875,12 +873,10 @@ static void calculate_deco_information(struct deco_state *ds, const struct deco_
int t0 = prev.sec, t1 = entry.sec; int t0 = prev.sec, t1 = entry.sec;
int time_stepsize = 20; int time_stepsize = 20;
depth_t max_ceiling; depth_t max_ceiling;
depth_t depth { .mm = entry.depth };
depth_t prev_depth { .mm = prev.depth };
divemode_t current_divemode = loop_d.at(entry.sec); divemode_t current_divemode = loop_d.at(entry.sec);
struct gasmix gasmix = loop.at(t1).first; struct gasmix gasmix = loop.at(t1).first;
entry.ambpressure = dive->depth_to_bar(depth); entry.ambpressure = dive->depth_to_bar(entry.depth);
entry.gfline = get_gf(ds, entry.ambpressure, dive) * (100.0 - AMB_PERCENTAGE) + AMB_PERCENTAGE; entry.gfline = get_gf(ds, entry.ambpressure, dive) * (100.0 - AMB_PERCENTAGE) + AMB_PERCENTAGE;
if (t0 > t1) { if (t0 > t1) {
report_info("non-monotonous dive stamps %d %d", t0, t1); report_info("non-monotonous dive stamps %d %d", t0, t1);
@ -889,7 +885,7 @@ static void calculate_deco_information(struct deco_state *ds, const struct deco_
if (t0 != t1 && t1 - t0 < time_stepsize) if (t0 != t1 && t1 - t0 < time_stepsize)
time_stepsize = t1 - t0; time_stepsize = t1 - t0;
for (int j = t0 + time_stepsize; j <= t1; j += time_stepsize) { for (int j = t0 + time_stepsize; j <= t1; j += time_stepsize) {
depth_t new_depth = interpolate(prev_depth, depth, j - t0, t1 - t0); depth_t new_depth = interpolate(prev.depth, entry.depth, j - t0, t1 - t0);
add_segment(ds, dive->depth_to_bar(new_depth), add_segment(ds, dive->depth_to_bar(new_depth),
gasmix, time_stepsize, entry.o2pressure.mbar, current_divemode, entry.sac, in_planner); gasmix, time_stepsize, entry.o2pressure.mbar, current_divemode, entry.sac, in_planner);
entry.icd_warning = ds->icd_warning; entry.icd_warning = ds->icd_warning;
@ -907,16 +903,16 @@ static void calculate_deco_information(struct deco_state *ds, const struct deco_
if (!first_iteration || in_planner) if (!first_iteration || in_planner)
vpmb_next_gradient(ds, ds->deco_time, surface_pressure / 1000.0, in_planner); vpmb_next_gradient(ds, ds->deco_time, surface_pressure / 1000.0, in_planner);
} }
entry.ceiling = deco_allowed_depth(tissue_tolerance_calc(ds, dive, dive->depth_to_bar(depth), in_planner), surface_pressure, dive, !prefs.calcceiling3m).mm; entry.ceiling = deco_allowed_depth(tissue_tolerance_calc(ds, dive, dive->depth_to_bar(entry.depth), in_planner), surface_pressure, dive, !prefs.calcceiling3m).mm;
if (prefs.calcceiling3m) if (prefs.calcceiling3m)
current_ceiling = deco_allowed_depth(tissue_tolerance_calc(ds, dive, dive->depth_to_bar(depth), in_planner), surface_pressure, dive, true); current_ceiling = deco_allowed_depth(tissue_tolerance_calc(ds, dive, dive->depth_to_bar(entry.depth), in_planner), surface_pressure, dive, true);
else else
current_ceiling.mm = entry.ceiling; current_ceiling.mm = entry.ceiling;
last_ceiling = current_ceiling; last_ceiling = current_ceiling;
/* If using VPM-B, take first_ceiling_pressure as the deepest ceiling */ /* If using VPM-B, take first_ceiling_pressure as the deepest ceiling */
if (decoMode(in_planner) == VPMB) { if (decoMode(in_planner) == VPMB) {
if (current_ceiling.mm >= first_ceiling.mm || if (current_ceiling.mm >= first_ceiling.mm ||
(time_deep_ceiling == t0 && depth.mm == prev_depth.mm)) { (time_deep_ceiling == t0 && entry.depth.mm == prev.depth.mm)) {
time_deep_ceiling = t1; time_deep_ceiling = t1;
first_ceiling = current_ceiling; first_ceiling = current_ceiling;
ds->first_ceiling_pressure.mbar = dive->depth_to_mbar(first_ceiling); ds->first_ceiling_pressure.mbar = dive->depth_to_mbar(first_ceiling);
@ -964,7 +960,7 @@ static void calculate_deco_information(struct deco_state *ds, const struct deco_
// marker should be handled differently! // marker should be handled differently!
// Don't scream if we violate the ceiling by a few cm. // Don't scream if we violate the ceiling by a few cm.
if (in_planner && !pi.waypoint_above_ceiling && if (in_planner && !pi.waypoint_above_ceiling &&
depth.mm < max_ceiling.mm - 100 && entry.sec > 0) { entry.depth.mm < max_ceiling.mm - 100 && entry.sec > 0) {
struct dive *non_const_dive = (struct dive *)dive; // cast away const! struct dive *non_const_dive = (struct dive *)dive; // cast away const!
add_event(&non_const_dive->dcs[0], entry.sec, SAMPLE_EVENT_CEILING, -1, max_ceiling.mm / 1000, add_event(&non_const_dive->dcs[0], entry.sec, SAMPLE_EVENT_CEILING, -1, max_ceiling.mm / 1000,
translate("gettextFromC", "planned waypoint above ceiling")); translate("gettextFromC", "planned waypoint above ceiling"));
@ -1113,17 +1109,16 @@ static void calculate_gas_information_new(const struct dive *dive, const struct
for (i = 1; i < pi.nr; i++) { for (i = 1; i < pi.nr; i++) {
double fn2, fhe; double fn2, fhe;
struct plot_data &entry = pi.entry[i]; struct plot_data &entry = pi.entry[i];
depth_t depth { .mm = entry.depth };
auto gasmix = loop.at(entry.sec).first; auto gasmix = loop.at(entry.sec).first;
amb_pressure = dive->depth_to_bar(depth); amb_pressure = dive->depth_to_bar(entry.depth);
divemode_t current_divemode = loop_d.at(entry.sec); divemode_t current_divemode = loop_d.at(entry.sec);
entry.pressures = fill_pressures(amb_pressure, gasmix, (current_divemode == OC) ? 0.0 : entry.o2pressure.mbar / 1000.0, current_divemode); entry.pressures = fill_pressures(amb_pressure, gasmix, (current_divemode == OC) ? 0.0 : entry.o2pressure.mbar / 1000.0, current_divemode);
fn2 = 1000.0 * entry.pressures.n2 / amb_pressure; fn2 = 1000.0 * entry.pressures.n2 / amb_pressure;
fhe = 1000.0 * entry.pressures.he / amb_pressure; fhe = 1000.0 * entry.pressures.he / amb_pressure;
if (dc->divemode == PSCR) { // OC pO2 is calulated for PSCR with or without external PO2 monitoring. if (dc->divemode == PSCR) { // OC pO2 is calulated for PSCR with or without external PO2 monitoring.
struct gasmix gasmix2 = loop.at(entry.sec).first; struct gasmix gasmix2 = loop.at(entry.sec).first;
entry.scr_OC_pO2.mbar = (int) dive->depth_to_mbar(depth) * get_o2(gasmix2) / 1000; entry.scr_OC_pO2.mbar = (int) dive->depth_to_mbar(entry.depth) * get_o2(gasmix2) / 1000;
} }
/* Calculate MOD, EAD, END and EADD based on partial pressures calculated before /* Calculate MOD, EAD, END and EADD based on partial pressures calculated before
@ -1132,9 +1127,9 @@ static void calculate_gas_information_new(const struct dive *dive, const struct
* EAD just uses N₂ ("Air" for nitrox dives) */ * EAD just uses N₂ ("Air" for nitrox dives) */
pressure_t modpO2 = { .mbar = (int)(prefs.modpO2 * 1000) }; pressure_t modpO2 = { .mbar = (int)(prefs.modpO2 * 1000) };
entry.mod = dive->gas_mod(gasmix, modpO2, 1_mm).mm; entry.mod = dive->gas_mod(gasmix, modpO2, 1_mm).mm;
entry.end = dive->mbar_to_depth(lrint(dive->depth_to_mbarf(depth) * (1000 - fhe) / 1000.0)).mm; entry.end = dive->mbar_to_depth(lrint(dive->depth_to_mbarf(entry.depth) * (1000 - fhe) / 1000.0)).mm;
entry.ead = dive->mbar_to_depth(lrint(dive->depth_to_mbarf(depth) * fn2 / (double)N2_IN_AIR)).mm; entry.ead = dive->mbar_to_depth(lrint(dive->depth_to_mbarf(entry.depth) * fn2 / (double)N2_IN_AIR)).mm;
entry.eadd = dive->mbar_to_depth(lrint(dive->depth_to_mbarf(depth) * entry.eadd = dive->mbar_to_depth(lrint(dive->depth_to_mbarf(entry.depth) *
(entry.pressures.o2 / amb_pressure * O2_DENSITY + (entry.pressures.o2 / amb_pressure * O2_DENSITY +
entry.pressures.n2 / amb_pressure * N2_DENSITY + entry.pressures.n2 / amb_pressure * N2_DENSITY +
entry.pressures.he / amb_pressure * HE_DENSITY) / entry.pressures.he / amb_pressure * HE_DENSITY) /
@ -1167,7 +1162,6 @@ static void fill_o2_values(const struct dive *dive, const struct divecomputer *d
for (i = 0; i < pi.nr; i++) { for (i = 0; i < pi.nr; i++) {
struct plot_data &entry = pi.entry[i]; struct plot_data &entry = pi.entry[i];
depth_t depth { .mm = entry.depth };
if (dc->divemode == CCR || (dc->divemode == PSCR && dc->no_o2sensors)) { if (dc->divemode == CCR || (dc->divemode == PSCR && dc->no_o2sensors)) {
if (i == 0) { // For 1st iteration, initialise the last_sensor values if (i == 0) { // For 1st iteration, initialise the last_sensor values
@ -1180,7 +1174,7 @@ static void fill_o2_values(const struct dive *dive, const struct divecomputer *d
else else
entry.o2sensor[j] = last_sensor[j]; entry.o2sensor[j] = last_sensor[j];
} // having initialised the empty o2 sensor values for this point on the profile, } // having initialised the empty o2 sensor values for this point on the profile,
amb_pressure.mbar = dive->depth_to_mbar(depth); amb_pressure.mbar = dive->depth_to_mbar(entry.depth);
o2pressure.mbar = calculate_ccr_po2(entry, dc); // ...calculate the po2 based on the sensor data o2pressure.mbar = calculate_ccr_po2(entry, dc); // ...calculate the po2 based on the sensor data
entry.o2pressure.mbar = std::min(o2pressure.mbar, amb_pressure.mbar); entry.o2pressure.mbar = std::min(o2pressure.mbar, amb_pressure.mbar);
} else { } else {
@ -1271,10 +1265,9 @@ static std::vector<std::string> plot_string(const struct dive *d, const struct p
int decimals, cyl; int decimals, cyl;
const char *unit; const char *unit;
const struct plot_data &entry = pi.entry[idx]; const struct plot_data &entry = pi.entry[idx];
depth_t depth { .mm = entry.depth };
std::vector<std::string> res; std::vector<std::string> res;
depthvalue = get_depth_units(depth.mm, NULL, &depth_unit); depthvalue = get_depth_units(entry.depth.mm, NULL, &depth_unit);
res.push_back(casprintf_loc(translate("gettextFromC", "@: %d:%02d"), FRACTION_TUPLE(entry.sec, 60))); res.push_back(casprintf_loc(translate("gettextFromC", "@: %d:%02d"), FRACTION_TUPLE(entry.sec, 60)));
res.push_back(casprintf_loc(translate("gettextFromC", "D: %.1f%s"), depthvalue, depth_unit)); res.push_back(casprintf_loc(translate("gettextFromC", "D: %.1f%s"), depthvalue, depth_unit));
for (cyl = 0; cyl < pi.nr_cylinders; cyl++) { for (cyl = 0; cyl < pi.nr_cylinders; cyl++) {
@ -1339,8 +1332,8 @@ static std::vector<std::string> plot_string(const struct dive *d, const struct p
break; break;
} }
} }
if (entry.stopdepth) { if (entry.stopdepth.mm > 0) {
depthvalue = get_depth_units(entry.stopdepth, NULL, &depth_unit); depthvalue = get_depth_units(entry.stopdepth.mm, NULL, &depth_unit);
if (entry.ndl > 0) { if (entry.ndl > 0) {
/* this is a safety stop as we still have ndl */ /* this is a safety stop as we still have ndl */
if (entry.stoptime) if (entry.stoptime)
@ -1365,8 +1358,8 @@ static std::vector<std::string> plot_string(const struct dive *d, const struct p
} }
if (entry.tts) if (entry.tts)
res.push_back(casprintf_loc(translate("gettextFromC", "TTS: %umin"), div_up(entry.tts, 60))); res.push_back(casprintf_loc(translate("gettextFromC", "TTS: %umin"), div_up(entry.tts, 60)));
if (entry.stopdepth_calc && entry.stoptime_calc) { if (entry.stopdepth_calc.mm > 0 && entry.stoptime_calc) {
depthvalue = get_depth_units(entry.stopdepth_calc, NULL, &depth_unit); depthvalue = get_depth_units(entry.stopdepth_calc.mm, NULL, &depth_unit);
res.push_back(casprintf_loc(translate("gettextFromC", "Deco: %umin @ %.0f%s (calc)"), div_up(entry.stoptime_calc, 60), res.push_back(casprintf_loc(translate("gettextFromC", "Deco: %umin @ %.0f%s (calc)"), div_up(entry.stoptime_calc, 60),
depthvalue, depth_unit)); depthvalue, depth_unit));
} else if (entry.in_deco_calc) { } else if (entry.in_deco_calc) {
@ -1464,11 +1457,11 @@ std::vector<std::string> compare_samples(const struct dive *d, const struct plot
int max_asc_speed = 0; int max_asc_speed = 0;
int max_desc_speed = 0; int max_desc_speed = 0;
int delta_depth = abs(start.depth - stop.depth); int delta_depth = abs(start.depth.mm - stop.depth.mm);
int delta_time = abs(start.sec - stop.sec); int delta_time = abs(start.sec - stop.sec);
int avg_depth = 0; depth_t avg_depth;
int max_depth = 0; depth_t max_depth;
int min_depth = INT_MAX; depth_t min_depth { .mm = INT_MAX };
int last_sec = start.sec; int last_sec = start.sec;
@ -1492,9 +1485,9 @@ std::vector<std::string> compare_samples(const struct dive *d, const struct plot
if (data.speed < max_asc_speed) if (data.speed < max_asc_speed)
max_asc_speed = data.speed; max_asc_speed = data.speed;
if (data.depth < min_depth) if (data.depth.mm < min_depth.mm)
min_depth = data.depth; min_depth = data.depth;
if (data.depth > max_depth) if (data.depth.mm > max_depth.mm)
max_depth = data.depth; max_depth = data.depth;
for (int cylinder_index = 0; cylinder_index < pi.nr_cylinders; cylinder_index++) { for (int cylinder_index = 0; cylinder_index < pi.nr_cylinders; cylinder_index++) {
@ -1533,13 +1526,13 @@ std::vector<std::string> compare_samples(const struct dive *d, const struct plot
depthvalue = get_depth_units(delta_depth, NULL, &depth_unit); depthvalue = get_depth_units(delta_depth, NULL, &depth_unit);
l += space + casprintf_loc(translate("gettextFromC", "ΔD:%.1f%s"), depthvalue, depth_unit); l += space + casprintf_loc(translate("gettextFromC", "ΔD:%.1f%s"), depthvalue, depth_unit);
depthvalue = get_depth_units(min_depth, NULL, &depth_unit); depthvalue = get_depth_units(min_depth.mm, NULL, &depth_unit);
l += space + casprintf_loc(translate("gettextFromC", "↓D:%.1f%s"), depthvalue, depth_unit); l += space + casprintf_loc(translate("gettextFromC", "↓D:%.1f%s"), depthvalue, depth_unit);
depthvalue = get_depth_units(max_depth, NULL, &depth_unit); depthvalue = get_depth_units(max_depth.mm, NULL, &depth_unit);
l += space + casprintf_loc(translate("gettextFromC", "↑D:%.1f%s"), depthvalue, depth_unit); l += space + casprintf_loc(translate("gettextFromC", "↑D:%.1f%s"), depthvalue, depth_unit);
depthvalue = get_depth_units(avg_depth, NULL, &depth_unit); depthvalue = get_depth_units(avg_depth.mm, NULL, &depth_unit);
l += space + casprintf_loc(translate("gettextFromC", "øD:%.1f%s"), depthvalue, depth_unit); l += space + casprintf_loc(translate("gettextFromC", "øD:%.1f%s"), depthvalue, depth_unit);
res.push_back(l); res.push_back(l);
@ -1586,7 +1579,7 @@ std::vector<std::string> compare_samples(const struct dive *d, const struct plot
const char *volume_unit; const char *volume_unit;
/* Mean pressure in ATM */ /* Mean pressure in ATM */
double atm = d->depth_to_atm(depth_t { .mm = avg_depth }); double atm = d->depth_to_atm(avg_depth);
/* milliliters per minute */ /* milliliters per minute */
int sac = lrint(total_volume_used / atm * 60 / delta_time); int sac = lrint(total_volume_used / atm * 60 / delta_time);

8
core/profile.h
View file

@ -41,7 +41,7 @@ struct plot_data {
int sec = 0; int sec = 0;
int temperature = 0; int temperature = 0;
/* Depth info */ /* Depth info */
int depth = 0; depth_t depth;
int ceiling = 0; int ceiling = 0;
std::array<int, 16> ceilings; std::array<int, 16> ceilings;
std::array<int, 16> percentages; std::array<int, 16> percentages;
@ -49,9 +49,9 @@ struct plot_data {
int tts = 0; int tts = 0;
int rbt = 0; int rbt = 0;
int stoptime = 0; int stoptime = 0;
int stopdepth = 0; depth_t stopdepth;
int cns = 0; int cns = 0;
int smoothed = 0; depth_t smoothed;
int sac = 0; int sac = 0;
int running_sum = 0; int running_sum = 0;
struct gas_pressures pressures; struct gas_pressures pressures;
@ -68,7 +68,7 @@ struct plot_data {
int ndl_calc = 0; int ndl_calc = 0;
int tts_calc = 0; int tts_calc = 0;
int stoptime_calc = 0; int stoptime_calc = 0;
int stopdepth_calc = 0; depth_t stopdepth_calc;
int pressure_time = 0; int pressure_time = 0;
int heartbeat = 0; int heartbeat = 0;
int bearing = 0; int bearing = 0;

18
core/save-profiledata.cpp
View file

@ -69,7 +69,7 @@ static void put_pd(struct membuffer *b, const struct plot_info &pi, int idx)
put_int(b, get_plot_interpolated_pressure(pi, idx, c)); put_int(b, get_plot_interpolated_pressure(pi, idx, c));
} }
put_int(b, entry.temperature); put_int(b, entry.temperature);
put_int(b, entry.depth); put_int(b, entry.depth.mm);
put_int(b, entry.ceiling); put_int(b, entry.ceiling);
for (int i = 0; i < 16; i++) for (int i = 0; i < 16; i++)
put_int(b, entry.ceilings[i]); put_int(b, entry.ceilings[i]);
@ -79,9 +79,9 @@ static void put_pd(struct membuffer *b, const struct plot_info &pi, int idx)
put_int(b, entry.tts); put_int(b, entry.tts);
put_int(b, entry.rbt); put_int(b, entry.rbt);
put_int(b, entry.stoptime); put_int(b, entry.stoptime);
put_int(b, entry.stopdepth); put_int(b, entry.stopdepth.mm);
put_int(b, entry.cns); put_int(b, entry.cns);
put_int(b, entry.smoothed); put_int(b, entry.smoothed.mm);
put_int(b, entry.sac); put_int(b, entry.sac);
put_int(b, entry.running_sum); put_int(b, entry.running_sum);
put_double(b, entry.pressures.o2); put_double(b, entry.pressures.o2);
@ -118,7 +118,7 @@ static void put_pd(struct membuffer *b, const struct plot_info &pi, int idx)
put_int(b, entry.ndl_calc); put_int(b, entry.ndl_calc);
put_int(b, entry.tts_calc); put_int(b, entry.tts_calc);
put_int(b, entry.stoptime_calc); put_int(b, entry.stoptime_calc);
put_int(b, entry.stopdepth_calc); put_int(b, entry.stopdepth_calc.mm);
put_int(b, entry.pressure_time); put_int(b, entry.pressure_time);
put_int(b, entry.heartbeat); put_int(b, entry.heartbeat);
put_int(b, entry.bearing); put_int(b, entry.bearing);
@ -199,7 +199,7 @@ static std::string format_st_event(const plot_data &entry, const plot_data &next
std::string format_string = prefs.subtitles_format_string; std::string format_string = prefs.subtitles_format_string;
replace_all(format_string, "[time]", format_string_std("%d:%02d", FRACTION_TUPLE(entry.sec, 60))); replace_all(format_string, "[time]", format_string_std("%d:%02d", FRACTION_TUPLE(entry.sec, 60)));
value = get_depth_units(entry.depth, &decimals, &unit); value = get_depth_units(entry.depth.mm, &decimals, &unit);
replace_all(format_string, "[depth]", format_string_std("%02.2f %s", value, unit)); replace_all(format_string, "[depth]", format_string_std("%02.2f %s", value, unit));
if (entry.temperature) { if (entry.temperature) {
@ -244,8 +244,8 @@ static std::string format_st_event(const plot_data &entry, const plot_data &next
replace_all(format_string, "[stoptime]", ""); replace_all(format_string, "[stoptime]", "");
} }
if (entry.stopdepth > 0) { if (entry.stopdepth.mm > 0) {
value = get_depth_units(entry.stopdepth, &decimals, &unit); value = get_depth_units(entry.stopdepth.mm, &decimals, &unit);
replace_all(format_string, "[stopdepth]", format_string_std("%02.2f %s", value, unit)); replace_all(format_string, "[stopdepth]", format_string_std("%02.2f %s", value, unit));
} else { } else {
replace_all(format_string, "[stopdepth]", ""); replace_all(format_string, "[stopdepth]", "");
@ -358,8 +358,8 @@ static std::string format_st_event(const plot_data &entry, const plot_data &next
replace_all(format_string, "[stoptime_calc]", ""); replace_all(format_string, "[stoptime_calc]", "");
} }
if (entry.stopdepth_calc > 0) { if (entry.stopdepth_calc.mm > 0) {
value = get_depth_units(entry.stopdepth_calc, &decimals, &unit); value = get_depth_units(entry.stopdepth_calc.mm, &decimals, &unit);
replace_all(format_string, "[stopdepth_calc]", format_string_std("%02.2f %s", value, unit)); replace_all(format_string, "[stopdepth_calc]", format_string_std("%02.2f %s", value, unit));
} else { } else {
replace_all(format_string, "[stopdepth_calc]", ""); replace_all(format_string, "[stopdepth_calc]", "");

2
core/units.h
View file

@ -90,7 +90,7 @@
* are supported. * are supported.
* *
* Moreover, multiplication and division with an integral are * Moreover, multiplication and division with an integral are
* suppoerted. Attention: the latter uses standard C++ integer * supported. Attention: the latter uses standard C++ integer
* semantics: it always rounds towards 0! * semantics: it always rounds towards 0!
* *
* Note: multiplication with a scalar is currently only supported * Note: multiplication with a scalar is currently only supported

2
profile-widget/diveeventitem.cpp
View file

@ -172,7 +172,7 @@ static int depthAtTime(const plot_info &pi, duration_t time)
qWarning("can't find a spot in the dataModel"); qWarning("can't find a spot in the dataModel");
return DEPTH_NOT_FOUND; return DEPTH_NOT_FOUND;
} }
return it->depth; return it->depth.mm;
} }
bool DiveEventItem::isInteresting(const struct dive *d, const struct divecomputer *dc, bool DiveEventItem::isInteresting(const struct dive *d, const struct divecomputer *dc,

30
profile-widget/diveprofileitem.cpp
View file

@ -135,7 +135,7 @@ void DiveProfileItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *o
static bool comp_depth(const struct plot_data &p1, const struct plot_data &p2) static bool comp_depth(const struct plot_data &p1, const struct plot_data &p2)
{ {
return p1.depth < p2.depth; return p1.depth.mm < p2.depth.mm;
} }
void DiveProfileItem::replot(const dive *d, int from, int to, bool in_planner) void DiveProfileItem::replot(const dive *d, int from, int to, bool in_planner)
@ -156,7 +156,7 @@ void DiveProfileItem::replot(const dive *d, int from, int to, bool in_planner)
/* not in deco implies this is a safety stop, no ceiling */ /* not in deco implies this is a safety stop, no ceiling */
p.append(QPointF(hAxis.posAtValue(entry->sec), vAxis.posAtValue(0))); p.append(QPointF(hAxis.posAtValue(entry->sec), vAxis.posAtValue(0)));
} else { } else {
p.append(QPointF(hAxis.posAtValue(entry->sec), vAxis.posAtValue(qMin(entry->stopdepth, entry->depth)))); p.append(QPointF(hAxis.posAtValue(entry->sec), vAxis.posAtValue(std::min(entry->stopdepth.mm, entry->depth.mm))));
} }
} }
setPolygon(p); setPolygon(p);
@ -186,7 +186,7 @@ void DiveProfileItem::replot(const dive *d, int from, int to, bool in_planner)
std::vector<Peak> stack; std::vector<Peak> stack;
stack.reserve(max_peaks); stack.reserve(max_peaks);
int highest_peak = std::max_element(data.begin() + from, data.begin() + to, comp_depth) - data.begin(); int highest_peak = std::max_element(data.begin() + from, data.begin() + to, comp_depth) - data.begin();
if (data[highest_peak].depth < min_depth) if (data[highest_peak].depth.mm < min_depth)
return; return;
stack.push_back(Peak{ from, to, highest_peak }); stack.push_back(Peak{ from, to, highest_peak });
while (!stack.empty()) { while (!stack.empty()) {
@ -204,22 +204,22 @@ void DiveProfileItem::replot(const dive *d, int from, int to, bool in_planner)
for (new_from = act_peak.peak + 1; new_from + 3 < act_peak.range_to; ++new_from) { for (new_from = act_peak.peak + 1; new_from + 3 < act_peak.range_to; ++new_from) {
if (data[new_from].sec > act_sample.sec + half_interval) if (data[new_from].sec > act_sample.sec + half_interval)
break; break;
if (data[new_from].depth < data[valley].depth) if (data[new_from].depth.mm < data[valley].depth.mm)
valley = new_from; valley = new_from;
} }
// Continue search until peaks reach the minimum prominence (height from valley). // Continue search until peaks reach the minimum prominence (height from valley).
for ( ; new_from + 3 < act_peak.range_to; ++new_from) { for ( ; new_from + 3 < act_peak.range_to; ++new_from) {
if (data[new_from].depth >= data[valley].depth + min_prominence) { if (data[new_from].depth.mm >= data[valley].depth.mm + min_prominence) {
int new_peak = std::max_element(data.begin() + new_from, data.begin() + act_peak.range_to, comp_depth) - data.begin(); int new_peak = std::max_element(data.begin() + new_from, data.begin() + act_peak.range_to, comp_depth) - data.begin();
if (data[new_peak].depth < min_depth) if (data[new_peak].depth.mm < min_depth)
break; break;
stack.push_back(Peak{ new_from, act_peak.range_to, new_peak }); stack.push_back(Peak{ new_from, act_peak.range_to, new_peak });
if (data[valley].depth >= min_depth) if (data[valley].depth.mm >= min_depth)
plot_depth_sample(data[valley], Qt::AlignHCenter | Qt::AlignBottom, getColor(SAMPLE_SHALLOW)); plot_depth_sample(data[valley], Qt::AlignHCenter | Qt::AlignBottom, getColor(SAMPLE_SHALLOW));
break; break;
} }
if (data[new_from].depth < data[valley].depth) if (data[new_from].depth.mm < data[valley].depth.mm)
valley = new_from; valley = new_from;
} }
@ -230,22 +230,22 @@ void DiveProfileItem::replot(const dive *d, int from, int to, bool in_planner)
for (new_to = act_peak.peak - 1; new_to >= act_peak.range_from + 3; --new_to) { for (new_to = act_peak.peak - 1; new_to >= act_peak.range_from + 3; --new_to) {
if (data[new_to].sec + half_interval < act_sample.sec) if (data[new_to].sec + half_interval < act_sample.sec)
break; break;
if (data[new_to].depth < data[valley].depth) if (data[new_to].depth.mm < data[valley].depth.mm)
valley = new_to; valley = new_to;
} }
// Continue search until peaks reach the minimum prominence (height from valley). // Continue search until peaks reach the minimum prominence (height from valley).
for ( ; new_to >= act_peak.range_from + 3; --new_to) { for ( ; new_to >= act_peak.range_from + 3; --new_to) {
if (data[new_to].depth >= data[valley].depth + min_prominence) { if (data[new_to].depth.mm >= data[valley].depth.mm + min_prominence) {
int new_peak = std::max_element(data.begin() + act_peak.range_from, data.begin() + new_to, comp_depth) - data.begin(); int new_peak = std::max_element(data.begin() + act_peak.range_from, data.begin() + new_to, comp_depth) - data.begin();
if (data[new_peak].depth < min_depth) if (data[new_peak].depth.mm < min_depth)
break; break;
stack.push_back(Peak{ act_peak.range_from, new_to, new_peak }); stack.push_back(Peak{ act_peak.range_from, new_to, new_peak });
if (data[valley].depth >= min_depth) if (data[valley].depth.mm >= min_depth)
plot_depth_sample(data[valley], Qt::AlignHCenter | Qt::AlignBottom, getColor(SAMPLE_SHALLOW)); plot_depth_sample(data[valley], Qt::AlignHCenter | Qt::AlignBottom, getColor(SAMPLE_SHALLOW));
break; break;
} }
if (data[new_to].depth < data[valley].depth) if (data[new_to].depth.mm < data[valley].depth.mm)
valley = new_to; valley = new_to;
} }
} }
@ -255,7 +255,7 @@ void DiveProfileItem::plot_depth_sample(const struct plot_data &entry, QFlags<Qt
{ {
auto item = std::make_unique<DiveTextItem>(dpr, 1.0, flags, this); auto item = std::make_unique<DiveTextItem>(dpr, 1.0, flags, this);
item->set(get_depth_string(entry.depth, true), color); item->set(get_depth_string(entry.depth, true), color);
item->setPos(hAxis.posAtValue(entry.sec), vAxis.posAtValue(entry.depth)); item->setPos(hAxis.posAtValue(entry.sec), vAxis.posAtValue(entry.depth.mm));
texts.push_back(std::move(item)); texts.push_back(std::move(item));
} }
@ -722,7 +722,7 @@ DiveReportedCeiling::DiveReportedCeiling(const plot_info &pInfo, const DiveCarte
std::pair<double,double> DiveReportedCeiling::getTimeValue(int i) const std::pair<double,double> DiveReportedCeiling::getTimeValue(int i) const
{ {
const plot_data &entry = pInfo.entry[i]; const plot_data &entry = pInfo.entry[i];
int value = entry.in_deco && entry.stopdepth ? std::min(entry.stopdepth, entry.depth) : 0; int value = entry.in_deco && entry.stopdepth.mm ? std::min(entry.stopdepth.mm, entry.depth.mm) : 0;
return { static_cast<double>(entry.sec), static_cast<double>(value) }; return { static_cast<double>(entry.sec), static_cast<double>(value) };
} }

2
profile-widget/profilescene.cpp
View file

@ -111,7 +111,7 @@ ProfileScene::ProfileScene(double dpr, bool printMode, bool isGrayscale) :
percentageAxis(new DiveCartesianAxis(DiveCartesianAxis::Position::Right, false, 2, 0, TIME_GRID, Qt::black, false, false, percentageAxis(new DiveCartesianAxis(DiveCartesianAxis::Position::Right, false, 2, 0, TIME_GRID, Qt::black, false, false,
dpr, 0.7, printMode, isGrayscale, *this)), dpr, 0.7, printMode, isGrayscale, *this)),
diveProfileItem(createItem<DiveProfileItem>(*profileYAxis, diveProfileItem(createItem<DiveProfileItem>(*profileYAxis,
[](const plot_data &item) { return (double)item.depth; }, [](const plot_data &item) { return (double)item.depth.mm; },
0, dpr)), 0, dpr)),
temperatureItem(createItem<DiveTemperatureItem>(*temperatureAxis, temperatureItem(createItem<DiveTemperatureItem>(*temperatureAxis,
[](const plot_data &item) { return (double)item.temperature; }, [](const plot_data &item) { return (double)item.temperature; },

4
profile-widget/ruleritem.cpp
View file

@ -42,13 +42,13 @@ void RulerNodeItem2::recalculate()
if (x() < 0) { if (x() < 0) {
setPos(0, y()); setPos(0, y());
} else if (x() > timeAxis->posAtValue(last.sec)) { } else if (x() > timeAxis->posAtValue(last.sec)) {
setPos(timeAxis->posAtValue(last.sec), depthAxis->posAtValue(last.depth)); setPos(timeAxis->posAtValue(last.sec), depthAxis->posAtValue(last.depth.mm));
} else { } else {
idx = 0; idx = 0;
while (idx < pInfo->nr && timeAxis->posAtValue(pInfo->entry[idx].sec) < x()) while (idx < pInfo->nr && timeAxis->posAtValue(pInfo->entry[idx].sec) < x())
++idx; ++idx;
const struct plot_data &data = pInfo->entry[idx]; const struct plot_data &data = pInfo->entry[idx];
setPos(timeAxis->posAtValue(data.sec), depthAxis->posAtValue(data.depth)); setPos(timeAxis->posAtValue(data.sec), depthAxis->posAtValue(data.depth.mm));
} }
} }