Subversion Repositories Kolibri OS

/**************************************************************************

 *

 * Copyright 2009 VMware, Inc.  All Rights Reserved.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the

 * "Software"), to deal in the Software without restriction, including

 * without limitation the rights to use, copy, modify, merge, publish,

 * distribute, sub license, and/or sell copies of the Software, and to

 * permit persons to whom the Software is furnished to do so, subject to

 * the following conditions:

 *

 * The above copyright notice and this permission notice (including the

 * next paragraph) shall be included in all copies or substantial portions

 * of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.

 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR

 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 *

 **************************************************************************/

#include "arc.h"

#include "matrix.h"

#include "bezier.h"

#include "polygon.h"

#include "stroker.h"

#include "path.h"

#include "util/u_debug.h"

#include "util/u_math.h"

#ifndef M_PI

#define M_PI 3.14159265358979323846

#endif

#define DEBUG_ARCS 0

static const VGfloat two_pi = M_PI * 2;

static const double coeffs3Low[2][4][4] = {

   {

      {  3.85268,   -21.229,      -0.330434,    0.0127842  },

      { -1.61486,     0.706564,    0.225945,    0.263682   },

      { -0.910164,    0.388383,    0.00551445,  0.00671814 },

      { -0.630184,    0.192402,    0.0098871,   0.0102527  }

   },

   {

      { -0.162211,    9.94329,     0.13723,     0.0124084  },

      { -0.253135,    0.00187735,  0.0230286,   0.01264    },

      { -0.0695069,  -0.0437594,   0.0120636,   0.0163087  },

      { -0.0328856,  -0.00926032, -0.00173573,  0.00527385 }

   }

};

/* coefficients for error estimation

   while using cubic Bézier curves for approximation

   1/4 <= b/a <= 1 */

static const double coeffs3High[2][4][4] = {

   {

      {  0.0899116, -19.2349,     -4.11711,     0.183362   },

      {  0.138148,   -1.45804,     1.32044,     1.38474    },

      {  0.230903,   -0.450262,    0.219963,    0.414038   },

      {  0.0590565,  -0.101062,    0.0430592,   0.0204699  }

   },

   {

      {  0.0164649,   9.89394,     0.0919496,   0.00760802 },

      {  0.0191603,  -0.0322058,   0.0134667,  -0.0825018  },

      {  0.0156192,  -0.017535,    0.00326508, -0.228157   },

      { -0.0236752,   0.0405821,  -0.0173086,   0.176187   }

   }

};

/* safety factor to convert the "best" error approximation

   into a "max bound" error */

static const double safety3[] = {

   0.001, 4.98, 0.207, 0.0067

};

/* The code below is from the OpenVG 1.1 Spec

 * Section 18.4 */

/* Given: Points (x0, y0) and (x1, y1)

 * Return: TRUE if a solution exists, FALSE otherwise

 *         Circle centers are written to (cx0, cy0) and (cx1, cy1)

 */

static VGboolean

find_unit_circles(double x0, double y0, double x1, double y1,

                  double *cx0, double *cy0,

                  double *cx1, double *cy1)

{

   /* Compute differences and averages */

   double dx = x0 - x1;

   double dy = y0 - y1;

   double xm = (x0 + x1)/2;

   double ym = (y0 + y1)/2;

   double dsq, disc, s, sdx, sdy;

   /* Solve for intersecting unit circles */

   dsq = dx*dx + dy*dy;

   if (dsq == 0.0) return VG_FALSE; /* Points are coincident */

   disc = 1.0/dsq - 1.0/4.0;

   /* the precision we care about here is around float so if we're

    * around the float defined zero then make it official to avoid

    * precision problems later on */

   if (floatIsZero(disc))

      disc = 0.0;

   if (disc < 0.0) return VG_FALSE; /* Points are too far apart */

   s = sqrt(disc);

   sdx = s*dx;

   sdy = s*dy;

   *cx0 = xm + sdy;

   *cy0 = ym - sdx;

   *cx1 = xm - sdy;

   *cy1 = ym + sdx;

   return VG_TRUE;

}

