#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;
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)
{
- int i;
+ 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;
+ int lasttemp = 0, lastpressure = 0;
+ int pressure_delta[MAX_CYLINDERS] = {INT_MAX, };
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;
lastdepth = depth;
lasttime = time;
}
+ /* 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)
return 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)
{
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)
{
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, rating);
MERGE_MAX(res, a, b, number);
MERGE_MAX(res, a, b, maxdepth.mm);
res->meandepth.mm = 0;
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);
}