3909N/A * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved. 0N/A * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 0N/A * This code is free software; you can redistribute it and/or modify it 0N/A * under the terms of the GNU General Public License version 2 only, as 2362N/A * published by the Free Software Foundation. Oracle designates this 0N/A * particular file as subject to the "Classpath" exception as provided 2362N/A * by Oracle in the LICENSE file that accompanied this code. 0N/A * This code is distributed in the hope that it will be useful, but WITHOUT 0N/A * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 0N/A * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 0N/A * version 2 for more details (a copy is included in the LICENSE file that 0N/A * accompanied this code). 0N/A * You should have received a copy of the GNU General Public License version 0N/A * 2 along with this work; if not, write to the Free Software Foundation, 0N/A * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 2362N/A * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 2362N/A * or visit www.oracle.com if you need additional information or have any 0N/A * Create a widened path as specified by the parameters. 0N/A * The specified {@code src} {@link Shape} is widened according 0N/A * to the specified attribute parameters as per the 0N/A * {@link BasicStroke} specification. 0N/A * @param src the source path to be widened 0N/A * @param width the width of the widened path as per {@code BasicStroke} 0N/A * @param caps the end cap decorations as per {@code BasicStroke} 0N/A * @param join the segment join decorations as per {@code BasicStroke} 0N/A * @param miterlimit the miter limit as per {@code BasicStroke} 0N/A * @param dashes the dash length array as per {@code BasicStroke} 0N/A * @param dashphase the initial dash phase as per {@code BasicStroke} 0N/A * @return the widened path stored in a new {@code Shape} object 0N/A * Sends the geometry for a widened path as specified by the parameters 0N/A * to the specified consumer. 0N/A * The specified {@code src} {@link Shape} is widened according 0N/A * to the parameters specified by the {@link BasicStroke} object. 0N/A * Adjustments are made to the path as appropriate for the 0N/A * {@link VALUE_STROKE_NORMALIZE} hint if the {@code normalize} 0N/A * boolean parameter is true. 0N/A * Adjustments are made to the path as appropriate for the 0N/A * {@link VALUE_ANTIALIAS_ON} hint if the {@code antialias} 0N/A * boolean parameter is true. 0N/A * The geometry of the widened path is forwarded to the indicated 0N/A * {@link PathConsumer2D} object as it is calculated. 0N/A * @param src the source path to be widened 0N/A * @param bs the {@code BasicSroke} object specifying the 0N/A * decorations to be applied to the widened path 0N/A * @param normalize indicates whether stroke normalization should 0N/A * @param antialias indicates whether or not adjustments appropriate 0N/A * to antialiased rendering should be applied 0N/A * @param consumer the {@code PathConsumer2D} instance to forward 0N/A * the widened geometry to 1685N/A /* First calculate the "maximum scale" of this transform. */ 1685N/A * Given a 2 x 2 affine matrix [ A B ] such that 1685N/A * v' = [x' y'] = [Ax + Cy, Bx + Dy], we want to 1685N/A * find the maximum magnitude (norm) of the vector v' 1685N/A * with the constraint (x^2 + y^2 = 1). 1685N/A * The equation to maximize is 1685N/A * |v'| = sqrt((Ax+Cy)^2+(Bx+Dy)^2) 1685N/A * or |v'| = sqrt((AA+BB)x^2 + 2(AC+BD)xy + (CC+DD)y^2). 1685N/A * Since sqrt is monotonic we can maximize |v'|^2 1685N/A * instead and plug in the substitution y = sqrt(1 - x^2). 1685N/A * Trigonometric equalities can then be used to get 1685N/A * rid of most of the sqrt terms. 1685N/A double EA = A*A + B*B;
// x^2 coefficient 1685N/A double EB =
2*(A*C + B*D);
// xy coefficient 1685N/A double EC = C*C + D*D;
// y^2 coefficient 1685N/A * There is a lot of calculus omitted here. 1685N/A * Conceptually, in the interests of understanding the 1685N/A * terms that the calculus produced we can consider 1685N/A * that EA and EC end up providing the lengths along 1685N/A * the major axes and the hypot term ends up being an 1685N/A * adjustment for the additional length along the off-axis 1685N/A * angle of rotated or sheared ellipses as well as an 1685N/A * adjustment for the fact that the equation below 1685N/A * averages the two major axis lengths. (Notice that 1685N/A * the hypot term contains a part which resolves to the 1685N/A * difference of these two axis lengths in the absence 1685N/A * In the calculus, the ratio of the EB and (EA-EC) terms 1685N/A * ends up being the tangent of 2*theta where theta is 1685N/A * the angle that the long axis of the ellipse makes 1685N/A * with the horizontal axis. Thus, this equation is 1685N/A * calculating the length of the hypotenuse of a triangle 1685N/A /* sqrt omitted, compare to squared limits below. */ 3444N/A // We use strokerat and outat so that in Stroker and Dasher we can work only 2956N/A // with the pre-transformation coordinates. This will repeat a lot of 2956N/A // computations done in the path iterator, but the alternative is to 2956N/A // work with transformed paths and compute untransformed coordinates 2956N/A // as needed. This would be faster but I do not think the complexity 2956N/A // of working with both untransformed and transformed coordinates in 2956N/A // the same code is worth it. 2956N/A // However, if a path's width is constant after a transformation, 2956N/A // we can skip all this untransforming. 2956N/A // If normalization is off we save some transformations by not 2956N/A // transforming the input to pisces. Instead, we apply the 2956N/A // transformation after the path processing has been done. 2956N/A // We can't do this if normalization is on, because it isn't a good 2956N/A // idea to normalize before the transformation is applied. 2956N/A // this rendering engine takes one dimensional curves and turns 2956N/A // them into 2D shapes by giving them width. 2956N/A // However, if everything is to be passed through a singular 2956N/A // transformation, these 2D shapes will be squashed down to 1D 2956N/A // again so, nothing can be drawn. 2956N/A // Every path needs an initial moveTo and a pathDone. If these 3444N/A // are not there this causes a SIGSEGV in libawt.so (at the time 2956N/A // of writing of this comment (September 16, 2010)). Actually, 3444N/A // I am not sure if the moveTo is necessary to avoid the SIGSEGV 2956N/A // but the pathDone is definitely needed. 2956N/A // If the transform is a constant multiple of an orthogonal transformation 2956N/A // then every length is just multiplied by a constant, so we just 2956N/A // need to transform input paths to stroker and tell stroker 2956N/A // the scaled width. This condition is satisfied if 2956N/A // a*b == -c*d && a*a+c*c == b*b+d*d. In the actual check below, we 2956N/A // leave a bit of room for error. 3444N/A // by now strokerat == null && outat == null. Input paths to 3444N/A // stroker (and maybe dasher) will have the full transform at 3444N/A // applied to them and nothing will happen to the output paths. 3444N/A // by now strokerat == at && outat == null. Input paths to 3444N/A // stroker (and maybe dasher) will have the full transform at 3444N/A // applied to them, then they will be normalized, and then 3444N/A // the inverse of *only the non translation part of at* will 3444N/A // be applied to the normalized paths. This won't cause problems 3444N/A // in stroker, because, suppose at = T*A, where T is just the 3444N/A // translation part of at, and A is the rest. T*A has already 3444N/A // applied. Ainv*T*A is not equal to T, but it is a translation, 3444N/A // which means that none of stroker's assumptions about its 3444N/A // input will be violated. After all this, A will be applied 3444N/A // outat == at && strokerat == null. This is because if no 3444N/A // normalization is done, we can just apply all our 3444N/A // transformations to stroker's output. 2956N/A // either at is null or it's the identity. In either case 2956N/A // we don't transform the path. 3444N/A // by now, at least one of outat and strokerat will be null. Unless at is not 3444N/A // a constant multiple of an orthogonal transformation, they will both be 3444N/A // null. In other cases, outat == at if normalization is off, and if 3444N/A // normalization is on, strokerat == at. 2639N/A // the adjustment applied to the current position. 2639N/A // the adjustment applied to the last moveTo position. 2639N/A // constants used in normalization computations 2639N/A // round to nearest (0.25, 0.25) pixel 2639N/A // round to nearest pixel center 2639N/A "not be created if no normalization is being done");
2639N/A // we don't want to deal with this case later. We just exit now 2639N/A // now that the end points are done, normalize the control points 2639N/A for (
int i =
0; i <
6; i++) {
0N/A * Construct an antialiased tile generator for the given shape with 0N/A * the given rendering attributes and store the bounds of the tile 0N/A * iteration in the bbox parameter. 0N/A * The {@code at} parameter specifies a transform that should affect 0N/A * both the shape and the {@code BasicStroke} attributes. 0N/A * The {@code clip} parameter specifies the current clip in effect 0N/A * in device coordinates and can be used to prune the data for the 0N/A * operation, but the renderer is not required to perform any 0N/A * If the {@code BasicStroke} parameter is null then the shape 0N/A * should be filled as is, otherwise the attributes of the 0N/A * {@code BasicStroke} should be used to specify a draw operation. 0N/A * The {@code thin} parameter indicates whether or not the 0N/A * transformed {@code BasicStroke} represents coordinates smaller 0N/A * than the minimum resolution of the antialiasing rasterizer as 0N/A * specified by the {@code getMinimumAAPenWidth()} method. 0N/A * Upon returning, this method will fill the {@code bbox} parameter 0N/A * with 4 values indicating the bounds of the iteration of the 0N/A * The iteration order of the tiles will be as specified by the 0N/A * for (y = bbox[1]; y < bbox[3]; y += tileheight) { 0N/A * for (x = bbox[0]; x < bbox[2]; x += tilewidth) { 0N/A * If there is no output to be rendered, this method may return 0N/A * @param s the shape to be rendered (fill or draw) 0N/A * @param at the transform to be applied to the shape and the 0N/A * @param clip the current clip in effect in device coordinates 0N/A * @param bs if non-null, a {@code BasicStroke} whose attributes 0N/A * should be applied to this operation 0N/A * @param thin true if the transformed stroke attributes are smaller 0N/A * than the minimum dropout pen width 0N/A * @param normalize true if the {@code VALUE_STROKE_NORMALIZE} 0N/A * {@code RenderingHint} is in effect 0N/A * @param bbox returns the bounds of the iteration 0N/A * @return the {@code AATileGenerator} instance to be consulted 0N/A * for tile coverages, or null if there is no output to render 3265N/A // REMIND: Deal with large coordinates! 3265N/A // Inner parallelogram was entirely consumed by stroke... 0N/A * Returns the minimum pen width that the antialiasing rasterizer 0N/A * can represent without dropouts occuring.