X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=dive.c;h=dad0e237bc8726f0c983ef73fdfa1d47fd8540c4;hb=4cff1f5b90217365d13ab2e2d5ff09b35590aab3;hp=32ea2ffe19a72f240df0638eafb1a9be3770a7d8;hpb=aa416e3c96dfa53db5ae277e72f6a03821c45cac;p=ext%2Fsubsurface.git

diff --git a/dive.c b/dive.c
index 32ea2ff..dad0e23 100644
--- a/dive.c
+++ b/dive.c
@@ -1,8 +1,125 @@
+/* dive.c */
+/* maintains the internal dive list structure */
 #include <string.h>
 #include <stdio.h>
 
 #include "dive.h"
 
+void add_event(struct dive *dive, int time, int type, int flags, int value, const char *name)
+{
+	struct event *ev, **p;
+	unsigned int size, len = strlen(name);
+
+	size = sizeof(*ev) + len + 1;
+	ev = malloc(size);
+	if (!ev)
+		return;
+	memset(ev, 0, size);
+	memcpy(ev->name, name, len);
+	ev->time.seconds = time;
+	ev->type = type;
+	ev->flags = flags;
+	ev->value = value;
+	ev->next = NULL;
+
+	p = &dive->events;
+	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)
+{
+	int decimals;
+	double d;
+	const char *unit;
+
+	switch (output_units.length) {
+	case METERS:
+		d = mm / 1000.0;
+		unit = "m";
+		decimals = d < 20;
+		break;
+	case FEET:
+		d = mm_to_feet(mm);
+		unit = "ft";
+		decimals = 0;
+		break;
+	}
+	if (frac)
+		*frac = decimals;
+	if (units)
+		*units = unit;
+	return d;
+}
+
 struct dive *alloc_dive(void)
 {
 	const int initial_samples = 5;
@@ -102,10 +219,19 @@ static void fixup_pressure(struct dive *dive, struct sample *sample)
 	if (index >= MAX_CYLINDERS)
 		return;
 	cyl = dive->cylinder + index;
-	if (!cyl->start.mbar)
-		cyl->start.mbar = pressure;
-	if (!cyl->end.mbar || pressure < cyl->end.mbar)
-		cyl->end.mbar = pressure;
+	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;
 }
 
 struct dive *fixup_dive(struct dive *dive)
@@ -117,7 +243,6 @@ struct dive *fixup_dive(struct dive *dive)
 	int maxdepth = 0, mintemp = 0;
 	int lastdepth = 0;
 	int lasttemp = 0;
-	temperature_t *redundant_temp = NULL;
 
 	for (i = 0; i < dive->samples; i++) {
 		struct sample *sample = dive->sample + i;
@@ -141,17 +266,12 @@ struct dive *fixup_dive(struct dive *dive)
 			/*
 			 * If we have consecutive identical
 			 * temperature readings, throw away
-			 * the redundant ones. We care about
-			 * the "edges" only.
+			 * the redundant ones.
 			 */
-			if (lasttemp == temp) {
-				if (redundant_temp)
-					redundant_temp->mkelvin = 0;
-				redundant_temp = &sample->temperature;
-			} else {
-				redundant_temp = NULL;
+			if (lasttemp == temp)
+				sample->temperature.mkelvin = 0;
+			else
 				lasttemp = temp;
-			}
 
 			if (!mintemp || temp < mintemp)
 				mintemp = temp;
@@ -171,12 +291,26 @@ struct dive *fixup_dive(struct dive *dive)
 	update_temperature(&dive->watertemp, mintemp);
 	update_depth(&dive->maxdepth, maxdepth);
 
+	add_people(dive->buddy);
+	add_people(dive->divemaster);
+	add_location(dive->location);
+	for (i = 0; i < MAX_CYLINDERS; i++) {
+		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;
+	}
+
 	return dive;
 }
 
 /* Don't pick a zero for MERGE_MIN() */
 #define MERGE_MAX(res, a, b, n) res->n = MAX(a->n, b->n)
 #define MERGE_MIN(res, a, b, n) res->n = (a->n)?(b->n)?MIN(a->n, b->n):(a->n):(b->n)
+#define MERGE_TXT(res, a, b, n) res->n = merge_text(a->n, b->n)
+#define MERGE_NONZERO(res, a, b, n) res->n = a->n ? a->n : b->n
 
 static struct dive *add_sample(struct sample *sample, int time, struct dive *dive)
 {
@@ -274,6 +408,59 @@ static char *merge_text(const char *a, const char *b)
 	return res;
 }
 
+#define SORT(a,b,field) \
+	if (a->field != b->field) return a->field < b->field ? -1 : 1
+
+static int sort_event(struct event *a, struct event *b)
+{
+	SORT(a,b,time.seconds);
+	SORT(a,b,type);
+	SORT(a,b,flags);
+	SORT(a,b,value);
+	return strcmp(a->name, b->name);
+}
+
+static void merge_events(struct dive *res, struct dive *src1, struct dive *src2, int offset)
+{
+	struct event *a, *b;
+	struct event **p = &res->events;
+
+	a = src1->events;
+	b = src2->events;
+	while (b) {
+		b->time.seconds += offset;
+		b = b->next;
+	}
+	b = src2->events;
+
+	while (a || b) {
+		int s;
+		if (!b) {
+			*p = a;
+			break;
+		}
+		if (!a) {
+			*p = b;
+			break;
+		}
+		s = sort_event(a, b);
+		/* Pick b */
+		if (s > 0) {
+			*p = b;
+			p = &b->next;
+			b = b->next;
+			continue;
+		}
+		/* Pick 'a' or neither */
+		if (s < 0) {
+			*p = a;
+			p = &a->next;
+		}
+		a = a->next;
+		continue;
+	}
+}
+
 /* Pick whichever has any info (if either). Prefer 'a' */
 static void merge_cylinder_type(cylinder_type_t *res, cylinder_type_t *a, cylinder_type_t *b)
 {
@@ -307,14 +494,18 @@ struct dive *try_to_merge(struct dive *a, struct dive *b)
 	int i;
 	struct dive *res;
 
-	if (a->when != b->when)
+	if ((a->when >= b->when + 60) || (a->when <= b->when - 60))
 		return NULL;
 
 	res = alloc_dive();
 
 	res->when = a->when;
-	res->location = merge_text(a->location, b->location);
-	res->notes = merge_text(a->notes, b->notes);
+	MERGE_NONZERO(res, a, b, latitude);
+	MERGE_NONZERO(res, a, b, longitude);
+	MERGE_TXT(res, a, b, location);
+	MERGE_TXT(res, a, b, notes);
+	MERGE_TXT(res, a, b, buddy);
+	MERGE_TXT(res, a, b, divemaster);
 	MERGE_MAX(res, a, b, number);
 	MERGE_MAX(res, a, b, maxdepth.mm);
 	res->meandepth.mm = 0;
@@ -324,6 +515,6 @@ struct dive *try_to_merge(struct dive *a, struct dive *b)
 	MERGE_MIN(res, a, b, watertemp.mkelvin);
 	for (i = 0; i < MAX_CYLINDERS; i++)
 		merge_cylinder_info(res->cylinder+i, a->cylinder + i, b->cylinder + i);
-
+	merge_events(res, a, b, 0);
 	return merge_samples(res, a, b, 0);
 }