1 /*

     2  * Copyright (c) 2007, 2015, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package sun.java2d.pisces;

    27 

    28 import java.util.Arrays;

    29 import java.util.Iterator;

    30 import static java.lang.Math.ulp;

    31 import static java.lang.Math.sqrt;

    32 

    33 import sun.awt.geom.PathConsumer2D;

    34 

    35 // TODO: some of the arithmetic here is too verbose and prone to hard to

    36 // debug typos. We should consider making a small Point/Vector class that

    37 // has methods like plus(Point), minus(Point), dot(Point), cross(Point)and such

    38 final class Stroker implements PathConsumer2D {

    39 

    40     private static final int MOVE_TO = 0;

    41     private static final int DRAWING_OP_TO = 1; // ie. curve, line, or quad

    42     private static final int CLOSE = 2;

    43 

    44     /**

    45      * Constant value for join style.

    46      */

    47     public static final int JOIN_MITER = 0;

    48 

    49     /**

    50      * Constant value for join style.

    51      */

    52     public static final int JOIN_ROUND = 1;

    53 

    54     /**

    55      * Constant value for join style.

    56      */

    57     public static final int JOIN_BEVEL = 2;

    58 

    59     /**

    60      * Constant value for end cap style.

    61      */

    62     public static final int CAP_BUTT = 0;

    63 

    64     /**

    65      * Constant value for end cap style.

    66      */

    67     public static final int CAP_ROUND = 1;

    68 

    69     /**

    70      * Constant value for end cap style.

    71      */

    72     public static final int CAP_SQUARE = 2;

    73 

    74     private final PathConsumer2D out;

    75 

    76     private final int capStyle;

    77     private final int joinStyle;

    78 

    79     private final float lineWidth2;

    80 

    81     private final float[][] offset = new float[3][2];

    82     private final float[] miter = new float[2];

    83     private final float miterLimitSq;

    84 

    85     private int prev;

    86 

    87     // The starting point of the path, and the slope there.

    88     private float sx0, sy0, sdx, sdy;

    89     // the current point and the slope there.

    90     private float cx0, cy0, cdx, cdy; // c stands for current

    91     // vectors that when added to (sx0,sy0) and (cx0,cy0) respectively yield the

    92     // first and last points on the left parallel path. Since this path is

    93     // parallel, it's slope at any point is parallel to the slope of the

    94     // original path (thought they may have different directions), so these

    95     // could be computed from sdx,sdy and cdx,cdy (and vice versa), but that

    96     // would be error prone and hard to read, so we keep these anyway.

    97     private float smx, smy, cmx, cmy;

    98 

    99     private final PolyStack reverse = new PolyStack();

   100 

   101     /**

   102      * Constructs a {@code Stroker}.

   103      *

   104      * @param pc2d an output {@code PathConsumer2D}.

   105      * @param lineWidth the desired line width in pixels

   106      * @param capStyle the desired end cap style, one of

   107      * {@code CAP_BUTT}, {@code CAP_ROUND} or

   108      * {@code CAP_SQUARE}.

   109      * @param joinStyle the desired line join style, one of

   110      * {@code JOIN_MITER}, {@code JOIN_ROUND} or

   111      * {@code JOIN_BEVEL}.

   112      * @param miterLimit the desired miter limit

   113      */

   114     public Stroker(PathConsumer2D pc2d,

   115                    float lineWidth,

   116                    int capStyle,

   117                    int joinStyle,

   118                    float miterLimit)

   119     {

   120         this.out = pc2d;

   121 

   122         this.lineWidth2 = lineWidth / 2;

   123         this.capStyle = capStyle;

   124         this.joinStyle = joinStyle;

   125 

   126         float limit = miterLimit * lineWidth2;

   127         this.miterLimitSq = limit*limit;

   128 

   129         this.prev = CLOSE;

   130     }

   131 

   132     private static void computeOffset(final float lx, final float ly,

   133                                       final float w, final float[] m)

   134     {

   135         final float len = (float) sqrt(lx*lx + ly*ly);

   136         if (len == 0) {

   137             m[0] = m[1] = 0;

   138         } else {

   139             m[0] = (ly * w)/len;

   140             m[1] = -(lx * w)/len;

   141         }

   142     }

   143 

   144     // Returns true if the vectors (dx1, dy1) and (dx2, dy2) are

   145     // clockwise (if dx1,dy1 needs to be rotated clockwise to close

   146     // the smallest angle between it and dx2,dy2).

   147     // This is equivalent to detecting whether a point q is on the right side

   148     // of a line passing through points p1, p2 where p2 = p1+(dx1,dy1) and

   149     // q = p2+(dx2,dy2), which is the same as saying p1, p2, q are in a

   150     // clockwise order.

   151     // NOTE: "clockwise" here assumes coordinates with 0,0 at the bottom left.

   152     private static boolean isCW(final float dx1, final float dy1,

   153                                 final float dx2, final float dy2)

   154     {

   155         return dx1 * dy2 <= dy1 * dx2;

   156     }

   157 

   158     // pisces used to use fixed point arithmetic with 16 decimal digits. I

   159     // didn't want to change the values of the constant below when I converted

   160     // it to floating point, so that's why the divisions by 2^16 are there.

   161     private static final float ROUND_JOIN_THRESHOLD = 1000/65536f;

   162 

   163     private void drawRoundJoin(float x, float y,

   164                                float omx, float omy, float mx, float my,

   165                                boolean rev,

   166                                float threshold)

   167     {

   168         if ((omx == 0 && omy == 0) || (mx == 0 && my == 0)) {

   169             return;

   170         }

   171 

   172         float domx = omx - mx;

   173         float domy = omy - my;

   174         float len = domx*domx + domy*domy;

   175         if (len < threshold) {

   176             return;

   177         }

   178 

   179         if (rev) {

   180             omx = -omx;

   181             omy = -omy;

   182             mx = -mx;

   183             my = -my;

   184         }

   185         drawRoundJoin(x, y, omx, omy, mx, my, rev);

   186     }

   187 

   188     private void drawRoundJoin(float cx, float cy,

   189                                float omx, float omy,

   190                                float mx, float my,

   191                                boolean rev)

   192     {

   193         // The sign of the dot product of mx,my and omx,omy is equal to the

   194         // the sign of the cosine of ext

   195         // (ext is the angle between omx,omy and mx,my).

   196         final float cosext = omx * mx + omy * my;

   197         // If it is >=0, we know that abs(ext) is <= 90 degrees, so we only

   198         // need 1 curve to approximate the circle section that joins omx,omy

   199         // and mx,my.

   200         final int numCurves = (cosext >= 0f) ? 1 : 2;

   201 

   202         switch (numCurves) {

   203         case 1:

   204             drawBezApproxForArc(cx, cy, omx, omy, mx, my, rev);

   205             break;

   206         case 2:

   207             // we need to split the arc into 2 arcs spanning the same angle.

   208             // The point we want will be one of the 2 intersections of the

   209             // perpendicular bisector of the chord (omx,omy)->(mx,my) and the

   210             // circle. We could find this by scaling the vector

   211             // (omx+mx, omy+my)/2 so that it has length=lineWidth2 (and thus lies

   212             // on the circle), but that can have numerical problems when the angle

   213             // between omx,omy and mx,my is close to 180 degrees. So we compute a

   214             // normal of (omx,omy)-(mx,my). This will be the direction of the

   215             // perpendicular bisector. To get one of the intersections, we just scale

   216             // this vector that its length is lineWidth2 (this works because the

   217             // perpendicular bisector goes through the origin). This scaling doesn't

   218             // have numerical problems because we know that lineWidth2 divided by

   219             // this normal's length is at least 0.5 and at most sqrt(2)/2 (because

   220             // we know the angle of the arc is > 90 degrees).

   221             float nx = my - omy, ny = omx - mx;

   222             float nlen = (float) sqrt(nx*nx + ny*ny);

   223             float scale = lineWidth2/nlen;

   224             float mmx = nx * scale, mmy = ny * scale;

   225 

   226             // if (isCW(omx, omy, mx, my) != isCW(mmx, mmy, mx, my)) then we've

   227             // computed the wrong intersection so we get the other one.

   228             // The test above is equivalent to if (rev).

   229             if (rev) {

   230                 mmx = -mmx;

   231                 mmy = -mmy;

   232             }

   233             drawBezApproxForArc(cx, cy, omx, omy, mmx, mmy, rev);

   234             drawBezApproxForArc(cx, cy, mmx, mmy, mx, my, rev);

   235             break;

   236         }

   237     }

   238 

   239     // the input arc defined by omx,omy and mx,my must span <= 90 degrees.

   240     private void drawBezApproxForArc(final float cx, final float cy,

   241                                      final float omx, final float omy,

   242                                      final float mx, final float my,

   243                                      boolean rev)

   244     {

   245         final float cosext2 = (omx * mx + omy * my) / (2f * lineWidth2 * lineWidth2);

   246 

   247         // check round off errors producing cos(ext) > 1 and a NaN below

   248         // cos(ext) == 1 implies colinear segments and an empty join anyway

   249         if (cosext2 >= 0.5f) {

   250             // just return to avoid generating a flat curve:

   251             return;

   252         }

   253 

   254         // cv is the length of P1-P0 and P2-P3 divided by the radius of the arc

   255         // (so, cv assumes the arc has radius 1). P0, P1, P2, P3 are the points that

   256         // define the bezier curve we're computing.

   257         // It is computed using the constraints that P1-P0 and P3-P2 are parallel

   258         // to the arc tangents at the endpoints, and that |P1-P0|=|P3-P2|.

   259         float cv = (float) ((4.0 / 3.0) * sqrt(0.5 - cosext2) /

   260                             (1.0 + sqrt(cosext2 + 0.5)));

   261         // if clockwise, we need to negate cv.

   262         if (rev) { // rev is equivalent to isCW(omx, omy, mx, my)

   263             cv = -cv;

   264         }

   265         final float x1 = cx + omx;

   266         final float y1 = cy + omy;

   267         final float x2 = x1 - cv * omy;

   268         final float y2 = y1 + cv * omx;

   269 

   270         final float x4 = cx + mx;

   271         final float y4 = cy + my;

   272         final float x3 = x4 + cv * my;

   273         final float y3 = y4 - cv * mx;

   274 

   275         emitCurveTo(x1, y1, x2, y2, x3, y3, x4, y4, rev);

   276     }

   277 

   278     private void drawRoundCap(float cx, float cy, float mx, float my) {

   279         final float C = 0.5522847498307933f;

   280         // the first and second arguments of the following two calls

   281         // are really will be ignored by emitCurveTo (because of the false),

   282         // but we put them in anyway, as opposed to just giving it 4 zeroes,

   283         // because it's just 4 additions and it's not good to rely on this

   284         // sort of assumption (right now it's true, but that may change).

   285         emitCurveTo(cx+mx,      cy+my,

   286                     cx+mx-C*my, cy+my+C*mx,

   287                     cx-my+C*mx, cy+mx+C*my,

   288                     cx-my,      cy+mx,

   289                     false);

   290         emitCurveTo(cx-my,      cy+mx,

   291                     cx-my-C*mx, cy+mx-C*my,

   292                     cx-mx-C*my, cy-my+C*mx,

   293                     cx-mx,      cy-my,

   294                     false);

   295     }

   296 

   297     // Put the intersection point of the lines (x0, y0) -> (x1, y1)

   298     // and (x0p, y0p) -> (x1p, y1p) in m[off] and m[off+1].

   299     // If the lines are parallel, it will put a non finite number in m.

   300     private void computeIntersection(final float x0, final float y0,

   301                                      final float x1, final float y1,

   302                                      final float x0p, final float y0p,

   303                                      final float x1p, final float y1p,

   304                                      final float[] m, int off)

   305     {

   306         float x10 = x1 - x0;

   307         float y10 = y1 - y0;

   308         float x10p = x1p - x0p;

   309         float y10p = y1p - y0p;

   310 

   311         float den = x10*y10p - x10p*y10;

   312         float t = x10p*(y0-y0p) - y10p*(x0-x0p);

   313         t /= den;

   314         m[off++] = x0 + t*x10;

   315         m[off] = y0 + t*y10;

   316     }

   317 

   318     private void drawMiter(final float pdx, final float pdy,

   319                            final float x0, final float y0,

   320                            final float dx, final float dy,

   321                            float omx, float omy, float mx, float my,

   322                            boolean rev)

   323     {

   324         if ((mx == omx && my == omy) ||

   325             (pdx == 0 && pdy == 0) ||

   326             (dx == 0 && dy == 0))

   327         {

   328             return;

   329         }

   330 

   331         if (rev) {

   332             omx = -omx;

   333             omy = -omy;

   334             mx = -mx;

   335             my = -my;

   336         }

   337 

   338         computeIntersection((x0 - pdx) + omx, (y0 - pdy) + omy, x0 + omx, y0 + omy,

   339                             (dx + x0) + mx, (dy + y0) + my, x0 + mx, y0 + my,

   340                             miter, 0);

   341 

   342         float lenSq = (miter[0]-x0)*(miter[0]-x0) + (miter[1]-y0)*(miter[1]-y0);

   343 

   344         // If the lines are parallel, lenSq will be either NaN or +inf

   345         // (actually, I'm not sure if the latter is possible. The important

   346         // thing is that -inf is not possible, because lenSq is a square).

   347         // For both of those values, the comparison below will fail and

   348         // no miter will be drawn, which is correct.

   349         if (lenSq < miterLimitSq) {

   350             emitLineTo(miter[0], miter[1], rev);

   351         }

   352     }

   353 

   354     public void moveTo(float x0, float y0) {

   355         if (prev == DRAWING_OP_TO) {

   356             finish();

   357         }

   358         this.sx0 = this.cx0 = x0;

   359         this.sy0 = this.cy0 = y0;

   360         this.cdx = this.sdx = 1;

   361         this.cdy = this.sdy = 0;

   362         this.prev = MOVE_TO;

   363     }

   364 

   365     public void lineTo(float x1, float y1) {

   366         float dx = x1 - cx0;

   367         float dy = y1 - cy0;

   368         if (dx == 0f && dy == 0f) {

   369             dx = 1;

   370         }

   371         computeOffset(dx, dy, lineWidth2, offset[0]);

   372         float mx = offset[0][0];

   373         float my = offset[0][1];

   374 

   375         drawJoin(cdx, cdy, cx0, cy0, dx, dy, cmx, cmy, mx, my);

   376 

   377         emitLineTo(cx0 + mx, cy0 + my);

   378         emitLineTo(x1 + mx, y1 + my);

   379 

   380         emitLineTo(cx0 - mx, cy0 - my, true);

   381         emitLineTo(x1 - mx, y1 - my, true);

   382 

   383         this.cmx = mx;

   384         this.cmy = my;

   385         this.cdx = dx;

   386         this.cdy = dy;

   387         this.cx0 = x1;

   388         this.cy0 = y1;

   389         this.prev = DRAWING_OP_TO;

   390     }

   391 

   392     public void closePath() {

   393         if (prev != DRAWING_OP_TO) {

   394             if (prev == CLOSE) {

   395                 return;

   396             }

   397             emitMoveTo(cx0, cy0 - lineWidth2);

   398             this.cmx = this.smx = 0;

   399             this.cmy = this.smy = -lineWidth2;

   400             this.cdx = this.sdx = 1;

   401             this.cdy = this.sdy = 0;

   402             finish();

   403             return;

   404         }

   405 

   406         if (cx0 != sx0 || cy0 != sy0) {

   407             lineTo(sx0, sy0);

   408         }

   409 

   410         drawJoin(cdx, cdy, cx0, cy0, sdx, sdy, cmx, cmy, smx, smy);

   411 

   412         emitLineTo(sx0 + smx, sy0 + smy);

   413 

   414         emitMoveTo(sx0 - smx, sy0 - smy);

   415         emitReverse();

   416 

   417         this.prev = CLOSE;

   418         emitClose();

   419     }

   420 

   421     private void emitReverse() {

   422         while(!reverse.isEmpty()) {

   423             reverse.pop(out);

   424         }

   425     }

   426 

   427     public void pathDone() {

   428         if (prev == DRAWING_OP_TO) {

   429             finish();

   430         }

   431 

   432         out.pathDone();

   433         // this shouldn't matter since this object won't be used

   434         // after the call to this method.

   435         this.prev = CLOSE;

   436     }

   437 

   438     private void finish() {

   439         if (capStyle == CAP_ROUND) {

   440             drawRoundCap(cx0, cy0, cmx, cmy);

   441         } else if (capStyle == CAP_SQUARE) {

   442             emitLineTo(cx0 - cmy + cmx, cy0 + cmx + cmy);

   443             emitLineTo(cx0 - cmy - cmx, cy0 + cmx - cmy);

   444         }

   445 

   446         emitReverse();

   447 

   448         if (capStyle == CAP_ROUND) {

   449             drawRoundCap(sx0, sy0, -smx, -smy);

   450         } else if (capStyle == CAP_SQUARE) {

   451             emitLineTo(sx0 + smy - smx, sy0 - smx - smy);

   452             emitLineTo(sx0 + smy + smx, sy0 - smx + smy);

   453         }

   454 

   455         emitClose();

   456     }

   457 

   458     private void emitMoveTo(final float x0, final float y0) {

   459         out.moveTo(x0, y0);

   460     }

   461 

   462     private void emitLineTo(final float x1, final float y1) {

   463         out.lineTo(x1, y1);

   464     }

   465 

   466     private void emitLineTo(final float x1, final float y1,

   467                             final boolean rev)

   468     {

   469         if (rev) {

   470             reverse.pushLine(x1, y1);

   471         } else {

   472             emitLineTo(x1, y1);

   473         }

   474     }

   475 

   476     private void emitQuadTo(final float x0, final float y0,

   477                             final float x1, final float y1,

   478                             final float x2, final float y2, final boolean rev)

   479     {

   480         if (rev) {

   481             reverse.pushQuad(x0, y0, x1, y1);

   482         } else {

   483             out.quadTo(x1, y1, x2, y2);

   484         }

   485     }

   486 

   487     private void emitCurveTo(final float x0, final float y0,

   488                              final float x1, final float y1,

   489                              final float x2, final float y2,

   490                              final float x3, final float y3, final boolean rev)

   491     {

   492         if (rev) {

   493             reverse.pushCubic(x0, y0, x1, y1, x2, y2);

   494         } else {

   495             out.curveTo(x1, y1, x2, y2, x3, y3);

   496         }

   497     }

   498 

   499     private void emitClose() {

   500         out.closePath();

   501     }

   502 

   503     private void drawJoin(float pdx, float pdy,

   504                           float x0, float y0,

   505                           float dx, float dy,

   506                           float omx, float omy,

   507                           float mx, float my)

   508     {

   509         if (prev != DRAWING_OP_TO) {

   510             emitMoveTo(x0 + mx, y0 + my);

   511             this.sdx = dx;

   512             this.sdy = dy;

   513             this.smx = mx;

   514             this.smy = my;

   515         } else {

   516             boolean cw = isCW(pdx, pdy, dx, dy);

   517             if (joinStyle == JOIN_MITER) {

   518                 drawMiter(pdx, pdy, x0, y0, dx, dy, omx, omy, mx, my, cw);

   519             } else if (joinStyle == JOIN_ROUND) {

   520                 drawRoundJoin(x0, y0,

   521                               omx, omy,

   522                               mx, my, cw,

   523                               ROUND_JOIN_THRESHOLD);

   524             }

   525             emitLineTo(x0, y0, !cw);

   526         }

   527         prev = DRAWING_OP_TO;

   528     }

   529 

   530     private static boolean within(final float x1, final float y1,

   531                                   final float x2, final float y2,

   532                                   final float ERR)

   533     {

   534         assert ERR > 0 : "";

   535         // compare taxicab distance. ERR will always be small, so using

   536         // true distance won't give much benefit

   537         return (Helpers.within(x1, x2, ERR) &&  // we want to avoid calling Math.abs

   538                 Helpers.within(y1, y2, ERR)); // this is just as good.

   539     }

   540 

   541     private void getLineOffsets(float x1, float y1,

   542                                 float x2, float y2,

   543                                 float[] left, float[] right) {

   544         computeOffset(x2 - x1, y2 - y1, lineWidth2, offset[0]);

   545         left[0] = x1 + offset[0][0];

   546         left[1] = y1 + offset[0][1];

   547         left[2] = x2 + offset[0][0];

   548         left[3] = y2 + offset[0][1];

   549         right[0] = x1 - offset[0][0];

   550         right[1] = y1 - offset[0][1];

   551         right[2] = x2 - offset[0][0];

   552         right[3] = y2 - offset[0][1];

   553     }

   554 

   555     private int computeOffsetCubic(float[] pts, final int off,

   556                                    float[] leftOff, float[] rightOff)

   557     {

   558         // if p1=p2 or p3=p4 it means that the derivative at the endpoint

   559         // vanishes, which creates problems with computeOffset. Usually

   560         // this happens when this stroker object is trying to winden

   561         // a curve with a cusp. What happens is that curveTo splits

   562         // the input curve at the cusp, and passes it to this function.

   563         // because of inaccuracies in the splitting, we consider points

   564         // equal if they're very close to each other.

   565         final float x1 = pts[off + 0], y1 = pts[off + 1];

   566         final float x2 = pts[off + 2], y2 = pts[off + 3];

   567         final float x3 = pts[off + 4], y3 = pts[off + 5];

   568         final float x4 = pts[off + 6], y4 = pts[off + 7];

   569 

   570         float dx4 = x4 - x3;

   571         float dy4 = y4 - y3;

   572         float dx1 = x2 - x1;

   573         float dy1 = y2 - y1;

   574 

   575         // if p1 == p2 && p3 == p4: draw line from p1->p4, unless p1 == p4,

   576         // in which case ignore if p1 == p2

   577         final boolean p1eqp2 = within(x1,y1,x2,y2, 6 * ulp(y2));

   578         final boolean p3eqp4 = within(x3,y3,x4,y4, 6 * ulp(y4));

   579         if (p1eqp2 && p3eqp4) {

   580             getLineOffsets(x1, y1, x4, y4, leftOff, rightOff);

   581             return 4;

   582         } else if (p1eqp2) {

   583             dx1 = x3 - x1;

   584             dy1 = y3 - y1;

   585         } else if (p3eqp4) {

   586             dx4 = x4 - x2;

   587             dy4 = y4 - y2;

   588         }

   589 

   590         // if p2-p1 and p4-p3 are parallel, that must mean this curve is a line

   591         float dotsq = (dx1 * dx4 + dy1 * dy4);

   592         dotsq = dotsq * dotsq;

   593         float l1sq = dx1 * dx1 + dy1 * dy1, l4sq = dx4 * dx4 + dy4 * dy4;

   594         if (Helpers.within(dotsq, l1sq * l4sq, 4 * ulp(dotsq))) {

   595             getLineOffsets(x1, y1, x4, y4, leftOff, rightOff);

   596             return 4;

   597         }

   598 

   599 //      What we're trying to do in this function is to approximate an ideal

   600 //      offset curve (call it I) of the input curve B using a bezier curve Bp.

   601 //      The constraints I use to get the equations are:

   602 //

   603 //      1. The computed curve Bp should go through I(0) and I(1). These are

   604 //      x1p, y1p, x4p, y4p, which are p1p and p4p. We still need to find

   605 //      4 variables: the x and y components of p2p and p3p (i.e. x2p, y2p, x3p, y3p).

   606 //

   607 //      2. Bp should have slope equal in absolute value to I at the endpoints. So,

   608 //      (by the way, the operator || in the comments below means "aligned with".

   609 //      It is defined on vectors, so when we say I'(0) || Bp'(0) we mean that

   610 //      vectors I'(0) and Bp'(0) are aligned, which is the same as saying

   611 //      that the tangent lines of I and Bp at 0 are parallel. Mathematically

   612 //      this means (I'(t) || Bp'(t)) <==> (I'(t) = c * Bp'(t)) where c is some

   613 //      nonzero constant.)

   614 //      I'(0) || Bp'(0) and I'(1) || Bp'(1). Obviously, I'(0) || B'(0) and

   615 //      I'(1) || B'(1); therefore, Bp'(0) || B'(0) and Bp'(1) || B'(1).

   616 //      We know that Bp'(0) || (p2p-p1p) and Bp'(1) || (p4p-p3p) and the same

   617 //      is true for any bezier curve; therefore, we get the equations

   618 //          (1) p2p = c1 * (p2-p1) + p1p

   619 //          (2) p3p = c2 * (p4-p3) + p4p

   620 //      We know p1p, p4p, p2, p1, p3, and p4; therefore, this reduces the number

   621 //      of unknowns from 4 to 2 (i.e. just c1 and c2).

   622 //      To eliminate these 2 unknowns we use the following constraint:

   623 //

   624 //      3. Bp(0.5) == I(0.5). Bp(0.5)=(x,y) and I(0.5)=(xi,yi), and I should note

   625 //      that I(0.5) is *the only* reason for computing dxm,dym. This gives us

   626 //          (3) Bp(0.5) = (p1p + 3 * (p2p + p3p) + p4p)/8, which is equivalent to

   627 //          (4) p2p + p3p = (Bp(0.5)*8 - p1p - p4p) / 3

   628 //      We can substitute (1) and (2) from above into (4) and we get:

   629 //          (5) c1*(p2-p1) + c2*(p4-p3) = (Bp(0.5)*8 - p1p - p4p)/3 - p1p - p4p

   630 //      which is equivalent to

   631 //          (6) c1*(p2-p1) + c2*(p4-p3) = (4/3) * (Bp(0.5) * 2 - p1p - p4p)

   632 //

   633 //      The right side of this is a 2D vector, and we know I(0.5), which gives us

   634 //      Bp(0.5), which gives us the value of the right side.

   635 //      The left side is just a matrix vector multiplication in disguise. It is

   636 //

   637 //      [x2-x1, x4-x3][c1]

   638 //      [y2-y1, y4-y3][c2]

   639 //      which, is equal to

   640 //      [dx1, dx4][c1]

   641 //      [dy1, dy4][c2]

   642 //      At this point we are left with a simple linear system and we solve it by

   643 //      getting the inverse of the matrix above. Then we use [c1,c2] to compute

   644 //      p2p and p3p.

   645 

   646         float x = 0.125f * (x1 + 3 * (x2 + x3) + x4);

   647         float y = 0.125f * (y1 + 3 * (y2 + y3) + y4);

   648         // (dxm,dym) is some tangent of B at t=0.5. This means it's equal to

   649         // c*B'(0.5) for some constant c.

   650         float dxm = x3 + x4 - x1 - x2, dym = y3 + y4 - y1 - y2;

   651 

   652         // this computes the offsets at t=0, 0.5, 1, using the property that

   653         // for any bezier curve the vectors p2-p1 and p4-p3 are parallel to

   654         // the (dx/dt, dy/dt) vectors at the endpoints.

   655         computeOffset(dx1, dy1, lineWidth2, offset[0]);

   656         computeOffset(dxm, dym, lineWidth2, offset[1]);

   657         computeOffset(dx4, dy4, lineWidth2, offset[2]);

   658         float x1p = x1 + offset[0][0]; // start

   659         float y1p = y1 + offset[0][1]; // point

   660         float xi  = x + offset[1][0]; // interpolation

   661         float yi  = y + offset[1][1]; // point

   662         float x4p = x4 + offset[2][0]; // end

   663         float y4p = y4 + offset[2][1]; // point

   664 

   665         float invdet43 = 4f / (3f * (dx1 * dy4 - dy1 * dx4));

   666 

   667         float two_pi_m_p1_m_p4x = 2*xi - x1p - x4p;

   668         float two_pi_m_p1_m_p4y = 2*yi - y1p - y4p;

   669         float c1 = invdet43 * (dy4 * two_pi_m_p1_m_p4x - dx4 * two_pi_m_p1_m_p4y);

   670         float c2 = invdet43 * (dx1 * two_pi_m_p1_m_p4y - dy1 * two_pi_m_p1_m_p4x);

   671 

   672         float x2p, y2p, x3p, y3p;

   673         x2p = x1p + c1*dx1;

   674         y2p = y1p + c1*dy1;

   675         x3p = x4p + c2*dx4;

   676         y3p = y4p + c2*dy4;

   677 

   678         leftOff[0] = x1p; leftOff[1] = y1p;

   679         leftOff[2] = x2p; leftOff[3] = y2p;

   680         leftOff[4] = x3p; leftOff[5] = y3p;

   681         leftOff[6] = x4p; leftOff[7] = y4p;

   682 

   683         x1p = x1 - offset[0][0]; y1p = y1 - offset[0][1];

   684         xi = xi - 2 * offset[1][0]; yi = yi - 2 * offset[1][1];

   685         x4p = x4 - offset[2][0]; y4p = y4 - offset[2][1];

   686 

   687         two_pi_m_p1_m_p4x = 2*xi - x1p - x4p;

   688         two_pi_m_p1_m_p4y = 2*yi - y1p - y4p;

   689         c1 = invdet43 * (dy4 * two_pi_m_p1_m_p4x - dx4 * two_pi_m_p1_m_p4y);

   690         c2 = invdet43 * (dx1 * two_pi_m_p1_m_p4y - dy1 * two_pi_m_p1_m_p4x);

   691 

   692         x2p = x1p + c1*dx1;

   693         y2p = y1p + c1*dy1;

   694         x3p = x4p + c2*dx4;

   695         y3p = y4p + c2*dy4;

   696 

   697         rightOff[0] = x1p; rightOff[1] = y1p;

   698         rightOff[2] = x2p; rightOff[3] = y2p;

   699         rightOff[4] = x3p; rightOff[5] = y3p;

   700         rightOff[6] = x4p; rightOff[7] = y4p;

   701         return 8;

   702     }

   703 

   704     // return the kind of curve in the right and left arrays.

   705     private int computeOffsetQuad(float[] pts, final int off,

   706                                   float[] leftOff, float[] rightOff)

   707     {

   708         final float x1 = pts[off + 0], y1 = pts[off + 1];

   709         final float x2 = pts[off + 2], y2 = pts[off + 3];

   710         final float x3 = pts[off + 4], y3 = pts[off + 5];

   711 

   712         final float dx3 = x3 - x2;

   713         final float dy3 = y3 - y2;

   714         final float dx1 = x2 - x1;

   715         final float dy1 = y2 - y1;

   716 

   717         // this computes the offsets at t = 0, 1

   718         computeOffset(dx1, dy1, lineWidth2, offset[0]);

   719         computeOffset(dx3, dy3, lineWidth2, offset[1]);

   720 

   721         leftOff[0]  = x1 + offset[0][0];  leftOff[1] = y1 + offset[0][1];

   722         leftOff[4]  = x3 + offset[1][0];  leftOff[5] = y3 + offset[1][1];

   723         rightOff[0] = x1 - offset[0][0]; rightOff[1] = y1 - offset[0][1];

   724         rightOff[4] = x3 - offset[1][0]; rightOff[5] = y3 - offset[1][1];

   725 

   726         float x1p = leftOff[0]; // start

   727         float y1p = leftOff[1]; // point

   728         float x3p = leftOff[4]; // end

   729         float y3p = leftOff[5]; // point

   730 

   731         // Corner cases:

   732         // 1. If the two control vectors are parallel, we'll end up with NaN's

   733         //    in leftOff (and rightOff in the body of the if below), so we'll

   734         //    do getLineOffsets, which is right.

   735         // 2. If the first or second two points are equal, then (dx1,dy1)==(0,0)

   736         //    or (dx3,dy3)==(0,0), so (x1p, y1p)==(x1p+dx1, y1p+dy1)

   737         //    or (x3p, y3p)==(x3p-dx3, y3p-dy3), which means that

   738         //    computeIntersection will put NaN's in leftOff and right off, and

   739         //    we will do getLineOffsets, which is right.

   740         computeIntersection(x1p, y1p, x1p+dx1, y1p+dy1, x3p, y3p, x3p-dx3, y3p-dy3, leftOff, 2);

   741         float cx = leftOff[2];

   742         float cy = leftOff[3];

   743 

   744         if (!(isFinite(cx) && isFinite(cy))) {

   745             // maybe the right path is not degenerate.

   746             x1p = rightOff[0];

   747             y1p = rightOff[1];

   748             x3p = rightOff[4];

   749             y3p = rightOff[5];

   750             computeIntersection(x1p, y1p, x1p+dx1, y1p+dy1, x3p, y3p, x3p-dx3, y3p-dy3, rightOff, 2);

   751             cx = rightOff[2];

   752             cy = rightOff[3];

   753             if (!(isFinite(cx) && isFinite(cy))) {

   754                 // both are degenerate. This curve is a line.

   755                 getLineOffsets(x1, y1, x3, y3, leftOff, rightOff);

   756                 return 4;

   757             }

   758             // {left,right}Off[0,1,4,5] are already set to the correct values.

   759             leftOff[2] = 2*x2 - cx;

   760             leftOff[3] = 2*y2 - cy;

   761             return 6;

   762         }

   763 

   764         // rightOff[2,3] = (x2,y2) - ((left_x2, left_y2) - (x2, y2))

   765         // == 2*(x2, y2) - (left_x2, left_y2)

   766         rightOff[2] = 2*x2 - cx;

   767         rightOff[3] = 2*y2 - cy;

   768         return 6;

   769     }

   770 

   771     private static boolean isFinite(float x) {

   772         return (Float.NEGATIVE_INFINITY < x && x < Float.POSITIVE_INFINITY);

   773     }

   774 

   775     // This is where the curve to be processed is put. We give it

   776     // enough room to store 2 curves: one for the current subdivision, the

   777     // other for the rest of the curve.

   778     private float[] middle = new float[2*8];

   779     private float[] lp = new float[8];

   780     private float[] rp = new float[8];

   781     private static final int MAX_N_CURVES = 11;

   782     private float[] subdivTs = new float[MAX_N_CURVES - 1];

   783 

   784     // If this class is compiled with ecj, then Hotspot crashes when OSR

   785     // compiling this function. See bugs 7004570 and 6675699

   786     // TODO: until those are fixed, we should work around that by

   787     // manually inlining this into curveTo and quadTo.

   788 /******************************* WORKAROUND **********************************

   789     private void somethingTo(final int type) {

   790         // need these so we can update the state at the end of this method

   791         final float xf = middle[type-2], yf = middle[type-1];

   792         float dxs = middle[2] - middle[0];

   793         float dys = middle[3] - middle[1];

   794         float dxf = middle[type - 2] - middle[type - 4];

   795         float dyf = middle[type - 1] - middle[type - 3];

   796         switch(type) {

   797         case 6:

   798             if ((dxs == 0f && dys == 0f) ||

   799                 (dxf == 0f && dyf == 0f)) {

   800                dxs = dxf = middle[4] - middle[0];

   801                dys = dyf = middle[5] - middle[1];

   802             }

   803             break;

   804         case 8:

   805             boolean p1eqp2 = (dxs == 0f && dys == 0f);

   806             boolean p3eqp4 = (dxf == 0f && dyf == 0f);

   807             if (p1eqp2) {

   808                 dxs = middle[4] - middle[0];

   809                 dys = middle[5] - middle[1];

   810                 if (dxs == 0f && dys == 0f) {

   811                     dxs = middle[6] - middle[0];

   812                     dys = middle[7] - middle[1];

   813                 }

   814             }

   815             if (p3eqp4) {

   816                 dxf = middle[6] - middle[2];

   817                 dyf = middle[7] - middle[3];

   818                 if (dxf == 0f && dyf == 0f) {

   819                     dxf = middle[6] - middle[0];

   820                     dyf = middle[7] - middle[1];

   821                 }

   822             }

   823         }

   824         if (dxs == 0f && dys == 0f) {

   825             // this happens iff the "curve" is just a point

   826             lineTo(middle[0], middle[1]);

   827             return;

   828         }

   829         // if these vectors are too small, normalize them, to avoid future

   830         // precision problems.

   831         if (Math.abs(dxs) < 0.1f && Math.abs(dys) < 0.1f) {

   832             float len = (float) sqrt(dxs*dxs + dys*dys);

   833             dxs /= len;

   834             dys /= len;

   835         }

   836         if (Math.abs(dxf) < 0.1f && Math.abs(dyf) < 0.1f) {

   837             float len = (float) sqrt(dxf*dxf + dyf*dyf);

   838             dxf /= len;

   839             dyf /= len;

   840         }

   841 

   842         computeOffset(dxs, dys, lineWidth2, offset[0]);

   843         final float mx = offset[0][0];

   844         final float my = offset[0][1];

   845         drawJoin(cdx, cdy, cx0, cy0, dxs, dys, cmx, cmy, mx, my);

   846 

   847         int nSplits = findSubdivPoints(middle, subdivTs, type, lineWidth2);

   848 

   849         int kind = 0;

   850         Iterator<Integer> it = Curve.breakPtsAtTs(middle, type, subdivTs, nSplits);

   851         while(it.hasNext()) {

   852             int curCurveOff = it.next();

   853 

   854             switch (type) {

   855             case 8:

   856                 kind = computeOffsetCubic(middle, curCurveOff, lp, rp);

   857                 break;

   858             case 6:

   859                 kind = computeOffsetQuad(middle, curCurveOff, lp, rp);

   860                 break;

   861             }

   862             emitLineTo(lp[0], lp[1]);

   863             switch(kind) {

   864             case 8:

   865                 emitCurveTo(lp[0], lp[1], lp[2], lp[3], lp[4], lp[5], lp[6], lp[7], false);

   866                 emitCurveTo(rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], rp[6], rp[7], true);

   867                 break;

   868             case 6:

   869                 emitQuadTo(lp[0], lp[1], lp[2], lp[3], lp[4], lp[5], false);

   870                 emitQuadTo(rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], true);

   871                 break;

   872             case 4:

   873                 emitLineTo(lp[2], lp[3]);

   874                 emitLineTo(rp[0], rp[1], true);

   875                 break;

   876             }

   877             emitLineTo(rp[kind - 2], rp[kind - 1], true);

   878         }

   879 

   880         this.cmx = (lp[kind - 2] - rp[kind - 2]) / 2;

   881         this.cmy = (lp[kind - 1] - rp[kind - 1]) / 2;

   882         this.cdx = dxf;

   883         this.cdy = dyf;

   884         this.cx0 = xf;

   885         this.cy0 = yf;

   886         this.prev = DRAWING_OP_TO;

   887     }

   888 ****************************** END WORKAROUND *******************************/

   889 

   890     // finds values of t where the curve in pts should be subdivided in order

   891     // to get good offset curves a distance of w away from the middle curve.

   892     // Stores the points in ts, and returns how many of them there were.

   893     private static Curve c = new Curve();

   894     private static int findSubdivPoints(float[] pts, float[] ts, final int type, final float w)

   895     {

   896         final float x12 = pts[2] - pts[0];

   897         final float y12 = pts[3] - pts[1];

   898         // if the curve is already parallel to either axis we gain nothing

   899         // from rotating it.

   900         if (y12 != 0f && x12 != 0f) {

   901             // we rotate it so that the first vector in the control polygon is

   902             // parallel to the x-axis. This will ensure that rotated quarter

   903             // circles won't be subdivided.

   904             final float hypot = (float) sqrt(x12 * x12 + y12 * y12);

   905             final float cos = x12 / hypot;

   906             final float sin = y12 / hypot;

   907             final float x1 = cos * pts[0] + sin * pts[1];

   908             final float y1 = cos * pts[1] - sin * pts[0];

   909             final float x2 = cos * pts[2] + sin * pts[3];

   910             final float y2 = cos * pts[3] - sin * pts[2];

   911             final float x3 = cos * pts[4] + sin * pts[5];

   912             final float y3 = cos * pts[5] - sin * pts[4];

   913             switch(type) {

   914             case 8:

   915                 final float x4 = cos * pts[6] + sin * pts[7];

   916                 final float y4 = cos * pts[7] - sin * pts[6];

   917                 c.set(x1, y1, x2, y2, x3, y3, x4, y4);

   918                 break;

   919             case 6:

   920                 c.set(x1, y1, x2, y2, x3, y3);

   921                 break;

   922             }

   923         } else {

   924             c.set(pts, type);

   925         }

   926 

   927         int ret = 0;

   928         // we subdivide at values of t such that the remaining rotated

   929         // curves are monotonic in x and y.

   930         ret += c.dxRoots(ts, ret);

   931         ret += c.dyRoots(ts, ret);

   932         // subdivide at inflection points.

   933         if (type == 8) {

   934             // quadratic curves can't have inflection points

   935             ret += c.infPoints(ts, ret);

   936         }

   937 

   938         // now we must subdivide at points where one of the offset curves will have

   939         // a cusp. This happens at ts where the radius of curvature is equal to w.

   940         ret += c.rootsOfROCMinusW(ts, ret, w, 0.0001f);

   941 

   942         ret = Helpers.filterOutNotInAB(ts, 0, ret, 0.0001f, 0.9999f);

   943         Helpers.isort(ts, 0, ret);

   944         return ret;

   945     }

   946 

   947     @Override public void curveTo(float x1, float y1,

   948                                   float x2, float y2,

   949                                   float x3, float y3)

   950     {

   951         middle[0] = cx0; middle[1] = cy0;

   952         middle[2] = x1;  middle[3] = y1;

   953         middle[4] = x2;  middle[5] = y2;

   954         middle[6] = x3;  middle[7] = y3;

   955 

   956         // inlined version of somethingTo(8);

   957         // See the TODO on somethingTo

   958 

   959         // need these so we can update the state at the end of this method

   960         final float xf = middle[6], yf = middle[7];

   961         float dxs = middle[2] - middle[0];

   962         float dys = middle[3] - middle[1];

   963         float dxf = middle[6] - middle[4];

   964         float dyf = middle[7] - middle[5];

   965 

   966         boolean p1eqp2 = (dxs == 0f && dys == 0f);

   967         boolean p3eqp4 = (dxf == 0f && dyf == 0f);

   968         if (p1eqp2) {

   969             dxs = middle[4] - middle[0];

   970             dys = middle[5] - middle[1];

   971             if (dxs == 0f && dys == 0f) {

   972                 dxs = middle[6] - middle[0];

   973                 dys = middle[7] - middle[1];

   974             }

   975         }

   976         if (p3eqp4) {

   977             dxf = middle[6] - middle[2];

   978             dyf = middle[7] - middle[3];

   979             if (dxf == 0f && dyf == 0f) {

   980                 dxf = middle[6] - middle[0];

   981                 dyf = middle[7] - middle[1];

   982             }

   983         }

   984         if (dxs == 0f && dys == 0f) {

   985             // this happens iff the "curve" is just a point

   986             lineTo(middle[0], middle[1]);

   987             return;

   988         }

   989 

   990         // if these vectors are too small, normalize them, to avoid future

   991         // precision problems.

   992         if (Math.abs(dxs) < 0.1f && Math.abs(dys) < 0.1f) {

   993             float len = (float) sqrt(dxs*dxs + dys*dys);

   994             dxs /= len;

   995             dys /= len;

   996         }

   997         if (Math.abs(dxf) < 0.1f && Math.abs(dyf) < 0.1f) {

   998             float len = (float) sqrt(dxf*dxf + dyf*dyf);

   999             dxf /= len;

  1000             dyf /= len;

  1001         }

  1002 

  1003         computeOffset(dxs, dys, lineWidth2, offset[0]);

  1004         final float mx = offset[0][0];

  1005         final float my = offset[0][1];

  1006         drawJoin(cdx, cdy, cx0, cy0, dxs, dys, cmx, cmy, mx, my);

  1007 

  1008         int nSplits = findSubdivPoints(middle, subdivTs, 8, lineWidth2);

  1009 

  1010         int kind = 0;

  1011         Iterator<Integer> it = Curve.breakPtsAtTs(middle, 8, subdivTs, nSplits);

  1012         while(it.hasNext()) {

  1013             int curCurveOff = it.next();

  1014 

  1015             kind = computeOffsetCubic(middle, curCurveOff, lp, rp);

  1016             emitLineTo(lp[0], lp[1]);

  1017             switch(kind) {

  1018             case 8:

  1019                 emitCurveTo(lp[0], lp[1], lp[2], lp[3], lp[4], lp[5], lp[6], lp[7], false);

  1020                 emitCurveTo(rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], rp[6], rp[7], true);

  1021                 break;

  1022             case 4:

  1023                 emitLineTo(lp[2], lp[3]);

  1024                 emitLineTo(rp[0], rp[1], true);

  1025                 break;

  1026             }

  1027             emitLineTo(rp[kind - 2], rp[kind - 1], true);

  1028         }

  1029 

  1030         this.cmx = (lp[kind - 2] - rp[kind - 2]) / 2;

  1031         this.cmy = (lp[kind - 1] - rp[kind - 1]) / 2;

  1032         this.cdx = dxf;

  1033         this.cdy = dyf;

  1034         this.cx0 = xf;

  1035         this.cy0 = yf;

  1036         this.prev = DRAWING_OP_TO;

  1037     }

  1038 

  1039     @Override public void quadTo(float x1, float y1, float x2, float y2) {

  1040         middle[0] = cx0; middle[1] = cy0;

  1041         middle[2] = x1;  middle[3] = y1;

  1042         middle[4] = x2;  middle[5] = y2;

  1043 

  1044         // inlined version of somethingTo(8);

  1045         // See the TODO on somethingTo

  1046 

  1047         // need these so we can update the state at the end of this method

  1048         final float xf = middle[4], yf = middle[5];

  1049         float dxs = middle[2] - middle[0];

  1050         float dys = middle[3] - middle[1];

  1051         float dxf = middle[4] - middle[2];

  1052         float dyf = middle[5] - middle[3];

  1053         if ((dxs == 0f && dys == 0f) || (dxf == 0f && dyf == 0f)) {

  1054             dxs = dxf = middle[4] - middle[0];

  1055             dys = dyf = middle[5] - middle[1];

  1056         }

  1057         if (dxs == 0f && dys == 0f) {

  1058             // this happens iff the "curve" is just a point

  1059             lineTo(middle[0], middle[1]);

  1060             return;

  1061         }

  1062         // if these vectors are too small, normalize them, to avoid future

  1063         // precision problems.

  1064         if (Math.abs(dxs) < 0.1f && Math.abs(dys) < 0.1f) {

  1065             float len = (float) sqrt(dxs*dxs + dys*dys);

  1066             dxs /= len;

  1067             dys /= len;

  1068         }

  1069         if (Math.abs(dxf) < 0.1f && Math.abs(dyf) < 0.1f) {

  1070             float len = (float) sqrt(dxf*dxf + dyf*dyf);

  1071             dxf /= len;

  1072             dyf /= len;

  1073         }

  1074 

  1075         computeOffset(dxs, dys, lineWidth2, offset[0]);

  1076         final float mx = offset[0][0];

  1077         final float my = offset[0][1];

  1078         drawJoin(cdx, cdy, cx0, cy0, dxs, dys, cmx, cmy, mx, my);

  1079 

  1080         int nSplits = findSubdivPoints(middle, subdivTs, 6, lineWidth2);

  1081 

  1082         int kind = 0;

  1083         Iterator<Integer> it = Curve.breakPtsAtTs(middle, 6, subdivTs, nSplits);

  1084         while(it.hasNext()) {

  1085             int curCurveOff = it.next();

  1086 

  1087             kind = computeOffsetQuad(middle, curCurveOff, lp, rp);

  1088             emitLineTo(lp[0], lp[1]);

  1089             switch(kind) {

  1090             case 6:

  1091                 emitQuadTo(lp[0], lp[1], lp[2], lp[3], lp[4], lp[5], false);

  1092                 emitQuadTo(rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], true);

  1093                 break;

  1094             case 4:

  1095                 emitLineTo(lp[2], lp[3]);

  1096                 emitLineTo(rp[0], rp[1], true);

  1097                 break;

  1098             }

  1099             emitLineTo(rp[kind - 2], rp[kind - 1], true);

  1100         }

  1101 

  1102         this.cmx = (lp[kind - 2] - rp[kind - 2]) / 2;

  1103         this.cmy = (lp[kind - 1] - rp[kind - 1]) / 2;

  1104         this.cdx = dxf;

  1105         this.cdy = dyf;

  1106         this.cx0 = xf;

  1107         this.cy0 = yf;

  1108         this.prev = DRAWING_OP_TO;

  1109     }

  1110 

  1111     @Override public long getNativeConsumer() {

  1112         throw new InternalError("Stroker doesn't use a native consumer");

  1113     }

  1114 

  1115     // a stack of polynomial curves where each curve shares endpoints with

  1116     // adjacent ones.

  1117     private static final class PolyStack {

  1118         float[] curves;

  1119         int end;

  1120         int[] curveTypes;

  1121         int numCurves;

  1122 

  1123         private static final int INIT_SIZE = 50;

  1124 

  1125         PolyStack() {

  1126             curves = new float[8 * INIT_SIZE];

  1127             curveTypes = new int[INIT_SIZE];

  1128             end = 0;

  1129             numCurves = 0;

  1130         }

  1131 

  1132         public boolean isEmpty() {

  1133             return numCurves == 0;

  1134         }