Profile support for multiple concurrent pressure sensors

This finally handles multiple cylinder pressures, both overlapping and
consecutive, and it seems to work on the nasty cases I've thrown at it.

Want to just track five different cylinders all at once, without any
pesky gas switch events? Sure, you can do that.  It will show five
different gas pressures for your five cylinders, and they will go down
as you breathe down the cylinders.

I obviously don't have any real data for that case, but I do have a test
file with five actual cylinders that all have samples over the whole
course of the dive.  The end result looks messy as hell, but what did
you expect?

HOWEVER.

The only way to do this sanely was

 - actually make the "struct plot_info" have all the cylinder pressures
   (so no "sensor index and pressure" - every cylinder has a pressure for
   every plot info entry)

   This obviously makes the plot_info much bigger. We used to have
   MAX_CYLINDERS be a fairly generous 8, which seems sane. The planning
   code made that 8 be 20. That seems questionable. But whatever.

   The good news is that the plot-info should hopefully get freed, and
   only be allocated one dive at a time, so the fact that it is big and
   nasty shouldn't be a scaling issue, though.

 - the "populate_pressure_information()" function had to be rewritten
   quite a bit. The good news is that it's actually simpler now, although
   I would not go so far as to really call it simple. It's still
   complicated and suble, but now it explicitly just does one cylinder at
   a time.

   It *used* to have this insanely complicated "keep track of the pressure
   ranges for every cylinder at once". I just couldn't stand that model
   and keep my sanity, so it now just tracks one cylinder at a time, and
   doesn't have an array of live data, instead the caller will just call
   it for each cylinder.

 - get rid of some of our hackier stuff, like the code that populates the
   plot_info data code with the currently selected cylinder number, and
   clears out any other pressures. That obviously does *not* work when you
   may not have a single primary cylinder any more.

Now, the above sounds like all good things. Yeah, it mostly is.

BUT.

There's a few big downsides from the above:

 - there's no sane way to do this as a series of small changes.

   The change to make the plot_info take an array of cylinder pressures
   rather than the sensor+pressure model really isn't amenable to "fix up
   one use at a time". When you switch over to the new data structure
   model, you have to switch over to the new way of populating the
   pressure ranges. The two just go hand in hand.

 - Some of our code *depended* on the "sensor+pressure" model. I fixed all
   the ones I could sanely fix. There was one particular case that I just
   couldn't sanely fix, and I didn't care enough about it to do something
   insane.

   So the only _known_ breakage is the "TankItem" profile widget. That's
   the bar at the bottom of the profile that shows which cylinder is in
   use right now. You'd think that would be trivial to fix up, and yes it
   would be - I could just use the regular model of

     firstcyl = explicit_first_cylinder(dive, dc)
     .. then iterate over the gas change events to see the others ..

   but the problem with the "TankItem" widget is that it does its own
   model, and it has thrown away the dive and the dive computer
   information. It just doesn't even know. It only knows what cylinders
   there are, and the plot_info. And it just used to look at the sensor
   number in the plot_info, and be done with that. That number no longer
   exists.

 - I have tested it, and I think the code is better, but hey, it's a
   fairly large patch to some of the more complex code in our code base.
   That "interpolate missing pressure fields" code really isn't pretty. It
   may be prettier, but..

Anyway, without further ado, here's the patch. No sign-off yet, because I
do think people should look and comment. But I think the patch is fine,
and I'll fix anythign that anybody can find, *except* for that TankItem
thing that I will refuse to touch. That class is ugly. It needs to have
access to the actual dive.

Note how it actually does remove more lines than it adds, and that's
despite added comments etc. The code really is simpler, but there may be
cases in there that need more work.

Known missing pieces that don't currently take advantage of concurrent
cylinder pressure data:

 - the momentary SAC rate coloring for dives will need more work

 - dive merging (but we expect to generally normally not merge dive
   computers, which is the main source of sensor data)

 - actually taking advantage of different sensor data from different
   dive computers

But most of all: Testing.  Lots and lots of testing to find all the
corner cases.

Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>

1 files changed, 61 insertions, 70 deletions

