src/output/charts/piechart.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 2004, 2009 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17
  18 #include <config.h>
  19
  20 #include <output/charts/piechart.h>
  21
  22 #include <assert.h>
  23 #include <float.h>
  24 #include <gsl/gsl_math.h>
  25 #include <math.h>
  26 #include <stdio.h>
  27
  28 #include <data/value-labels.h>
  29 #include <libpspp/str.h>
  30 #include <output/charts/plot-chart.h>
  31 #include <output/chart-provider.h>
  32
  33 #include "minmax.h"
  34
  35 struct piechart
  36   {
  37     struct chart chart;
  38     char *title;
  39     struct slice *slices;
  40     int n_slices;
  41   };
  42
  43 static const struct chart_class piechart_class;
  44
  45 /* Draw a single slice of the pie */
  46 static void
  47 draw_segment(cairo_t *,
  48              double centre_x, double centre_y,
  49              double radius,
  50              double start_angle, double segment_angle,
  51              const struct chart_colour *) ;
  52
  53
  54
  55 /* Creates and returns a chart that will render a piechart with
  56    the given TITLE and the N_SLICES described in SLICES. */
  57 struct chart *
  58 piechart_create (const char *title, const struct slice *slices, int n_slices)
  59 {
  60   struct piechart *pie;
  61   int i;
  62
  63   pie = xmalloc (sizeof *pie);
  64   chart_init (&pie->chart, &piechart_class);
  65   pie->title = xstrdup (title);
  66   pie->slices = xnmalloc (n_slices, sizeof *pie->slices);
  67   for (i = 0; i < n_slices; i++)
  68     {
  69       const struct slice *src = &slices[i];
  70       struct slice *dst = &pie->slices[i];
  71
  72       ds_init_string (&dst->label, &src->label);
  73       dst->magnitude = src->magnitude;
  74     }
  75   pie->n_slices = n_slices;
  76   return &pie->chart;
  77 }
  78
  79 static void
  80 piechart_draw (const struct chart *chart, cairo_t *cr,
  81                struct chart_geometry *geom)
  82 {
  83   struct piechart *pie = (struct piechart *) chart;
  84   double total_magnitude;
  85   double left_label, right_label;
  86   double centre_x, centre_y;
  87   double radius;
  88   double angle;
  89   int i;
  90
  91   centre_x = (geom->data_right + geom->data_left) / 2.0 ;
  92   centre_y = (geom->data_top + geom->data_bottom) / 2.0 ;
  93
  94   left_label = geom->data_left + (geom->data_right - geom->data_left)/10.0;
  95   right_label = geom->data_right - (geom->data_right - geom->data_left)/10.0;
  96
  97   radius = MIN (5.0 / 12.0 * (geom->data_top - geom->data_bottom),
  98                 1.0 / 4.0 * (geom->data_right - geom->data_left));
  99
 100   radius = MIN (5.0 / 12.0 * (geom->data_top - geom->data_bottom),
 101                 1.0 / 4.0 * (geom->data_right - geom->data_left));
 102
 103   chart_write_title (cr, geom, "%s", pie->title);
 104
 105   total_magnitude = 0.0;
 106   for (i = 0; i < pie->n_slices; i++)
 107     total_magnitude += pie->slices[i].magnitude;
 108
 109   angle = 0.0;
 110   for (i = 0; i < pie->n_slices ; ++i )
 111     {
 112       const double segment_angle =
 113         pie->slices[i].magnitude / total_magnitude * 2 * M_PI ;
 114
 115       const double label_x = centre_x -
 116         radius * sin(angle + segment_angle/2.0);
 117
 118       const double label_y = centre_y +
 119         radius * cos(angle + segment_angle/2.0);
 120
 121       /* Fill the segment */
 122       draw_segment (cr,
 123                     centre_x, centre_y, radius,
 124                     angle, segment_angle,
 125                     &data_colour[i % N_CHART_COLOURS]);
 126
 127       /* Now add the labels */
 128       if ( label_x < centre_x )
 129         {
 130           cairo_move_to (cr, label_x, label_y);
 131           cairo_line_to (cr, left_label, label_y);
 132           cairo_stroke (cr);
 133           cairo_move_to (cr, left_label, label_y + 5);
 134           chart_label (cr, 'l', 'x', ds_cstr (&pie->slices[i].label));
 135         }
 136       else
 137         {
 138           cairo_move_to (cr, label_x, label_y);
 139           cairo_line_to (cr, right_label, label_y);
 140           cairo_stroke (cr);
 141           cairo_move_to (cr, right_label, label_y + 5);
 142           chart_label (cr, 'r', 'x', ds_cstr (&pie->slices[i].label));
 143         }
 144
 145       angle += segment_angle;
 146     }
 147
 148   /* Draw an outline to the pie */
 149   cairo_arc (cr, centre_x, centre_y, radius, 0, 2 * M_PI);
 150   cairo_stroke (cr);
 151 }
 152
 153 /* Draw a single slice of the pie */
 154 static void
 155 draw_segment(cairo_t *cr,
 156              double x0, double y0,
 157              double radius,
 158              double start_angle, double segment_angle,
 159              const struct chart_colour *colour)
 160 {
 161   cairo_move_to (cr, x0, y0);
 162   cairo_arc (cr, x0, y0, radius, start_angle, start_angle + segment_angle);
 163   cairo_line_to (cr, x0, y0);
 164   cairo_save (cr);
 165   cairo_set_source_rgb (cr,
 166                         colour->red / 255.0,
 167                         colour->green / 255.0,
 168                         colour->blue / 255.0);
 169   cairo_fill_preserve (cr);
 170   cairo_restore (cr);
 171   cairo_stroke (cr);
 172 }
 173
 174 static void
 175 piechart_destroy (struct chart *chart)
 176 {
 177   struct piechart *pie = (struct piechart *) chart;
 178   int i;
 179
 180   free (pie->title);
 181   for (i = 0; i < pie->n_slices; i++)
 182     {
 183       struct slice *slice = &pie->slices[i];
 184       ds_destroy (&slice->label);
 185     }
 186   free (pie->slices);
 187   free (pie);
 188 }
 189
 190 static const struct chart_class piechart_class =
 191   {
 192     piechart_draw,
 193     piechart_destroy
 194   };