History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/sun/java2d/pisces/Stroker.java (1 of 18352 files). Show all

Unified · Split

java/pkg/sun/java2d/pisces/Stroker.java+1223−0
@@ -0,0 +1,1223 @@
1/*
2 * Copyright (c) 2007, 2011, 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
26package sun.java2d.pisces;
27
28import java.util.Arrays;
29import java.util.Iterator;
30import static java.lang.Math.ulp;
31import static java.lang.Math.sqrt;
32
33import 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
38final 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</code>.
103 *
104 * @param pc2d an output <code>PathConsumer2D</code>.
105 * @param lineWidth the desired line width in pixels
106 * @param capStyle the desired end cap style, one of
107 * <code>CAP_BUTT</code>, <code>CAP_ROUND</code> or
108 * <code>CAP_SQUARE</code>.
109 * @param joinStyle the desired line join style, one of
110 * <code>JOIN_MITER</code>, <code>JOIN_ROUND</code> or
111 * <code>JOIN_BEVEL</code>.
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 double 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 >= 0 ? 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 float cosext2 = (omx * mx + omy * my) / (2 * lineWidth2 * lineWidth2);
246 // cv is the length of P1-P0 and P2-P3 divided by the radius of the arc
247 // (so, cv assumes the arc has radius 1). P0, P1, P2, P3 are the points that
248 // define the bezier curve we're computing.
249 // It is computed using the constraints that P1-P0 and P3-P2 are parallel
250 // to the arc tangents at the endpoints, and that |P1-P0|=|P3-P2|.
251 float cv = (float) ((4.0 / 3.0) * sqrt(0.5-cosext2) /
252 (1.0 + sqrt(cosext2+0.5)));
253 // if clockwise, we need to negate cv.
254 if (rev) { // rev is equivalent to isCW(omx, omy, mx, my)
255 cv = -cv;
256 }
257 final float x1 = cx + omx;
258 final float y1 = cy + omy;
259 final float x2 = x1 - cv * omy;
260 final float y2 = y1 + cv * omx;
261
262 final float x4 = cx + mx;
263 final float y4 = cy + my;
264 final float x3 = x4 + cv * my;
265 final float y3 = y4 - cv * mx;
266
267 emitCurveTo(x1, y1, x2, y2, x3, y3, x4, y4, rev);
268 }
269
270 private void drawRoundCap(float cx, float cy, float mx, float my) {
271 final float C = 0.5522847498307933f;
272 // the first and second arguments of the following two calls
273 // are really will be ignored by emitCurveTo (because of the false),
274 // but we put them in anyway, as opposed to just giving it 4 zeroes,
275 // because it's just 4 additions and it's not good to rely on this
276 // sort of assumption (right now it's true, but that may change).
277 emitCurveTo(cx+mx, cy+my,
278 cx+mx-C*my, cy+my+C*mx,
279 cx-my+C*mx, cy+mx+C*my,
280 cx-my, cy+mx,
281 false);
282 emitCurveTo(cx-my, cy+mx,
283 cx-my-C*mx, cy+mx-C*my,
284 cx-mx-C*my, cy-my+C*mx,
285 cx-mx, cy-my,
286 false);
287 }
288
289 // Put the intersection point of the lines (x0, y0) -> (x1, y1)
290 // and (x0p, y0p) -> (x1p, y1p) in m[off] and m[off+1].
291 // If the lines are parallel, it will put a non finite number in m.
292 private void computeIntersection(final float x0, final float y0,
293 final float x1, final float y1,
294 final float x0p, final float y0p,
295 final float x1p, final float y1p,
296 final float[] m, int off)
297 {
298 float x10 = x1 - x0;
299 float y10 = y1 - y0;
300 float x10p = x1p - x0p;
301 float y10p = y1p - y0p;
302
303 float den = x10*y10p - x10p*y10;
304 float t = x10p*(y0-y0p) - y10p*(x0-x0p);
305 t /= den;
306 m[off++] = x0 + t*x10;
307 m[off] = y0 + t*y10;
308 }
309
310 private void drawMiter(final float pdx, final float pdy,
311 final float x0, final float y0,
312 final float dx, final float dy,
313 float omx, float omy, float mx, float my,
314 boolean rev)
315 {
316 if ((mx == omx && my == omy) ||
317 (pdx == 0 && pdy == 0) ||
318 (dx == 0 && dy == 0))
319 {
320 return;
321 }
322
323 if (rev) {
324 omx = -omx;
325 omy = -omy;
326 mx = -mx;
327 my = -my;
328 }
329
330 computeIntersection((x0 - pdx) + omx, (y0 - pdy) + omy, x0 + omx, y0 + omy,
331 (dx + x0) + mx, (dy + y0) + my, x0 + mx, y0 + my,
332 miter, 0);
333
334 float lenSq = (miter[0]-x0)*(miter[0]-x0) + (miter[1]-y0)*(miter[1]-y0);
335
336 // If the lines are parallel, lenSq will be either NaN or +inf
337 // (actually, I'm not sure if the latter is possible. The important
338 // thing is that -inf is not possible, because lenSq is a square).
339 // For both of those values, the comparison below will fail and
340 // no miter will be drawn, which is correct.
341 if (lenSq < miterLimitSq) {
342 emitLineTo(miter[0], miter[1], rev);
343 }
344 }
345
346 public void moveTo(float x0, float y0) {
347 if (prev == DRAWING_OP_TO) {
348 finish();
349 }
350 this.sx0 = this.cx0 = x0;
351 this.sy0 = this.cy0 = y0;
352 this.cdx = this.sdx = 1;
353 this.cdy = this.sdy = 0;
354 this.prev = MOVE_TO;
355 }
356
357 public void lineTo(float x1, float y1) {
358 float dx = x1 - cx0;
359 float dy = y1 - cy0;
360 if (dx == 0f && dy == 0f) {
361 dx = 1;
362 }
363 computeOffset(dx, dy, lineWidth2, offset[0]);
364 float mx = offset[0][0];
365 float my = offset[0][1];
366
367 drawJoin(cdx, cdy, cx0, cy0, dx, dy, cmx, cmy, mx, my);
368
369 emitLineTo(cx0 + mx, cy0 + my);
370 emitLineTo(x1 + mx, y1 + my);
371
372 emitLineTo(cx0 - mx, cy0 - my, true);
373 emitLineTo(x1 - mx, y1 - my, true);
374
375 this.cmx = mx;
376 this.cmy = my;
377 this.cdx = dx;
378 this.cdy = dy;
379 this.cx0 = x1;
380 this.cy0 = y1;
381 this.prev = DRAWING_OP_TO;
382 }
383
384 public void closePath() {
385 if (prev != DRAWING_OP_TO) {
386 if (prev == CLOSE) {
387 return;
388 }
389 emitMoveTo(cx0, cy0 - lineWidth2);
390 this.cmx = this.smx = 0;
391 this.cmy = this.smy = -lineWidth2;
392 this.cdx = this.sdx = 1;
393 this.cdy = this.sdy = 0;
394 finish();
395 return;
396 }
397
398 if (cx0 != sx0 || cy0 != sy0) {
399 lineTo(sx0, sy0);
400 }
401
402 drawJoin(cdx, cdy, cx0, cy0, sdx, sdy, cmx, cmy, smx, smy);
403
404 emitLineTo(sx0 + smx, sy0 + smy);
405
406 emitMoveTo(sx0 - smx, sy0 - smy);
407 emitReverse();
408
409 this.prev = CLOSE;
410 emitClose();
411 }
412
413 private void emitReverse() {
414 while(!reverse.isEmpty()) {
415 reverse.pop(out);
416 }
417 }
418
419 public void pathDone() {
420 if (prev == DRAWING_OP_TO) {
421 finish();
422 }
423
424 out.pathDone();
425 // this shouldn't matter since this object won't be used
426 // after the call to this method.
427 this.prev = CLOSE;
428 }
429
430 private void finish() {
431 if (capStyle == CAP_ROUND) {
432 drawRoundCap(cx0, cy0, cmx, cmy);
433 } else if (capStyle == CAP_SQUARE) {
434 emitLineTo(cx0 - cmy + cmx, cy0 + cmx + cmy);
435 emitLineTo(cx0 - cmy - cmx, cy0 + cmx - cmy);
436 }
437
438 emitReverse();
439
440 if (capStyle == CAP_ROUND) {
441 drawRoundCap(sx0, sy0, -smx, -smy);
442 } else if (capStyle == CAP_SQUARE) {
443 emitLineTo(sx0 + smy - smx, sy0 - smx - smy);
444 emitLineTo(sx0 + smy + smx, sy0 - smx + smy);
445 }
446
447 emitClose();
448 }
449
450 private void emitMoveTo(final float x0, final float y0) {
451 out.moveTo(x0, y0);
452 }
453
454 private void emitLineTo(final float x1, final float y1) {
455 out.lineTo(x1, y1);
456 }
457
458 private void emitLineTo(final float x1, final float y1,
459 final boolean rev)
460 {
461 if (rev) {
462 reverse.pushLine(x1, y1);
463 } else {
464 emitLineTo(x1, y1);
465 }
466 }
467
468 private void emitQuadTo(final float x0, final float y0,
469 final float x1, final float y1,
470 final float x2, final float y2, final boolean rev)
471 {
472 if (rev) {
473 reverse.pushQuad(x0, y0, x1, y1);
474 } else {
475 out.quadTo(x1, y1, x2, y2);
476 }
477 }
478
479 private void emitCurveTo(final float x0, final float y0,
480 final float x1, final float y1,
481 final float x2, final float y2,
482 final float x3, final float y3, final boolean rev)
483 {
484 if (rev) {
485 reverse.pushCubic(x0, y0, x1, y1, x2, y2);
486 } else {
487 out.curveTo(x1, y1, x2, y2, x3, y3);
488 }
489 }
490
491 private void emitClose() {
492 out.closePath();
493 }
494
495 private void drawJoin(float pdx, float pdy,
496 float x0, float y0,
497 float dx, float dy,
498 float omx, float omy,
499 float mx, float my)
500 {
501 if (prev != DRAWING_OP_TO) {
502 emitMoveTo(x0 + mx, y0 + my);
503 this.sdx = dx;
504 this.sdy = dy;
505 this.smx = mx;
506 this.smy = my;
507 } else {
508 boolean cw = isCW(pdx, pdy, dx, dy);
509 if (joinStyle == JOIN_MITER) {
510 drawMiter(pdx, pdy, x0, y0, dx, dy, omx, omy, mx, my, cw);
511 } else if (joinStyle == JOIN_ROUND) {
512 drawRoundJoin(x0, y0,
513 omx, omy,
514 mx, my, cw,
515 ROUND_JOIN_THRESHOLD);
516 }
517 emitLineTo(x0, y0, !cw);
518 }
519 prev = DRAWING_OP_TO;
520 }
521
522 private static boolean within(final float x1, final float y1,
523 final float x2, final float y2,
524 final float ERR)
525 {
526 assert ERR > 0 : "";
527 // compare taxicab distance. ERR will always be small, so using
528 // true distance won't give much benefit
529 return (Helpers.within(x1, x2, ERR) && // we want to avoid calling Math.abs
530 Helpers.within(y1, y2, ERR)); // this is just as good.
531 }
532
533 private void getLineOffsets(float x1, float y1,
534 float x2, float y2,
535 float[] left, float[] right) {
536 computeOffset(x2 - x1, y2 - y1, lineWidth2, offset[0]);
537 left[0] = x1 + offset[0][0];
538 left[1] = y1 + offset[0][1];
539 left[2] = x2 + offset[0][0];
540 left[3] = y2 + offset[0][1];
541 right[0] = x1 - offset[0][0];
542 right[1] = y1 - offset[0][1];
543 right[2] = x2 - offset[0][0];
544 right[3] = y2 - offset[0][1];
545 }
546
547 private int computeOffsetCubic(float[] pts, final int off,
548 float[] leftOff, float[] rightOff)
549 {
550 // if p1=p2 or p3=p4 it means that the derivative at the endpoint
551 // vanishes, which creates problems with computeOffset. Usually
552 // this happens when this stroker object is trying to winden
553 // a curve with a cusp. What happens is that curveTo splits
554 // the input curve at the cusp, and passes it to this function.
555 // because of inaccuracies in the splitting, we consider points
556 // equal if they're very close to each other.
557 final float x1 = pts[off + 0], y1 = pts[off + 1];
558 final float x2 = pts[off + 2], y2 = pts[off + 3];
559 final float x3 = pts[off + 4], y3 = pts[off + 5];
560 final float x4 = pts[off + 6], y4 = pts[off + 7];
561
562 float dx4 = x4 - x3;
563 float dy4 = y4 - y3;
564 float dx1 = x2 - x1;
565 float dy1 = y2 - y1;
566
567 // if p1 == p2 && p3 == p4: draw line from p1->p4, unless p1 == p4,
568 // in which case ignore if p1 == p2
569 final boolean p1eqp2 = within(x1,y1,x2,y2, 6 * ulp(y2));
570 final boolean p3eqp4 = within(x3,y3,x4,y4, 6 * ulp(y4));
571 if (p1eqp2 && p3eqp4) {
572 getLineOffsets(x1, y1, x4, y4, leftOff, rightOff);
573 return 4;
574 } else if (p1eqp2) {
575 dx1 = x3 - x1;
576 dy1 = y3 - y1;
577 } else if (p3eqp4) {
578 dx4 = x4 - x2;
579 dy4 = y4 - y2;
580 }
581
582 // if p2-p1 and p4-p3 are parallel, that must mean this curve is a line
583 float dotsq = (dx1 * dx4 + dy1 * dy4);
584 dotsq = dotsq * dotsq;
585 float l1sq = dx1 * dx1 + dy1 * dy1, l4sq = dx4 * dx4 + dy4 * dy4;
586 if (Helpers.within(dotsq, l1sq * l4sq, 4 * ulp(dotsq))) {
587 getLineOffsets(x1, y1, x4, y4, leftOff, rightOff);
588 return 4;
589 }
590
591// What we're trying to do in this function is to approximate an ideal
592// offset curve (call it I) of the input curve B using a bezier curve Bp.
593// The constraints I use to get the equations are:
594//
595// 1. The computed curve Bp should go through I(0) and I(1). These are
596// x1p, y1p, x4p, y4p, which are p1p and p4p. We still need to find
597// 4 variables: the x and y components of p2p and p3p (i.e. x2p, y2p, x3p, y3p).
598//
599// 2. Bp should have slope equal in absolute value to I at the endpoints. So,
600// (by the way, the operator || in the comments below means "aligned with".
601// It is defined on vectors, so when we say I'(0) || Bp'(0) we mean that
602// vectors I'(0) and Bp'(0) are aligned, which is the same as saying
603// that the tangent lines of I and Bp at 0 are parallel. Mathematically
604// this means (I'(t) || Bp'(t)) <==> (I'(t) = c * Bp'(t)) where c is some
605// nonzero constant.)
606// I'(0) || Bp'(0) and I'(1) || Bp'(1). Obviously, I'(0) || B'(0) and
607// I'(1) || B'(1); therefore, Bp'(0) || B'(0) and Bp'(1) || B'(1).
608// We know that Bp'(0) || (p2p-p1p) and Bp'(1) || (p4p-p3p) and the same
609// is true for any bezier curve; therefore, we get the equations
610// (1) p2p = c1 * (p2-p1) + p1p
611// (2) p3p = c2 * (p4-p3) + p4p
612// We know p1p, p4p, p2, p1, p3, and p4; therefore, this reduces the number
613// of unknowns from 4 to 2 (i.e. just c1 and c2).
614// To eliminate these 2 unknowns we use the following constraint:
615//
616// 3. Bp(0.5) == I(0.5). Bp(0.5)=(x,y) and I(0.5)=(xi,yi), and I should note
617// that I(0.5) is *the only* reason for computing dxm,dym. This gives us
618// (3) Bp(0.5) = (p1p + 3 * (p2p + p3p) + p4p)/8, which is equivalent to
619// (4) p2p + p3p = (Bp(0.5)*8 - p1p - p4p) / 3
620// We can substitute (1) and (2) from above into (4) and we get:
621// (5) c1*(p2-p1) + c2*(p4-p3) = (Bp(0.5)*8 - p1p - p4p)/3 - p1p - p4p
622// which is equivalent to
623// (6) c1*(p2-p1) + c2*(p4-p3) = (4/3) * (Bp(0.5) * 2 - p1p - p4p)
624//
625// The right side of this is a 2D vector, and we know I(0.5), which gives us
626// Bp(0.5), which gives us the value of the right side.
627// The left side is just a matrix vector multiplication in disguise. It is
628//
629// [x2-x1, x4-x3][c1]
630// [y2-y1, y4-y3][c2]
631// which, is equal to
632// [dx1, dx4][c1]
633// [dy1, dy4][c2]
634// At this point we are left with a simple linear system and we solve it by
635// getting the inverse of the matrix above. Then we use [c1,c2] to compute
636// p2p and p3p.
637
638 float x = 0.125f * (x1 + 3 * (x2 + x3) + x4);
639 float y = 0.125f * (y1 + 3 * (y2 + y3) + y4);
640 // (dxm,dym) is some tangent of B at t=0.5. This means it's equal to
641 // c*B'(0.5) for some constant c.
642 float dxm = x3 + x4 - x1 - x2, dym = y3 + y4 - y1 - y2;
643
644 // this computes the offsets at t=0, 0.5, 1, using the property that
645 // for any bezier curve the vectors p2-p1 and p4-p3 are parallel to
646 // the (dx/dt, dy/dt) vectors at the endpoints.
647 computeOffset(dx1, dy1, lineWidth2, offset[0]);
648 computeOffset(dxm, dym, lineWidth2, offset[1]);
649 computeOffset(dx4, dy4, lineWidth2, offset[2]);
650 float x1p = x1 + offset[0][0]; // start
651 float y1p = y1 + offset[0][1]; // point
652 float xi = x + offset[1][0]; // interpolation
653 float yi = y + offset[1][1]; // point
654 float x4p = x4 + offset[2][0]; // end
655 float y4p = y4 + offset[2][1]; // point
656
657 float invdet43 = 4f / (3f * (dx1 * dy4 - dy1 * dx4));
658
659 float two_pi_m_p1_m_p4x = 2*xi - x1p - x4p;
660 float two_pi_m_p1_m_p4y = 2*yi - y1p - y4p;
661 float c1 = invdet43 * (dy4 * two_pi_m_p1_m_p4x - dx4 * two_pi_m_p1_m_p4y);
662 float c2 = invdet43 * (dx1 * two_pi_m_p1_m_p4y - dy1 * two_pi_m_p1_m_p4x);
663
664 float x2p, y2p, x3p, y3p;
665 x2p = x1p + c1*dx1;
666 y2p = y1p + c1*dy1;
667 x3p = x4p + c2*dx4;
668 y3p = y4p + c2*dy4;
669
670 leftOff[0] = x1p; leftOff[1] = y1p;
671 leftOff[2] = x2p; leftOff[3] = y2p;
672 leftOff[4] = x3p; leftOff[5] = y3p;
673 leftOff[6] = x4p; leftOff[7] = y4p;
674
675 x1p = x1 - offset[0][0]; y1p = y1 - offset[0][1];
676 xi = xi - 2 * offset[1][0]; yi = yi - 2 * offset[1][1];
677 x4p = x4 - offset[2][0]; y4p = y4 - offset[2][1];
678
679 two_pi_m_p1_m_p4x = 2*xi - x1p - x4p;
680 two_pi_m_p1_m_p4y = 2*yi - y1p - y4p;
681 c1 = invdet43 * (dy4 * two_pi_m_p1_m_p4x - dx4 * two_pi_m_p1_m_p4y);
682 c2 = invdet43 * (dx1 * two_pi_m_p1_m_p4y - dy1 * two_pi_m_p1_m_p4x);
683
684 x2p = x1p + c1*dx1;
685 y2p = y1p + c1*dy1;
686 x3p = x4p + c2*dx4;
687 y3p = y4p + c2*dy4;
688
689 rightOff[0] = x1p; rightOff[1] = y1p;
690 rightOff[2] = x2p; rightOff[3] = y2p;
691 rightOff[4] = x3p; rightOff[5] = y3p;
692 rightOff[6] = x4p; rightOff[7] = y4p;
693 return 8;
694 }
695
696 // return the kind of curve in the right and left arrays.
697 private int computeOffsetQuad(float[] pts, final int off,
698 float[] leftOff, float[] rightOff)
699 {
700 final float x1 = pts[off + 0], y1 = pts[off + 1];
701 final float x2 = pts[off + 2], y2 = pts[off + 3];
702 final float x3 = pts[off + 4], y3 = pts[off + 5];
703
704 final float dx3 = x3 - x2;
705 final float dy3 = y3 - y2;
706 final float dx1 = x2 - x1;
707 final float dy1 = y2 - y1;
708
709 // this computes the offsets at t = 0, 1
710 computeOffset(dx1, dy1, lineWidth2, offset[0]);
711 computeOffset(dx3, dy3, lineWidth2, offset[1]);
712
713 leftOff[0] = x1 + offset[0][0]; leftOff[1] = y1 + offset[0][1];
714 leftOff[4] = x3 + offset[1][0]; leftOff[5] = y3 + offset[1][1];
715 rightOff[0] = x1 - offset[0][0]; rightOff[1] = y1 - offset[0][1];
716 rightOff[4] = x3 - offset[1][0]; rightOff[5] = y3 - offset[1][1];
717
718 float x1p = leftOff[0]; // start
719 float y1p = leftOff[1]; // point
720 float x3p = leftOff[4]; // end
721 float y3p = leftOff[5]; // point
722
723 // Corner cases:
724 // 1. If the two control vectors are parallel, we'll end up with NaN's
725 // in leftOff (and rightOff in the body of the if below), so we'll
726 // do getLineOffsets, which is right.
727 // 2. If the first or second two points are equal, then (dx1,dy1)==(0,0)
728 // or (dx3,dy3)==(0,0), so (x1p, y1p)==(x1p+dx1, y1p+dy1)
729 // or (x3p, y3p)==(x3p-dx3, y3p-dy3), which means that
730 // computeIntersection will put NaN's in leftOff and right off, and
731 // we will do getLineOffsets, which is right.
732 computeIntersection(x1p, y1p, x1p+dx1, y1p+dy1, x3p, y3p, x3p-dx3, y3p-dy3, leftOff, 2);
733 float cx = leftOff[2];
734 float cy = leftOff[3];
735
736 if (!(isFinite(cx) && isFinite(cy))) {
737 // maybe the right path is not degenerate.
738 x1p = rightOff[0];
739 y1p = rightOff[1];
740 x3p = rightOff[4];
741 y3p = rightOff[5];
742 computeIntersection(x1p, y1p, x1p+dx1, y1p+dy1, x3p, y3p, x3p-dx3, y3p-dy3, rightOff, 2);
743 cx = rightOff[2];
744 cy = rightOff[3];
745 if (!(isFinite(cx) && isFinite(cy))) {
746 // both are degenerate. This curve is a line.
747 getLineOffsets(x1, y1, x3, y3, leftOff, rightOff);
748 return 4;
749 }
750 // {left,right}Off[0,1,4,5] are already set to the correct values.
751 leftOff[2] = 2*x2 - cx;
752 leftOff[3] = 2*y2 - cy;
753 return 6;
754 }
755
756 // rightOff[2,3] = (x2,y2) - ((left_x2, left_y2) - (x2, y2))
757 // == 2*(x2, y2) - (left_x2, left_y2)
758 rightOff[2] = 2*x2 - cx;
759 rightOff[3] = 2*y2 - cy;
760 return 6;
761 }
762
763 private static boolean isFinite(float x) {
764 return (Float.NEGATIVE_INFINITY < x && x < Float.POSITIVE_INFINITY);
765 }
766
767 // This is where the curve to be processed is put. We give it
768 // enough room to store 2 curves: one for the current subdivision, the
769 // other for the rest of the curve.
770 private float[] middle = new float[2*8];
771 private float[] lp = new float[8];
772 private float[] rp = new float[8];
773 private static final int MAX_N_CURVES = 11;
774 private float[] subdivTs = new float[MAX_N_CURVES - 1];
775
776 // If this class is compiled with ecj, then Hotspot crashes when OSR
777 // compiling this function. See bugs 7004570 and 6675699
778 // TODO: until those are fixed, we should work around that by
779 // manually inlining this into curveTo and quadTo.
780/******************************* WORKAROUND **********************************
781 private void somethingTo(final int type) {
782 // need these so we can update the state at the end of this method
783 final float xf = middle[type-2], yf = middle[type-1];
784 float dxs = middle[2] - middle[0];
785 float dys = middle[3] - middle[1];
786 float dxf = middle[type - 2] - middle[type - 4];
787 float dyf = middle[type - 1] - middle[type - 3];
788 switch(type) {
789 case 6:
790 if ((dxs == 0f && dys == 0f) ||
791 (dxf == 0f && dyf == 0f)) {
792 dxs = dxf = middle[4] - middle[0];
793 dys = dyf = middle[5] - middle[1];
794 }
795 break;
796 case 8:
797 boolean p1eqp2 = (dxs == 0f && dys == 0f);
798 boolean p3eqp4 = (dxf == 0f && dyf == 0f);
799 if (p1eqp2) {
800 dxs = middle[4] - middle[0];
801 dys = middle[5] - middle[1];
802 if (dxs == 0f && dys == 0f) {
803 dxs = middle[6] - middle[0];
804 dys = middle[7] - middle[1];
805 }
806 }
807 if (p3eqp4) {
808 dxf = middle[6] - middle[2];
809 dyf = middle[7] - middle[3];
810 if (dxf == 0f && dyf == 0f) {
811 dxf = middle[6] - middle[0];
812 dyf = middle[7] - middle[1];
813 }
814 }
815 }
816 if (dxs == 0f && dys == 0f) {
817 // this happens iff the "curve" is just a point
818 lineTo(middle[0], middle[1]);
819 return;
820 }
821 // if these vectors are too small, normalize them, to avoid future
822 // precision problems.
823 if (Math.abs(dxs) < 0.1f && Math.abs(dys) < 0.1f) {
824 float len = (float) sqrt(dxs*dxs + dys*dys);
825 dxs /= len;
826 dys /= len;
827 }
828 if (Math.abs(dxf) < 0.1f && Math.abs(dyf) < 0.1f) {
829 float len = (float) sqrt(dxf*dxf + dyf*dyf);
830 dxf /= len;
831 dyf /= len;
832 }
833
834 computeOffset(dxs, dys, lineWidth2, offset[0]);
835 final float mx = offset[0][0];
836 final float my = offset[0][1];
837 drawJoin(cdx, cdy, cx0, cy0, dxs, dys, cmx, cmy, mx, my);
838
839 int nSplits = findSubdivPoints(middle, subdivTs, type, lineWidth2);
840
841 int kind = 0;
842 Iterator<Integer> it = Curve.breakPtsAtTs(middle, type, subdivTs, nSplits);
843 while(it.hasNext()) {
844 int curCurveOff = it.next();
845
846 switch (type) {
847 case 8:
848 kind = computeOffsetCubic(middle, curCurveOff, lp, rp);
849 break;
850 case 6:
851 kind = computeOffsetQuad(middle, curCurveOff, lp, rp);
852 break;
853 }
854 emitLineTo(lp[0], lp[1]);
855 switch(kind) {
856 case 8:
857 emitCurveTo(lp[0], lp[1], lp[2], lp[3], lp[4], lp[5], lp[6], lp[7], false);
858 emitCurveTo(rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], rp[6], rp[7], true);
859 break;
860 case 6:
861 emitQuadTo(lp[0], lp[1], lp[2], lp[3], lp[4], lp[5], false);
862 emitQuadTo(rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], true);
863 break;
864 case 4:
865 emitLineTo(lp[2], lp[3]);
866 emitLineTo(rp[0], rp[1], true);
867 break;
868 }
869 emitLineTo(rp[kind - 2], rp[kind - 1], true);
870 }
871
872 this.cmx = (lp[kind - 2] - rp[kind - 2]) / 2;
873 this.cmy = (lp[kind - 1] - rp[kind - 1]) / 2;
874 this.cdx = dxf;
875 this.cdy = dyf;
876 this.cx0 = xf;
877 this.cy0 = yf;
878 this.prev = DRAWING_OP_TO;
879 }
880****************************** END WORKAROUND *******************************/
881
882 // finds values of t where the curve in pts should be subdivided in order
883 // to get good offset curves a distance of w away from the middle curve.
884 // Stores the points in ts, and returns how many of them there were.
885 private static Curve c = new Curve();
886 private static int findSubdivPoints(float[] pts, float[] ts, final int type, final float w)
887 {
888 final float x12 = pts[2] - pts[0];
889 final float y12 = pts[3] - pts[1];
890 // if the curve is already parallel to either axis we gain nothing
891 // from rotating it.
892 if (y12 != 0f && x12 != 0f) {
893 // we rotate it so that the first vector in the control polygon is
894 // parallel to the x-axis. This will ensure that rotated quarter
895 // circles won't be subdivided.
896 final float hypot = (float) sqrt(x12 * x12 + y12 * y12);
897 final float cos = x12 / hypot;
898 final float sin = y12 / hypot;
899 final float x1 = cos * pts[0] + sin * pts[1];
900 final float y1 = cos * pts[1] - sin * pts[0];
901 final float x2 = cos * pts[2] + sin * pts[3];
902 final float y2 = cos * pts[3] - sin * pts[2];
903 final float x3 = cos * pts[4] + sin * pts[5];
904 final float y3 = cos * pts[5] - sin * pts[4];
905 switch(type) {
906 case 8:
907 final float x4 = cos * pts[6] + sin * pts[7];
908 final float y4 = cos * pts[7] - sin * pts[6];
909 c.set(x1, y1, x2, y2, x3, y3, x4, y4);
910 break;
911 case 6:
912 c.set(x1, y1, x2, y2, x3, y3);
913 break;
914 }
915 } else {
916 c.set(pts, type);
917 }
918
919 int ret = 0;
920 // we subdivide at values of t such that the remaining rotated
921 // curves are monotonic in x and y.
922 ret += c.dxRoots(ts, ret);
923 ret += c.dyRoots(ts, ret);
924 // subdivide at inflection points.
925 if (type == 8) {
926 // quadratic curves can't have inflection points
927 ret += c.infPoints(ts, ret);
928 }
929
930 // now we must subdivide at points where one of the offset curves will have
931 // a cusp. This happens at ts where the radius of curvature is equal to w.
932 ret += c.rootsOfROCMinusW(ts, ret, w, 0.0001f);
933
934 ret = Helpers.filterOutNotInAB(ts, 0, ret, 0.0001f, 0.9999f);
935 Helpers.isort(ts, 0, ret);
936 return ret;
937 }
938
939 @Override public void curveTo(float x1, float y1,
940 float x2, float y2,
941 float x3, float y3)
942 {
943 middle[0] = cx0; middle[1] = cy0;
944 middle[2] = x1; middle[3] = y1;
945 middle[4] = x2; middle[5] = y2;
946 middle[6] = x3; middle[7] = y3;
947
948 // inlined version of somethingTo(8);
949 // See the TODO on somethingTo
950
951 // need these so we can update the state at the end of this method
952 final float xf = middle[6], yf = middle[7];
953 float dxs = middle[2] - middle[0];
954 float dys = middle[3] - middle[1];
955 float dxf = middle[6] - middle[4];
956 float dyf = middle[7] - middle[5];
957
958 boolean p1eqp2 = (dxs == 0f && dys == 0f);
959 boolean p3eqp4 = (dxf == 0f && dyf == 0f);
960 if (p1eqp2) {
961 dxs = middle[4] - middle[0];
962 dys = middle[5] - middle[1];
963 if (dxs == 0f && dys == 0f) {
964 dxs = middle[6] - middle[0];
965 dys = middle[7] - middle[1];
966 }
967 }
968 if (p3eqp4) {
969 dxf = middle[6] - middle[2];
970 dyf = middle[7] - middle[3];
971 if (dxf == 0f && dyf == 0f) {
972 dxf = middle[6] - middle[0];
973 dyf = middle[7] - middle[1];
974 }
975 }
976 if (dxs == 0f && dys == 0f) {
977 // this happens iff the "curve" is just a point
978 lineTo(middle[0], middle[1]);
979 return;
980 }
981
982 // if these vectors are too small, normalize them, to avoid future
983 // precision problems.
984 if (Math.abs(dxs) < 0.1f && Math.abs(dys) < 0.1f) {
985 float len = (float) sqrt(dxs*dxs + dys*dys);
986 dxs /= len;
987 dys /= len;
988 }
989 if (Math.abs(dxf) < 0.1f && Math.abs(dyf) < 0.1f) {
990 float len = (float) sqrt(dxf*dxf + dyf*dyf);
991 dxf /= len;
992 dyf /= len;
993 }
994
995 computeOffset(dxs, dys, lineWidth2, offset[0]);
996 final float mx = offset[0][0];
997 final float my = offset[0][1];
998 drawJoin(cdx, cdy, cx0, cy0, dxs, dys, cmx, cmy, mx, my);
999
1000 int nSplits = findSubdivPoints(middle, subdivTs, 8, lineWidth2);
1001
1002 int kind = 0;
1003 Iterator<Integer> it = Curve.breakPtsAtTs(middle, 8, subdivTs, nSplits);
1004 while(it.hasNext()) {
1005 int curCurveOff = it.next();
1006
1007 kind = computeOffsetCubic(middle, curCurveOff, lp, rp);
1008 emitLineTo(lp[0], lp[1]);
1009 switch(kind) {
1010 case 8:
1011 emitCurveTo(lp[0], lp[1], lp[2], lp[3], lp[4], lp[5], lp[6], lp[7], false);
1012 emitCurveTo(rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], rp[6], rp[7], true);
1013 break;
1014 case 4:
1015 emitLineTo(lp[2], lp[3]);
1016 emitLineTo(rp[0], rp[1], true);
1017 break;
1018 }
1019 emitLineTo(rp[kind - 2], rp[kind - 1], true);
1020 }
1021
1022 this.cmx = (lp[kind - 2] - rp[kind - 2]) / 2;
1023 this.cmy = (lp[kind - 1] - rp[kind - 1]) / 2;
1024 this.cdx = dxf;
1025 this.cdy = dyf;
1026 this.cx0 = xf;
1027 this.cy0 = yf;
1028 this.prev = DRAWING_OP_TO;
1029 }
1030
1031 @Override public void quadTo(float x1, float y1, float x2, float y2) {
1032 middle[0] = cx0; middle[1] = cy0;
1033 middle[2] = x1; middle[3] = y1;
1034 middle[4] = x2; middle[5] = y2;
1035
1036 // inlined version of somethingTo(8);
1037 // See the TODO on somethingTo
1038
1039 // need these so we can update the state at the end of this method
1040 final float xf = middle[4], yf = middle[5];
1041 float dxs = middle[2] - middle[0];
1042 float dys = middle[3] - middle[1];
1043 float dxf = middle[4] - middle[2];
1044 float dyf = middle[5] - middle[3];
1045 if ((dxs == 0f && dys == 0f) || (dxf == 0f && dyf == 0f)) {
1046 dxs = dxf = middle[4] - middle[0];
1047 dys = dyf = middle[5] - middle[1];
1048 }
1049 if (dxs == 0f && dys == 0f) {
1050 // this happens iff the "curve" is just a point
1051 lineTo(middle[0], middle[1]);
1052 return;
1053 }
1054 // if these vectors are too small, normalize them, to avoid future
1055 // precision problems.
1056 if (Math.abs(dxs) < 0.1f && Math.abs(dys) < 0.1f) {
1057 float len = (float) sqrt(dxs*dxs + dys*dys);
1058 dxs /= len;
1059 dys /= len;
1060 }
1061 if (Math.abs(dxf) < 0.1f && Math.abs(dyf) < 0.1f) {
1062 float len = (float) sqrt(dxf*dxf + dyf*dyf);
1063 dxf /= len;
1064 dyf /= len;
1065 }
1066
1067 computeOffset(dxs, dys, lineWidth2, offset[0]);
1068 final float mx = offset[0][0];
1069 final float my = offset[0][1];
1070 drawJoin(cdx, cdy, cx0, cy0, dxs, dys, cmx, cmy, mx, my);
1071
1072 int nSplits = findSubdivPoints(middle, subdivTs, 6, lineWidth2);
1073
1074 int kind = 0;
1075 Iterator<Integer> it = Curve.breakPtsAtTs(middle, 6, subdivTs, nSplits);
1076 while(it.hasNext()) {
1077 int curCurveOff = it.next();
1078
1079 kind = computeOffsetQuad(middle, curCurveOff, lp, rp);
1080 emitLineTo(lp[0], lp[1]);
1081 switch(kind) {
1082 case 6:
1083 emitQuadTo(lp[0], lp[1], lp[2], lp[3], lp[4], lp[5], false);
1084 emitQuadTo(rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], true);
1085 break;
1086 case 4:
1087 emitLineTo(lp[2], lp[3]);
1088 emitLineTo(rp[0], rp[1], true);
1089 break;
1090 }
1091 emitLineTo(rp[kind - 2], rp[kind - 1], true);
1092 }
1093
1094 this.cmx = (lp[kind - 2] - rp[kind - 2]) / 2;
1095 this.cmy = (lp[kind - 1] - rp[kind - 1]) / 2;
1096 this.cdx = dxf;
1097 this.cdy = dyf;
1098 this.cx0 = xf;
1099 this.cy0 = yf;
1100 this.prev = DRAWING_OP_TO;
1101 }
1102
1103 @Override public long getNativeConsumer() {
1104 throw new InternalError("Stroker doesn't use a native consumer");
1105 }
1106
1107 // a stack of polynomial curves where each curve shares endpoints with
1108 // adjacent ones.
1109 private static final class PolyStack {
1110 float[] curves;
1111 int end;
1112 int[] curveTypes;
1113 int numCurves;
1114
1115 private static final int INIT_SIZE = 50;
1116
1117 PolyStack() {
1118 curves = new float[8 * INIT_SIZE];
1119 curveTypes = new int[INIT_SIZE];
1120 end = 0;
1121 numCurves = 0;
1122 }
1123
1124 public boolean isEmpty() {
1125 return numCurves == 0;
1126 }
1127
1128 private void ensureSpace(int n) {
1129 if (end + n >= curves.length) {
1130 int newSize = (end + n) * 2;
1131 curves = Arrays.copyOf(curves, newSize);
1132 }
1133 if (numCurves >= curveTypes.length) {
1134 int newSize = numCurves * 2;
1135 curveTypes = Arrays.copyOf(curveTypes, newSize);
1136 }
1137 }
1138
1139 public void pushCubic(float x0, float y0,
1140 float x1, float y1,
1141 float x2, float y2)
1142 {
1143 ensureSpace(6);
1144 curveTypes[numCurves++] = 8;
1145 // assert(x0 == lastX && y0 == lastY)
1146
1147 // we reverse the coordinate order to make popping easier
1148 curves[end++] = x2; curves[end++] = y2;
1149 curves[end++] = x1; curves[end++] = y1;
1150 curves[end++] = x0; curves[end++] = y0;
1151 }
1152
1153 public void pushQuad(float x0, float y0,
1154 float x1, float y1)
1155 {
1156 ensureSpace(4);
1157 curveTypes[numCurves++] = 6;
1158 // assert(x0 == lastX && y0 == lastY)
1159 curves[end++] = x1; curves[end++] = y1;
1160 curves[end++] = x0; curves[end++] = y0;
1161 }
1162
1163 public void pushLine(float x, float y) {
1164 ensureSpace(2);
1165 curveTypes[numCurves++] = 4;
1166 // assert(x0 == lastX && y0 == lastY)
1167 curves[end++] = x; curves[end++] = y;
1168 }
1169
1170 @SuppressWarnings("unused")
1171 public int pop(float[] pts) {
1172 int ret = curveTypes[numCurves - 1];
1173 numCurves--;
1174 end -= (ret - 2);
1175 System.arraycopy(curves, end, pts, 0, ret - 2);
1176 return ret;
1177 }
1178
1179 public void pop(PathConsumer2D io) {
1180 numCurves--;
1181 int type = curveTypes[numCurves];
1182 end -= (type - 2);
1183 switch(type) {
1184 case 8:
1185 io.curveTo(curves[end+0], curves[end+1],
1186 curves[end+2], curves[end+3],
1187 curves[end+4], curves[end+5]);
1188 break;
1189 case 6:
1190 io.quadTo(curves[end+0], curves[end+1],
1191 curves[end+2], curves[end+3]);
1192 break;
1193 case 4:
1194 io.lineTo(curves[end], curves[end+1]);
1195 }
1196 }
1197
1198 @Override
1199 public String toString() {
1200 String ret = "";
1201 int nc = numCurves;
1202 int end = this.end;
1203 while (nc > 0) {
1204 nc--;
1205 int type = curveTypes[numCurves];
1206 end -= (type - 2);
1207 switch(type) {
1208 case 8:
1209 ret += "cubic: ";
1210 break;
1211 case 6:
1212 ret += "quad: ";
1213 break;
1214 case 4:
1215 ret += "line: ";
1216 break;
1217 }
1218 ret += Arrays.toString(Arrays.copyOfRange(curves, end, end+type-2)) + "\n";
1219 }
1220 return ret;
1221 }
1222 }
1223}