lib/drawer.c

   1 /*  drawer.c
   2     part of swftools
   3
   4     A generic structure for providing vector drawing.
   5     (Helper routines, spline approximation, simple text drawers)
   6
   7     Copyright (C) 2003 Matthias Kramm <kramm@quiss.org>
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17     GNU General Public License for more details.
  18
  19     You should have received a copy of the GNU General Public License
  20     along with this program; if not, write to the Free Software
  21     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <memory.h>
  26 #include <math.h>
  27 #include "drawer.h"
  28
  29 static char* getToken(const char**p)
  30 {
  31     const char*start;
  32     char*result;
  33     while(**p && strchr(" ,\t\n\r", **p)) {
  34         (*p)++;
  35     }
  36     start = *p;
  37     while(**p && !strchr(" ,\t\n\r", **p)) {
  38         (*p)++;
  39     }
  40     result = malloc((*p)-start+1);
  41     memcpy(result,start,(*p)-start+1);
  42     result[(*p)-start] = 0;
  43     return result;
  44 }
  45
  46 void draw_conicTo(drawer_t*draw, FPOINT*  c, FPOINT*  to)
  47 {
  48     FPOINT* pos = &draw->pos;
  49     FPOINT c1,c2;
  50     c1.x = (pos->x + 2 * c->x) / 3;
  51     c1.y = (pos->y + 2 * c->y) / 3;
  52     c2.x = (2 * c->x + to->x) / 3;
  53     c2.y = (2 * c->y + to->y) / 3;
  54     draw_cubicTo(draw, &c1,&c2,to);
  55
  56     draw->pos = *to;
  57 }
  58
  59 void draw_string(drawer_t*draw, const char*string)
  60 {
  61     const char*p = string;
  62     while(*p) {
  63         char*token = getToken(&p);
  64         if(!token || !*token)
  65             break;
  66         if(!strncmp(token, "moveTo", 6)) {
  67             FPOINT to;
  68             to.x = atoi(getToken(&p));
  69             to.y = atoi(getToken(&p));
  70             draw->moveTo(draw, &to);
  71         }
  72         else if(!strncmp(token, "lineTo", 6)) {
  73             FPOINT to;
  74             to.x = atoi(getToken(&p));
  75             to.y = atoi(getToken(&p));
  76             draw->lineTo(draw, &to);
  77         }
  78         else if(!strncmp(token, "curveTo", 7) || !strncmp(token, "splineTo", 8)) {
  79             FPOINT mid,to;
  80             mid.x = atoi(getToken(&p));
  81             mid.y = atoi(getToken(&p));
  82             to.x = atoi(getToken(&p));
  83             to.y = atoi(getToken(&p));
  84             draw->splineTo(draw, &mid, &to);
  85         }
  86         else if(!strncmp(token, "cubicTo", 5)) {
  87             FPOINT mid1,mid2,to;
  88             mid1.x = atoi(getToken(&p));
  89             mid1.y = atoi(getToken(&p));
  90             mid2.x = atoi(getToken(&p));
  91             mid2.y = atoi(getToken(&p));
  92             to.x = atoi(getToken(&p));
  93             to.y = atoi(getToken(&p));
  94             draw_cubicTo(draw, &mid1, &mid2, &to);
  95         }
  96         else fprintf(stderr, "drawer: Warning: unknown primitive '%s'", token);
  97
  98         free(token);
  99     }
 100 }
 101
 102 struct SPLINEPOINT
 103 {
 104     double x,y;
 105 };
 106
 107 struct qspline
 108 {
 109     struct SPLINEPOINT start;
 110     struct SPLINEPOINT control;
 111     struct SPLINEPOINT end;
 112 };
 113
 114 struct cspline
 115 {
 116     struct SPLINEPOINT start;
 117     struct SPLINEPOINT control1;
 118     struct SPLINEPOINT control2;
 119     struct SPLINEPOINT end;
 120 };
 121
 122 static inline struct SPLINEPOINT cspline_getpoint(const struct cspline*s, double t)
 123 {
 124     struct SPLINEPOINT p;
 125     double tt = t*t;
 126     double ttt = tt*t;
 127     double mt = (1-t);
 128     double mtmt = mt*(1-t);
 129     double mtmtmt = mtmt*(1-t);
 130     p.x= s->end.x*ttt + 3*s->control2.x*tt*mt
 131             + 3*s->control1.x*t*mtmt + s->start.x*mtmtmt;
 132     p.y= s->end.y*ttt + 3*s->control2.y*tt*mt
 133             + 3*s->control1.y*t*mtmt + s->start.y*mtmtmt;
 134     return p;
 135 }
 136 static struct SPLINEPOINT qspline_getpoint(const struct qspline*s, double t)
 137 {
 138     struct SPLINEPOINT p;
 139     p.x= s->end.x*t*t + 2*s->control.x*t*(1-t) + s->start.x*(1-t)*(1-t);
 140     p.y= s->end.y*t*t + 2*s->control.y*t*(1-t) + s->start.y*(1-t)*(1-t);
 141     return p;
 142 }
 143
 144 static int approximate3(const struct cspline*s, struct qspline*q, int size, double quality2)
 145 {
 146     unsigned int gran = 0;
 147     unsigned int istep = 0x80000000;
 148     unsigned int istart = 0;
 149     int num = 0;
 150     int level = 0;
 151
 152     while(istart<0x80000000)
 153     {
 154         unsigned int iend = istart + istep;
 155         double start = istart/(double)0x80000000;
 156         double end = iend/(double)0x80000000;
 157         struct qspline test;
 158         double pos,qpos;
 159         char left = 0,recurse=0;
 160         int t;
 161         int probes = 15;
 162
 163         /* create simple approximation: a qspline which run's through the
 164            qspline point at 0.5 */
 165         test.start = cspline_getpoint(s, start);
 166         test.control = cspline_getpoint(s, (start+end)/2);
 167         test.end = cspline_getpoint(s, end);
 168         /* fix the control point:
 169            move it so that the new spline does runs through it */
 170         test.control.x = -(test.end.x + test.start.x)/2 + 2*(test.control.x);
 171         test.control.y = -(test.end.y + test.start.y)/2 + 2*(test.control.y);
 172
 173         /* depending on where we are in the spline, we either try to match
 174            the left or right tangent */
 175         if(start<0.5)
 176             left=1;
 177         /* get derivative */
 178         pos = left?start:end;
 179         qpos = pos*pos;
 180         test.control.x = s->end.x*(3*qpos) + 3*s->control2.x*(2*pos-3*qpos) +
 181                     3*s->control1.x*(1-4*pos+3*qpos) + s->start.x*(-3+6*pos-3*qpos);
 182         test.control.y = s->end.y*(3*qpos) + 3*s->control2.y*(2*pos-3*qpos) +
 183                     3*s->control1.y*(1-4*pos+3*qpos) + s->start.y*(-3+6*pos-3*qpos);
 184         if(left) {
 185             test.control.x *= (end-start)/2;
 186             test.control.y *= (end-start)/2;
 187             test.control.x += test.start.x;
 188             test.control.y += test.start.y;
 189         } else {
 190             test.control.x *= -(end-start)/2;
 191             test.control.y *= -(end-start)/2;
 192             test.control.x += test.end.x;
 193             test.control.y += test.end.y;
 194         }
 195
 196         /* measure the spline's accurancy, by taking a number of probes */
 197
 198         for(t=0;t<probes;t++) {
 199             struct SPLINEPOINT qr1,qr2,cr1,cr2;
 200             double pos = 0.5/(probes*2)*(t*2+1);
 201             double dx,dy;
 202             double dist1,dist2;
 203             qr1 = qspline_getpoint(&test, pos);
 204             cr1 = cspline_getpoint(s, start+pos*(end-start));
 205
 206             dx = qr1.x - cr1.x;
 207             dy = qr1.y - cr1.y;
 208             dist1 = dx*dx+dy*dy;
 209
 210             if(dist1>quality2) {
 211                 recurse=1;break;
 212             }
 213             qr2 = qspline_getpoint(&test, (1-pos));
 214             cr2 = cspline_getpoint(s, start+(1-pos)*(end-start));
 215
 216             dx = qr2.x - cr2.x;
 217             dy = qr2.y - cr2.y;
 218             dist2 = dx*dx+dy*dy;
 219
 220             if(dist2>quality2) {
 221                 recurse=1;break;
 222             }
 223         }
 224
 225         if(recurse && istep>1 && size-level > num) {
 226             istep >>= 1;
 227             level++;
 228         } else {
 229             *q++ = test;
 230             num++;
 231             istart += istep;
 232             while(!(istart & istep)) {
 233                 level--;
 234                 istep <<= 1;
 235             }
 236         }
 237     }
 238     return num;
 239 }
 240
 241 void draw_cubicTo(drawer_t*draw, FPOINT*  control1, FPOINT* control2, FPOINT*  to)
 242 {
 243     struct qspline q[128];
 244     struct cspline c;
 245     c.start.x = draw->pos.x;
 246     c.start.y = draw->pos.y;
 247     c.control1.x = control1->x;
 248     c.control1.y = control1->y;
 249     c.control2.x = control2->x;
 250     c.control2.y = control2->y;
 251     c.end.x = to->x;
 252     c.end.y = to->y;
 253     double quality = 80;
 254     double maxerror = (500-(quality*5)>1?500-(quality*5):1)/20.0;
 255
 256     int num = approximate3(&c, q, 128, maxerror*maxerror);
 257     int t;
 258     for(t=0;t<num;t++) {
 259         FPOINT mid;
 260         FPOINT to;
 261         mid.x = q[t].control.x;
 262         mid.y = q[t].control.y;
 263         to.x = q[t].end.x;
 264         to.y = q[t].end.y;
 265         draw->splineTo(draw, &mid, &to);
 266     }
 267 }
 268
 269