| /* |
| * Copyright (c) 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. |
| * |
| * 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. |
| * |
| */ |
| |
| /** |
| * @test |
| * @bug 7047069 |
| * @summary Array can dynamically change size when assigned to an object field |
| * |
| * @run main/othervm -Xbatch Test7047069 |
| */ |
| |
| import java.util.*; |
| import java.awt.geom.*; |
| |
| public class Test7047069 { |
| static boolean verbose; |
| |
| static final int GROW_SIZE = 24; // Multiple of cubic & quad curve size |
| |
| float squareflat; // Square of the flatness parameter |
| // for testing against squared lengths |
| |
| int limit; // Maximum number of recursion levels |
| |
| float hold[] = new float[14]; // The cache of interpolated coords |
| // Note that this must be long enough |
| // to store a full cubic segment and |
| // a relative cubic segment to avoid |
| // aliasing when copying the coords |
| // of a curve to the end of the array. |
| // This is also serendipitously equal |
| // to the size of a full quad segment |
| // and 2 relative quad segments. |
| |
| int holdEnd; // The index of the last curve segment |
| // being held for interpolation |
| |
| int holdIndex; // The index of the curve segment |
| // that was last interpolated. This |
| // is the curve segment ready to be |
| // returned in the next call to |
| // currentSegment(). |
| |
| int levels[]; // The recursion level at which |
| // each curve being held in storage |
| // was generated. |
| |
| int levelIndex; // The index of the entry in the |
| // levels array of the curve segment |
| // at the holdIndex |
| |
| public static void subdivide(float src[], int srcoff, |
| float left[], int leftoff, |
| float right[], int rightoff) |
| { |
| float x1 = src[srcoff + 0]; |
| float y1 = src[srcoff + 1]; |
| float ctrlx = src[srcoff + 2]; |
| float ctrly = src[srcoff + 3]; |
| float x2 = src[srcoff + 4]; |
| float y2 = src[srcoff + 5]; |
| if (left != null) { |
| left[leftoff + 0] = x1; |
| left[leftoff + 1] = y1; |
| } |
| if (right != null) { |
| right[rightoff + 4] = x2; |
| right[rightoff + 5] = y2; |
| } |
| x1 = (x1 + ctrlx) / 2f; |
| y1 = (y1 + ctrly) / 2f; |
| x2 = (x2 + ctrlx) / 2f; |
| y2 = (y2 + ctrly) / 2f; |
| ctrlx = (x1 + x2) / 2f; |
| ctrly = (y1 + y2) / 2f; |
| if (left != null) { |
| left[leftoff + 2] = x1; |
| left[leftoff + 3] = y1; |
| left[leftoff + 4] = ctrlx; |
| left[leftoff + 5] = ctrly; |
| } |
| if (right != null) { |
| right[rightoff + 0] = ctrlx; |
| right[rightoff + 1] = ctrly; |
| right[rightoff + 2] = x2; |
| right[rightoff + 3] = y2; |
| } |
| } |
| |
| public static double getFlatnessSq(float coords[], int offset) { |
| return Line2D.ptSegDistSq(coords[offset + 0], coords[offset + 1], |
| coords[offset + 4], coords[offset + 5], |
| coords[offset + 2], coords[offset + 3]); |
| } |
| |
| public Test7047069() { |
| this.squareflat = .0001f * .0001f; |
| holdIndex = hold.length - 6; |
| holdEnd = hold.length - 2; |
| hold[holdIndex + 0] = (float) (Math.random() * 100); |
| hold[holdIndex + 1] = (float) (Math.random() * 100); |
| hold[holdIndex + 2] = (float) (Math.random() * 100); |
| hold[holdIndex + 3] = (float) (Math.random() * 100); |
| hold[holdIndex + 4] = (float) (Math.random() * 100); |
| hold[holdIndex + 5] = (float) (Math.random() * 100); |
| levelIndex = 0; |
| this.limit = 10; |
| this.levels = new int[limit + 1]; |
| } |
| |
| /* |
| * Ensures that the hold array can hold up to (want) more values. |
| * It is currently holding (hold.length - holdIndex) values. |
| */ |
| void ensureHoldCapacity(int want) { |
| if (holdIndex - want < 0) { |
| int have = hold.length - holdIndex; |
| int newsize = hold.length + GROW_SIZE; |
| float newhold[] = new float[newsize]; |
| System.arraycopy(hold, holdIndex, |
| newhold, holdIndex + GROW_SIZE, |
| have); |
| if (verbose) System.err.println("old hold = "+hold+"["+hold.length+"]"); |
| if (verbose) System.err.println("replacement hold = "+newhold+"["+newhold.length+"]"); |
| hold = newhold; |
| if (verbose) System.err.println("new hold = "+hold+"["+hold.length+"]"); |
| if (verbose) System.err.println("replacement hold still = "+newhold+"["+newhold.length+"]"); |
| holdIndex += GROW_SIZE; |
| holdEnd += GROW_SIZE; |
| } |
| } |
| |
| private boolean next() { |
| if (holdIndex >= holdEnd) { |
| return false; |
| } |
| |
| int level = levels[levelIndex]; |
| while (level < limit) { |
| if (getFlatnessSq(hold, holdIndex) < squareflat) { |
| break; |
| } |
| |
| ensureHoldCapacity(4); |
| subdivide(hold, holdIndex, |
| hold, holdIndex - 4, |
| hold, holdIndex); |
| holdIndex -= 4; |
| |
| // Now that we have subdivided, we have constructed |
| // two curves of one depth lower than the original |
| // curve. One of those curves is in the place of |
| // the former curve and one of them is in the next |
| // set of held coordinate slots. We now set both |
| // curves level values to the next higher level. |
| level++; |
| levels[levelIndex] = level; |
| levelIndex++; |
| levels[levelIndex] = level; |
| } |
| |
| // This curve segment is flat enough, or it is too deep |
| // in recursion levels to try to flatten any more. The |
| // two coordinates at holdIndex+4 and holdIndex+5 now |
| // contain the endpoint of the curve which can be the |
| // endpoint of an approximating line segment. |
| holdIndex += 4; |
| levelIndex--; |
| return true; |
| } |
| |
| public static void main(String argv[]) { |
| verbose = (argv.length > 0); |
| for (int i = 0; i < 100000; i++) { |
| Test7047069 st = new Test7047069(); |
| while (st.next()) {} |
| } |
| } |
| } |