cairo_show_text(cr, buffer);
}
+struct ev_select {
+ char *ev_name;
+ gboolean plot_ev;
+};
+static struct ev_select *ev_namelist;
+static int evn_allocated;
+static int evn_used;
+
+void evn_foreach(void (*callback)(const char *, int *, void *), void *data)
+{
+ int i;
+
+ for (i = 0; i < evn_used; i++) {
+ callback(ev_namelist[i].ev_name, &ev_namelist[i].plot_ev, data);
+ }
+}
+
+void remember_event(const char *eventname)
+{
+ int i=0, len;
+
+ if (!eventname || (len = strlen(eventname)) == 0)
+ return;
+ while (i < evn_used) {
+ if (!strncmp(eventname,ev_namelist[i].ev_name,len))
+ return;
+ i++;
+ }
+ if (evn_used == evn_allocated) {
+ evn_allocated += 10;
+ ev_namelist = realloc(ev_namelist, evn_allocated * sizeof(struct ev_select));
+ if (! ev_namelist)
+ /* we are screwed, but let's just bail out */
+ return;
+ }
+ ev_namelist[evn_used].ev_name = strdup(eventname);
+ ev_namelist[evn_used].plot_ev = TRUE;
+ evn_used++;
+}
+
static void plot_one_event(struct graphics_context *gc, struct plot_info *pi, struct event *event, const text_render_options_t *tro)
{
int i, depth = 0;
int x,y;
+ /* is plotting this event disabled? */
+ if (event->name) {
+ for (i = 0; i < evn_used; i++) {
+ if (! strcmp(event->name, ev_namelist[i].ev_name)) {
+ if (ev_namelist[i].plot_ev)
+ break;
+ else
+ return;
+ }
+ }
+ }
for (i = 0; i < pi->nr; i++) {
struct plot_data *data = pi->entry + i;
if (event->time.seconds < data->sec)
static void plot_depth_profile(struct graphics_context *gc, struct plot_info *pi)
{
- int i;
+ int i, incr;
cairo_t *cr = gc->cr;
int sec, depth;
struct plot_data *entry;
int maxtime, maxdepth, marker;
+ int increments[4] = { 5*60, 10*60, 15*60, 30*60 };
/* Get plot scaling limits */
maxtime = get_maxtime(pi);
maxdepth = get_maxdepth(pi);
- /* Time markers: every 5 min */
+ /* Time markers: at most every 5 min, but no more than 12 markers
+ * and for convenience we do 5, 10, 15 or 30 min intervals.
+ * This allows for 6h dives - enough (I hope) for even the craziest
+ * divers - but just in case, for those 8h depth-record-breaking dives,
+ * we double the interval if this still doesn't get us to 12 or fewer
+ * time markers */
+ i = 0;
+ while (maxtime / increments[i] > 12 && i < 4)
+ i++;
+ incr = increments[i];
+ while (maxtime / incr > 12)
+ incr *= 2;
+
gc->leftx = 0; gc->rightx = maxtime;
gc->topy = 0; gc->bottomy = 1.0;
- for (i = 5*60; i < maxtime; i += 5*60) {
+ set_source_rgba(gc, 1, 1, 1, 0.5);
+ for (i = incr; i < maxtime; i += incr) {
move_to(gc, i, 0);
line_to(gc, i, 1);
}
+ cairo_stroke(cr);
+
+ /* now the text on every second time marker */
+ text_render_options_t tro = {10, 0.2, 1.0, 0.2, CENTER, TOP};
+ for (i = incr; i < maxtime; i += 2 * incr)
+ plot_text(gc, &tro, i, 1, "%d", i/60);
/* Depth markers: every 30 ft or 10 m*/
gc->leftx = 0; gc->rightx = 1.0;
static void plot_single_temp_text(struct graphics_context *gc, int sec, int mkelvin)
{
- int deg;
+ double deg;
const char *unit;
static const text_render_options_t tro = {12, 0.2, 0.2, 1.0, LEFT, TOP};
- temperature_t temperature = { mkelvin };
- if (output_units.temperature == FAHRENHEIT) {
- deg = to_F(temperature);
- unit = UTF8_DEGREE "F";
- } else {
- deg = to_C(temperature);
- unit = UTF8_DEGREE "C";
- }
- plot_text(gc, &tro, sec, temperature.mkelvin, "%d%s", deg, unit);
+ deg = get_temp_units(mkelvin, &unit);
+
+ plot_text(gc, &tro, sec, mkelvin, "%d%s", (int)(deg + 0.5), unit);
}
static void plot_temperature_text(struct graphics_context *gc, struct plot_info *pi)
plot_pressure_helper(gc, pi, INTERPOLATED_PR);
}
-static int mbar_to_PSI(int mbar)
-{
- pressure_t p = {mbar};
- return to_PSI(p);
-}
-
static void plot_pressure_value(struct graphics_context *gc, int mbar, int sec,
int xalign, int yalign)
{
int pressure;
const char *unit;
- switch (output_units.pressure) {
- case PASCAL:
- pressure = mbar * 100;
- unit = "pascal";
- break;
- case BAR:
- pressure = (mbar + 500) / 1000;
- unit = "bar";
- break;
- case PSI:
- pressure = mbar_to_PSI(mbar);
- unit = "psi";
- break;
- }
+ pressure = get_pressure_units(mbar, &unit);
text_render_options_t tro = {10, 0.2, 1.0, 0.2, xalign, yalign};
plot_text(gc, &tro, sec, mbar, "%d %s", pressure, unit);
}
return;
/* only loop over the actual events from the dive computer */
- for (i = 2; i < pi->nr - 2; i++) {
+ for (i = 2; i < pi->nr; i++) {
entry = pi->entry + i;
if (!entry->same_cylinder) {
for (cyl = 0; cyl < MAX_CYLINDERS; cyl++) {
cur_pr[cyl] = track_pr[cyl]->start;
}
- for (i = 0; i < dive->samples; i++) {
- entry = pi->entry + i + 2;
+
+ /* The first two are "fillers" */
+ for (i = 2; i < pi->nr; i++) {
+ entry = pi->entry + i;
if (SENSOR_PRESSURE(entry)) {
cur_pr[entry->cylinderindex] = SENSOR_PRESSURE(entry);
} else {
* sides, so that you can do end-points without having to worry
* about it.
*/
-static struct plot_info *create_plot_info(struct dive *dive)
+static struct plot_info *create_plot_info(struct dive *dive, int nr_samples, struct sample *dive_sample)
{
int cylinderindex = -1;
int lastdepth, lastindex;
- int i, nr = dive->samples + 4, sec, cyl;
+ int i, nr = nr_samples + 4, sec, cyl;
size_t alloc_size = plot_info_size(nr);
struct plot_info *pi;
pr_track_t *track_pr[MAX_CYLINDERS] = {NULL, };
pr_track_t *pr_track, *current;
gboolean missing_pr = FALSE;
- struct plot_data *entry;
+ struct plot_data *entry = NULL;
pi = malloc(alloc_size);
if (!pi)
sec = 0;
lastindex = 0;
lastdepth = -1;
- for (i = 0; i < dive->samples; i++) {
+ for (i = 0; i < nr_samples; i++) {
int depth;
- struct sample *sample = dive->sample+i;
+ struct sample *sample = dive_sample+i;
entry = pi->entry + i + 2;
sec = entry->sec = sample->time.seconds;
for (cyl = 0; cyl < MAX_CYLINDERS; cyl++) /* initialize the start pressures */
track_pr[cyl] = pr_track_alloc(dive->cylinder[cyl].start.mbar, -1);
- current = track_pr[dive->sample[0].cylinderindex];
- for (i = 0; i < dive->samples; i++) {
+ current = track_pr[pi->entry[2].cylinderindex];
+ for (i = 0; i < nr_samples; i++) {
entry = pi->entry + i + 2;
entry->same_cylinder = entry->cylinderindex == cylinderindex;
missing_pr |= !SENSOR_PRESSURE(entry);
}
- current->t_end = entry->sec;
+ if (entry)
+ current->t_end = entry->sec;
+
for (cyl = 0; cyl < MAX_CYLINDERS; cyl++) { /* initialize the end pressures */
int pr = dive->cylinder[cyl].end.mbar;
if (pr && track_pr[cyl]) {
pr_track->end = pr;
}
}
- if (lastdepth)
- lastindex = i + 2;
/* Fill in the last two entries with empty values but valid times */
- i = dive->samples + 2;
+ i = nr_samples + 2;
pi->entry[i].sec = sec + 20;
pi->entry[i+1].sec = sec + 40;
pi->nr = lastindex+1;
void plot(struct graphics_context *gc, cairo_rectangle_int_t *drawing_area, struct dive *dive)
{
- struct plot_info *pi = create_plot_info(dive);
+ struct plot_info *pi;
+ static struct sample fake[4];
+ struct sample *sample = dive->sample;
+ int nr = dive->samples;
+
+ if (!nr) {
+ int duration = dive->duration.seconds;
+ int maxdepth = dive->maxdepth.mm;
+ sample = fake;
+ fake[1].time.seconds = duration * 0.05;
+ fake[1].depth.mm = maxdepth;
+ fake[2].time.seconds = duration * 0.95;
+ fake[2].depth.mm = maxdepth;
+ fake[3].time.seconds = duration * 1.00;
+ nr = 4;
+ }
+
+ pi = create_plot_info(dive, nr, sample);
cairo_translate(gc->cr, drawing_area->x, drawing_area->y);
cairo_set_line_width(gc->cr, 2);