Keep track of data ranges as data is added

This avoids the need to loop over the data to find its range just
before drawing. This is in preparation for code that will allow for a
custom viewing range (such as for zooming) rather than always
displaying all available data.

diff --git a/acre.c b/acre.c
index b844d755153911710ebad19570b710a06d37a2db..92ee39beea6aa92e8e623d3c7ab0d9c36e4db63c 100644 (file)
--- a/acre.c
+++ b/acre.c
@@ -38,6 +38,9 @@ typedef struct _acre_data_point_2d {
 struct _acre_data {
     char *name;
 
+    acre_data_point_2d_t min;
+    acre_data_point_2d_t max;
+
     acre_data_point_2d_t *points;
     unsigned int points_size;
     unsigned int num_points;
@@ -45,8 +48,10 @@ struct _acre_data {
 
 typedef struct _acre_axis {
     char *label;
-    double min;
-    double max;
+    double data_min;
+    double data_max;
+    double view_min;
+    double view_max;
 } acre_axis_t;
 
 typedef struct _acre_color {
@@ -90,12 +95,16 @@ acre_create (void)
     acre->title = NULL;
 
     acre->x_axis.label = NULL;
-    acre->x_axis.min = 0.0;
-    acre->x_axis.max = 0.0;
+    acre->x_axis.data_min = 0.0;
+    acre->x_axis.data_max = 0.0;
+    acre->x_axis.view_min = 0.0;
+    acre->x_axis.view_max = 0.0;
 
     acre->y_axis.label = NULL;
-    acre->y_axis.min = 0.0;
-    acre->y_axis.max = 0.0;
+    acre->y_axis.data_min = 0.0;
+    acre->y_axis.data_max = 0.0;
+    acre->y_axis.view_min = 0.0;
+    acre->y_axis.view_max = 0.0;
 
     acre->data = NULL;
     acre->data_size = 0;
@@ -176,6 +185,25 @@ acre_add_data (acre_t *acre, acre_data_t *data)
     }
 
     acre->data[acre->num_data] = data;
+
+    if (acre->num_data == 0) {
+       acre->x_axis.data_min = data->min.x;
+       acre->y_axis.data_min = data->min.y;
+
+       acre->x_axis.data_max = data->max.x;
+       acre->y_axis.data_max = data->max.y;
+    } else {
+       if (data->min.x < acre->x_axis.data_min)
+           acre->x_axis.data_min = data->min.x;
+       if (data->min.y < acre->y_axis.data_min)
+           acre->y_axis.data_min = data->min.y;
+
+       if (data->max.x > acre->x_axis.data_max)
+           acre->x_axis.data_max = data->max.x;
+       if (data->max.y > acre->y_axis.data_max)
+           acre->y_axis.data_max = data->max.y;
+    }
+
     acre->num_data++;
 }
 
@@ -285,9 +313,9 @@ _draw_title_and_labels (acre_t *acre)
     y_axis_layout = _create_layout (acre, acre->y_axis.label);
 
     min_y = _create_layout_printf (acre, "%g",
-                                  round (acre->y_axis.min));
+                                  round (acre->y_axis.view_min));
     max_y = _create_layout_printf (acre, "%g",
-                                  round (acre->y_axis.max));
+                                  round (acre->y_axis.view_max));
 
     pango_layout_get_pixel_size (min_y, &min_y_width, NULL);
     pango_layout_get_pixel_size (max_y, &max_y_width, NULL);
@@ -434,39 +462,23 @@ _set_transform_to_data_space (acre_t *acre)
                     acre->chart.x,
                     acre->chart.y + acre->chart.height);
     cairo_scale (cr,
-                acre->chart.width / (acre->x_axis.max - acre->x_axis.min),
-                - acre->chart.height /(acre->y_axis.max - acre->y_axis.min));
-    cairo_translate (cr, -acre->x_axis.min, -acre->y_axis.min);
+                acre->chart.width / (acre->x_axis.view_max - acre->x_axis.view_min),
+                - acre->chart.height /(acre->y_axis.view_max - acre->y_axis.view_min));
+    cairo_translate (cr, -acre->x_axis.view_min, -acre->y_axis.view_min);
 }
 
 static void
 _compute_axis_ranges (acre_t *acre)
 {
-    unsigned int d, i;
-    acre_data_t *data;
     double x_adjust, y_adjust;
     cairo_t *cr = acre->cr;
 
-    acre->x_axis.min = acre->data[0]->points[0].x;
-    acre->x_axis.max = acre->data[0]->points[0].x;
-    acre->y_axis.min = acre->data[0]->points[0].y;
-    acre->y_axis.min = acre->data[0]->points[0].y;
+    /* First, simply set view ranges to data ranges. */
+    acre->x_axis.view_min = acre->x_axis.data_min;
+    acre->x_axis.view_max = acre->x_axis.data_max;
 
-    /* First, simply find the extrema of the data. */
-    for (d = 0; d < acre->num_data; d++) {
-       data = acre->data[d];
-       for (i = 0; i < data->num_points; i++) {
-           if (data->points[i].x < acre->x_axis.min)
-               acre->x_axis.min = data->points[i].x;
-           if (data->points[i].x > acre->x_axis.max)
-               acre->x_axis.max = data->points[i].x;
-
-           if (data->points[i].y < acre->y_axis.min)
-               acre->y_axis.min = data->points[i].y;
-           if (data->points[i].y > acre->y_axis.max)
-               acre->y_axis.max = data->points[i].y;
-       }
-    }
+    acre->y_axis.view_min = acre->y_axis.data_min;
+    acre->y_axis.view_max = acre->y_axis.data_max;
 
     /* Next, we want to ensure that the data never collides with the
      * ticks. So we expand each axis on its minimum side as needed. */
@@ -480,20 +492,20 @@ _compute_axis_ranges (acre_t *acre)
        y = ACRE_TICK_MAJOR_SIZE + 2.0;
        cairo_device_to_user_distance (cr, &x, &y);
 
-       acre->x_axis.min -= x;
-       acre->y_axis.min += y;
+       acre->x_axis.view_min -= x;
+       acre->y_axis.view_min += y;
     }
     cairo_restore (cr);
 
     /* Then, increase the axis ranges just enough so that the step
      * sizes for the ticks will be integers.
      */