/* Given:  Ellipse parameters rh, rv, rot (in degrees),

 *         endpoints (x0, y0) and (x1, y1)

 * Return: TRUE if a solution exists, FALSE otherwise

 *         Ellipse centers are written to (cx0, cy0) and (cx1, cy1)

 */

static VGboolean

find_ellipses(double rh, double rv, double rot,

              double x0, double y0, double x1, double y1,

              double *cx0, double *cy0, double *cx1, double *cy1)

{

   double COS, SIN, x0p, y0p, x1p, y1p, pcx0, pcy0, pcx1, pcy1;

   /* Convert rotation angle from degrees to radians */

   rot *= M_PI/180.0;

   /* Pre-compute rotation matrix entries */

   COS = cos(rot); SIN = sin(rot);

   /* Transform (x0, y0) and (x1, y1) into unit space */

   /* using (inverse) rotate, followed by (inverse) scale   */

   x0p = (x0*COS + y0*SIN)/rh;

   y0p = (-x0*SIN + y0*COS)/rv;

   x1p = (x1*COS + y1*SIN)/rh;

   y1p = (-x1*SIN + y1*COS)/rv;

   if (!find_unit_circles(x0p, y0p, x1p, y1p,

                          &pcx0, &pcy0, &pcx1, &pcy1)) {

      return VG_FALSE;

   }

   /* Transform back to original coordinate space */

   /* using (forward) scale followed by (forward) rotate */

   pcx0 *= rh; pcy0 *= rv;

   pcx1 *= rh; pcy1 *= rv;

   *cx0 = pcx0*COS - pcy0*SIN;

   *cy0 = pcx0*SIN + pcy0*COS;

   *cx1 = pcx1*COS - pcy1*SIN;

   *cy1 = pcx1*SIN + pcy1*COS;

   return VG_TRUE;

}

static INLINE VGboolean

try_to_fix_radii(struct arc *arc)

{

   double COS, SIN, rot, x0p, y0p, x1p, y1p;

   double dx, dy, dsq, scale;

   /* Convert rotation angle from degrees to radians */

   rot = DEGREES_TO_RADIANS(arc->theta);

   /* Pre-compute rotation matrix entries */

   COS = cos(rot); SIN = sin(rot);

   /* Transform (x0, y0) and (x1, y1) into unit space */

   /* using (inverse) rotate, followed by (inverse) scale   */

   x0p = (arc->x1*COS + arc->y1*SIN)/arc->a;

   y0p = (-arc->x1*SIN + arc->y1*COS)/arc->b;

   x1p = (arc->x2*COS + arc->y2*SIN)/arc->a;

   y1p = (-arc->x2*SIN + arc->y2*COS)/arc->b;

   /* Compute differences and averages */

   dx = x0p - x1p;

   dy = y0p - y1p;

   dsq = dx*dx + dy*dy;

#if 0

   if (dsq <= 0.001) {

      debug_printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaaaaa\n");

   }

#endif

   scale = 1/(2/sqrt(dsq));

   arc->a *= scale;

   arc->b *= scale;

   return VG_TRUE;

}

static INLINE double vector_normalize(double *v)

{

   double sq = v[0] * v[0] + v[1] * v[1];

   return sqrt(sq);

}

static INLINE double vector_orientation(double *v)

{

   double norm = vector_normalize(v);

   double cosa = v[0] / norm;

   double sina = v[1] / norm;

   return (sina>=0 ? acos(cosa) : 2*M_PI - acos(cosa));

}

static INLINE double vector_dot(double *v0,

                                double *v1)

{

   return v0[0] * v1[0] + v0[1] * v1[1];

}

static INLINE double vector_angles(double *v0,

                                   double *v1)

{

   double dot = vector_dot(v0, v1);

   double norm0 = vector_normalize(v0);

   double norm1 = vector_normalize(v1);

   return acos(dot / (norm0 * norm1));

}

static VGboolean find_angles(struct arc *arc)