diff --git a/profile-widget/diveprofileitem.cpp b/profile-widget/diveprofileitem.cpp
index fcaca3a88..6f2bf98b0 100644
--- a/profile-widget/diveprofileitem.cpp
+++ b/profile-widget/diveprofileitem.cpp
@@ -683,108 +683,99 @@ void DiveGasPressureItem::modelDataChanged(const QModelIndex &topLeft, const QMo
 	// We don't have enougth data to calculate things, quit.
 	if (!shouldCalculateStuff(topLeft, bottomRight))
 		return;
-	int last_index = -1;
-	QPolygonF boundingPoly, o2Poly; // This is the "Whole Item", but a pressure can be divided in N Polygons.
+
+	int plotted_cyl[MAX_CYLINDERS] = { false, };
+	int last_plotted[MAX_CYLINDERS] = { 0, };
+	QPolygonF poly[MAX_CYLINDERS];
+	QPolygonF boundingPoly;
 	polygons.clear();
-	polygons.append(o2Poly);
 
 	for (int i = 0, count = dataModel->rowCount(); i < count; i++) {
-		plot_data *entry = dataModel->data().entry + i;
-		int mbar = GET_PRESSURE(entry, 0);
-		int o2mbar = GET_PRESSURE(entry, 1);
+		struct plot_data *entry = dataModel->data().entry + i;
 
-		if ((int)entry->sensor[0] != last_index) {
-			polygons.append(QPolygonF()); // this is the polygon that will be actually drawn on screen.
-			last_index = entry->sensor[0];
-		}
-		if (!mbar) {
-			continue;
-		}
-		if (o2mbar) {
-			QPointF o2point(hAxis->posAtValue(entry->sec), vAxis->posAtValue(o2mbar));
-			boundingPoly.push_back(o2point);
-			polygons.first().push_back(o2point);
+		for (int cyl = 0; cyl < MAX_CYLINDERS; cyl++) {
+			int mbar = GET_PRESSURE(entry, cyl);
+			int time = entry->sec;
+
+			if (!mbar)
+				continue;
+
+			QPointF point(hAxis->posAtValue(time), vAxis->posAtValue(mbar));
+			boundingPoly.push_back(point);
+
+			if (plotted_cyl[cyl]) {
+				/* Have we used this culinder in the last two minutes? Continue */
+				if (time - last_plotted[cyl] <= 2*60) {
+					poly[cyl].push_back(point);
+					last_plotted[cyl] = time;
+					continue;
+				}
+
+				/* Finish the previous one, start a new one */
+				polygons.append(poly[cyl]);
+				poly[cyl] = QPolygonF();
+			}
+
+			plotted_cyl[cyl] = true;
+			last_plotted[cyl] = time;
+			poly[cyl].push_back(point);
 		}
+	}
 
-		QPointF point(hAxis->posAtValue(entry->sec), vAxis->posAtValue(mbar));
-		boundingPoly.push_back(point);    // The BoundingRect
-		polygons.last().push_back(point); // The polygon thta will be plotted.
+	for (int cyl = 0; cyl < MAX_CYLINDERS; cyl++) {
+		if (!plotted_cyl[cyl])
+			continue;
+		polygons.append(poly[cyl]);
 	}
+
 	setPolygon(boundingPoly);
 	qDeleteAll(texts);
 	texts.clear();
-	int mbar, cyl, lastcyl;
-	int o2mbar, o2cyl;
+
 	int seen_cyl[MAX_CYLINDERS] = { false, };
 	int last_pressure[MAX_CYLINDERS] = { 0, };
 	int last_time[MAX_CYLINDERS] = { 0, };
-	struct plot_data *entry;
-
-	cyl = o2cyl = lastcyl = -1;
-	mbar = o2mbar = 0;
 
 	double print_y_offset[8][2] = { { 0, -0.5 }, { 0, -0.5 }, { 0, -0.5 }, { 0, -0.5 }, { 0, -0.5 } ,{ 0, -0.5 }, { 0, -0.5 }, { 0, -0.5 } };
-	// CCR dives: These are offset values used to print the gas lables and pressures on a CCR dive profile at
-	// appropriate Y-coordinates: One doublet of values for each of 8 cylinders.
+	// These are offset values used to print the gas lables and pressures on a
+	// dive profile at appropriate Y-coordinates: One doublet of values for each
+	// of 8 cylinders.
 	// Order of offsets within a doublet: gas lable offset; gas pressure offset.
 	// The array is initialised with default values that apply to non-CCR dives.
 
-	bool offsets_initialised = false;
-	QFlags<Qt::AlignmentFlag> alignVar= Qt::AlignTop, align_dil = Qt::AlignBottom, align_o2 = Qt::AlignTop;
+	QFlags<Qt::AlignmentFlag> alignVar = Qt::AlignTop;
+	QFlags<Qt::AlignmentFlag> align[MAX_CYLINDERS];
+
 	double axisRange = (vAxis->maximum() - vAxis->minimum())/1000;	// Convert axis pressure range to bar
 	double axisLog = log10(log10(axisRange));
+
 	for (int i = 0, count = dataModel->rowCount(); i < count; i++) {
-		entry = dataModel->data().entry + i;
-
-		cyl = entry->sensor[0];
-		o2cyl = entry->sensor[1];
-		mbar = GET_PRESSURE(entry, 0);
-		o2mbar = GET_PRESSURE(entry, 1);
-
-		if (o2mbar) {	//  Do we have a second cylinder pressure? If so, do
-				// The first time an o2 value is detected, see if the oxygen cyl pressure graph starts above or below the dil graph
-			if (!offsets_initialised) {	// Initialise the parameters for placing the text correctly near the graph line:
-				if ((o2mbar > mbar)) {	// If above, write o2 start cyl pressure above graph and diluent pressure below graph:
-					print_y_offset[o2cyl][0] = -7 * axisLog; // y offset for oxygen gas lable (above); pressure offsets=-0.5, already initialised
-					print_y_offset[cyl][0] = 5 * axisLog; // y offset for diluent gas lable (below)
-				} else {				// ... else write o2 start cyl pressure below graph:
-					print_y_offset[o2cyl][0]  = 5 * axisLog; // o2 lable & pressure below graph; pressure offsets=-0.5, already initialised
-					print_y_offset[cyl][0] = -7.8 * axisLog;  // and diluent lable above graph.
-					align_dil = Qt::AlignTop;
-					align_o2  = Qt::AlignBottom;
-				}
-				offsets_initialised = true;
-			}
+		struct plot_data *entry = dataModel->data().entry + i;
 
-			if (!seen_cyl[o2cyl]) {	//For o2, on the left of profile, write lable and pressure
-				plotPressureValue(o2mbar, entry->sec, align_o2, print_y_offset[o2cyl][1]);
-				plotGasValue(o2mbar, entry->sec, displayed_dive.cylinder[o2cyl].gasmix, align_o2, print_y_offset[o2cyl][0]);
-				seen_cyl[o2cyl] = true;
-			}
-			last_pressure[o2cyl] = o2mbar;
-			last_time[o2cyl] = entry->sec;
-			alignVar = align_dil;
-		}
+		for (int cyl = 0; cyl < MAX_CYLINDERS; cyl++) {
+			int mbar = GET_PRESSURE(entry, cyl);
 
-		if (!mbar)
-			continue;
+			if (!mbar)
+				continue;
 
-		if (cyl != lastcyl) {		// Pressure value near the left hand edge of the profile - other cylinders:
-			lastcyl = cyl;		// For each other cylinder, write the gas lable and pressure
 			if (!seen_cyl[cyl]) {
 				plotPressureValue(mbar, entry->sec, alignVar, print_y_offset[cyl][1]);
-				plotGasValue(mbar, entry->sec, displayed_dive.cylinder[cyl].gasmix, align_dil, print_y_offset[cyl][0]);
+				plotGasValue(mbar, entry->sec, displayed_dive.cylinder[cyl].gasmix, alignVar, print_y_offset[cyl][0]);
 				seen_cyl[cyl] = true;
+
+				/* Alternate alignment as we see cylinder use.. */
+				align[cyl] = alignVar;
+				alignVar ^= Qt::AlignTop | Qt::AlignBottom;
 			}
+			last_pressure[cyl] = mbar;
+			last_time[cyl] = entry->sec;
 		}
-		last_pressure[cyl] = mbar;
-		last_time[cyl] = entry->sec;
 	}
 
-	for (cyl = 0; cyl < MAX_CYLINDERS; cyl++) {	// For each cylinder, on right hand side of profile, write cylinder pressure
-		alignVar = ((o2cyl >= 0) && (cyl == o2cyl)) ? align_o2 : align_dil;
+	// For each cylinder, on right hand side of profile, write cylinder pressure
+	for (int cyl = 0; cyl < MAX_CYLINDERS; cyl++) {
 		if (last_time[cyl]) {
-			plotPressureValue(last_pressure[cyl], last_time[cyl], (alignVar | Qt::AlignLeft), print_y_offset[cyl][1]);
+			plotPressureValue(last_pressure[cyl], last_time[cyl], align[cyl] | Qt::AlignLeft, print_y_offset[cyl][1]);
 		}
 	}
 }