X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=acre.c;h=a01dbe5c2f1275c0c4f77b049844c8220b2c69e8;hb=5897f1f7f868e2fdfa51fc8e3bb9e02d49171b2b;hp=e7b4a0f82b1984dfe47a093ad0252a6d7bb3539a;hpb=fb885ce6b3cdd5cde8b3c21821b49e2a82f6f11f;p=acre

diff --git a/acre.c b/acre.c
index e7b4a0f..a01dbe5 100644
--- a/acre.c
+++ b/acre.c
@@ -17,10 +17,15 @@
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  */
 
+#define _ISOC99_SOURCE /* for round() */
+#define _XOPEN_SOURCE 500
+#define _GNU_SOURCE /* for asprintf() */
+
 #include "acre.h"
 #include "xmalloc.h"
 
 #include <string.h>
+#include <stdarg.h>
 #include <math.h>
 
 typedef struct _acre_data_point_2d {
@@ -36,14 +41,31 @@ struct _acre_data {
     unsigned int num_points;
 };
 
+typedef struct _acre_axis {
+    char *label;
+    double min;
+    double max;
+} acre_axis_t;
+
 struct _acre {
     char *title;
-    char *x_axis_label;
-    char *y_axis_label;
+    acre_axis_t x_axis;
+    acre_axis_t y_axis;
 
     acre_data_t **data;
     unsigned int data_size;
     unsigned int num_data;
+
+    /* Data for drawing. */
+    cairo_t *cr;
+    PangoFontDescription *font;
+
+    /* Total size including labels. */
+    int width;
+    int height;
+
+    /* Position and size of chart alone. */
+    PangoRectangle chart;
 };
 
 /* Create a new, empty plot. */
@@ -55,13 +77,24 @@ acre_create (void)
     acre = xmalloc (sizeof (acre_t));
 
     acre->title = NULL;
-    acre->x_axis_label = NULL;
-    acre->y_axis_label = NULL;
+
+    acre->x_axis.label = NULL;
+    acre->x_axis.min = 0.0;
+    acre->x_axis.max = 0.0;
+
+    acre->y_axis.label = NULL;
+    acre->y_axis.min = 0.0;
+    acre->y_axis.max = 0.0;
 
     acre->data = NULL;
     acre->data_size = 0;
     acre->num_data = 0;
 
+    acre->chart.x = 0;
+    acre->chart.y = 0;
+    acre->chart.width = 0;
+    acre->chart.height = 0;
+
     return acre;
 }
 
@@ -72,8 +105,8 @@ acre_destroy (acre_t *acre)
     unsigned int i;
 
     free (acre->title);
-    free (acre->x_axis_label);
-    free (acre->y_axis_label);
+    free (acre->x_axis.label);
+    free (acre->y_axis.label);
 
     for (i = 0; i < acre->num_data; i++)
 	acre_data_destroy (acre->data[i]);
