/* * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package sun.java2d.pisces; import java.awt.Shape;import java.awt.BasicStroke;import java.awt.geom.Path2D;import java.awt.geom.AffineTransform;import java.awt.geom.PathIterator; import sun.awt.geom.PathConsumer2D;import sun.java2d.pipe.Region;import sun.java2d.pipe.RenderingEngine;import sun.java2d.pipe.AATileGenerator; public class PiscesRenderingEngine extends RenderingEngine { private static enum NormMode {OFF, ON_NO_AA, ON_WITH_AA} /** * Create a widened path as specified by the parameters. * <p> * The specified {@code src} {@link Shape} is widened according * to the specified attribute parameters as per the * {@link BasicStroke} specification. * * @param src the source path to be widened * @param width the width of the widened path as per {@code BasicStroke} * @param caps the end cap decorations as per {@code BasicStroke} * @param join the segment join decorations as per {@code BasicStroke} * @param miterlimit the miter limit as per {@code BasicStroke} * @param dashes the dash length array as per {@code BasicStroke} * @param dashphase the initial dash phase as per {@code BasicStroke} * @return the widened path stored in a new {@code Shape} object * @since 1.7 */ public Shape createStrokedShape(Shape src, float width, int caps, int join, float miterlimit, float dashes[], float dashphase) { final Path2D p2d = new Path2D.Float(); strokeTo(src, null, width, NormMode.OFF, caps, join, miterlimit, dashes, dashphase, new PathConsumer2D() { public void moveTo(float x0, float y0) { p2d.moveTo(x0, y0); } public void lineTo(float x1, float y1) { p2d.lineTo(x1, y1); } public void closePath() { p2d.closePath(); } public void pathDone() {} public void curveTo(float x1, float y1, float x2, float y2, float x3, float y3) { p2d.curveTo(x1, y1, x2, y2, x3, y3); } public void quadTo(float x1, float y1, float x2, float y2) { p2d.quadTo(x1, y1, x2, y2); } public long getNativeConsumer() { throw new InternalError("Not using a native peer"); } }); return p2d; } /** * Sends the geometry for a widened path as specified by the parameters * to the specified consumer. * <p> * The specified {@code src} {@link Shape} is widened according * to the parameters specified by the {@link BasicStroke} object. * Adjustments are made to the path as appropriate for the * {@link VALUE_STROKE_NORMALIZE} hint if the {@code normalize} * boolean parameter is true. * Adjustments are made to the path as appropriate for the * {@link VALUE_ANTIALIAS_ON} hint if the {@code antialias} * boolean parameter is true. * <p> * The geometry of the widened path is forwarded to the indicated * {@link PathConsumer2D} object as it is calculated. * * @param src the source path to be widened * @param bs the {@code BasicSroke} object specifying the * decorations to be applied to the widened path * @param normalize indicates whether stroke normalization should * be applied * @param antialias indicates whether or not adjustments appropriate * to antialiased rendering should be applied * @param consumer the {@code PathConsumer2D} instance to forward * the widened geometry to * @since 1.7 */ public void strokeTo(Shape src, AffineTransform at, BasicStroke bs, boolean thin, boolean normalize, boolean antialias, final PathConsumer2D consumer) { NormMode norm = (normalize) ? ((antialias) ? NormMode.ON_WITH_AA : NormMode.ON_NO_AA) : NormMode.OFF; strokeTo(src, at, bs, thin, norm, antialias, consumer); } void strokeTo(Shape src, AffineTransform at, BasicStroke bs, boolean thin, NormMode normalize, boolean antialias, PathConsumer2D pc2d) { float lw; if (thin) { if (antialias) { lw = userSpaceLineWidth(at, 0.5f); } else { lw = userSpaceLineWidth(at, 1.0f); } } else { lw = bs.getLineWidth(); } strokeTo(src, at, lw, normalize, bs.getEndCap(), bs.getLineJoin(), bs.getMiterLimit(), bs.getDashArray(), bs.getDashPhase(), pc2d); } private float userSpaceLineWidth(AffineTransform at, float lw) { double widthScale; if ((at.getType() & (AffineTransform.TYPE_GENERAL_TRANSFORM | AffineTransform.TYPE_GENERAL_SCALE)) != 0) { widthScale = Math.sqrt(at.getDeterminant()); } else { /* First calculate the "maximum scale" of this transform. */ double A = at.getScaleX(); // m00 double C = at.getShearX(); // m01 double B = at.getShearY(); // m10 double D = at.getScaleY(); // m11 /* * Given a 2 x 2 affine matrix [ A B ] such that * [ C D ] * v' = [x' y'] = [Ax + Cy, Bx + Dy], we want to * find the maximum magnitude (norm) of the vector v' * with the constraint (x^2 + y^2 = 1). * The equation to maximize is * |v'| = sqrt((Ax+Cy)^2+(Bx+Dy)^2) * or |v'| = sqrt((AA+BB)x^2 + 2(AC+BD)xy + (CC+DD)y^2). * Since sqrt is monotonic we can maximize |v'|^2 * instead and plug in the substitution y = sqrt(1 - x^2). * Trigonometric equalities can then be used to get * rid of most of the sqrt terms. */ double EA = A*A + B*B; // x^2 coefficient double EB = 2*(A*C + B*D); // xy coefficient double EC = C*C + D*D; // y^2 coefficient /* * There is a lot of calculus omitted here. * * Conceptually, in the interests of understanding the * terms that the calculus produced we can consider * that EA and EC end up providing the lengths along * the major axes and the hypot term ends up being an * adjustment for the additional length along the off-axis * angle of rotated or sheared ellipses as well as an * adjustment for the fact that the equation below * averages the two major axis lengths. (Notice that * the hypot term contains a part which resolves to the * difference of these two axis lengths in the absence * of rotation.) * * In the calculus, the ratio of the EB and (EA-EC) terms * ends up being the tangent of 2*theta where theta is * the angle that the long axis of the ellipse makes * with the horizontal axis. Thus, this equation is * calculating the length of the hypotenuse of a triangle * along that axis. */ double hypot = Math.sqrt(EB*EB + (EA-EC)*(EA-EC)); /* sqrt omitted, compare to squared limits below. */ double widthsquared = ((EA + EC + hypot)/2.0); widthScale = Math.sqrt(widthsquared); } return (float) (lw / widthScale); } void strokeTo(Shape src, AffineTransform at, float width, NormMode normalize, int caps, int join, float miterlimit, float dashes[], float dashphase, PathConsumer2D pc2d) { // We use strokerat and outat so that in Stroker and Dasher we can work only // with the pre-transformation coordinates. This will repeat a lot of // computations done in the path iterator, but the alternative is to // work with transformed paths and compute untransformed coordinates // as needed. This would be faster but I do not think the complexity // of working with both untransformed and transformed coordinates in // the same code is worth it. // However, if a path's width is constant after a transformation, // we can skip all this untransforming. // If normalization is off we save some transformations by not // transforming the input to pisces. Instead, we apply the // transformation after the path processing has been done. // We can't do this if normalization is on, because it isn't a good // idea to normalize before the transformation is applied. AffineTransform strokerat = null; AffineTransform outat = null; PathIterator pi = null; if (at != null && !at.isIdentity()) { final double a = at.getScaleX(); final double b = at.getShearX(); final double c = at.getShearY(); final double d = at.getScaleY(); final double det = a * d - c * b; if (Math.abs(det) <= 2 * Float.MIN_VALUE) { // this rendering engine takes one dimensional curves and turns // them into 2D shapes by giving them width. // However, if everything is to be passed through a singular // transformation, these 2D shapes will be squashed down to 1D // again so, nothing can be drawn. // Every path needs an initial moveTo and a pathDone. If these // are not there this causes a SIGSEGV in libawt.so (at the time // of writing of this comment (September 16, 2010)). Actually, // I am not sure if the moveTo is necessary to avoid the SIGSEGV // but the pathDone is definitely needed. pc2d.moveTo(0, 0); pc2d.pathDone(); return; } // If the transform is a constant multiple of an orthogonal transformation // then every length is just multiplied by a constant, so we just // need to transform input paths to stroker and tell stroker // the scaled width. This condition is satisfied if // a*b == -c*d && a*a+c*c == b*b+d*d. In the actual check below, we // leave a bit of room for error. if (nearZero(a*b + c*d, 2) && nearZero(a*a+c*c - (b*b+d*d), 2)) { double scale = Math.sqrt(a*a + c*c); if (dashes != null) { dashes = java.util.Arrays.copyOf(dashes, dashes.length); for (int i = 0; i < dashes.length; i++) { dashes[i] = (float)(scale * dashes[i]); } dashphase = (float)(scale * dashphase); } width = (float)(scale * width); pi = src.getPathIterator(at); if (normalize != NormMode.OFF) { pi = new NormalizingPathIterator(pi, normalize); } // by now strokerat == null && outat == null. Input paths to // stroker (and maybe dasher) will have the full transform at // applied to them and nothing will happen to the output paths. } else { if (normalize != NormMode.OFF) { strokerat = at; pi = src.getPathIterator(at); pi = new NormalizingPathIterator(pi, normalize); // by now strokerat == at && outat == null. Input paths to // stroker (and maybe dasher) will have the full transform at // applied to them, then they will be normalized, and then // the inverse of *only the non translation part of at* will // be applied to the normalized paths. This won't cause problems // in stroker, because, suppose at = T*A, where T is just the // translation part of at, and A is the rest. T*A has already // been applied to Stroker/Dasher's input. Then Ainv will be // applied. Ainv*T*A is not equal to T, but it is a translation, // which means that none of stroker's assumptions about its // input will be violated. After all this, A will be applied // to stroker's output. } else { outat = at; pi = src.getPathIterator(null); // outat == at && strokerat == null. This is because if no // normalization is done, we can just apply all our // transformations to stroker's output. } } } else { // either at is null or it's the identity. In either case // we don't transform the path. pi = src.getPathIterator(null); if (normalize != NormMode.OFF) { pi = new NormalizingPathIterator(pi, normalize); } } // by now, at least one of outat and strokerat will be null. Unless at is not // a constant multiple of an orthogonal transformation, they will both be // null. In other cases, outat == at if normalization is off, and if // normalization is on, strokerat == at. pc2d = TransformingPathConsumer2D.transformConsumer(pc2d, outat); pc2d = TransformingPathConsumer2D.deltaTransformConsumer(pc2d, strokerat); pc2d = new Stroker(pc2d, width, caps, join, miterlimit); if (dashes != null) { pc2d = new Dasher(pc2d, dashes, dashphase); } pc2d = TransformingPathConsumer2D.inverseDeltaTransformConsumer(pc2d, strokerat); pathTo(pi, pc2d); } private static boolean nearZero(double num, int nulps) { return Math.abs(num) < nulps * Math.ulp(num); } private static class NormalizingPathIterator implements PathIterator { private final PathIterator src; // the adjustment applied to the current position. private float curx_adjust, cury_adjust; // the adjustment applied to the last moveTo position. private float movx_adjust, movy_adjust; // constants used in normalization computations private final float lval, rval; NormalizingPathIterator(PathIterator src, NormMode mode) { this.src = src; switch (mode) { case ON_NO_AA: // round to nearest (0.25, 0.25) pixel lval = rval = 0.25f; break; case ON_WITH_AA: // round to nearest pixel center lval = 0f; rval = 0.5f; break; case OFF: throw new InternalError("A NormalizingPathIterator should " + "not be created if no normalization is being done"); default: throw new InternalError("Unrecognized normalization mode"); } } public int currentSegment(float[] coords) { int type = src.currentSegment(coords); int lastCoord; switch(type) { case PathIterator.SEG_CUBICTO: lastCoord = 4; break; case PathIterator.SEG_QUADTO: lastCoord = 2; break; case PathIterator.SEG_LINETO: case PathIterator.SEG_MOVETO: lastCoord = 0; break; case PathIterator.SEG_CLOSE: // we don't want to deal with this case later. We just exit now curx_adjust = movx_adjust; cury_adjust = movy_adjust; return type; default: throw new InternalError("Unrecognized curve type"); } // normalize endpoint float x_adjust = (float)Math.floor(coords[lastCoord] + lval) + rval - coords[lastCoord]; float y_adjust = (float)Math.floor(coords[lastCoord+1] + lval) + rval - coords[lastCoord + 1]; coords[lastCoord ] += x_adjust; coords[lastCoord + 1] += y_adjust; // now that the end points are done, normalize the control points switch(type) { case PathIterator.SEG_CUBICTO: coords[0] += curx_adjust; coords[1] += cury_adjust; coords[2] += x_adjust; coords[3] += y_adjust; break; case PathIterator.SEG_QUADTO: coords[0] += (curx_adjust + x_adjust) / 2; coords[1] += (cury_adjust + y_adjust) / 2; break; case PathIterator.SEG_LINETO: break; case PathIterator.SEG_MOVETO: movx_adjust = x_adjust; movy_adjust = y_adjust; break; case PathIterator.SEG_CLOSE: throw new InternalError("This should be handled earlier."); } curx_adjust = x_adjust; cury_adjust = y_adjust; return type; } public int currentSegment(double[] coords) { float[] tmp = new float[6]; int type = this.currentSegment(tmp); for (int i = 0; i < 6; i++) { coords[i] = (float) tmp[i]; } return type; } public int getWindingRule() { return src.getWindingRule(); } public boolean isDone() { return src.isDone(); } public void next() { src.next(); } } static void pathTo(PathIterator pi, PathConsumer2D pc2d) { RenderingEngine.feedConsumer(pi, pc2d); pc2d.pathDone(); } /** * Construct an antialiased tile generator for the given shape with * the given rendering attributes and store the bounds of the tile * iteration in the bbox parameter. * The {@code at} parameter specifies a transform that should affect * both the shape and the {@code BasicStroke} attributes. * The {@code clip} parameter specifies the current clip in effect * in device coordinates and can be used to prune the data for the * operation, but the renderer is not required to perform any * clipping. * If the {@code BasicStroke} parameter is null then the shape * should be filled as is, otherwise the attributes of the * {@code BasicStroke} should be used to specify a draw operation.Lines 1–500 of 656. Load more
/* * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package sun.java2d.pisces; import java.awt.Shape; import java.awt.BasicStroke; import java.awt.geom.Path2D; import java.awt.geom.AffineTransform; import java.awt.geom.PathIterator; import sun.awt.geom.PathConsumer2D; import sun.java2d.pipe.Region; import sun.java2d.pipe.RenderingEngine; import sun.java2d.pipe.AATileGenerator; public class PiscesRenderingEngine extends RenderingEngine { private static enum NormMode {OFF, ON_NO_AA, ON_WITH_AA} /** * Create a widened path as specified by the parameters. * <p> * The specified {@code src} {@link Shape} is widened according * to the specified attribute parameters as per the * {@link BasicStroke} specification. * * @param src the source path to be widened * @param width the width of the widened path as per {@code BasicStroke} * @param caps the end cap decorations as per {@code BasicStroke} * @param join the segment join decorations as per {@code BasicStroke} * @param miterlimit the miter limit as per {@code BasicStroke} * @param dashes the dash length array as per {@code BasicStroke} * @param dashphase the initial dash phase as per {@code BasicStroke} * @return the widened path stored in a new {@code Shape} object * @since 1.7 */ public Shape createStrokedShape(Shape src, float width, int caps, int join, float miterlimit, float dashes[], float dashphase) { final Path2D p2d = new Path2D.Float(); strokeTo(src, null, width, NormMode.OFF, caps, join, miterlimit, dashes, dashphase, new PathConsumer2D() { public void moveTo(float x0, float y0) { p2d.moveTo(x0, y0); } public void lineTo(float x1, float y1) { p2d.lineTo(x1, y1); } public void closePath() { p2d.closePath(); } public void pathDone() {} public void curveTo(float x1, float y1, float x2, float y2, float x3, float y3) { p2d.curveTo(x1, y1, x2, y2, x3, y3); } public void quadTo(float x1, float y1, float x2, float y2) { p2d.quadTo(x1, y1, x2, y2); } public long getNativeConsumer() { throw new InternalError("Not using a native peer"); } }); return p2d; } /** * Sends the geometry for a widened path as specified by the parameters * to the specified consumer. * <p> * The specified {@code src} {@link Shape} is widened according * to the parameters specified by the {@link BasicStroke} object. * Adjustments are made to the path as appropriate for the * {@link VALUE_STROKE_NORMALIZE} hint if the {@code normalize} * boolean parameter is true. * Adjustments are made to the path as appropriate for the * {@link VALUE_ANTIALIAS_ON} hint if the {@code antialias} * boolean parameter is true. * <p> * The geometry of the widened path is forwarded to the indicated * {@link PathConsumer2D} object as it is calculated. * * @param src the source path to be widened * @param bs the {@code BasicSroke} object specifying the * decorations to be applied to the widened path * @param normalize indicates whether stroke normalization should * be applied * @param antialias indicates whether or not adjustments appropriate * to antialiased rendering should be applied * @param consumer the {@code PathConsumer2D} instance to forward * the widened geometry to * @since 1.7 */ public void strokeTo(Shape src, AffineTransform at, BasicStroke bs, boolean thin, boolean normalize, boolean antialias, final PathConsumer2D consumer) { NormMode norm = (normalize) ? ((antialias) ? NormMode.ON_WITH_AA : NormMode.ON_NO_AA) : NormMode.OFF; strokeTo(src, at, bs, thin, norm, antialias, consumer); } void strokeTo(Shape src, AffineTransform at, BasicStroke bs, boolean thin, NormMode normalize, boolean antialias, PathConsumer2D pc2d) { float lw; if (thin) { if (antialias) { lw = userSpaceLineWidth(at, 0.5f); } else { lw = userSpaceLineWidth(at, 1.0f); } } else { lw = bs.getLineWidth(); } strokeTo(src, at, lw, normalize, bs.getEndCap(), bs.getLineJoin(), bs.getMiterLimit(), bs.getDashArray(), bs.getDashPhase(), pc2d); } private float userSpaceLineWidth(AffineTransform at, float lw) { double widthScale; if ((at.getType() & (AffineTransform.TYPE_GENERAL_TRANSFORM | AffineTransform.TYPE_GENERAL_SCALE)) != 0) { widthScale = Math.sqrt(at.getDeterminant()); } else { /* First calculate the "maximum scale" of this transform. */ double A = at.getScaleX(); // m00 double C = at.getShearX(); // m01 double B = at.getShearY(); // m10 double D = at.getScaleY(); // m11 /* * Given a 2 x 2 affine matrix [ A B ] such that * [ C D ] * v' = [x' y'] = [Ax + Cy, Bx + Dy], we want to * find the maximum magnitude (norm) of the vector v' * with the constraint (x^2 + y^2 = 1). * The equation to maximize is * |v'| = sqrt((Ax+Cy)^2+(Bx+Dy)^2) * or |v'| = sqrt((AA+BB)x^2 + 2(AC+BD)xy + (CC+DD)y^2). * Since sqrt is monotonic we can maximize |v'|^2 * instead and plug in the substitution y = sqrt(1 - x^2). * Trigonometric equalities can then be used to get * rid of most of the sqrt terms. */ double EA = A*A + B*B; // x^2 coefficient double EB = 2*(A*C + B*D); // xy coefficient double EC = C*C + D*D; // y^2 coefficient /* * There is a lot of calculus omitted here. * * Conceptually, in the interests of understanding the * terms that the calculus produced we can consider * that EA and EC end up providing the lengths along * the major axes and the hypot term ends up being an * adjustment for the additional length along the off-axis * angle of rotated or sheared ellipses as well as an * adjustment for the fact that the equation below * averages the two major axis lengths. (Notice that * the hypot term contains a part which resolves to the * difference of these two axis lengths in the absence * of rotation.) * * In the calculus, the ratio of the EB and (EA-EC) terms * ends up being the tangent of 2*theta where theta is * the angle that the long axis of the ellipse makes * with the horizontal axis. Thus, this equation is * calculating the length of the hypotenuse of a triangle * along that axis. */ double hypot = Math.sqrt(EB*EB + (EA-EC)*(EA-EC)); /* sqrt omitted, compare to squared limits below. */ double widthsquared = ((EA + EC + hypot)/2.0); widthScale = Math.sqrt(widthsquared); } return (float) (lw / widthScale); } void strokeTo(Shape src, AffineTransform at, float width, NormMode normalize, int caps, int join, float miterlimit, float dashes[], float dashphase, PathConsumer2D pc2d) { // We use strokerat and outat so that in Stroker and Dasher we can work only // with the pre-transformation coordinates. This will repeat a lot of // computations done in the path iterator, but the alternative is to // work with transformed paths and compute untransformed coordinates // as needed. This would be faster but I do not think the complexity // of working with both untransformed and transformed coordinates in // the same code is worth it. // However, if a path's width is constant after a transformation, // we can skip all this untransforming. // If normalization is off we save some transformations by not // transforming the input to pisces. Instead, we apply the // transformation after the path processing has been done. // We can't do this if normalization is on, because it isn't a good // idea to normalize before the transformation is applied. AffineTransform strokerat = null; AffineTransform outat = null; PathIterator pi = null; if (at != null && !at.isIdentity()) { final double a = at.getScaleX(); final double b = at.getShearX(); final double c = at.getShearY(); final double d = at.getScaleY(); final double det = a * d - c * b; if (Math.abs(det) <= 2 * Float.MIN_VALUE) { // this rendering engine takes one dimensional curves and turns // them into 2D shapes by giving them width. // However, if everything is to be passed through a singular // transformation, these 2D shapes will be squashed down to 1D // again so, nothing can be drawn. // Every path needs an initial moveTo and a pathDone. If these // are not there this causes a SIGSEGV in libawt.so (at the time // of writing of this comment (September 16, 2010)). Actually, // I am not sure if the moveTo is necessary to avoid the SIGSEGV // but the pathDone is definitely needed. pc2d.moveTo(0, 0); pc2d.pathDone(); return; } // If the transform is a constant multiple of an orthogonal transformation // then every length is just multiplied by a constant, so we just // need to transform input paths to stroker and tell stroker // the scaled width. This condition is satisfied if // a*b == -c*d && a*a+c*c == b*b+d*d. In the actual check below, we // leave a bit of room for error. if (nearZero(a*b + c*d, 2) && nearZero(a*a+c*c - (b*b+d*d), 2)) { double scale = Math.sqrt(a*a + c*c); if (dashes != null) { dashes = java.util.Arrays.copyOf(dashes, dashes.length); for (int i = 0; i < dashes.length; i++) { dashes[i] = (float)(scale * dashes[i]); } dashphase = (float)(scale * dashphase); } width = (float)(scale * width); pi = src.getPathIterator(at); if (normalize != NormMode.OFF) { pi = new NormalizingPathIterator(pi, normalize); } // by now strokerat == null && outat == null. Input paths to // stroker (and maybe dasher) will have the full transform at // applied to them and nothing will happen to the output paths. } else { if (normalize != NormMode.OFF) { strokerat = at; pi = src.getPathIterator(at); pi = new NormalizingPathIterator(pi, normalize); // by now strokerat == at && outat == null. Input paths to // stroker (and maybe dasher) will have the full transform at // applied to them, then they will be normalized, and then // the inverse of *only the non translation part of at* will // be applied to the normalized paths. This won't cause problems // in stroker, because, suppose at = T*A, where T is just the // translation part of at, and A is the rest. T*A has already // been applied to Stroker/Dasher's input. Then Ainv will be // applied. Ainv*T*A is not equal to T, but it is a translation, // which means that none of stroker's assumptions about its // input will be violated. After all this, A will be applied // to stroker's output. } else { outat = at; pi = src.getPathIterator(null); // outat == at && strokerat == null. This is because if no // normalization is done, we can just apply all our // transformations to stroker's output. } } } else { // either at is null or it's the identity. In either case // we don't transform the path. pi = src.getPathIterator(null); if (normalize != NormMode.OFF) { pi = new NormalizingPathIterator(pi, normalize); } } // by now, at least one of outat and strokerat will be null. Unless at is not // a constant multiple of an orthogonal transformation, they will both be // null. In other cases, outat == at if normalization is off, and if // normalization is on, strokerat == at. pc2d = TransformingPathConsumer2D.transformConsumer(pc2d, outat); pc2d = TransformingPathConsumer2D.deltaTransformConsumer(pc2d, strokerat); pc2d = new Stroker(pc2d, width, caps, join, miterlimit); if (dashes != null) { pc2d = new Dasher(pc2d, dashes, dashphase); } pc2d = TransformingPathConsumer2D.inverseDeltaTransformConsumer(pc2d, strokerat); pathTo(pi, pc2d); } private static boolean nearZero(double num, int nulps) { return Math.abs(num) < nulps * Math.ulp(num); } private static class NormalizingPathIterator implements PathIterator { private final PathIterator src; // the adjustment applied to the current position. private float curx_adjust, cury_adjust; // the adjustment applied to the last moveTo position. private float movx_adjust, movy_adjust; // constants used in normalization computations private final float lval, rval; NormalizingPathIterator(PathIterator src, NormMode mode) { this.src = src; switch (mode) { case ON_NO_AA: // round to nearest (0.25, 0.25) pixel lval = rval = 0.25f; break; case ON_WITH_AA: // round to nearest pixel center lval = 0f; rval = 0.5f; break; case OFF: throw new InternalError("A NormalizingPathIterator should " + "not be created if no normalization is being done"); default: throw new InternalError("Unrecognized normalization mode"); } } public int currentSegment(float[] coords) { int type = src.currentSegment(coords); int lastCoord; switch(type) { case PathIterator.SEG_CUBICTO: lastCoord = 4; break; case PathIterator.SEG_QUADTO: lastCoord = 2; break; case PathIterator.SEG_LINETO: case PathIterator.SEG_MOVETO: lastCoord = 0; break; case PathIterator.SEG_CLOSE: // we don't want to deal with this case later. We just exit now curx_adjust = movx_adjust; cury_adjust = movy_adjust; return type; default: throw new InternalError("Unrecognized curve type"); } // normalize endpoint float x_adjust = (float)Math.floor(coords[lastCoord] + lval) + rval - coords[lastCoord]; float y_adjust = (float)Math.floor(coords[lastCoord+1] + lval) + rval - coords[lastCoord + 1]; coords[lastCoord ] += x_adjust; coords[lastCoord + 1] += y_adjust; // now that the end points are done, normalize the control points switch(type) { case PathIterator.SEG_CUBICTO: coords[0] += curx_adjust; coords[1] += cury_adjust; coords[2] += x_adjust; coords[3] += y_adjust; break; case PathIterator.SEG_QUADTO: coords[0] += (curx_adjust + x_adjust) / 2; coords[1] += (cury_adjust + y_adjust) / 2; break; case PathIterator.SEG_LINETO: break; case PathIterator.SEG_MOVETO: movx_adjust = x_adjust; movy_adjust = y_adjust; break; case PathIterator.SEG_CLOSE: throw new InternalError("This should be handled earlier."); } curx_adjust = x_adjust; cury_adjust = y_adjust; return type; } public int currentSegment(double[] coords) { float[] tmp = new float[6]; int type = this.currentSegment(tmp); for (int i = 0; i < 6; i++) { coords[i] = (float) tmp[i]; } return type; } public int getWindingRule() { return src.getWindingRule(); } public boolean isDone() { return src.isDone(); } public void next() { src.next(); } } static void pathTo(PathIterator pi, PathConsumer2D pc2d) { RenderingEngine.feedConsumer(pi, pc2d); pc2d.pathDone(); } /** * Construct an antialiased tile generator for the given shape with * the given rendering attributes and store the bounds of the tile * iteration in the bbox parameter. * The {@code at} parameter specifies a transform that should affect * both the shape and the {@code BasicStroke} attributes. * The {@code clip} parameter specifies the current clip in effect * in device coordinates and can be used to prune the data for the * operation, but the renderer is not required to perform any * clipping. * If the {@code BasicStroke} parameter is null then the shape * should be filled as is, otherwise the attributes of the * {@code BasicStroke} should be used to specify a draw operation.