X-Git-Url: http://git.tdb.fi/?p=ext%2Fsubsurface.git;a=blobdiff_plain;f=dive.c;h=aee09d53a8b37796fc6f2fa0e448f92102be745e;hp=b57205bc5ff096841cc0d0f3626265a650f9228f;hb=b693bb3fb962c54767f8430058575441df243b13;hpb=41a1cf4b1967c689f4c3dab60ac284a1313bb9b4

diff --git a/dive.c b/dive.c
index b57205b..aee09d5 100644
--- a/dive.c
+++ b/dive.c
@@ -26,6 +26,73 @@ void add_event(struct dive *dive, int time, int type, int flags, int value, cons
 	while (*p)
 		p = &(*p)->next;
 	*p = ev;
+	remember_event(name);
+}
+
+int get_pressure_units(unsigned int mb, const char **units)
+{
+	int pressure;
+	const char* unit;
+
+	switch (output_units.pressure) {
+	case PASCAL:
+		pressure = mb * 100;
+		unit = "pascal";
+		break;
+	case BAR:
+		pressure = (mb + 500) / 1000;
+		unit = "bar";
+		break;
+	case PSI:
+		pressure = mbar_to_PSI(mb);
+		unit = "psi";
+		break;
+	}
+	if (units)
+		*units = unit;
+	return pressure;
+}
+
+double get_temp_units(unsigned int mk, const char **units)
+{
+	double deg;
+	const char *unit;
+
+	if (output_units.temperature == FAHRENHEIT) {
+		deg = mkelvin_to_F(mk);
+		unit = UTF8_DEGREE "F";
+	} else {
+		deg = mkelvin_to_C(mk);
+		unit = UTF8_DEGREE "C";
+	}
+	if (units)
+		*units = unit;
+	return deg;
+}
+
+double get_volume_units(unsigned int ml, int *frac, const char **units)
+{
+	int decimals;
+	double vol;
+	const char *unit;
+
+	switch (output_units.volume) {
+	case LITER:
+		vol = ml / 1000.0;
+		unit = "l";
+		decimals = 1;
+		break;
+	case CUFT:
+		vol = ml_to_cuft(ml);
+		unit = "cuft";
+		decimals = 2;
+		break;
+	}
+	if (frac)
+		*frac = decimals;
+	if (units)
+		*units = unit;
+	return vol;
 }
 
 double get_depth_units(unsigned int mm, int *frac, const char **units)
@@ -53,6 +120,28 @@ double get_depth_units(unsigned int mm, int *frac, const char **units)
 	return d;
 }
 
+double get_weight_units(unsigned int grams, int *frac, const char **units)
+{
+	int decimals;
+	double value;
+	const char* unit;
+
+	if (output_units.weight == LBS) {
+		value = grams_to_lbs(grams);
+		unit = "lbs";
+		decimals = 0;
+	} else {
+		value = grams / 1000.0;
+		unit = "kg";
+		decimals = 1;
+	}
+	if (frac)
+		*frac = decimals;
+	if (units)
+		*units = unit;
+	return value;
+}
+
 struct dive *alloc_dive(void)
 {
 	const int initial_samples = 5;
@@ -93,7 +182,7 @@ struct sample *prepare_sample(struct dive **divep)
 	return NULL;
 }
 
-void finish_sample(struct dive *dive, struct sample *sample)
+void finish_sample(struct dive *dive)
 {
 	dive->samples++;
 }
@@ -140,64 +229,191 @@ static void update_temperature(temperature_t *temperature, int new)
 	}
 }
 