-    _expand_range_for_width (&acre->x_axis.min,
-                            &acre->x_axis.max,
+    _expand_range_for_width (&acre->x_axis.view_min,
+                            &acre->x_axis.view_max,
                             acre->chart.width);
 
-    _expand_range_for_width (&acre->y_axis.min,
-                            &acre->y_axis.max,
+    _expand_range_for_width (&acre->y_axis.view_min,
+                            &acre->y_axis.view_max,
                             acre->chart.height);
 
     /* Finally, we also translate the axis ranges slightly so that the
@@ -510,11 +522,11 @@ _compute_axis_ranges (acre_t *acre)
        y_adjust = (round (y_adjust + 0.5) - 0.5) - y_adjust;
        cairo_device_to_user_distance (cr, &x_adjust, &y_adjust);
 
-       acre->x_axis.min -= x_adjust;
-       acre->x_axis.max -= x_adjust;
+       acre->x_axis.view_min -= x_adjust;
+       acre->x_axis.view_max -= x_adjust;
 
-       acre->y_axis.min -= y_adjust;
-       acre->y_axis.max -= y_adjust;
+       acre->y_axis.view_min -= y_adjust;
+       acre->y_axis.view_max -= y_adjust;
     }
     cairo_restore (cr);
 }
@@ -681,9 +693,9 @@ _draw_ticks (acre_t *acre,
        cairo_save (cr);
        {
            if (ticks == ACRE_TICKS_X)
-               cairo_move_to (cr, t, acre->y_axis.min);
+               cairo_move_to (cr, t, acre->y_axis.view_min);
            else
-               cairo_move_to (cr, acre->x_axis.min, t);
+               cairo_move_to (cr, acre->x_axis.view_min, t);
 
            cairo_identity_matrix (cr);
 
@@ -711,9 +723,9 @@ _draw_ticks (acre_t *acre,
            layout = _create_layout_printf (acre, "%g", t);
 
            if (ticks == ACRE_TICKS_X)
-               cairo_move_to (cr, t, acre->y_axis.min);
+               cairo_move_to (cr, t, acre->y_axis.view_min);
            else
-               cairo_move_to (cr, acre->x_axis.min, t);
+               cairo_move_to (cr, acre->x_axis.view_min, t);
 
            cairo_identity_matrix (cr);
            pango_layout_get_pixel_size (layout, &width, &height);
@@ -801,8 +813,8 @@ _draw_frame_and_ticks (acre_t *acre)
     cairo_set_source_rgb (cr, 0, 0, 0); /* black */
 
     /* ticks */
-    _draw_ticks (acre, acre->x_axis.min, acre->x_axis.max, ACRE_TICKS_X);
-    _draw_ticks (acre, acre->y_axis.min, acre->y_axis.max, ACRE_TICKS_Y);
+    _draw_ticks (acre, acre->x_axis.view_min, acre->x_axis.view_max, ACRE_TICKS_X);
+    _draw_ticks (acre, acre->y_axis.view_min, acre->y_axis.view_max, ACRE_TICKS_Y);
 
     /* frame */
     cairo_rectangle (cr,
@@ -906,5 +918,24 @@ acre_data_add_point_2d (acre_data_t *data, double x, double y)
 
     data->points[data->num_points].x = x;
     data->points[data->num_points].y = y;
+
+    if (data->num_points == 0) {
+       data->min.x = x;
+       data->min.y = y;
+
+       data->max.x = x;
+       data->max.y = y;
+    } else {
+       if (x < data->min.x)
+           data->min.x = x;
+       if (y < data->min.y)
+           data->min.y = y;
+
+       if (x > data->max.x)
+           data->max.x = x;
+       if (y > data->max.y)
+           data->max.y = y;
+    }
+
     data->num_points++;
 }