{

   double vec0[2], vec1[2];

   double lambda1, lambda2;

   double angle;

   struct matrix matrix;

   if (floatIsZero(arc->a) || floatIsZero(arc->b)) {

      return VG_FALSE;

   }

   /* map the points to an identity circle */

   matrix_load_identity(&matrix);

   matrix_scale(&matrix, 1.f, arc->a/arc->b);

   matrix_rotate(&matrix, -arc->theta);

   matrix_map_point(&matrix,

                    arc->x1, arc->y1,

                    &arc->x1, &arc->y1);

   matrix_map_point(&matrix,

                    arc->x2, arc->y2,

                    &arc->x2, &arc->y2);

   matrix_map_point(&matrix,

                    arc->cx, arc->cy,

                    &arc->cx, &arc->cy);

#if DEBUG_ARCS

   debug_printf("Matrix 3 [%f, %f, %f| %f, %f, %f| %f, %f, %f]\n",

                matrix.m[0], matrix.m[1], matrix.m[2],

                matrix.m[3], matrix.m[4], matrix.m[5],

                matrix.m[6], matrix.m[7], matrix.m[8]);

   debug_printf("Endpoints [%f, %f], [%f, %f]\n",

                arc->x1, arc->y1, arc->x2, arc->y2);

#endif

   vec0[0] = arc->x1 - arc->cx;

   vec0[1] = arc->y1 - arc->cy;

   vec1[0] = arc->x2 - arc->cx;

   vec1[1] = arc->y2 - arc->cy;

#if DEBUG_ARCS

   debug_printf("Vec is [%f, %f], [%f, %f], [%f, %f]\n",

                vec0[0], vec0[1], vec1[0], vec1[1], arc->cx, arc->cy);

#endif

   lambda1 = vector_orientation(vec0);

   if (isnan(lambda1))

      lambda1 = 0.f;

   if (arc->type == VG_SCWARC_TO ||

       arc->type == VG_SCCWARC_TO)

      angle = vector_angles(vec0, vec1);

   else if (arc->type == VG_LCWARC_TO ||

            arc->type == VG_LCCWARC_TO) {

      angle = 2*M_PI - vector_angles(vec0, vec1);

   } else

      abort();

   if (isnan(angle))

      angle = M_PI;

   if (arc->type == VG_SCWARC_TO ||

       arc->type == VG_LCWARC_TO)

      lambda2 = lambda1 - angle;

   else

      lambda2 = lambda1 + angle;

#if DEBUG_ARCS

   debug_printf("Angle is %f and (%f, %f)\n", angle, lambda1, lambda2);

#endif

#if 0

   arc->eta1 = atan2(sin(lambda1) / arc->b,

                     cos(lambda1) / arc->a);

   arc->eta2 = atan2(sin(lambda2) / arc->b,

                     cos(lambda2) / arc->a);

   /* make sure we have eta1 <= eta2 <= eta1 + 2 PI */

   arc->eta2 -= two_pi * floor((arc->eta2 - arc->eta1) / two_pi);

   /* the preceding correction fails if we have exactly et2 - eta1 = 2 PI

      it reduces the interval to zero length */

   if ((lambda2 - lambda1 > M_PI) && (arc->eta2 - arc->eta1 < M_PI)) {

      arc->eta2 += 2 * M_PI;

   }

#else

   arc->eta1 = lambda1;

   arc->eta2 = lambda2;

#endif

   return VG_TRUE;

}

#if DEBUG_ARCS

static void check_endpoints(struct arc *arc)

{

   double x1, y1, x2, y2;

   double a_cos_eta1 = arc->a * cos(arc->eta1);

   double b_sin_eta1 = arc->b * sin(arc->eta1);

   x1 = arc->cx + a_cos_eta1 * arc->cos_theta -

        b_sin_eta1 * arc->sin_theta;

   y1 = arc->cy + a_cos_eta1 * arc->sin_theta +

        b_sin_eta1 * arc->cos_theta;

   double a_cos_eta2 = arc->a * cos(arc->eta2);

   double b_sin_eta2 = arc->b * sin(arc->eta2);

   x2 = arc->cx + a_cos_eta2 * arc->cos_theta -

        b_sin_eta2 * arc->sin_theta;

   y2 = arc->cy + a_cos_eta2 * arc->sin_theta +

        b_sin_eta2 * arc->cos_theta;

   debug_printf("Computed (%f, %f), (%f, %f)\n",

                x1, y1, x2, y2);

   debug_printf("Real     (%f, %f), (%f, %f)\n",

                arc->x1, arc->y1,

                arc->x2, arc->y2);

}