@@ -94,17 +127,17 @@ acre_set_title (acre_t *acre, const char *title)
 void
 acre_set_x_axis_label (acre_t *acre, const char *label)
 {
-    free (acre->x_axis_label);
+    free (acre->x_axis.label);
 
-    acre->x_axis_label = strdup (label);
+    acre->x_axis.label = strdup (label);
 }
 
 void
 acre_set_y_axis_label (acre_t *acre, const char *label)
 {
-    free (acre->y_axis_label);
+    free (acre->y_axis.label);
 
-    acre->y_axis_label = strdup (label);
+    acre->y_axis.label = strdup (label);
 }
 
 /* Add a dataset to the plot. The plot assumes ownership of the
@@ -129,32 +162,91 @@ acre_add_data (acre_t *acre, acre_data_t *data)
 #define ACRE_FONT_SIZE 12
 #define ACRE_TITLE_FONT_SIZE 32
 #define ACRE_PAD (ACRE_FONT_SIZE)
-#define ACRE_TICK_SIZE 4
+#define ACRE_TICK_SIZE 6
+#define ACRE_X_TICK_VALUE_PAD 2
+#define ACRE_Y_TICK_VALUE_PAD 4
 
-/* Draw the plot to the given cairo context within a user-space
- * rectangle from (0, 0) to (width, height). This size includes all
- * space for extra-plot elements (such as the title, the axis labels,
- * etc.)
- */
-void
-acre_draw (acre_t *acre, cairo_t *cr, double width, double height)
+static PangoLayout *
+_create_layout (acre_t *acre, const char *text)
+{
+    PangoLayout *layout;
+
+    layout = pango_cairo_create_layout (acre->cr);
+    pango_layout_set_font_description (layout, acre->font);
+    pango_layout_set_text (layout, text, -1);
+    pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
+
+    return layout;
+}
+
+#define PRINTF_FORMAT(fmt_index, va_index) __attribute__ ((__format__(__printf__, fmt_index, va_index)))
+
+static PangoLayout *
+_create_layout_vprintf (acre_t *acre, const char *fmt, va_list ap)
+{
+    PangoLayout *layout;
+    char *text;
+
+    vasprintf (&text, fmt, ap);
+
+    layout = _create_layout (acre, text);
+
+    free (text);
+
+    return layout;
+}
+
+static PangoLayout *
+_create_layout_printf (acre_t *acre, const char *fmt, ...)
+    PRINTF_FORMAT (2, 3);
+
+static PangoLayout *
+_create_layout_printf (acre_t *acre, const char *fmt, ...)
+{
+    va_list ap;
+    PangoLayout *layout;
+
+    va_start (ap, fmt);
+
+    layout = _create_layout_vprintf (acre, fmt, ap);
+
+    va_end (ap);
+
+    return layout;
+}
+
+static void
+_destroy_layout (PangoLayout *layout)
+{
+    g_object_unref (layout);
+}
+
+static void
+_show_layout (cairo_t *cr, PangoLayout *layout)
 {
-    PangoFontDescription *acre_font, *title_font;
+    pango_cairo_show_layout (cr, layout);
+
+    _destroy_layout (layout);
+}
+
+static void
+_draw_title_and_labels (acre_t *acre)
+{
+    cairo_t *cr = acre->cr;
+    PangoFontDescription *title_font;
     PangoLayout *title_layout, *x_axis_layout, *y_axis_layout;
+    PangoLayout *min_y, *max_y;
+    int min_y_width, max_y_width, y_axis_value_width;
     int title_width, title_height;
     int x_axis_width, x_axis_height;
     int y_axis_width, y_axis_height;
-    PangoRectangle chart, new_chart;
+    PangoRectangle new_chart;
 
     cairo_save (cr);
 
-    cairo_set_source_rgb (cr, 1, 1, 1);
-
-    cairo_paint (cr);
-
-    acre_font = pango_font_description_new ();
-    pango_font_description_set_family (acre_font, ACRE_FONT_FAMILY);
-    pango_font_description_set_absolute_size (acre_font,
+    acre->font = pango_font_description_new ();
+    pango_font_description_set_family (acre->font, ACRE_FONT_FAMILY);
+    pango_font_description_set_absolute_size (acre->font,
 					      ACRE_FONT_SIZE * PANGO_SCALE);
 
     title_font = pango_font_description_new ();
@@ -162,82 +254,381 @@ acre_draw (acre_t *acre, cairo_t *cr, double width, double height)
     pango_font_description_set_absolute_size (title_font,
 					      ACRE_TITLE_FONT_SIZE * PANGO_SCALE);
 
-    title_layout = pango_cairo_create_layout (cr);
+    title_layout = _create_layout (acre, acre->title);
     pango_layout_set_font_description (title_layout, title_font);
-    pango_layout_set_text (title_layout, acre->title, -1);
-    pango_layout_set_alignment (title_layout, PANGO_ALIGN_CENTER);
 
-    x_axis_layout = pango_cairo_create_layout (cr);
-    pango_layout_set_font_description (x_axis_layout, acre_font);
-    pango_layout_set_text (x_axis_layout, acre->x_axis_label, -1);
-    pango_layout_set_alignment (x_axis_layout, PANGO_ALIGN_CENTER);
+    x_axis_layout = _create_layout (acre, acre->x_axis.label);
+    y_axis_layout = _create_layout (acre, acre->y_axis.label);
+
+    min_y = _create_layout_printf (acre, "%g",
+				   round (acre->y_axis.min));
+    max_y = _create_layout_printf (acre, "%g",
+				   round (acre->y_axis.max));
 
-    y_axis_layout = pango_cairo_create_layout (cr);
-    pango_layout_set_font_description (y_axis_layout, acre_font);
-    pango_layout_set_text (y_axis_layout, acre->y_axis_label, -1);
-    pango_layout_set_alignment (y_axis_layout, PANGO_ALIGN_CENTER);
+    pango_layout_get_pixel_size (min_y, &min_y_width, NULL);
+    pango_layout_get_pixel_size (max_y, &max_y_width, NULL);
+    y_axis_value_width = MAX (min_y_width, max_y_width);
+
+    _destroy_layout (min_y);
+    _destroy_layout (max_y);
 
     /* Iterate with the layout of the title and axis labels until they
      * are stable, (this requires iteration since we don't know what
      * to set their widths to in advance due to the wrapping of the
      * other elements). */
-    chart.x = 0;
-    chart.y = 0;
-    chart.width = width;
-    chart.height = height;
     while (1) {
-	pango_layout_set_width (title_layout, chart.width * PANGO_SCALE);
-	pango_layout_set_width (x_axis_layout, chart.width * PANGO_SCALE);
-	pango_layout_set_width (y_axis_layout, chart.height * PANGO_SCALE);
+	pango_layout_set_width (title_layout, acre->chart.width * PANGO_SCALE);
+	pango_layout_set_width (x_axis_layout, acre->chart.width * PANGO_SCALE);
+	pango_layout_set_width (y_axis_layout, acre->chart.height * PANGO_SCALE);
 
 	pango_layout_get_pixel_size (title_layout, &title_width, &title_height);
 	pango_layout_get_pixel_size (x_axis_layout, &x_axis_width, &x_axis_height);
 	pango_layout_get_pixel_size (y_axis_layout, &y_axis_width, &y_axis_height);
 
 	new_chart.x = ACRE_PAD + y_axis_height +
-	    ACRE_PAD + ACRE_FONT_SIZE;
-	new_chart.width = width - chart.x - ACRE_PAD;
+	    ACRE_PAD + y_axis_value_width + ACRE_Y_TICK_VALUE_PAD;
+	new_chart.width = acre->width - acre->chart.x - ACRE_PAD;
 
 	new_chart.y = ACRE_PAD + title_height + ACRE_PAD;
-	new_chart.height = height - chart.y - (ACRE_FONT_SIZE + ACRE_PAD + x_axis_height + ACRE_PAD);
-
-	if (new_chart.x == chart.x &&
-	    new_chart.y == chart.y &&
-	    new_chart.width == chart.width &&
-	    new_chart.height == chart.height)
+	new_chart.height = acre->height - acre->chart.y - 
+	    (ACRE_X_TICK_VALUE_PAD + ACRE_FONT_SIZE +
+	     ACRE_PAD + x_axis_height + ACRE_PAD);
+
+	if (new_chart.x == acre->chart.x &&
+	    new_chart.y == acre->chart.y &&
+	    new_chart.width == acre->chart.width &&
+	    new_chart.height == acre->chart.height)
 	{
 	    break;
 	}
 
-	chart.x = new_chart.x;
-	chart.y = new_chart.y;
-	chart.width = new_chart.width;
-	chart.height = new_chart.height;
+	acre->chart.x = new_chart.x;
+	acre->chart.y = new_chart.y;
+	acre->chart.width = new_chart.width;
+	acre->chart.height = new_chart.height;
     }
 
     cairo_set_source_rgb (cr, 0, 0, 0);
 
-    cairo_move_to (cr, chart.x, ACRE_PAD);
-    pango_cairo_show_layout (cr, title_layout);
+    cairo_move_to (cr, acre->chart.x, ACRE_PAD);
+    _show_layout (cr, title_layout);
 
     cairo_save (cr);
     {
-	cairo_translate (cr, ACRE_PAD, chart.y + chart.height);
+	cairo_translate (cr, ACRE_PAD, acre->chart.y + acre->chart.height);
 	cairo_rotate (cr, - M_PI / 2.0);
 	cairo_move_to (cr, 0, 0);
-	pango_cairo_show_layout (cr, y_axis_layout);
+	_show_layout (cr, y_axis_layout);
     }
     cairo_restore (cr);
 
-    cairo_move_to (cr, chart.x,
-		   chart.y + chart.height + ACRE_FONT_SIZE + ACRE_PAD);
-    pango_cairo_show_layout (cr, x_axis_layout);
+    cairo_move_to (cr, acre->chart.x,
+		   acre->chart.y + acre->chart.height +
+		   ACRE_FONT_SIZE + ACRE_PAD);
+    _show_layout (cr, x_axis_layout);
+
+    cairo_restore (cr);
+}
+
+/* For a given axis range, compute a step size (in data space) to
+ * generate a suitable number of ticks (5 or so). */
+static double
+_step_for_range (double range)
+{
+    double step, scale_factor;
+
+    /* We want roughly 5 major ticks for the chart. */
+    step = range / 5;
+
+    /* Normalize the step so we can easily snap it to a desirable
+     * value. */
+    scale_factor = pow (10.0, floor (log10 (step)));
+    step /= scale_factor;
+
+    /* We want increments of 1, 2.5, 5, or 10 (times some power of
+     * 10). The threshold values between these are computed
+     * logarithmically. */
+    if (step < 3.535533905932738) {
+	if (step < 1.58113883008419)
+	    step = 1.0;
+	else
+	    step = 2.5;
+    } else {
+	if (step < 7.071067811865475)
+	    step = 5.0;
+	else
+	    step = 10.0;
+    }
+
+    /* Un-normalize and we now have the data value that we want to
+     * step at. */
+    return step * scale_factor;
+}
+
+/* Given an axis range, we can compute a desired data-space step
+ * amount for the major ticks (see _step_for_range). To get
+ * nice-looking pixel-snapped ticks we want to expand the range
+ * slightly. */
+static void
+_expand_range_for_width (double *axis_min, double *axis_max, int pixel_size)
+{
+    double range, new_range, step, pixel_step;
+
+    range = *axis_max - *axis_min;
+
+    step = _step_for_range (range);
+    pixel_step = step * pixel_size / range;
+
+    /* We expand the range by the ratio of the pixel step to the floor
+     * of the pixel_step.
+     */
+    new_range = range * pixel_step / floor (pixel_step);
+
+    /* And spread the increase out on either side of the range. */
+    *axis_min -= (new_range - range) / 2.0;
+    *axis_max += (new_range - range) / 2.0;
+}
+
+/* Setup a transformation in acre->cr such that data values plotted
+ * will appear where they should within the chart.
+ */
+static void
+_set_transform_to_data_space (acre_t *acre)
+{
+    cairo_t *cr = acre->cr;
+
+    cairo_translate (cr,
+		     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);
+}
 
+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 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;
+	}
+    }
+
+    /* Next, 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,
+			     acre->chart.width);
+
+    _expand_range_for_width (&acre->y_axis.min,
+			     &acre->y_axis.max,
+			     acre->chart.height);
+
+    /* Finally, we also translate the axis ranges slightly so that the
+     * ticks land on half-integer device-pixel positions.
+     */
+    cairo_save (cr);
+    {
+	_set_transform_to_data_space (acre);
+
+	x_adjust = 0.0;
+	y_adjust = 0.0;
+	cairo_user_to_device (cr, &x_adjust, &y_adjust);
+	x_adjust = (round (x_adjust + 0.5) - 0.5) - x_adjust;
+	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->y_axis.min -= y_adjust;
+	acre->y_axis.max -= y_adjust;
+    }
+    cairo_restore (cr);
+}
+
+static void
+_draw_data (acre_t *acre)
+{
+    cairo_t *cr = acre->cr;
+    unsigned int d, i;
+    acre_data_t *data;
+
+    cairo_save (cr);
+
+    cairo_set_source_rgb (cr, 0, 0, 0);
+
+    _set_transform_to_data_space (acre);
+
+    for (d = 0; d < acre->num_data; d++) {
+	data = acre->data[d];
+	cairo_new_path (cr);
+	for (i = 0; i < data->num_points; i++) {
+	    cairo_line_to (cr,
+			   data->points[i].x,
+			   data->points[i].y);
+	}
+	cairo_save (cr);
+	{
+	    cairo_identity_matrix (cr);
+	    cairo_set_line_width (cr, 1.0);
+	    cairo_stroke (cr);
+	}
+	cairo_restore (cr);
+    }
+
+    cairo_restore (cr);
+}
+
+typedef enum _ticks { ACRE_TICKS_X, ACRE_TICKS_Y } acre_ticks_t;
+
+static void
+_draw_ticks (acre_t *acre,
+	     double axis_min, double axis_max,
+	     acre_ticks_t ticks)
+{
+    cairo_t *cr = acre->cr;
+    double i, step;
+
+    cairo_save (cr);
+
+    _set_transform_to_data_space (acre);
+
+    step = _step_for_range (axis_max - axis_min);
+    i = (floor (axis_min / step) + 1) * step;
+
+    while (i <= axis_max) {
+	if (ticks == ACRE_TICKS_X)
+	    cairo_move_to (cr, i, acre->y_axis.min);
+	else
+	    cairo_move_to (cr, acre->x_axis.min, i);
+
+	/* tick */
+	cairo_save (cr);
+	{
+	    cairo_identity_matrix (cr);
+	    if (ticks == ACRE_TICKS_X) {
+		cairo_rel_line_to (cr, 0, 0.5);
+		cairo_rel_line_to (cr, 0, -ACRE_TICK_SIZE-0.5);
+	    } else {
+		cairo_rel_line_to (cr, -0.5, 0);
+		cairo_rel_line_to (cr, ACRE_TICK_SIZE+0.5, 0);
+	    }
+	    cairo_set_line_width (cr, 1.0);
+	    cairo_stroke (cr);
+	}
+	cairo_restore (cr);
+
+	/* label */
+	cairo_save (cr);
+	{
+	    PangoLayout *layout;
+	    int width, height;
+
+	    layout = _create_layout_printf (acre, "%g", i);
+
+	    if (ticks == ACRE_TICKS_X)
+		cairo_move_to (cr, i, acre->y_axis.min);
+	    else
+		cairo_move_to (cr, acre->x_axis.min, i);
+
+	    cairo_identity_matrix (cr);
+	    pango_layout_get_pixel_size (layout, &width, &height);
+
+	    if (ticks == ACRE_TICKS_X)
+		cairo_rel_move_to (cr, -width / 2, ACRE_X_TICK_VALUE_PAD);
+	    else
+		cairo_rel_move_to (cr, -width - ACRE_Y_TICK_VALUE_PAD,
+				   -height/2);
+
+	    _show_layout (cr, layout);
+	}
+	cairo_restore (cr);
+
+	i += step;
+    }
+
+    cairo_restore (cr);
+}
+
+static void
+_draw_frame_and_ticks (acre_t *acre)
+{
+    cairo_t *cr = acre->cr;
+
+    cairo_save (cr);
+
+    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);
+
+    /* frame */
     cairo_rectangle (cr,
-		     chart.x - 0.5, chart.y - 0.5,
-		     chart.width + 1.0, chart.height + 1.0);
+		     acre->chart.x - 0.5, acre->chart.y - 0.5,
+		     acre->chart.width + 1.0, acre->chart.height + 1.0);
     cairo_set_line_width (cr, 1.0);
     cairo_stroke (cr);
+
+    cairo_restore (cr);
+}
+
+/* Draw the plot to the given cairo context within a user-space
+ * rectangle from (0, 0) to (width, height). This size includes all
+ * space for extra-plot elements (such as the title, the axis labels,
+ * etc.)
+ */
+void
+acre_draw (acre_t *acre, cairo_t *cr, int width, int height)
+{
+    acre->cr = cr;
+
+    acre->width = width;
+    acre->height = height;
+
+    acre->chart.width = width;
+    acre->chart.height = height;
+
+    cairo_save (cr);
+
+    cairo_set_source_rgb (cr, 1, 1, 1);
+
+    /* We compute the axis ranges before doing label layout so that we
+     * can account for the width of the y-axis value labels. */
+    _compute_axis_ranges (acre);
+
+    _draw_title_and_labels (acre);
+
+    /* And we recompute the axis ranges now that the title and axis
+     * label space is all measured and accounted for. */
+    _compute_axis_ranges (acre);
+
+    _draw_data (acre);
+
+    _draw_frame_and_ticks (acre);
 }
 
 /* Create a new dataset---a collection of (x, y) datapoints. A single