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

diff --git a/profile.c b/profile.c
index f1f3761..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);
@@ -102,9 +107,9 @@ static void dump_pi (struct plot_info *pi)
 	int i;
 
 	printf("pi:{nr:%d maxtime:%d meandepth:%d maxdepth:%d \n"
-		"    minpressure:%d maxpressure:%d endpressure:%d mintemp:%d maxtemp:%d\n",
+		"    maxpressure:%d mintemp:%d maxtemp:%d\n",
 		pi->nr, pi->maxtime, pi->meandepth, pi->maxdepth,
-		pi->minpressure, pi->maxpressure, pi->endpressure, pi->mintemp, pi->maxtemp);
+		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",
@@ -476,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);
@@ -595,55 +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 void plot_pressure_value(struct graphics_context *gc, int mbar, int sec,
@@ -671,14 +731,19 @@ static void plot_cylinder_pressure_text(struct graphics_context *gc, struct plot
 
 	/* 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) */
+	 * 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;
 			}
@@ -686,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++) {
@@ -780,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;
 		}
@@ -931,13 +994,15 @@ 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);
@@ -1153,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);
 	}
 
@@ -1167,10 +1232,17 @@ static struct plot_info *create_plot_info(struct dive *dive, int nr_samples, str
 			pr_track->end = pr;
 		}
 	}
-	/* Fill in the last two entries with empty values but valid times */
+	/* 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 */
@@ -1179,8 +1251,15 @@ static struct plot_info *create_plot_info(struct dive *dive, int nr_samples, str
 		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;
 
@@ -1233,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);