#endif

void arc_init(struct arc *arc,

              VGPathSegment type,

              VGfloat x1, VGfloat y1,

              VGfloat x2, VGfloat y2,

              VGfloat rh, VGfloat rv,

              VGfloat rot)

{

   assert(type == VG_SCCWARC_TO ||

          type == VG_SCWARC_TO ||

          type == VG_LCCWARC_TO ||

          type == VG_LCWARC_TO);

   arc->type = type;

   arc->x1  = x1;

   arc->y1  = y1;

   arc->x2  = x2;

   arc->y2  = y2;

   arc->a   = rh;

   arc->b   = rv;

   arc->theta = rot;

   arc->cos_theta = cos(arc->theta);

   arc->sin_theta = sin(arc->theta);

   {

      double cx0, cy0, cx1, cy1;

      double cx, cy;

      arc->is_valid =  find_ellipses(rh, rv, rot, x1, y1, x2, y2,

                                     &cx0, &cy0, &cx1, &cy1);

      if (!arc->is_valid && try_to_fix_radii(arc)) {

         rh = arc->a;

         rv = arc->b;

         arc->is_valid =

            find_ellipses(rh, rv, rot, x1, y1, x2, y2,

                          &cx0, &cy0, &cx1, &cy1);

      }

      if (type == VG_SCWARC_TO ||

          type == VG_LCCWARC_TO) {

         cx = cx1;

         cy = cy1;

      } else {

         cx = cx0;

         cy = cy0;

      }

#if DEBUG_ARCS

      debug_printf("Centers are : (%f, %f) , (%f, %f). Real (%f, %f)\n",

                   cx0, cy0, cx1, cy1, cx, cy);

#endif

      arc->cx = cx;

      arc->cy = cy;

      if (arc->is_valid) {

         arc->is_valid = find_angles(arc);

#if DEBUG_ARCS

         check_endpoints(arc);

#endif

         /* remap a few points. find_angles requires

          * rot in angles, the rest of the code

          * will need them in radians. and find_angles

          * modifies the center to match an identity

          * circle so lets reset it */

         arc->theta = DEGREES_TO_RADIANS(rot);

         arc->cos_theta = cos(arc->theta);

         arc->sin_theta = sin(arc->theta);

         arc->cx = cx;

         arc->cy = cy;

      }

   }

}

static INLINE double rational_function(double x, const double *c)

{

   return (x * (x * c[0] + c[1]) + c[2]) / (x + c[3]);

}

static double estimate_error(struct arc *arc,

                             double etaA, double etaB)

{

   double eta  = 0.5 * (etaA + etaB);

   double x    = arc->b / arc->a;

   double dEta = etaB - etaA;

   double cos2 = cos(2 * eta);

   double cos4 = cos(4 * eta);

   double cos6 = cos(6 * eta);

   double c0, c1;

   /* select the right coeficients set according to degree and b/a */

   const double (*coeffs)[4][4];

   const double *safety;

   coeffs = (x < 0.25) ? coeffs3Low : coeffs3High;

   safety = safety3;

   c0 = rational_function(x, coeffs[0][0])

        + cos2 * rational_function(x, coeffs[0][1])

        + cos4 * rational_function(x, coeffs[0][2])

        + cos6 * rational_function(x, coeffs[0][3]);

   c1 = rational_function(x, coeffs[1][0])

        + cos2 * rational_function(x, coeffs[1][1])

        + cos4 * rational_function(x, coeffs[1][2])

        + cos6 * rational_function(x, coeffs[1][3]);

   return rational_function(x, safety) * arc->a * exp(c0 + c1 * dEta);

}

struct arc_cb {

   void (*move)(struct arc_cb *cb, VGfloat x, VGfloat y);

   void (*point)(struct arc_cb *cb, VGfloat x, VGfloat y);

   void (*bezier)(struct arc_cb *cb, struct bezier *bezier);

   void *user_data;

};

static void cb_null_move(struct arc_cb *cb, VGfloat x, VGfloat y)

{

}

static void polygon_point(struct arc_cb *cb, VGfloat x, VGfloat y)

{

   struct polygon *poly = (struct polygon*)cb->user_data;

   polygon_vertex_append(poly, x, y);

}