-/*
- * If you have more than 32 cylinders, you'd better have a 64-bit build.
- * And if you have more than 64 cylinders, you need to use another tool,
- * or fix this up to do something odd.
- */
-static unsigned long fixup_pressure(struct dive *dive, struct sample *sample, unsigned long flags)
+static void fixup_pressure(struct dive *dive, struct sample *sample)
 {
-	unsigned long mask;
 	unsigned int pressure, index;
 	cylinder_t *cyl;
 
 	pressure = sample->cylinderpressure.mbar;
 	if (!pressure)
-		return flags;
+		return;
 	index = sample->cylinderindex;
 	if (index >= MAX_CYLINDERS)
-		return flags;
+		return;
 	cyl = dive->cylinder + index;
-	if (!cyl->start.mbar)
-		cyl->start.mbar = pressure;
-	/*
-	 * If we already have an end pressure, without
-	 * ever having seen a sample for this cylinder,
-	 * that means that somebody set the end pressure
-	 * by hand
-	 */
-	mask = 1ul << index;
-	if (cyl->end.mbar) {
-		if (!(flags & mask))
-			return flags;
+	if (!cyl->sample_start.mbar)
+		cyl->sample_start.mbar = pressure;
+	cyl->sample_end.mbar = pressure;
+}
+
+/*
+ * If the cylinder tank pressures are within half a bar
+ * (about 8 PSI) of the sample pressures, we consider it
+ * to be a rounding error, and throw them away as redundant.
+ */
+static int same_rounded_pressure(pressure_t a, pressure_t b)
+{
+	return abs(a.mbar - b.mbar) <= 500;
+}
+
+static void sanitize_gasmix(struct gasmix *mix)
+{
+	unsigned int o2, he;
+
+	o2 = mix->o2.permille;
+	he = mix->he.permille;
+
+	/* Regular air: leave empty */
+	if (!he) {
+		if (!o2)
+			return;
+		/* 20.9% or 21% O2 is just air */
+		if (o2 >= 209 && o2 <= 210) {
+			mix->o2.permille = 0;
+			return;
+		}
 	}
-	flags |= mask;
-
-	/* we need to handle the user entering beginning and end tank pressures
-	 * - maybe even IF we have samples. But for now if we have air pressure
-	 * data in the samples, we use that instead of the minimum
-	 * if (!cyl->end.mbar || pressure < cyl->end.mbar)
-	 */
-	cyl->end.mbar = pressure;
-	return flags;
+
+	/* Sane mix? */
+	if (o2 <= 1000 && he <= 1000 && o2+he <= 1000)
+		return;
+	fprintf(stderr, "Odd gasmix: %d O2 %d He\n", o2, he);
+	memset(mix, 0, sizeof(*mix));
 }
 
-struct dive *fixup_dive(struct dive *dive)
+/*
+ * See if the size/workingpressure looks like some standard cylinder
+ * size, eg "AL80".
+ */
+static void match_standard_cylinder(cylinder_type_t *type)
+{
+	double cuft;
+	int psi, len;
+	const char *fmt;
+	char buffer[20], *p;
+
+	/* Do we already have a cylinder description? */
+	if (type->description)
+		return;
+
+	cuft = ml_to_cuft(type->size.mliter);
+	cuft *= to_ATM(type->workingpressure);
+	psi = to_PSI(type->workingpressure);
+
+	switch (psi) {
+	case 2300 ... 2500:	/* 2400 psi: LP tank */
+		fmt = "LP%d";
+		break;
+	case 2600 ... 2700:	/* 2640 psi: LP+10% */
+		fmt = "LP%d";
+		break;
+	case 2900 ... 3100:	/* 3000 psi: ALx tank */
+		fmt = "AL%d";
+		break;
+	case 3400 ... 3500:	/* 3442 psi: HP tank */
+		fmt = "HP%d";
+		break;
+	case 3700 ... 3850:	/* HP+10% */
+		fmt = "HP%d+";
+		break;
+	default:
+		return;
+	}
+	len = snprintf(buffer, sizeof(buffer), fmt, (int) (cuft+0.5));
+	p = malloc(len+1);
+	if (!p)
+		return;
+	memcpy(p, buffer, len+1);
+	type->description = p;
+}
+
+
+/*
+ * There are two ways to give cylinder size information:
+ *  - total amount of gas in cuft (depends on working pressure and physical size)
+ *  - physical size
+ *
+ * where "physical size" is the one that actually matters and is sane.
+ *
+ * We internally use physical size only. But we save the workingpressure
+ * so that we can do the conversion if required.
+ */
+static void sanitize_cylinder_type(cylinder_type_t *type)
+{
+	double volume_of_air, atm, volume;
+
+	/* If we have no working pressure, it had *better* be just a physical size! */
+	if (!type->workingpressure.mbar)
+		return;
+
+	/* No size either? Nothing to go on */
+	if (!type->size.mliter)
+		return;
+
+	if (input_units.volume == CUFT) {
+		/* confusing - we don't really start from ml but millicuft !*/
+		volume_of_air = cuft_to_l(type->size.mliter);
+		atm = to_ATM(type->workingpressure);		/* working pressure in atm */
+		volume = volume_of_air / atm;			/* milliliters at 1 atm: "true size" */
+		type->size.mliter = volume + 0.5;
+	}
+
+	/* Ok, we have both size and pressure: try to match a description */
+	match_standard_cylinder(type);
+}
+
+static void sanitize_cylinder_info(struct dive *dive)
 {
 	int i;
+
+	for (i = 0; i < MAX_CYLINDERS; i++) {
+		sanitize_gasmix(&dive->cylinder[i].gasmix);
+		sanitize_cylinder_type(&dive->cylinder[i].type);
+	}
+}
+
+struct dive *fixup_dive(struct dive *dive)
+{
+	int i,j;
 	double depthtime = 0;
 	int lasttime = 0;
+	int lastindex = -1;
 	int start = -1, end = -1;
 	int maxdepth = 0, mintemp = 0;
 	int lastdepth = 0;
-	int lasttemp = 0;
-	unsigned long flags = 0;
+	int lasttemp = 0, lastpressure = 0;
+	int pressure_delta[MAX_CYLINDERS] = {INT_MAX, };
 
+	sanitize_cylinder_info(dive);
 	for (i = 0; i < dive->samples; i++) {
 		struct sample *sample = dive->sample + i;
 		int time = sample->time.seconds;
 		int depth = sample->depth.mm;
 		int temp = sample->temperature.mkelvin;
+		int pressure = sample->cylinderpressure.mbar;
+		int index = sample->cylinderindex;
+
+		if (index == lastindex) {
+			/* Remove duplicate redundant pressure information */
+			if (pressure == lastpressure)
+				sample->cylinderpressure.mbar = 0;
+			/* check for simply linear data in the samples
+			   +INT_MAX means uninitialized, -INT_MAX means not linear */
+			if (pressure_delta[index] != -INT_MAX && lastpressure) {
+				if (pressure_delta[index] == INT_MAX) {
+					pressure_delta[index] = abs(pressure - lastpressure);
+				} else {
+					int cur_delta = abs(pressure - lastpressure);
+					if (cur_delta && abs(cur_delta - pressure_delta[index]) > 150) {
+						/* ok the samples aren't just a linearisation
+						 * between start and end */
+						pressure_delta[index] = -INT_MAX;
+					}
+				}
+			}
+		}
+		lastindex = index;
+		lastpressure = pressure;
 
 		if (lastdepth)
 			end = time;
@@ -209,7 +425,7 @@ struct dive *fixup_dive(struct dive *dive)
 				maxdepth = depth;
 		}
 
-		flags = fixup_pressure(dive, sample, flags);
+		fixup_pressure(dive, sample);
 
 		if (temp) {
 			/*
@@ -229,8 +445,47 @@ struct dive *fixup_dive(struct dive *dive)
 		lastdepth = depth;
 		lasttime = time;
 	}
-	if (end < 0)
+	/* if all the samples for a cylinder have pressure data that
+	 * is basically equidistant throw out the sample cylinder pressure
+	 * information but make sure we still have a valid start and end
+	 * pressure
+	 * this happens when DivingLog decides to linearalize the
+	 * pressure between beginning and end and for strange reasons
+	 * decides to put that in the sample data as if it came from
+	 * the dive computer; we don't want that (we'll visualize with
+	 * constant SAC rate instead)
+	 * WARNING WARNING - I have only seen this in single tank dives
+	 * --- maybe I should try to create a multi tank dive and see what
+	 * --- divinglog does there - but the code right now is only tested
+	 * --- for the single tank case */
+	for (j = 0; j < MAX_CYLINDERS; j++) {
+		if (abs(pressure_delta[j]) != INT_MAX) {
+			cylinder_t *cyl = dive->cylinder + j;
+			for (i = 0; i < dive->samples; i++)
+				if (dive->sample[i].cylinderindex == j)
+					dive->sample[i].cylinderpressure.mbar = 0;
+			if (! cyl->start.mbar)
+				cyl->start.mbar = cyl->sample_start.mbar;
+			if (! cyl->end.mbar)
+				cyl->end.mbar = cyl->sample_end.mbar;
+			cyl->sample_start.mbar = 0;
+			cyl->sample_end.mbar = 0;
+		}
+	}
+	if (end < 0) {
+		/* Assume an ascent/descent rate of 9 m/min */
+		int depth = dive->maxdepth.mm;
+		int asc_desc_time = depth*60/9000;
+		int duration = dive->duration.seconds;
+
+		/* Protect against insane dives - make mean be half of max */
+		if (duration <= asc_desc_time) {
+			duration = 2;
+			asc_desc_time = 1;
+		}
+		dive->meandepth.mm = depth*(duration-asc_desc_time)/duration;
 		return dive;
+	}
 
 	update_duration(&dive->duration, end - start);
 	if (start != end)
@@ -243,9 +498,18 @@ struct dive *fixup_dive(struct dive *dive)
 	add_people(dive->buddy);
 	add_people(dive->divemaster);
 	add_location(dive->location);
+	add_suit(dive->suit);
 	for (i = 0; i < MAX_CYLINDERS; i++) {
-		cylinder_type_t *type = &dive->cylinder[i].type;
-		add_cylinder_description(type);
+		cylinder_t *cyl = dive->cylinder + i;
+		add_cylinder_description(&cyl->type);
+		if (same_rounded_pressure(cyl->sample_start, cyl->start))
+			cyl->start.mbar = 0;
+		if (same_rounded_pressure(cyl->sample_end, cyl->end))
+			cyl->end.mbar = 0;
+	}
+	for (i = 0; i < MAX_WEIGHTSYSTEMS; i++) {
+		weightsystem_t *ws = dive->weightsystem + i;
+		add_weightsystem_description(ws);
 	}
 
 	return dive;
@@ -265,7 +529,7 @@ static struct dive *add_sample(struct sample *sample, int time, struct dive *div
 		return NULL;
 	*p = *sample;
 	p->time.seconds = time;
-	finish_sample(dive, p);
+	finish_sample(dive);
 	return dive;
 }
 
@@ -451,6 +715,8 @@ struct dive *try_to_merge(struct dive *a, struct dive *b)
 	MERGE_TXT(res, a, b, notes);
 	MERGE_TXT(res, a, b, buddy);
 	MERGE_TXT(res, a, b, divemaster);
+	MERGE_MAX(res, a, b, rating);
+	MERGE_TXT(res, a, b, suit);
 	MERGE_MAX(res, a, b, number);
 	MERGE_MAX(res, a, b, maxdepth.mm);
 	res->meandepth.mm = 0;