mirror of
https://github.com/subsurface/subsurface.git
synced 2025-02-19 22:16:15 +00:00
profile: make plotdata::depth depth_t
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
Michael Keller
parent
851e8bc5ee
commit
94a54d8e35
9 changed files with 97 additions and 104 deletions
|
|
@ -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)
|
||||
{
|
||||
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)
|
||||
return 0;
|
||||
|
|
|
|||
133
core/profile.cpp
133
core/profile.cpp
|
|
@ -46,13 +46,12 @@ static void dump_pi(const struct plot_info &pi)
|
|||
pi.maxpressure, pi.mintemp, pi.maxtemp);
|
||||
for (i = 0; i < pi.nr; 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"
|
||||
" 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,
|
||||
entry.pressure[0], entry.pressure[1],
|
||||
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);
|
||||
}
|
||||
|
|
@ -123,7 +122,7 @@ static int get_local_sac(struct plot_info &pi, int idx1, int idx2, struct dive *
|
|||
return 0;
|
||||
|
||||
/* 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);
|
||||
|
||||
cyl = dive->get_cylinder(index);
|
||||
|
|
@ -167,23 +166,23 @@ static void analyze_plot_info(struct plot_info &pi)
|
|||
/* Smoothing function: 5-point triangular smooth */
|
||||
for (size_t i = 2; i < pi.entry.size(); i++) {
|
||||
struct plot_data &entry = pi.entry[i];
|
||||
int depth;
|
||||
depth_t depth;
|
||||
|
||||
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;
|
||||
entry.smoothed = (depth + 4) / 9;
|
||||
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_mm) / 9;
|
||||
}
|
||||
/* vertical velocity in mm/sec */
|
||||
/* 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) {
|
||||
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);
|
||||
/* 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) {
|
||||
int past = -2;
|
||||
while (i + past > 0 && pi.entry[i].sec - pi.entry[i+past].sec < 15)
|
||||
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));
|
||||
}
|
||||
} 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
|
||||
* and zero out the sensor pressure (since this is a synthetic entry)
|
||||
* 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 &prev = pi.entry[pi.entry.size() - 2];
|
||||
entry = prev;
|
||||
entry.sec = time;
|
||||
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.ndl = -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.pressures.resize(pi.nr_cylinders * 2);
|
||||
|
||||
int lastdepth = 0;
|
||||
depth_t lastdepth;
|
||||
int lasttime = 0;
|
||||
int lasttemp = 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) {
|
||||
int time = sample.time.seconds;
|
||||
int offset, delta;
|
||||
int depth = sample.depth.mm;
|
||||
int sac = sample.sac.mliter;
|
||||
|
||||
/* 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 */
|
||||
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;
|
||||
}
|
||||
|
||||
/* 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 */
|
||||
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 */
|
||||
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;
|
||||
}
|
||||
|
||||
plot_data &entry = add_entry(pi);
|
||||
plot_data &prev = pi.entry[pi.entry.size() - 2];
|
||||
entry.sec = time;
|
||||
entry.depth = depth;
|
||||
entry.depth = sample.depth;
|
||||
|
||||
entry.running_sum = prev.running_sum + (time - prev.sec) * (depth + prev.depth) / 2;
|
||||
entry.stopdepth = sample.stopdepth.mm;
|
||||
entry.running_sum = prev.running_sum + (time - prev.sec) * (sample.depth.mm + prev.depth.mm) / 2;
|
||||
entry.stopdepth = sample.stopdepth;
|
||||
entry.stoptime = sample.stoptime.seconds;
|
||||
entry.ndl = sample.ndl.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)
|
||||
++evit;
|
||||
lasttime = time;
|
||||
lastdepth = depth;
|
||||
lastdepth = entry.depth;
|
||||
|
||||
if (time > pi.maxtime)
|
||||
break;
|
||||
|
|
@ -446,7 +444,7 @@ static void populate_plot_entries(const struct dive *dive, const struct divecomp
|
|||
int time = evit->time.seconds;
|
||||
|
||||
if (time > lasttime) {
|
||||
insert_entry(pi, evit->time.seconds, 0, 0);
|
||||
insert_entry(pi, evit->time.seconds, 0_m, 0);
|
||||
lasttime = time;
|
||||
}
|
||||
++evit;
|
||||
|
|
@ -492,7 +490,7 @@ static int sac_between(const struct dive *dive, const struct plot_info &pi, int
|
|||
do {
|
||||
const struct plot_data &entry = pi.entry[first];
|
||||
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;
|
||||
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 &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;
|
||||
if (prev.sec < time)
|
||||
break;
|
||||
|
|
@ -581,7 +579,7 @@ static void fill_sac(const struct dive *dive, struct plot_info &pi, int idx, con
|
|||
while (++idx < pi.nr) {
|
||||
const struct plot_data &entry = pi.entry[last];
|
||||
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;
|
||||
if (next.sec > time)
|
||||
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 depth_t deco_stepsize = m_or_ft(3, 10);
|
||||
/* at what depth is the current deco-step? */
|
||||
depth_t ascent_depth { .mm = entry.depth };
|
||||
int next_stop = round_up(deco_allowed_depth(
|
||||
depth_t ascent_depth = entry.depth;
|
||||
depth_t 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)};
|
||||
/* 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 */
|
||||
entry.tts_calc = 0;
|
||||
|
||||
/* 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 */
|
||||
if (next_stop == 0) {
|
||||
if (entry.depth < 3000) {
|
||||
if (next_stop.mm <= 0) {
|
||||
if (entry.depth.mm < 3000) {
|
||||
entry.ndl = MAX_PROFILE_DECO;
|
||||
return;
|
||||
}
|
||||
|
|
@ -798,23 +796,23 @@ static void calculate_ndl_tts(struct deco_state *ds, const struct dive *dive, st
|
|||
entry.in_deco_calc = true;
|
||||
|
||||
/* 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),
|
||||
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);
|
||||
}
|
||||
ascent_depth.mm = next_stop;
|
||||
ascent_depth = next_stop;
|
||||
|
||||
/* And how long is the current deco-step? */
|
||||
entry.stoptime_calc = 0;
|
||||
entry.stopdepth_calc = next_stop;
|
||||
next_stop -= deco_stepsize.mm;
|
||||
next_stop -= deco_stepsize;
|
||||
|
||||
/* 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 */
|
||||
if (ascent_depth.mm == entry.stopdepth_calc)
|
||||
if (ascent_depth.mm == entry.stopdepth_calc.mm)
|
||||
entry.stoptime_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),
|
||||
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 */
|
||||
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),
|
||||
gasmix, ascent_s_per_deco_step, entry.o2pressure.mbar, divemode, prefs.decosac, in_planner);
|
||||
ascent_depth.mm = next_stop;
|
||||
next_stop -= deco_stepsize.mm;
|
||||
ascent_depth = next_stop;
|
||||
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 time_stepsize = 20;
|
||||
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);
|
||||
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;
|
||||
if (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)
|
||||
time_stepsize = t1 - t0;
|
||||
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),
|
||||
gasmix, time_stepsize, entry.o2pressure.mbar, current_divemode, entry.sac, in_planner);
|
||||
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)
|
||||
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)
|
||||
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
|
||||
current_ceiling.mm = entry.ceiling;
|
||||
last_ceiling = current_ceiling;
|
||||
/* If using VPM-B, take first_ceiling_pressure as the deepest ceiling */
|
||||
if (decoMode(in_planner) == VPMB) {
|
||||
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;
|
||||
first_ceiling = current_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!
|
||||
// Don't scream if we violate the ceiling by a few cm.
|
||||
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!
|
||||
add_event(&non_const_dive->dcs[0], entry.sec, SAMPLE_EVENT_CEILING, -1, max_ceiling.mm / 1000,
|
||||
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++) {
|
||||
double fn2, fhe;
|
||||
struct plot_data &entry = pi.entry[i];
|
||||
depth_t depth { .mm = entry.depth };
|
||||
|
||||
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);
|
||||
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;
|
||||
fhe = 1000.0 * entry.pressures.he / amb_pressure;
|
||||
if (dc->divemode == PSCR) { // OC pO2 is calulated for PSCR with or without external PO2 monitoring.
|
||||
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
|
||||
|
|
@ -1132,9 +1127,9 @@ static void calculate_gas_information_new(const struct dive *dive, const struct
|
|||
* EAD just uses N₂ ("Air" for nitrox dives) */
|
||||
pressure_t modpO2 = { .mbar = (int)(prefs.modpO2 * 1000) };
|
||||
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.ead = dive->mbar_to_depth(lrint(dive->depth_to_mbarf(depth) * fn2 / (double)N2_IN_AIR)).mm;
|
||||
entry.eadd = dive->mbar_to_depth(lrint(dive->depth_to_mbarf(depth) *
|
||||
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(entry.depth) * fn2 / (double)N2_IN_AIR)).mm;
|
||||
entry.eadd = dive->mbar_to_depth(lrint(dive->depth_to_mbarf(entry.depth) *
|
||||
(entry.pressures.o2 / amb_pressure * O2_DENSITY +
|
||||
entry.pressures.n2 / amb_pressure * N2_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++) {
|
||||
struct plot_data &entry = pi.entry[i];
|
||||
depth_t depth { .mm = entry.depth };
|
||||
|
||||
if (dc->divemode == CCR || (dc->divemode == PSCR && dc->no_o2sensors)) {
|
||||
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
|
||||
entry.o2sensor[j] = last_sensor[j];
|
||||
} // 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
|
||||
entry.o2pressure.mbar = std::min(o2pressure.mbar, amb_pressure.mbar);
|
||||
} else {
|
||||
|
|
@ -1271,10 +1265,9 @@ static std::vector<std::string> plot_string(const struct dive *d, const struct p
|
|||
int decimals, cyl;
|
||||
const char *unit;
|
||||
const struct plot_data &entry = pi.entry[idx];
|
||||
depth_t depth { .mm = entry.depth };
|
||||
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: %.1f%s"), depthvalue, depth_unit));
|
||||
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;
|
||||
}
|
||||
}
|
||||
if (entry.stopdepth) {
|
||||
depthvalue = get_depth_units(entry.stopdepth, NULL, &depth_unit);
|
||||
if (entry.stopdepth.mm > 0) {
|
||||
depthvalue = get_depth_units(entry.stopdepth.mm, NULL, &depth_unit);
|
||||
if (entry.ndl > 0) {
|
||||
/* this is a safety stop as we still have ndl */
|
||||
if (entry.stoptime)
|
||||
|
|
@ -1365,8 +1358,8 @@ static std::vector<std::string> plot_string(const struct dive *d, const struct p
|
|||
}
|
||||
if (entry.tts)
|
||||
res.push_back(casprintf_loc(translate("gettextFromC", "TTS: %umin"), div_up(entry.tts, 60)));
|
||||
if (entry.stopdepth_calc && entry.stoptime_calc) {
|
||||
depthvalue = get_depth_units(entry.stopdepth_calc, NULL, &depth_unit);
|
||||
if (entry.stopdepth_calc.mm > 0 && entry.stoptime_calc) {
|
||||
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),
|
||||
depthvalue, depth_unit));
|
||||
} 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_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 avg_depth = 0;
|
||||
int max_depth = 0;
|
||||
int min_depth = INT_MAX;
|
||||
depth_t avg_depth;
|
||||
depth_t max_depth;
|
||||
depth_t min_depth { .mm = INT_MAX };
|
||||
|
||||
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)
|
||||
max_asc_speed = data.speed;
|
||||
|
||||
if (data.depth < min_depth)
|
||||
if (data.depth.mm < min_depth.mm)
|
||||
min_depth = data.depth;
|
||||
if (data.depth > max_depth)
|
||||
if (data.depth.mm > max_depth.mm)
|
||||
max_depth = data.depth;
|
||||
|
||||
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);
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
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;
|
||||
|
||||
/* 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 */
|
||||
int sac = lrint(total_volume_used / atm * 60 / delta_time);
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ struct plot_data {
|
|||
int sec = 0;
|
||||
int temperature = 0;
|
||||
/* Depth info */
|
||||
int depth = 0;
|
||||
depth_t depth;
|
||||
int ceiling = 0;
|
||||
std::array<int, 16> ceilings;
|
||||
std::array<int, 16> percentages;
|
||||
|
|
@ -49,9 +49,9 @@ struct plot_data {
|
|||
int tts = 0;
|
||||
int rbt = 0;
|
||||
int stoptime = 0;
|
||||
int stopdepth = 0;
|
||||
depth_t stopdepth;
|
||||
int cns = 0;
|
||||
int smoothed = 0;
|
||||
depth_t smoothed;
|
||||
int sac = 0;
|
||||
int running_sum = 0;
|
||||
struct gas_pressures pressures;
|
||||
|
|
@ -68,7 +68,7 @@ struct plot_data {
|
|||
int ndl_calc = 0;
|
||||
int tts_calc = 0;
|
||||
int stoptime_calc = 0;
|
||||
int stopdepth_calc = 0;
|
||||
depth_t stopdepth_calc;
|
||||
int pressure_time = 0;
|
||||
int heartbeat = 0;
|
||||
int bearing = 0;
|
||||
|
|
|
|||
|
|
@ -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, entry.temperature);
|
||||
put_int(b, entry.depth);
|
||||
put_int(b, entry.depth.mm);
|
||||
put_int(b, entry.ceiling);
|
||||
for (int i = 0; i < 16; 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.rbt);
|
||||
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.smoothed);
|
||||
put_int(b, entry.smoothed.mm);
|
||||
put_int(b, entry.sac);
|
||||
put_int(b, entry.running_sum);
|
||||
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.tts_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.heartbeat);
|
||||
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;
|
||||
|
||||
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));
|
||||
|
||||
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]", "");
|
||||
}
|
||||
|
||||
if (entry.stopdepth > 0) {
|
||||
value = get_depth_units(entry.stopdepth, &decimals, &unit);
|
||||
if (entry.stopdepth.mm > 0) {
|
||||
value = get_depth_units(entry.stopdepth.mm, &decimals, &unit);
|
||||
replace_all(format_string, "[stopdepth]", format_string_std("%02.2f %s", value, unit));
|
||||
} else {
|
||||
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]", "");
|
||||
}
|
||||
|
||||
if (entry.stopdepth_calc > 0) {
|
||||
value = get_depth_units(entry.stopdepth_calc, &decimals, &unit);
|
||||
if (entry.stopdepth_calc.mm > 0) {
|
||||
value = get_depth_units(entry.stopdepth_calc.mm, &decimals, &unit);
|
||||
replace_all(format_string, "[stopdepth_calc]", format_string_std("%02.2f %s", value, unit));
|
||||
} else {
|
||||
replace_all(format_string, "[stopdepth_calc]", "");
|
||||
|
|
|
|||
|
|
@ -90,7 +90,7 @@
|
|||
* are supported.
|
||||
*
|
||||
* 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!
|
||||
*
|
||||
* Note: multiplication with a scalar is currently only supported
|
||||
|
|
|
|||
|
|
@ -172,7 +172,7 @@ static int depthAtTime(const plot_info &pi, duration_t time)
|
|||
qWarning("can't find a spot in the dataModel");
|
||||
return DEPTH_NOT_FOUND;
|
||||
}
|
||||
return it->depth;
|
||||
return it->depth.mm;
|
||||
}
|
||||
|
||||
bool DiveEventItem::isInteresting(const struct dive *d, const struct divecomputer *dc,
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
{
|
||||
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)
|
||||
|
|
@ -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 */
|
||||
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))));
|
||||
p.append(QPointF(hAxis.posAtValue(entry->sec), vAxis.posAtValue(std::min(entry->stopdepth.mm, entry->depth.mm))));
|
||||
}
|
||||
}
|
||||
setPolygon(p);
|
||||
|
|
@ -186,7 +186,7 @@ void DiveProfileItem::replot(const dive *d, int from, int to, bool in_planner)
|
|||
std::vector<Peak> stack;
|
||||
stack.reserve(max_peaks);
|
||||
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;
|
||||
stack.push_back(Peak{ from, to, highest_peak });
|
||||
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) {
|
||||
if (data[new_from].sec > act_sample.sec + half_interval)
|
||||
break;
|
||||
if (data[new_from].depth < data[valley].depth)
|
||||
if (data[new_from].depth.mm < data[valley].depth.mm)
|
||||
valley = new_from;
|
||||
}
|
||||
// Continue search until peaks reach the minimum prominence (height from valley).
|
||||
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();
|
||||
if (data[new_peak].depth < min_depth)
|
||||
if (data[new_peak].depth.mm < min_depth)
|
||||
break;
|
||||
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));
|
||||
break;
|
||||
}
|
||||
if (data[new_from].depth < data[valley].depth)
|
||||
if (data[new_from].depth.mm < data[valley].depth.mm)
|
||||
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) {
|
||||
if (data[new_to].sec + half_interval < act_sample.sec)
|
||||
break;
|
||||
if (data[new_to].depth < data[valley].depth)
|
||||
if (data[new_to].depth.mm < data[valley].depth.mm)
|
||||
valley = new_to;
|
||||
}
|
||||
// Continue search until peaks reach the minimum prominence (height from valley).
|
||||
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();
|
||||
if (data[new_peak].depth < min_depth)
|
||||
if (data[new_peak].depth.mm < min_depth)
|
||||
break;
|
||||
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));
|
||||
break;
|
||||
}
|
||||
if (data[new_to].depth < data[valley].depth)
|
||||
if (data[new_to].depth.mm < data[valley].depth.mm)
|
||||
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);
|
||||
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));
|
||||
}
|
||||
|
||||
|
|
@ -722,7 +722,7 @@ DiveReportedCeiling::DiveReportedCeiling(const plot_info &pInfo, const DiveCarte
|
|||
std::pair<double,double> DiveReportedCeiling::getTimeValue(int i) const
|
||||
{
|
||||
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) };
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
dpr, 0.7, printMode, isGrayscale, *this)),
|
||||
diveProfileItem(createItem<DiveProfileItem>(*profileYAxis,
|
||||
[](const plot_data &item) { return (double)item.depth; },
|
||||
[](const plot_data &item) { return (double)item.depth.mm; },
|
||||
0, dpr)),
|
||||
temperatureItem(createItem<DiveTemperatureItem>(*temperatureAxis,
|
||||
[](const plot_data &item) { return (double)item.temperature; },
|
||||
|
|
|
|||
|
|
@ -42,13 +42,13 @@ void RulerNodeItem2::recalculate()
|
|||
if (x() < 0) {
|
||||
setPos(0, y());
|
||||
} 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 {
|
||||
idx = 0;
|
||||
while (idx < pInfo->nr && timeAxis->posAtValue(pInfo->entry[idx].sec) < x())
|
||||
++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));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue