lib/art/art_vpath_bpath.c

   1 /* Libart_LGPL - library of basic graphic primitives
   2  * Copyright (C) 1998 Raph Levien
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library 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 GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /* Basic constructors and operations for bezier paths */
  21
  22 #include "config.h"
  23 #include "art_vpath_bpath.h"
  24
  25 #include <math.h>
  26
  27 #include "art_misc.h"
  28
  29 #include "art_bpath.h"
  30 #include "art_vpath.h"
  31
  32 /* p must be allocated 2^level points. */
  33
  34 /* level must be >= 1 */
  35 ArtPoint *
  36 art_bezier_to_vec (double x0, double y0,
  37                    double x1, double y1,
  38                    double x2, double y2,
  39                    double x3, double y3,
  40                    ArtPoint *p,
  41                    int level)
  42 {
  43   double x_m, y_m;
  44
  45 #ifdef VERBOSE
  46   printf ("bezier_to_vec: %g,%g %g,%g %g,%g %g,%g %d\n",
  47           x0, y0, x1, y1, x2, y2, x3, y3, level);
  48 #endif
  49   if (level == 1) {
  50     x_m = (x0 + 3 * (x1 + x2) + x3) * 0.125;
  51     y_m = (y0 + 3 * (y1 + y2) + y3) * 0.125;
  52     p->x = x_m;
  53     p->y = y_m;
  54     p++;
  55     p->x = x3;
  56     p->y = y3;
  57     p++;
  58 #ifdef VERBOSE
  59     printf ("-> (%g, %g) -> (%g, %g)\n", x_m, y_m, x3, y3);
  60 #endif
  61   } else {
  62     double xa1, ya1;
  63     double xa2, ya2;
  64     double xb1, yb1;
  65     double xb2, yb2;
  66
  67     xa1 = (x0 + x1) * 0.5;
  68     ya1 = (y0 + y1) * 0.5;
  69     xa2 = (x0 + 2 * x1 + x2) * 0.25;
  70     ya2 = (y0 + 2 * y1 + y2) * 0.25;
  71     xb1 = (x1 + 2 * x2 + x3) * 0.25;
  72     yb1 = (y1 + 2 * y2 + y3) * 0.25;
  73     xb2 = (x2 + x3) * 0.5;
  74     yb2 = (y2 + y3) * 0.5;
  75     x_m = (xa2 + xb1) * 0.5;
  76     y_m = (ya2 + yb1) * 0.5;
  77 #ifdef VERBOSE
  78     printf ("%g,%g %g,%g %g,%g %g,%g\n", xa1, ya1, xa2, ya2,
  79             xb1, yb1, xb2, yb2);
  80 #endif
  81     p = art_bezier_to_vec (x0, y0, xa1, ya1, xa2, ya2, x_m, y_m, p, level - 1);
  82     p = art_bezier_to_vec (x_m, y_m, xb1, yb1, xb2, yb2, x3, y3, p, level - 1);
  83   }
  84   return p;
  85 }
  86
  87 #define RENDER_LEVEL 4
  88 #define RENDER_SIZE (1 << (RENDER_LEVEL))
  89
  90 /**
  91  * art_vpath_render_bez: Render a bezier segment into the vpath.
  92  * @p_vpath: Where the pointer to the #ArtVpath structure is stored.
  93  * @pn_points: Pointer to the number of points in *@p_vpath.
  94  * @pn_points_max: Pointer to the number of points allocated.
  95  * @x0: X coordinate of starting bezier point.
  96  * @y0: Y coordinate of starting bezier point.
  97  * @x1: X coordinate of first bezier control point.
  98  * @y1: Y coordinate of first bezier control point.
  99  * @x2: X coordinate of second bezier control point.
 100  * @y2: Y coordinate of second bezier control point.
 101  * @x3: X coordinate of ending bezier point.
 102  * @y3: Y coordinate of ending bezier point.
 103  * @flatness: Flatness control.
 104  *
 105  * Renders a bezier segment into the vector path, reallocating and
 106  * updating *@p_vpath and *@pn_vpath_max as necessary. *@pn_vpath is
 107  * incremented by the number of vector points added.
 108  *
 109  * This step includes (@x0, @y0) but not (@x3, @y3).
 110  *
 111  * The @flatness argument guides the amount of subdivision. The Adobe
 112  * PostScript reference manual defines flatness as the maximum
 113  * deviation between the any point on the vpath approximation and the
 114  * corresponding point on the "true" curve, and we follow this
 115  * definition here. A value of 0.25 should ensure high quality for aa
 116  * rendering.
 117 **/
 118 static void
 119 art_vpath_render_bez (ArtVpath **p_vpath, int *pn, int *pn_max,
 120                       double x0, double y0,
 121                       double x1, double y1,
 122                       double x2, double y2,
 123                       double x3, double y3,
 124                       double flatness)
 125 {
 126   double x3_0, y3_0;
 127   double z3_0_dot;
 128   double z1_dot, z2_dot;
 129   double z1_perp, z2_perp;
 130   double max_perp_sq;
 131
 132   double x_m, y_m;
 133   double xa1, ya1;
 134   double xa2, ya2;
 135   double xb1, yb1;
 136   double xb2, yb2;
 137
 138   /* It's possible to optimize this routine a fair amount.
 139
 140      First, once the _dot conditions are met, they will also be met in
 141      all further subdivisions. So we might recurse to a different
 142      routine that only checks the _perp conditions.
 143
 144      Second, the distance _should_ decrease according to fairly
 145      predictable rules (a factor of 4 with each subdivision). So it might
 146      be possible to note that the distance is within a factor of 4 of
 147      acceptable, and subdivide once. But proving this might be hard.
 148
 149      Third, at the last subdivision, x_m and y_m can be computed more
 150      expeditiously (as in the routine above).
 151
 152      Finally, if we were able to subdivide by, say 2 or 3, this would
 153      allow considerably finer-grain control, i.e. fewer points for the
 154      same flatness tolerance. This would speed things up downstream.
 155
 156      In any case, this routine is unlikely to be the bottleneck. It's
 157      just that I have this undying quest for more speed...
 158
 159   */
 160
 161   x3_0 = x3 - x0;
 162   y3_0 = y3 - y0;
 163
 164   /* z3_0_dot is dist z0-z3 squared */
 165   z3_0_dot = x3_0 * x3_0 + y3_0 * y3_0;
 166
 167   if (z3_0_dot < 0.001)
 168     {
 169       /* if start and end point are almost identical, the flatness tests
 170        * don't work properly, so fall back on testing whether both of
 171        * the other two control points are the same as the start point,
 172        * too.
 173        */
 174       if (hypot(x1 - x0, y1 - y0) < 0.001
 175           && hypot(x2 - x0, y2 - y0) < 0.001)
 176           goto nosubdivide;
 177       else
 178           goto subdivide;
 179     }
 180
 181   /* we can avoid subdivision if:
 182
 183      z1 has distance no more than flatness from the z0-z3 line
 184
 185      z1 is no more z0'ward than flatness past z0-z3
 186
 187      z1 is more z0'ward than z3'ward on the line traversing z0-z3
 188
 189      and correspondingly for z2 */
 190
 191   /* perp is distance from line, multiplied by dist z0-z3 */
 192   max_perp_sq = flatness * flatness * z3_0_dot;
 193
 194   z1_perp = (y1 - y0) * x3_0 - (x1 - x0) * y3_0;
 195   if (z1_perp * z1_perp > max_perp_sq)
 196     goto subdivide;
 197
 198   z2_perp = (y3 - y2) * x3_0 - (x3 - x2) * y3_0;
 199   if (z2_perp * z2_perp > max_perp_sq)
 200     goto subdivide;
 201
 202   z1_dot = (x1 - x0) * x3_0 + (y1 - y0) * y3_0;
 203   if (z1_dot < 0 && z1_dot * z1_dot > max_perp_sq)
 204     goto subdivide;
 205
 206   z2_dot = (x3 - x2) * x3_0 + (y3 - y2) * y3_0;
 207   if (z2_dot < 0 && z2_dot * z2_dot > max_perp_sq)
 208     goto subdivide;
 209
 210   if (z1_dot + z1_dot > z3_0_dot)
 211     goto subdivide;
 212
 213   if (z2_dot + z2_dot > z3_0_dot)
 214     goto subdivide;
 215
 216
 217  nosubdivide:
 218   /* don't subdivide */
 219   art_vpath_add_point (p_vpath, pn, pn_max,
 220                        ART_LINETO, x3, y3);
 221   return;
 222
 223  subdivide:
 224
 225   xa1 = (x0 + x1) * 0.5;
 226   ya1 = (y0 + y1) * 0.5;
 227   xa2 = (x0 + 2 * x1 + x2) * 0.25;
 228   ya2 = (y0 + 2 * y1 + y2) * 0.25;
 229   xb1 = (x1 + 2 * x2 + x3) * 0.25;
 230   yb1 = (y1 + 2 * y2 + y3) * 0.25;
 231   xb2 = (x2 + x3) * 0.5;
 232   yb2 = (y2 + y3) * 0.5;
 233   x_m = (xa2 + xb1) * 0.5;
 234   y_m = (ya2 + yb1) * 0.5;
 235 #ifdef VERBOSE
 236   printf ("%g,%g %g,%g %g,%g %g,%g\n", xa1, ya1, xa2, ya2,
 237           xb1, yb1, xb2, yb2);
 238 #endif
 239   art_vpath_render_bez (p_vpath, pn, pn_max,
 240                         x0, y0, xa1, ya1, xa2, ya2, x_m, y_m, flatness);
 241   art_vpath_render_bez (p_vpath, pn, pn_max,
 242                         x_m, y_m, xb1, yb1, xb2, yb2, x3, y3, flatness);
 243 }
 244
 245 /**
 246  * art_bez_path_to_vec: Create vpath from bezier path.
 247  * @bez: Bezier path.
 248  * @flatness: Flatness control.
 249  *
 250  * Creates a vector path closely approximating the bezier path defined by
 251  * @bez. The @flatness argument controls the amount of subdivision. In
 252  * general, the resulting vpath deviates by at most @flatness pixels
 253  * from the "ideal" path described by @bez.
 254  *
 255  * Return value: Newly allocated vpath.
 256  **/
 257 ArtVpath *
 258 art_bez_path_to_vec (const ArtBpath *bez, double flatness)
 259 {
 260   ArtVpath *vec;
 261   int vec_n, vec_n_max;
 262   int bez_index;
 263   double x, y;
 264
 265   vec_n = 0;
 266   vec_n_max = RENDER_SIZE;
 267   vec = art_new (ArtVpath, vec_n_max);
 268
 269   /* Initialization is unnecessary because of the precondition that the
 270      bezier path does not begin with LINETO or CURVETO, but is here
 271      to make the code warning-free. */
 272   x = 0;
 273   y = 0;
 274
 275   bez_index = 0;
 276   do
 277     {
 278 #ifdef VERBOSE
 279       printf ("%s %g %g\n",
 280               bez[bez_index].code == ART_CURVETO ? "curveto" :
 281               bez[bez_index].code == ART_LINETO ? "lineto" :
 282               bez[bez_index].code == ART_MOVETO ? "moveto" :
 283               bez[bez_index].code == ART_MOVETO_OPEN ? "moveto-open" :
 284               "end", bez[bez_index].x3, bez[bez_index].y3);
 285 #endif
 286       /* make sure space for at least one more code */
 287       if (vec_n >= vec_n_max)
 288         art_expand (vec, ArtVpath, vec_n_max);
 289       switch (bez[bez_index].code)
 290         {
 291         case ART_MOVETO_OPEN:
 292         case ART_MOVETO:
 293         case ART_LINETO:
 294           x = bez[bez_index].x3;
 295           y = bez[bez_index].y3;
 296           vec[vec_n].code = bez[bez_index].code;
 297           vec[vec_n].x = x;
 298           vec[vec_n].y = y;
 299           vec_n++;
 300           break;
 301         case ART_END:
 302           vec[vec_n].code = bez[bez_index].code;
 303           vec[vec_n].x = 0;
 304           vec[vec_n].y = 0;
 305           vec_n++;
 306           break;
 307         case ART_CURVETO:
 308 #ifdef VERBOSE
 309           printf ("%g,%g %g,%g %g,%g %g,%g\n", x, y,
 310                          bez[bez_index].x1, bez[bez_index].y1,
 311                          bez[bez_index].x2, bez[bez_index].y2,
 312                          bez[bez_index].x3, bez[bez_index].y3);
 313 #endif
 314           art_vpath_render_bez (&vec, &vec_n, &vec_n_max,
 315                                 x, y,
 316                                 bez[bez_index].x1, bez[bez_index].y1,
 317                                 bez[bez_index].x2, bez[bez_index].y2,
 318                                 bez[bez_index].x3, bez[bez_index].y3,
 319                                 flatness);
 320           x = bez[bez_index].x3;
 321           y = bez[bez_index].y3;
 322           break;
 323         }
 324     }
 325   while (bez[bez_index++].code != ART_END);
 326   return vec;
 327 }
 328