static void polygon_bezier(struct arc_cb *cb, struct bezier *bezier)

{

   struct polygon *poly = (struct polygon*)cb->user_data;

   bezier_add_to_polygon(bezier, poly);

}

static void stroke_point(struct arc_cb *cb, VGfloat x, VGfloat y)

{

   struct stroker *stroker = (struct stroker*)cb->user_data;

   stroker_line_to(stroker, x, y);

}

static void stroke_curve(struct arc_cb *cb, struct bezier *bezier)

{

   struct stroker *stroker = (struct stroker*)cb->user_data;

   stroker_curve_to(stroker,

                    bezier->x2, bezier->y2,

                    bezier->x3, bezier->y3,

                    bezier->x4, bezier->y4);

}

static void stroke_emit_point(struct arc_cb *cb, VGfloat x, VGfloat y)

{

   struct stroker *stroker = (struct stroker*)cb->user_data;

   stroker_emit_line_to(stroker, x, y);

}

static void stroke_emit_curve(struct arc_cb *cb, struct bezier *bezier)

{

   struct stroker *stroker = (struct stroker*)cb->user_data;

   stroker_emit_curve_to(stroker,

                         bezier->x2, bezier->y2,

                         bezier->x3, bezier->y3,

                         bezier->x4, bezier->y4);

}

static void arc_path_move(struct arc_cb *cb, VGfloat x, VGfloat y)

{

   struct path *path = (struct path*)cb->user_data;

   path_move_to(path, x, y);

}

static void arc_path_point(struct arc_cb *cb, VGfloat x, VGfloat y)

{

   struct path *path = (struct path*)cb->user_data;

   path_line_to(path, x, y);

}

static void arc_path_bezier(struct arc_cb *cb, struct bezier *bezier)

{

   struct path *path = (struct path*)cb->user_data;

   path_cubic_to(path,

                 bezier->x2, bezier->y2,

                 bezier->x3, bezier->y3,

                 bezier->x4, bezier->y4);

}

static INLINE int num_beziers_needed(struct arc *arc)

{

   double threshold = 0.05;

   VGboolean found = VG_FALSE;

   int n = 1;

   double min_eta, max_eta;

   min_eta = MIN2(arc->eta1, arc->eta2);

   max_eta = MAX2(arc->eta1, arc->eta2);

   while ((! found) && (n < 1024)) {

      double d_eta = (max_eta - min_eta) / n;

      if (d_eta <= 0.5 * M_PI) {

         double eta_b = min_eta;

         int i;

         found = VG_TRUE;

         for (i = 0; found && (i < n); ++i) {

            double etaA = eta_b;

            eta_b += d_eta;

            found = (estimate_error(arc, etaA, eta_b) <= threshold);

         }

      }

      n = n << 1;

   }

   return n;

}

static void arc_to_beziers(struct arc *arc,

                           struct arc_cb cb,

                           struct matrix *matrix)

{

   int i;

   int n = 1;

   double d_eta, eta_b, cos_eta_b,

      sin_eta_b, a_cos_eta_b, b_sin_eta_b, a_sin_eta_b,

      b_cos_eta_b, x_b, y_b, x_b_dot, y_b_dot, lx, ly;

   double t, alpha;

   { /* always move to the start of the arc */

      VGfloat x = arc->x1;

      VGfloat y = arc->y1;

      matrix_map_point(matrix, x, y, &x, &y);

      cb.move(&cb, x, y);

   }

   if (!arc->is_valid) {

      VGfloat x = arc->x2;

      VGfloat y = arc->y2;

      matrix_map_point(matrix, x, y, &x, &y);

      cb.point(&cb, x, y);

      return;

   }

   /* find the number of Bézier curves needed */

   n = num_beziers_needed(arc);

   d_eta = (arc->eta2 - arc->eta1) / n;

   eta_b = arc->eta1;

   cos_eta_b  = cos(eta_b);

   sin_eta_b  = sin(eta_b);

   a_cos_eta_b = arc->a * cos_eta_b;

   b_sin_eta_b = arc->b * sin_eta_b;

   a_sin_eta_b = arc->a * sin_eta_b;

