lib/gfxpoly/convert.c

   1 #include <stdlib.h>
   2 #include <math.h>
   3 #include <string.h>
   4 #include "../gfxdevice.h"
   5 #include "../mem.h"
   6 #include "poly.h"
   7
   8 /* factor that determines into how many line fragments a spline is converted */
   9 #define SUBFRACTION (2.4)
  10
  11 static edge_t*edge_new(int x1, int y1, int x2, int y2)
  12 {
  13     edge_t*s = rfx_calloc(sizeof(edge_t));
  14     s->a.x = x1;
  15     s->a.y = y1;
  16     s->b.x = x2;
  17     s->b.y = y2;
  18     return s;
  19 }
  20
  21 static inline int32_t convert_coord(double x)
  22 {
  23     /* we clamp to 31 bit instead of 32 bit because we use
  24        a (x1-x2) shortcut when comparing coordinates
  25     */
  26     if(x < -0x40000000) x = -0x40000000;
  27     if(x >  0x3fffffff) x =  0x3fffffff;
  28     return ceil(x);
  29 }
  30
  31 static inline void gfxpoly_add_edge(gfxpoly_t*poly, double _x1, double _y1, double _x2, double _y2)
  32 {
  33     int x1 = convert_coord(_x1);
  34     int y1 = convert_coord(_y1);
  35     int x2 = convert_coord(_x2);
  36     int y2 = convert_coord(_y2);
  37
  38     if(x1!=x2 || y1!=y2) {
  39         edge_t*s = edge_new(x1, y1, x2, y2);
  40         s->next = poly->edges;
  41         poly->edges = s;
  42     }
  43 }
  44
  45 static void convert_gfxline(gfxline_t*line, void*data, void(*moveto)(void*data, double x, double y), void(*lineto)(void*data, double x, double y), void(*setgridsize)(void*data, double g))
  46 {
  47     assert(!line || line[0].type == gfx_moveTo);
  48     double lastx=0,lasty=0;
  49     while(line) {
  50         if(line->type == gfx_moveTo) {
  51             if(line->next && line->next->type != gfx_moveTo && (line->x!=lastx || line->y!=lasty)) {
  52                 moveto(data, line->x, line->y);
  53             }
  54         } else if(line->type == gfx_lineTo) {
  55             lineto(data, line->x, line->y);
  56         } else if(line->type == gfx_splineTo) {
  57             int parts = (int)(sqrt(fabs(line->x-2*line->sx+lastx) +
  58                                    fabs(line->y-2*line->sy+lasty))*SUBFRACTION);
  59             if(!parts) parts = 1;
  60             double stepsize = 1.0/parts;
  61             int i;
  62             for(i=0;i<parts;i++) {
  63                 double t = (double)i*stepsize;
  64                 double sx = (line->x*t*t + 2*line->sx*t*(1-t) + lastx*(1-t)*(1-t));
  65                 double sy = (line->y*t*t + 2*line->sy*t*(1-t) + lasty*(1-t)*(1-t));
  66                 lineto(data, sx, sy);
  67             }
  68             lineto(data, line->x, line->y);
  69         }
  70         lastx = line->x;
  71         lasty = line->y;
  72         line = line->next;
  73     }
  74 }
  75
  76 static char* readline(FILE*fi)
  77 {
  78     char c;
  79     while(1) {
  80         int l = fread(&c, 1, 1, fi);
  81         if(!l)
  82             return 0;
  83         if(c!=10 || c!=13)
  84             break;
  85     }
  86     char line[256];
  87     int pos = 0;
  88     while(1) {
  89         line[pos++] = c;
  90         line[pos] = 0;
  91         int l = fread(&c, 1, 1, fi);
  92         if(!l || c==10 || c==13) {
  93             return strdup(line);
  94         }
  95     }
  96 }
  97
  98 static void convert_file(const char*filename, void*data, void(*moveto)(void*data, double x, double y), void(*lineto)(void*data, double x, double y),void(*setgridsize)(void*data, double gridsize))
  99 {
 100     FILE*fi = fopen(filename, "rb");
 101     if(!fi) {
 102         perror(filename);
 103     }
 104     int count = 0;
 105     double g = 0;
 106     double lastx=0,lasty=0;
 107     while(1) {
 108         char*line = readline(fi);
 109         if(!line)
 110             break;
 111         double x,y;
 112         char s[256];
 113         if(sscanf(line, "%lf %lf %s", &x, &y, &s) == 3) {
 114             if(s && !strcmp(s,"moveto")) {
 115                 moveto(data, x, y);
 116                 count++;
 117             } else if(s && !strcmp(s,"lineto")) {
 118                 lineto(data, x, y);
 119                 count++;
 120             } else {
 121                 fprintf(stderr, "invalid command: %s\n", s);
 122             }
 123         } else if(sscanf(line, "%% gridsize %lf", &g) == 1) {
 124             setgridsize(data, g);
 125         }
 126         free(line);
 127     }
 128     fclose(fi);
 129     if(g) {
 130         fprintf(stderr, "loaded %d points from %s (gridsize %f)\n", count, filename, g);
 131     } else {
 132         fprintf(stderr, "loaded %d points from %s\n", count, filename);
 133     }
 134 }
 135
 136 typedef struct _stdpoly {
 137     gfxpoly_t*poly;
 138     double lastx,lasty;
 139     double z;
 140 } stdpoly_t;
 141 static void stdmoveto(void*data, double x, double y)
 142 {
 143     stdpoly_t*d = (stdpoly_t*)data;
 144     x *= d->z;
 145     y *= d->z;
 146     d->lastx = x;d->lasty = y;
 147 }
 148 static void stdlineto(void*data, double x, double y)
 149 {
 150     stdpoly_t*d = (stdpoly_t*)data;
 151     x *= d->z;
 152     y *= d->z;
 153     gfxpoly_add_edge(d->poly, d->lastx, d->lasty, x, y);
 154     d->lastx = x;d->lasty = y;
 155 }
 156 static void stdsetgridsize(void*data, double gridsize)
 157 {
 158     stdpoly_t*d = (stdpoly_t*)data;
 159     d->poly->gridsize = gridsize;
 160 }
 161 gfxpoly_t* gfxpoly_from_gfxline(gfxline_t*line, double gridsize)
 162 {
 163     stdpoly_t data;
 164     data.poly = gfxpoly_new(gridsize);
 165     data.z = 1.0 / gridsize;
 166     data.lastx = data.lasty = 0;
 167     convert_gfxline(line, &data, stdmoveto, stdlineto, stdsetgridsize);
 168     return data.poly;
 169 }
 170 gfxpoly_t* gfxpoly_from_file(const char*filename, double gridsize)
 171 {
 172     stdpoly_t data;
 173     data.poly = gfxpoly_new(gridsize);
 174     data.z = 1.0 / gridsize;
 175     data.lastx = data.lasty = 0;
 176     convert_file(filename, &data, stdmoveto, stdlineto, stdsetgridsize);
 177     return data.poly;
 178 }
 179
 180 typedef struct _compactpoly {
 181     gfxcompactpoly_t*poly;
 182     point_t last;
 183     double z;
 184     int strokes_size;
 185     point_t*points;
 186     int num_points;
 187     int points_size;
 188     segment_dir_t dir;
 189 } compactpoly_t;
 190
 191 void add_segment(compactpoly_t*data, point_t start, segment_dir_t dir)
 192 {
 193     if(data->poly->num_strokes == data->strokes_size) {
 194         data->strokes_size <<= 1;
 195         assert(data->strokes_size > data->poly->num_strokes);
 196         data->poly->strokes = rfx_realloc(data->poly->strokes, data->strokes_size);
 197     }
 198     data->poly->strokes[data->poly->num_strokes].dir = dir;
 199     data->points[0] = start;
 200     data->num_points = 1;
 201     data->dir = dir;
 202 }
 203 void finish_segment(compactpoly_t*data)
 204 {
 205     if(data->num_points <= 1)
 206         return;
 207     point_t*p = malloc(sizeof(point_t)*data->num_points);
 208     data->poly->strokes[data->poly->num_strokes-1].points = p;
 209     if(data->dir == DIR_UP) {
 210         int t;
 211         int s = data->num_points;
 212         for(t=0;t<data->num_points;t++) {
 213             p[--s] = data->points[t];
 214         }
 215     } else {
 216         memcpy(p, data->points, sizeof(point_t)*data->num_points);
 217     }
 218     data->poly->num_strokes++;
 219 }
 220 static void compactmoveto(void*_data, double _x, double _y)
 221 {
 222     compactpoly_t*data = (compactpoly_t*)_data;
 223     data->dir = DIR_UNKNOWN;
 224     point_t p;
 225     p.x = convert_coord(_x);
 226     p.y = convert_coord(_y);
 227     data->last = p;
 228 }
 229 static void compactlineto(void*_data, double _x, double _y)
 230 {
 231     compactpoly_t*data = (compactpoly_t*)_data;
 232     point_t p;
 233     p.x = convert_coord(_x);
 234     p.y = convert_coord(_y);
 235     if(p.y < data->last.y && data->dir != DIR_UP ||
 236        p.y > data->last.y && data->dir != DIR_DOWN) {
 237         data->dir = p.y > data->last.y ? DIR_DOWN : DIR_UP;
 238         finish_segment(data);
 239         add_segment(data, data->last, data->dir);
 240     }
 241     if(data->points_size == data->num_points) {
 242         data->points_size <<= 1;
 243         assert(data->points_size > data->num_points);
 244         data->points = rfx_realloc(data->points, data->points_size);
 245     }
 246     data->points[data->num_points++] = p;
 247 }
 248 static void compactsetgridsize(void*data, double gridsize)
 249 {
 250     compactpoly_t*d = (compactpoly_t*)data;
 251     d->poly->gridsize = gridsize;
 252 }
 253 static void compactinit(compactpoly_t*data, double gridsize)
 254 {
 255     data->poly = rfx_calloc(sizeof(gfxcompactpoly_t));
 256     data->poly->gridsize = gridsize;
 257     data->z = 1.0 / gridsize;
 258     data->last.x = data->last.y = 0;
 259     data->strokes_size = 16;
 260     data->num_points = 0;
 261     data->points_size = 16;
 262     data->points = (point_t*)rfx_alloc(sizeof(point_t)*data->points_size);
 263     data->poly->strokes = (gfxstroke_t*)rfx_alloc(sizeof(gfxstroke_t)*data->strokes_size);
 264 }
 265 static gfxcompactpoly_t*compactfinish(compactpoly_t*data)
 266 {
 267     finish_segment(data);
 268     data->poly->strokes = rfx_realloc(data->poly->strokes, sizeof(gfxstroke_t)*data->poly->num_strokes);
 269     free(data->points);
 270     return data->poly;
 271 }
 272 gfxcompactpoly_t* gfxcompactpoly_from_gfxline(gfxline_t*line, double gridsize)
 273 {
 274     compactpoly_t data;
 275     compactinit(&data, gridsize);
 276     data.poly->gridsize = gridsize;
 277     convert_gfxline(line, &data, compactmoveto, compactlineto, compactsetgridsize);
 278     return compactfinish(&data);
 279 }
 280 gfxcompactpoly_t* gfxcompactpoly_from_file(const char*filename, double gridsize)
 281 {
 282     compactpoly_t data;
 283     compactinit(&data, gridsize);
 284     data.poly->gridsize = gridsize;
 285     convert_file(filename, &data, compactmoveto, compactlineto, compactsetgridsize);
 286     return compactfinish(&data);
 287 }
 288 void gfxcompactpoly_free(gfxcompactpoly_t*poly)
 289 {
 290     int t;
 291     for(t=0;t<poly->num_strokes;t++) {
 292         free(poly->strokes[t].points);
 293     }
 294     free(poly->strokes);
 295     free(poly);
 296 }
 297