X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=profile.c;h=9fab8b2e89f5ae72cf4732f91e48d4a3cb73de00;hb=e7491d3bf50ad31bbee38abc9da823c9cbdb9cd1;hp=9952b18e3340f70be5735f3e745e73708c1e530c;hpb=7c1deb37c702ad668f40ae6a9a14cd2faf918ae4;p=ext%2Fsubsurface.git

diff --git a/profile.c b/profile.c
index 9952b18..9fab8b2 100644
--- a/profile.c
+++ b/profile.c
@@ -21,8 +21,7 @@ struct plot_info {
 	int nr;
 	int maxtime;
 	int meandepth, maxdepth;
-	int minpressure, maxpressure;
-	int endpressure; /* start pressure better be max pressure */
+	int maxpressure;
 	int mintemp, maxtemp;
 	struct plot_data {
 		unsigned int same_cylinder:1;
@@ -45,10 +44,11 @@ struct plot_info {
 #define INTERPOLATED_PR 1
 #define SENSOR_PRESSURE(_entry) (_entry)->pressure[SENSOR_PR]
 #define INTERPOLATED_PRESSURE(_entry) (_entry)->pressure[INTERPOLATED_PR]
+#define GET_PRESSURE(_entry) (SENSOR_PRESSURE(_entry) ? : INTERPOLATED_PRESSURE(_entry))
 
 /* convert velocity to colors */
 typedef struct { double r, g, b; } rgb_t;
-static const rgb_t rgb[] = {
+static const rgb_t velocity_color[] = {
 	[STABLE]   = {0.0, 0.4, 0.0},
 	[SLOW]     = {0.4, 0.8, 0.0},
 	[MODERATE] = {0.8, 0.8, 0.0},
@@ -89,6 +89,11 @@ static void set_source_rgba(struct graphics_context *gc, double r, double g, dou
 	cairo_set_source_rgba(gc->cr, r, g, b, a);
 }
 
+static void set_source_rgb_struct(struct graphics_context *gc, const rgb_t *rgb)
+{
+	set_source_rgba(gc, rgb->r, rgb->g, rgb->b, 1);
+}
+
 void set_source_rgb(struct graphics_context *gc, double r, double g, double b)
 {
 	set_source_rgba(gc, r, g, b, 1);
@@ -96,6 +101,24 @@ void set_source_rgb(struct graphics_context *gc, double r, double g, double b)
 
 #define ROUND_UP(x,y) ((((x)+(y)-1)/(y))*(y))
 
+/* debugging tool - not normally used */
+static void dump_pi (struct plot_info *pi)
+{
+	int i;
+
+	printf("pi:{nr:%d maxtime:%d meandepth:%d maxdepth:%d \n"
+		"    maxpressure:%d mintemp:%d maxtemp:%d\n",
+		pi->nr, pi->maxtime, pi->meandepth, pi->maxdepth,
+		pi->maxpressure, pi->mintemp, pi->maxtemp);
+	for (i = 0; i < pi->nr; i++)
+		printf("    entry[%d]:{same_cylinder:%d cylinderindex:%d sec:%d pressure:{%d,%d}\n"
+			"                temperature:%d depth:%d smoothed:%d}\n",
+			i, pi->entry[i].same_cylinder, pi->entry[i].cylinderindex, pi->entry[i].sec,
+			pi->entry[i].pressure[0], pi->entry[i].pressure[1],
+			pi->entry[i].temperature, pi->entry[i].depth, pi->entry[i].smoothed);
+	printf("   }\n");
+}
+
 /*
  * When showing dive profiles, we scale things to the
  * current dive. However, we don't scale past less than
@@ -276,6 +299,7 @@ static void plot_text_samples(struct graphics_context *gc, struct plot_info *pi)
 	static const text_render_options_t deep = {14, 1.0, 0.2, 0.2, CENTER, TOP};
 	static const text_render_options_t shallow = {14, 1.0, 0.2, 0.2, CENTER, BOTTOM};
 	int i;
+	int last = -1;
 
 	for (i = 0; i < pi->nr; i++) {
 		struct plot_data *entry = pi->entry + i;
@@ -283,11 +307,18 @@ static void plot_text_samples(struct graphics_context *gc, struct plot_info *pi)
 		if (entry->depth < 2000)
 			continue;
 
-		if (entry == entry->max[2])
+		if ((entry == entry->max[2]) && entry->depth != last) {
 			render_depth_sample(gc, entry, &deep);
+			last = entry->depth;
+		}
 
-		if (entry == entry->min[2])
+		if ((entry == entry->min[2]) && entry->depth != last) {
 			render_depth_sample(gc, entry, &shallow);
+			last = entry->depth;
+		}
+
+		if (entry->depth != last)
+			last = -1;
 	}
 }
 
@@ -450,9 +481,8 @@ static void plot_depth_profile(struct graphics_context *gc, struct plot_info *pi
 		/* we want to draw the segments in different colors
 		 * representing the vertical velocity, so we need to
 		 * chop this into short segments */
-		rgb_t color = rgb[entry->velocity];
 		depth = entry->depth;
-		set_source_rgb(gc, color.r, color.g, color.b);
+		set_source_rgb_struct(gc, &velocity_color[entry->velocity]);
 		move_to(gc, entry[-1].sec, entry[-1].depth);
 		line_to(gc, sec, depth);
 		cairo_stroke(cr);
@@ -485,25 +515,19 @@ static int setup_temperature_limits(struct graphics_context *gc, struct plot_inf
 
 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 };
+	static const text_render_options_t tro = {12, 0.6, 0.6, 1.0, LEFT, TOP};
 
-	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)
 {
 	int i;
-	int last = 0, sec = 0;
+	int last = -300, sec = 0;
 	int last_temperature = 0, last_printed_temp = 0;
 
 	if (!setup_temperature_limits(gc, pi))
@@ -517,14 +541,23 @@ static void plot_temperature_text(struct graphics_context *gc, struct plot_info
 			continue;
 		last_temperature = mkelvin;
 		sec = entry->sec;
-		if (sec < last + 300)
+		/* don't print a temperature
+		 * if it's been less than 5min and less than a 2K change OR
+		 * if it's been less than 2min OR if the change from the
+		 * last print is less than .4K (and therefore less than 1F */
+		if (((sec < last + 300) && (abs(mkelvin - last_printed_temp) < 2000)) ||
+			(sec < last + 120) ||
+			(abs(mkelvin - last_printed_temp) < 400))
 			continue;
 		last = sec;
 		plot_single_temp_text(gc,sec,mkelvin);
 		last_printed_temp = mkelvin;
 	}
-	/* it would be nice to print the end temperature, if it's different */
-	if (abs(last_temperature - last_printed_temp) > 500)
+	/* it would be nice to 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 ((abs(last_temperature - last_printed_temp) > 500) ||
+		((double)last / (double)sec < 0.75))
 		plot_single_temp_text(gc, sec, last_temperature);
 }
 
@@ -566,61 +599,111 @@ static int get_cylinder_pressure_range(struct graphics_context *gc, struct plot_
 	return pi->maxpressure != 0;
 }
 
-static void plot_pressure_helper(struct graphics_context *gc, struct plot_info *pi, int type)
+#define SAC_COLORS 9
+static const rgb_t sac_color[SAC_COLORS] = {
+	{ 0.0, 0.4, 0.2},
+	{ 0.2, 0.6, 0.2},
+	{ 0.4, 0.8, 0.2},
+	{ 0.6, 0.8, 0.2},
+	{ 0.8, 0.8, 0.2},
+	{ 0.8, 0.6, 0.2},
+	{ 0.8, 0.4, 0.2},
+	{ 0.9, 0.3, 0.2},
+	{ 1.0, 0.2, 0.2},
+};
+
+/* set the color for the pressure plot according to temporary sac rate
+ * as compared to avg_sac; the calculation simply maps the delta between
+ * sac and avg_sac to indexes 0 .. (SAC_COLORS - 1) with everything
+ * more than 6000 ml/min below avg_sac mapped to 0 */
+
+static void set_sac_color(struct graphics_context *gc, int sac, int avg_sac)
+{
+	int sac_index = 0;
+	int delta = sac - avg_sac + 7000;
+
+	sac_index = delta / 2000;
+	if (sac_index < 0)
+		sac_index = 0;
+	if (sac_index > SAC_COLORS - 1)
+		sac_index = SAC_COLORS - 1;
+	set_source_rgb_struct(gc, &sac_color[sac_index]);
+}
+
+/* calculate the current SAC in ml/min and convert to int */
+#define GET_LOCAL_SAC(_entry1, _entry2, _dive)	(int)				\
+	((GET_PRESSURE((_entry1)) - GET_PRESSURE((_entry2))) *			\
+		(_dive)->cylinder[(_entry1)->cylinderindex].type.size.mliter /	\
+		(((_entry2)->sec - (_entry1)->sec) / 60.0) /			\
+		(1 + ((_entry1)->depth + (_entry2)->depth) / 20000.0) /		\
+		1000.0)
+
+#define SAC_WINDOW 45	/* sliding window in seconds for current SAC calculation */
+
+static void plot_cylinder_pressure(struct graphics_context *gc, struct plot_info *pi,
+				struct dive *dive)
 {
 	int i;
+	int last = -1;
 	int lift_pen = FALSE;
+	int first_plot = TRUE;
+	int sac = 0;
+	struct plot_data *last_entry = NULL;
+
+	if (!get_cylinder_pressure_range(gc, pi))
+		return;
 
 	for (i = 0; i < pi->nr; i++) {
 		int mbar;
 		struct plot_data *entry = pi->entry + i;
 
-		mbar = entry->pressure[type];
-		if (!entry->same_cylinder)
+		mbar = GET_PRESSURE(entry);
+		if (!entry->same_cylinder) {
 			lift_pen = TRUE;
+			last_entry = NULL;
+		}
 		if (!mbar) {
 			lift_pen = TRUE;
 			continue;
 		}
+		if (!last_entry) {
+			last = i;
+			last_entry = entry;
+			if (first_plot) {
+				/* don't start with a sac of 0, so just calculate the first one */
+				sac = GET_LOCAL_SAC(entry, pi->entry + i + 1, dive);
+			}
+		} else {
+			int j;
+			sac = 0;
+			for (j = last; j < i; j++)
+				sac += GET_LOCAL_SAC(pi->entry + j, pi->entry + j + 1, dive);
+			sac /= (i - last);
+			if (entry->sec - last_entry->sec >= SAC_WINDOW) {
+				last++;
+				last_entry = pi->entry + last;
+			}
+		}
+		set_sac_color(gc, sac, dive->sac);
 		if (lift_pen) {
-			if (i > 0 && entry->same_cylinder) {
+			if (!first_plot && entry->same_cylinder) {
 				/* if we have a previous event from the same tank,
-				 * draw at least a short line .
-				 * This uses the implementation detail that the
-				 * type is either 0 or 1 */
+				 * draw at least a short line */
 				int prev_pr;
-				prev_pr = (entry-1)->pressure[type] ? : (entry-1)->pressure[1 - type];
+				prev_pr = GET_PRESSURE(entry - 1);
 				move_to(gc, (entry-1)->sec, prev_pr);
 				line_to(gc, entry->sec, mbar);
-			} else
+			} else {
+				first_plot = FALSE;
 				move_to(gc, entry->sec, mbar);
+			}
 			lift_pen = FALSE;
-		}
-		else
+		} else {
 			line_to(gc, entry->sec, mbar);
+		}
+		cairo_stroke(gc->cr);
+		move_to(gc, entry->sec, mbar);
 	}
-	cairo_stroke(gc->cr);
-
-}
-
-static void plot_cylinder_pressure(struct graphics_context *gc, struct plot_info *pi)
-{
-	if (!get_cylinder_pressure_range(gc, pi))
-		return;
-
-	/* first plot the pressure readings we have from the dive computer */
-	set_source_rgba(gc, 0.2, 1.0, 0.2, 0.80);
-	plot_pressure_helper(gc, pi, SENSOR_PR);
-
-	/* then, in a different color, the interpolated values */
-	set_source_rgba(gc, 1.0, 1.0, 0.2, 0.80);
-	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,
@@ -629,20 +712,7 @@ static void plot_pressure_value(struct graphics_context *gc, int mbar, int sec,
 	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);
 }
@@ -659,14 +729,21 @@ static void plot_cylinder_pressure_text(struct graphics_context *gc, struct plot
 	if (!get_cylinder_pressure_range(gc, pi))
 		return;
 
-	/* only loop over the actual events from the dive computer */
-	for (i = 2; i < pi->nr - 2; i++) {
+	/* only loop over the actual events from the dive computer
+	 * plus the second synthetic event at the start (to make sure
+	 * we get "time=0" right)
+	 * sadly with a recent change that first entry may no longer
+	 * have any pressure reading - in that case just grab the
+	 * pressure from the second entry */
+	if (GET_PRESSURE(pi->entry + 1) == 0 && GET_PRESSURE(pi->entry + 2) !=0)
+		INTERPOLATED_PRESSURE(pi->entry + 1) = GET_PRESSURE(pi->entry + 2);
+	for (i = 1; i < pi->nr; i++) {
 		entry = pi->entry + i;
 
 		if (!entry->same_cylinder) {
 			cyl = entry->cylinderindex;
 			if (!seen_cyl[cyl]) {
-				mbar = SENSOR_PRESSURE(entry) ? : INTERPOLATED_PRESSURE(entry);
+				mbar = GET_PRESSURE(entry);
 				plot_pressure_value(gc, mbar, entry->sec, LEFT, BOTTOM);
 				seen_cyl[cyl] = TRUE;
 			}
@@ -674,14 +751,14 @@ static void plot_cylinder_pressure_text(struct graphics_context *gc, struct plot
 				/* remember the last pressure and time of
 				 * the previous cylinder */
 				cyl = (entry - 1)->cylinderindex;
-				last_pressure[cyl] =
-					SENSOR_PRESSURE(entry - 1) ? : INTERPOLATED_PRESSURE(entry - 1);
+				last_pressure[cyl] = GET_PRESSURE(entry - 1);
 				last_time[cyl] = (entry - 1)->sec;
 			}
 		}
 	}
 	cyl = entry->cylinderindex;
-	last_pressure[cyl] = SENSOR_PRESSURE(entry) ? : INTERPOLATED_PRESSURE(entry);
+	if (GET_PRESSURE(entry))
+		last_pressure[cyl] = GET_PRESSURE(entry);
 	last_time[cyl] = entry->sec;
 
 	for (cyl = 0; cyl < MAX_CYLINDERS; cyl++) {
@@ -768,12 +845,10 @@ static struct plot_info *analyze_plot_info(struct plot_info *pi)
 	/* Do pressure min/max based on the non-surface data */
 	for (i = 0; i < nr; i++) {
 		struct plot_data *entry = pi->entry+i;
-		int pressure = SENSOR_PRESSURE(entry) ? : INTERPOLATED_PRESSURE(entry);
+		int pressure = GET_PRESSURE(entry);
 		int temperature = entry->temperature;
 
 		if (pressure) {
-			if (!pi->minpressure || pressure < pi->minpressure)
-				pi->minpressure = pressure;
 			if (pressure > pi->maxpressure)
 				pi->maxpressure = pressure;
 		}
@@ -887,8 +962,10 @@ static void fill_missing_tank_pressures(struct dive *dive, struct plot_info *pi,
 	for (cyl = 0; cyl < MAX_CYLINDERS; cyl++) {
 		cur_pr[cyl] = track_pr[cyl]->start;
 	}
-	/* The first two and last two entries are "fillers" */
-	for (i = 2; i < pi->nr-2; i++) {
+
+	/* The first two are "fillers", but in case we don't have a sample
+	 * at time 0 we need to process the second of them here */
+	for (i = 1; i < pi->nr; i++) {
 		entry = pi->entry + i;
 		if (SENSOR_PRESSURE(entry)) {
 			cur_pr[entry->cylinderindex] = SENSOR_PRESSURE(entry);
@@ -917,17 +994,20 @@ static void fill_missing_tank_pressures(struct dive *dive, struct plot_info *pi,
 				if (!nlist) {
 					/* just continue without calculating
 					 * interpolated values */
+					INTERPOLATED_PRESSURE(entry) = cur_pr[entry->cylinderindex];
 					list = NULL;
 					continue;
 				}
-				magic = (nlist->end - cur_pr[entry->cylinderindex]) / pt;				}
+				magic = (nlist->end - cur_pr[entry->cylinderindex]) / pt;
+			}
 			if (pt != 0.0) {
 				double cur_pt = (entry->sec - (entry-1)->sec) *
-					(1 + entry->depth / 10000.0);
+					(1 + (entry->depth + (entry-1)->depth) / 20000.0);
 				INTERPOLATED_PRESSURE(entry) =
 					cur_pr[entry->cylinderindex] + cur_pt * magic;
 				cur_pr[entry->cylinderindex] = INTERPOLATED_PRESSURE(entry);
-			}
+			} else
+				INTERPOLATED_PRESSURE(entry) = cur_pr[entry->cylinderindex];
 		}
 	}
 }
@@ -994,6 +1074,19 @@ static void check_gas_change_events(struct dive *dive, struct plot_info *pi)
 	set_cylinder_index(pi, i, cylinderindex, ~0u);
 }
 
+/* for computers that track gas changes through events */
+static int count_gas_change_events(struct dive *dive)
+{
+	int count = 0;
+	struct event *ev = get_next_gaschange(dive->events);
+
+	while (ev) {
+		count++;
+		ev = get_next_gaschange(ev->next);
+	}
+	return count;
+}
+
 /*
  * Create a plot-info with smoothing and ranged min/max
  *
@@ -1005,48 +1098,103 @@ static struct plot_info *create_plot_info(struct dive *dive, int nr_samples, str
 {
 	int cylinderindex = -1;
 	int lastdepth, lastindex;
-	int i, nr = nr_samples + 4, sec, cyl;
-	size_t alloc_size = plot_info_size(nr);
+	int i, pi_idx, nr, sec, cyl;
+	size_t alloc_size;
 	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 = NULL;
+	struct event *ev;
 
+	/* we want to potentially add synthetic plot_info elements for the gas changes */
+	nr = nr_samples + 4 + 2 * count_gas_change_events(dive);
+	alloc_size = plot_info_size(nr);
 	pi = malloc(alloc_size);
 	if (!pi)
 		return pi;
 	memset(pi, 0, alloc_size);
 	pi->nr = nr;
+	pi_idx = 2; /* the two extra events at the start */
+	/* check for gas changes before the samples start */
+	ev = get_next_gaschange(dive->events);
+	while (ev && ev->time.seconds < dive_sample->time.seconds) {
+		entry = pi->entry + pi_idx;
+		entry->sec = ev->time.seconds;
+		entry->depth = 0; /* is that always correct ? */
+		pi_idx++;
+		ev = get_next_gaschange(ev->next);
+	}
+	if (ev && ev->time.seconds == dive_sample->time.seconds) {
+		/* we already have a sample at the time of the event */
+		ev = get_next_gaschange(ev->next);
+	}
 	sec = 0;
 	lastindex = 0;
 	lastdepth = -1;
 	for (i = 0; i < nr_samples; i++) {
 		int depth;
+		int delay = 0;
 		struct sample *sample = dive_sample+i;
 
-		entry = pi->entry + i + 2;
-		sec = entry->sec = sample->time.seconds;
+		entry = pi->entry + i + pi_idx;
+		while (ev && ev->time.seconds < sample->time.seconds) {
+			/* insert two fake plot info structures for the end of
+			 * the old tank and the start of the new tank */
+			entry->sec = ev->time.seconds;
+			(entry+1)->sec = ev->time.seconds + 1;
+			/* we need a fake depth - let's interpolate */
+			if (i) {
+				entry->depth = sample->depth.mm -
+					(sample->depth.mm - (sample-1)->depth.mm) / 2;
+			} else
+				entry->depth = sample->depth.mm;
+			(entry+1)->depth = entry->depth;
+			pi_idx += 2;
+			entry = pi->entry + i + pi_idx;
+			ev = get_next_gaschange(ev->next);
+		}
+		if (ev && ev->time.seconds == sample->time.seconds) {
+			/* we already have a sample at the time of the event
+			 * just add a new one for the old tank and delay the
+			 * real even by one second (to keep time monotonous) */
+			entry->sec = ev->time.seconds;
+			entry->depth = sample->depth.mm;
+			pi_idx++;
+			entry = pi->entry + i + pi_idx;
+			ev = get_next_gaschange(ev->next);
+			delay = 1;
+		}
+		sec = entry->sec = sample->time.seconds + delay;
 		depth = entry->depth = sample->depth.mm;
 		entry->cylinderindex = sample->cylinderindex;
 		SENSOR_PRESSURE(entry) = sample->cylinderpressure.mbar;
 		entry->temperature = sample->temperature.mkelvin;
 
 		if (depth || lastdepth)
-			lastindex = i+2;
+			lastindex = i + pi_idx;
 
 		lastdepth = depth;
 		if (depth > pi->maxdepth)
 			pi->maxdepth = depth;
 	}
-
+	entry = pi->entry + i + pi_idx;
+	/* are there still unprocessed gas changes? that would be very strange */
+	while (ev) {
+		entry->sec = ev->time.seconds;
+		entry->depth = 0; /* why are there gas changes after the dive is over? */
+		pi_idx++;
+		entry = pi->entry + i + pi_idx;
+		ev = get_next_gaschange(ev->next);
+	}
+	nr = nr_samples + pi_idx - 2;
 	check_gas_change_events(dive, pi);
 
 	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[pi->entry[2].cylinderindex];
-	for (i = 0; i < nr_samples; i++) {
-		entry = pi->entry + i + 2;
+	for (i = 0; i < nr + 1; i++) {
+		entry = pi->entry + i + 1;
 
 		entry->same_cylinder = entry->cylinderindex == cylinderindex;
 		cylinderindex = entry->cylinderindex;
@@ -1070,7 +1218,7 @@ static struct plot_info *create_plot_info(struct dive *dive, int nr_samples, str
 		}
 		/* finally, do the discrete integration to get the SAC rate equivalent */
 		current->pressure_time += (entry->sec - (entry-1)->sec) *
-						(1 + entry->depth / 10000.0);
+			(1 + (entry->depth + (entry-1)->depth) / 20000.0);
 		missing_pr |= !SENSOR_PRESSURE(entry);
 	}
 
@@ -1084,17 +1232,34 @@ static struct plot_info *create_plot_info(struct dive *dive, int nr_samples, str
 			pr_track->end = pr;
 		}
 	}
-	if (lastdepth)
-		lastindex = i + 2;
-	/* Fill in the last two entries with empty values but valid times */
-	i = nr_samples + 2;
+	/* Fill in the last two entries with empty values but valid times
+	 * without creating a false cylinder change event */
+	i = nr + 2;
 	pi->entry[i].sec = sec + 20;
+	pi->entry[i].same_cylinder = 1;
+	pi->entry[i].cylinderindex = pi->entry[i-1].cylinderindex;
+	INTERPOLATED_PRESSURE(pi->entry + i) = GET_PRESSURE(pi->entry + i - 1);
 	pi->entry[i+1].sec = sec + 40;
+	pi->entry[i+1].same_cylinder = 1;
+	pi->entry[i+1].cylinderindex = pi->entry[i-1].cylinderindex;
+	INTERPOLATED_PRESSURE(pi->entry + i + 1) = GET_PRESSURE(pi->entry + i - 1);
+	/* the number of actual entries - some computers have lots of
+	 * depth 0 samples at the end of a dive, we want to make sure
+	 * we have exactly one of them at the end */
 	pi->nr = lastindex+1;
+	while (pi->nr <= i+2 && pi->entry[pi->nr-1].depth > 0)
+		pi->nr++;
 	pi->maxtime = pi->entry[lastindex].sec;
 
-	pi->endpressure = pi->minpressure = dive->cylinder[0].end.mbar;
-	pi->maxpressure = dive->cylinder[0].start.mbar;
+	/* Analyze_plot_info() will do the sample max pressures,
+	 * this handles the manual pressures
+	 */
+	pi->maxpressure = 0;
+	for (cyl = 0; cyl < MAX_CYLINDERS; cyl++) {
+		unsigned int mbar = dive->cylinder[cyl].start.mbar;
+		if (mbar > pi->maxpressure)
+			pi->maxpressure = mbar;
+	}
 
 	pi->meandepth = dive->meandepth.mm;
 
@@ -1103,6 +1268,8 @@ static struct plot_info *create_plot_info(struct dive *dive, int nr_samples, str
 	}
 	for (cyl = 0; cyl < MAX_CYLINDERS; cyl++)
 		list_free(track_pr[cyl]);
+	if (0) /* awesome for debugging - not useful otherwise */
+		dump_pi(pi);
 	return analyze_plot_info(pi);
 }
 
@@ -1145,13 +1312,13 @@ void plot(struct graphics_context *gc, cairo_rectangle_int_t *drawing_area, stru
 	/* Temperature profile */
 	plot_temperature_profile(gc, pi);
 
-	/* Cylinder pressure plot */
-	plot_cylinder_pressure(gc, pi);
-
 	/* Depth profile */
 	plot_depth_profile(gc, pi);
 	plot_events(gc, pi, dive);
 
+	/* Cylinder pressure plot */
+	plot_cylinder_pressure(gc, pi, dive);
+
 	/* Text on top of all graphs.. */
 	plot_temperature_text(gc, pi);
 	plot_depth_text(gc, pi);