   b_cos_eta_b = arc->b * cos_eta_b;

   x_b       = arc->cx + a_cos_eta_b * arc->cos_theta -

               b_sin_eta_b * arc->sin_theta;

   y_b       = arc->cy + a_cos_eta_b * arc->sin_theta +

               b_sin_eta_b * arc->cos_theta;

   x_b_dot    = -a_sin_eta_b * arc->cos_theta -

                b_cos_eta_b * arc->sin_theta;

   y_b_dot    = -a_sin_eta_b * arc->sin_theta +

                b_cos_eta_b * arc->cos_theta;

   {

      VGfloat x = x_b, y = y_b;

      matrix_map_point(matrix, x, y, &x, &y);

      cb.point(&cb, x, y);

   }

   lx = x_b;

   ly = y_b;

   t     = tan(0.5 * d_eta);

   alpha = sin(d_eta) * (sqrt(4 + 3 * t * t) - 1) / 3;

   for (i = 0; i < n; ++i) {

      struct bezier bezier;

      double xA    = x_b;

      double yA    = y_b;

      double xADot = x_b_dot;

      double yADot = y_b_dot;

      eta_b    += d_eta;

      cos_eta_b  = cos(eta_b);

      sin_eta_b  = sin(eta_b);

      a_cos_eta_b = arc->a * cos_eta_b;

      b_sin_eta_b = arc->b * sin_eta_b;

      a_sin_eta_b = arc->a * sin_eta_b;

      b_cos_eta_b = arc->b * cos_eta_b;

      x_b       = arc->cx + a_cos_eta_b * arc->cos_theta -

                  b_sin_eta_b * arc->sin_theta;

      y_b       = arc->cy + a_cos_eta_b * arc->sin_theta +

                  b_sin_eta_b * arc->cos_theta;

      x_b_dot    = -a_sin_eta_b * arc->cos_theta -

                   b_cos_eta_b * arc->sin_theta;

      y_b_dot    = -a_sin_eta_b * arc->sin_theta +

                   b_cos_eta_b * arc->cos_theta;

      bezier_init(&bezier,

                  lx, ly,

                  (float) (xA + alpha * xADot), (float) (yA + alpha * yADot),

                  (float) (x_b - alpha * x_b_dot), (float) (y_b - alpha * y_b_dot),

                  (float) x_b,                   (float) y_b);

#if 0

      debug_printf("%d) Bezier (%f, %f), (%f, %f), (%f, %f), (%f, %f)\n",

                   i,

                   bezier.x1, bezier.y1,

                   bezier.x2, bezier.y2,

                   bezier.x3, bezier.y3,

                   bezier.x4, bezier.y4);

#endif

      bezier_transform(&bezier, matrix);

      cb.bezier(&cb, &bezier);

      lx = x_b;

      ly = y_b;

   }

}

void arc_add_to_polygon(struct arc *arc,

                        struct polygon *poly,

                        struct matrix *matrix)

{

   struct arc_cb cb;

   cb.move = cb_null_move;

   cb.point = polygon_point;

   cb.bezier = polygon_bezier;

   cb.user_data = poly;

   arc_to_beziers(arc, cb, matrix);

}

void arc_stroke_cb(struct arc *arc,

                   struct stroker *stroke,

                   struct matrix *matrix)

{

   struct arc_cb cb;

   cb.move = cb_null_move;

   cb.point = stroke_point;

   cb.bezier = stroke_curve;

   cb.user_data = stroke;

   arc_to_beziers(arc, cb, matrix);

}

void arc_stroker_emit(struct arc *arc,

                      struct stroker *stroker,

                      struct matrix *matrix)

{

   struct arc_cb cb;

   cb.move = cb_null_move;

   cb.point = stroke_emit_point;

   cb.bezier = stroke_emit_curve;

   cb.user_data = stroker;

   arc_to_beziers(arc, cb, matrix);

}

void arc_to_path(struct arc *arc,

                 struct path *path,

                 struct matrix *matrix)

{

   struct arc_cb cb;

   cb.move = arc_path_move;

   cb.point = arc_path_point;

   cb.bezier = arc_path_bezier;

   cb.user_data = path;

   arc_to_beziers(arc, cb, matrix);

}