| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /** |
| * @author Denis M. Kishenko |
| * @version $Revision$ |
| */ |
| |
| package java.awt.geom; |
| |
| import java.util.NoSuchElementException; |
| |
| import org.apache.harmony.awt.internal.nls.Messages; |
| |
| /** |
| * The Class Arc2D represents a segment of a curve inscribed in a rectangle. The |
| * curve is defined by a start angle and an extent angle (the end angle minus |
| * the start angle) as a pie wedge whose point is in the center of the |
| * rectangle. The Arc2D as a shape may be either OPEN (including nothing but the |
| * curved arc segment itself), CHORD (the curved arc segment closed by a |
| * connecting segment from the end to the beginning of the arc, or PIE (the |
| * segments from the end of the arc to the center of the rectangle and from the |
| * center of the rectangle back to the arc's start point are included). |
| * |
| * @since Android 1.0 |
| */ |
| public abstract class Arc2D extends RectangularShape { |
| |
| /** |
| * The arc type OPEN indicates that the shape includes only the curved arc |
| * segment. |
| */ |
| public final static int OPEN = 0; |
| |
| /** |
| * The arc type CHORD indicates that as a shape the connecting segment from |
| * the end point of the curved arc to the beginning point is included. |
| */ |
| public final static int CHORD = 1; |
| |
| /** |
| * The arc type PIE indicates that as a shape the two segments from the |
| * arc's endpoint to the center of the rectangle and from the center of the |
| * rectangle to the arc's endpoint are included. |
| */ |
| public final static int PIE = 2; |
| |
| /** |
| * The Class Float is a subclass of Arc2D in which all of the data values |
| * are given as floats. |
| * |
| * @see Arc2D.Double |
| * @since Android 1.0 |
| */ |
| public static class Float extends Arc2D { |
| |
| /** |
| * The x coordinate of the upper left corner of the rectangle that |
| * contains the arc. |
| */ |
| public float x; |
| |
| /** |
| * The y coordinate of the upper left corner of the rectangle that |
| * contains the arc. |
| */ |
| public float y; |
| |
| /** |
| * The width of the rectangle that contains the arc. |
| */ |
| public float width; |
| |
| /** |
| * The height of the rectangle that contains the arc. |
| */ |
| public float height; |
| |
| /** |
| * The start angle of the arc in degrees. |
| */ |
| public float start; |
| |
| /** |
| * The width angle of the arc in degrees. |
| */ |
| public float extent; |
| |
| /** |
| * Instantiates a new Arc2D of type OPEN with float values. |
| */ |
| public Float() { |
| super(OPEN); |
| } |
| |
| /** |
| * Instantiates a new Arc2D of the specified type with float values. |
| * |
| * @param type |
| * the type of the new Arc2D, either {@link Arc2D#OPEN}, |
| * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}. |
| */ |
| public Float(int type) { |
| super(type); |
| } |
| |
| /** |
| * Instantiates a Arc2D with the specified float-valued data. |
| * |
| * @param x |
| * the x coordinate of the upper left corner of the rectangle |
| * that contains the arc. |
| * @param y |
| * the y coordinate of the upper left corner of the rectangle |
| * that contains the arc. |
| * @param width |
| * the width of the rectangle that contains the arc. |
| * @param height |
| * the height of the rectangle that contains the arc. |
| * @param start |
| * the start angle of the arc in degrees. |
| * @param extent |
| * the width angle of the arc in degrees. |
| * @param type |
| * the type of the new Arc2D, either {@link Arc2D#OPEN}, |
| * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}. |
| */ |
| public Float(float x, float y, float width, float height, float start, float extent, |
| int type) { |
| super(type); |
| this.x = x; |
| this.y = y; |
| this.width = width; |
| this.height = height; |
| this.start = start; |
| this.extent = extent; |
| } |
| |
| /** |
| * Instantiates a new Angle2D with the specified float-valued data and |
| * the bounding rectangle given by the parameter bounds. |
| * |
| * @param bounds |
| * the bounding rectangle of the Angle2D. |
| * @param start |
| * the start angle of the arc in degrees. |
| * @param extent |
| * the width angle of the arc in degrees. |
| * @param type |
| * the type of the new Arc2D, either {@link Arc2D#OPEN}, |
| * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}. |
| */ |
| public Float(Rectangle2D bounds, float start, float extent, int type) { |
| super(type); |
| this.x = (float)bounds.getX(); |
| this.y = (float)bounds.getY(); |
| this.width = (float)bounds.getWidth(); |
| this.height = (float)bounds.getHeight(); |
| this.start = start; |
| this.extent = extent; |
| } |
| |
| @Override |
| public double getX() { |
| return x; |
| } |
| |
| @Override |
| public double getY() { |
| return y; |
| } |
| |
| @Override |
| public double getWidth() { |
| return width; |
| } |
| |
| @Override |
| public double getHeight() { |
| return height; |
| } |
| |
| @Override |
| public double getAngleStart() { |
| return start; |
| } |
| |
| @Override |
| public double getAngleExtent() { |
| return extent; |
| } |
| |
| @Override |
| public boolean isEmpty() { |
| return width <= 0.0f || height <= 0.0f; |
| } |
| |
| @Override |
| public void setArc(double x, double y, double width, double height, double start, |
| double extent, int type) { |
| this.setArcType(type); |
| this.x = (float)x; |
| this.y = (float)y; |
| this.width = (float)width; |
| this.height = (float)height; |
| this.start = (float)start; |
| this.extent = (float)extent; |
| } |
| |
| @Override |
| public void setAngleStart(double start) { |
| this.start = (float)start; |
| } |
| |
| @Override |
| public void setAngleExtent(double extent) { |
| this.extent = (float)extent; |
| } |
| |
| @Override |
| protected Rectangle2D makeBounds(double x, double y, double width, double height) { |
| return new Rectangle2D.Float((float)x, (float)y, (float)width, (float)height); |
| } |
| |
| } |
| |
| /** |
| * The Class Double is a subclass of Arc2D in which all of the data values |
| * are given as doubles. |
| * |
| * @see Arc2D.Float |
| * @since Android 1.0 |
| */ |
| public static class Double extends Arc2D { |
| |
| /** |
| * The x coordinate of the upper left corner of the rectangle that |
| * contains the arc. |
| */ |
| public double x; |
| |
| /** |
| * The y coordinate of the upper left corner of the rectangle that |
| * contains the arc. |
| */ |
| public double y; |
| |
| /** |
| * The width of the rectangle that contains the arc. |
| */ |
| public double width; |
| |
| /** |
| * The height of the rectangle that contains the arc. |
| */ |
| public double height; |
| |
| /** |
| * The start angle of the arc in degrees. |
| */ |
| public double start; |
| |
| /** |
| * The width angle of the arc in degrees. |
| */ |
| public double extent; |
| |
| /** |
| * Instantiates a new Arc2D of type OPEN with double values. |
| */ |
| public Double() { |
| super(OPEN); |
| } |
| |
| /** |
| * Instantiates a new Arc2D of the specified type with double values. |
| * |
| * @param type |
| * the type of the new Arc2D, either {@link Arc2D#OPEN}, |
| * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}. |
| */ |
| public Double(int type) { |
| super(type); |
| } |
| |
| /** |
| * Instantiates a Arc2D with the specified double-valued data. |
| * |
| * @param x |
| * the x coordinate of the upper left corner of the rectangle |
| * that contains the arc. |
| * @param y |
| * the y coordinate of the upper left corner of the rectangle |
| * that contains the arc. |
| * @param width |
| * the width of the rectangle that contains the arc. |
| * @param height |
| * the height of the rectangle that contains the arc. |
| * @param start |
| * the start angle of the arc in degrees. |
| * @param extent |
| * the width angle of the arc in degrees. |
| * @param type |
| * the type of the new Arc2D, either {@link Arc2D#OPEN}, |
| * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}. |
| */ |
| public Double(double x, double y, double width, double height, double start, double extent, |
| int type) { |
| super(type); |
| this.x = x; |
| this.y = y; |
| this.width = width; |
| this.height = height; |
| this.start = start; |
| this.extent = extent; |
| } |
| |
| /** |
| * Instantiates a new Angle2D with the specified float-valued data and |
| * the bounding rectangle given by the parameter bounds. |
| * |
| * @param bounds |
| * the bounding rectangle of the Angle2D. |
| * @param start |
| * the start angle of the arc in degrees. |
| * @param extent |
| * the width angle of the arc in degrees. |
| * @param type |
| * the type of the new Arc2D, either {@link Arc2D#OPEN}, |
| * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}. |
| */ |
| public Double(Rectangle2D bounds, double start, double extent, int type) { |
| super(type); |
| this.x = bounds.getX(); |
| this.y = bounds.getY(); |
| this.width = bounds.getWidth(); |
| this.height = bounds.getHeight(); |
| this.start = start; |
| this.extent = extent; |
| } |
| |
| @Override |
| public double getX() { |
| return x; |
| } |
| |
| @Override |
| public double getY() { |
| return y; |
| } |
| |
| @Override |
| public double getWidth() { |
| return width; |
| } |
| |
| @Override |
| public double getHeight() { |
| return height; |
| } |
| |
| @Override |
| public double getAngleStart() { |
| return start; |
| } |
| |
| @Override |
| public double getAngleExtent() { |
| return extent; |
| } |
| |
| @Override |
| public boolean isEmpty() { |
| return width <= 0.0 || height <= 0.0; |
| } |
| |
| @Override |
| public void setArc(double x, double y, double width, double height, double start, |
| double extent, int type) { |
| this.setArcType(type); |
| this.x = x; |
| this.y = y; |
| this.width = width; |
| this.height = height; |
| this.start = start; |
| this.extent = extent; |
| } |
| |
| @Override |
| public void setAngleStart(double start) { |
| this.start = start; |
| } |
| |
| @Override |
| public void setAngleExtent(double extent) { |
| this.extent = extent; |
| } |
| |
| @Override |
| protected Rectangle2D makeBounds(double x, double y, double width, double height) { |
| return new Rectangle2D.Double(x, y, width, height); |
| } |
| |
| } |
| |
| /** |
| * The Class Iterator is the subclass of PathIterator that is used to |
| * traverse the boundary of a shape of type Arc2D. |
| */ |
| class Iterator implements PathIterator { |
| |
| /** |
| * The x coordinate of the center of the arc's bounding rectangle. |
| */ |
| double x; |
| |
| /** |
| * The y coordinate of the center of the arc's bounding rectangle. |
| */ |
| double y; |
| |
| /** |
| * Half of the width of the arc's bounding rectangle (the radius in the |
| * case of a circular arc). |
| */ |
| double width; |
| |
| /** |
| * Half of the height of the arc's bounding rectangle (the radius in the |
| * case of a circular arc). |
| */ |
| double height; |
| |
| /** |
| * The start angle of the arc in degrees. |
| */ |
| double angle; |
| |
| /** |
| * The angle extent in degrees. |
| */ |
| double extent; |
| |
| /** |
| * The closure type of the arc. |
| */ |
| int type; |
| |
| /** |
| * The path iterator transformation. |
| */ |
| AffineTransform t; |
| |
| /** |
| * The current segment index. |
| */ |
| int index; |
| |
| /** |
| * The number of arc segments the source arc subdivided to be |
| * approximated by Bezier curves. Depends on extent value. |
| */ |
| int arcCount; |
| |
| /** |
| * The number of line segments. Depends on closure type. |
| */ |
| int lineCount; |
| |
| /** |
| * The step to calculate next arc subdivision point. |
| */ |
| double step; |
| |
| /** |
| * The temporary value of cosinus of the current angle. |
| */ |
| double cos; |
| |
| /** |
| * The temporary value of sinus of the current angle. |
| */ |
| double sin; |
| |
| /** The coefficient to calculate control points of Bezier curves. */ |
| double k; |
| |
| /** |
| * The temporary value of x coordinate of the Bezier curve control |
| * vector. |
| */ |
| double kx; |
| |
| /** |
| * The temporary value of y coordinate of the Bezier curve control |
| * vector. |
| */ |
| double ky; |
| |
| /** |
| * The x coordinate of the first path point (MOVE_TO). |
| */ |
| double mx; |
| |
| /** |
| * The y coordinate of the first path point (MOVE_TO). |
| */ |
| double my; |
| |
| /** |
| * Constructs a new Arc2D.Iterator for given line and transformation |
| * |
| * @param a |
| * the source Arc2D object. |
| * @param t |
| * the AffineTransformation. |
| */ |
| Iterator(Arc2D a, AffineTransform t) { |
| if (width < 0 || height < 0) { |
| arcCount = 0; |
| lineCount = 0; |
| index = 1; |
| return; |
| } |
| |
| this.width = a.getWidth() / 2.0; |
| this.height = a.getHeight() / 2.0; |
| this.x = a.getX() + width; |
| this.y = a.getY() + height; |
| this.angle = -Math.toRadians(a.getAngleStart()); |
| this.extent = -a.getAngleExtent(); |
| this.type = a.getArcType(); |
| this.t = t; |
| |
| if (Math.abs(extent) >= 360.0) { |
| arcCount = 4; |
| k = 4.0 / 3.0 * (Math.sqrt(2.0) - 1.0); |
| step = Math.PI / 2.0; |
| if (extent < 0.0) { |
| step = -step; |
| k = -k; |
| } |
| } else { |
| arcCount = (int)Math.rint(Math.abs(extent) / 90.0); |
| step = Math.toRadians(extent / arcCount); |
| k = 4.0 / 3.0 * (1.0 - Math.cos(step / 2.0)) / Math.sin(step / 2.0); |
| } |
| |
| lineCount = 0; |
| if (type == Arc2D.CHORD) { |
| lineCount++; |
| } else if (type == Arc2D.PIE) { |
| lineCount += 2; |
| } |
| } |
| |
| public int getWindingRule() { |
| return WIND_NON_ZERO; |
| } |
| |
| public boolean isDone() { |
| return index > arcCount + lineCount; |
| } |
| |
| public void next() { |
| index++; |
| } |
| |
| public int currentSegment(double[] coords) { |
| if (isDone()) { |
| // awt.4B=Iterator out of bounds |
| throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$ |
| } |
| int type; |
| int count; |
| if (index == 0) { |
| type = SEG_MOVETO; |
| count = 1; |
| cos = Math.cos(angle); |
| sin = Math.sin(angle); |
| kx = k * width * sin; |
| ky = k * height * cos; |
| coords[0] = mx = x + cos * width; |
| coords[1] = my = y + sin * height; |
| } else if (index <= arcCount) { |
| type = SEG_CUBICTO; |
| count = 3; |
| coords[0] = mx - kx; |
| coords[1] = my + ky; |
| angle += step; |
| cos = Math.cos(angle); |
| sin = Math.sin(angle); |
| kx = k * width * sin; |
| ky = k * height * cos; |
| coords[4] = mx = x + cos * width; |
| coords[5] = my = y + sin * height; |
| coords[2] = mx + kx; |
| coords[3] = my - ky; |
| } else if (index == arcCount + lineCount) { |
| type = SEG_CLOSE; |
| count = 0; |
| } else { |
| type = SEG_LINETO; |
| count = 1; |
| coords[0] = x; |
| coords[1] = y; |
| } |
| if (t != null) { |
| t.transform(coords, 0, coords, 0, count); |
| } |
| return type; |
| } |
| |
| public int currentSegment(float[] coords) { |
| if (isDone()) { |
| // awt.4B=Iterator out of bounds |
| throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$ |
| } |
| int type; |
| int count; |
| if (index == 0) { |
| type = SEG_MOVETO; |
| count = 1; |
| cos = Math.cos(angle); |
| sin = Math.sin(angle); |
| kx = k * width * sin; |
| ky = k * height * cos; |
| coords[0] = (float)(mx = x + cos * width); |
| coords[1] = (float)(my = y + sin * height); |
| } else if (index <= arcCount) { |
| type = SEG_CUBICTO; |
| count = 3; |
| coords[0] = (float)(mx - kx); |
| coords[1] = (float)(my + ky); |
| angle += step; |
| cos = Math.cos(angle); |
| sin = Math.sin(angle); |
| kx = k * width * sin; |
| ky = k * height * cos; |
| coords[4] = (float)(mx = x + cos * width); |
| coords[5] = (float)(my = y + sin * height); |
| coords[2] = (float)(mx + kx); |
| coords[3] = (float)(my - ky); |
| } else if (index == arcCount + lineCount) { |
| type = SEG_CLOSE; |
| count = 0; |
| } else { |
| type = SEG_LINETO; |
| count = 1; |
| coords[0] = (float)x; |
| coords[1] = (float)y; |
| } |
| if (t != null) { |
| t.transform(coords, 0, coords, 0, count); |
| } |
| return type; |
| } |
| |
| } |
| |
| /** |
| * The closure type of the arc. |
| */ |
| private int type; |
| |
| /** |
| * Instantiates a new arc2D. |
| * |
| * @param type |
| * the closure type. |
| */ |
| protected Arc2D(int type) { |
| setArcType(type); |
| } |
| |
| /** |
| * Takes the double-valued data and creates the corresponding Rectangle2D |
| * object with values either of type float or of type double depending on |
| * whether this Arc2D instance is of type Float or Double. |
| * |
| * @param x |
| * the x coordinate of the upper left corner of the bounding |
| * rectangle. |
| * @param y |
| * the y coordinate of the upper left corner of the bounding |
| * rectangle. |
| * @param width |
| * the width of the bounding rectangle. |
| * @param height |
| * the height of the bounding rectangle. |
| * @return the corresponding Rectangle2D object. |
| */ |
| protected abstract Rectangle2D makeBounds(double x, double y, double width, double height); |
| |
| /** |
| * Gets the start angle. |
| * |
| * @return the start angle. |
| */ |
| public abstract double getAngleStart(); |
| |
| /** |
| * Gets the width angle. |
| * |
| * @return the width angle. |
| */ |
| public abstract double getAngleExtent(); |
| |
| /** |
| * Sets the start angle. |
| * |
| * @param start |
| * the new start angle. |
| */ |
| public abstract void setAngleStart(double start); |
| |
| /** |
| * Sets the width angle. |
| * |
| * @param extent |
| * the new width angle. |
| */ |
| public abstract void setAngleExtent(double extent); |
| |
| /** |
| * Sets the data values that define the arc. |
| * |
| * @param x |
| * the x coordinate of the upper left corner of the rectangle |
| * that contains the arc. |
| * @param y |
| * the y coordinate of the upper left corner of the rectangle |
| * that contains the arc. |
| * @param width |
| * the width of the rectangle that contains the arc. |
| * @param height |
| * the height of the rectangle that contains the arc. |
| * @param start |
| * the start angle of the arc in degrees. |
| * @param extent |
| * the width angle of the arc in degrees. |
| * @param type |
| * the type of the new Arc2D, either {@link Arc2D#OPEN}, |
| * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}. |
| */ |
| public abstract void setArc(double x, double y, double width, double height, double start, |
| double extent, int type); |
| |
| /** |
| * Gets the arc type, either {@link Arc2D#OPEN}, {@link Arc2D#CHORD}, or |
| * {@link Arc2D#PIE}. |
| * |
| * @return the arc type. |
| */ |
| public int getArcType() { |
| return type; |
| } |
| |
| /** |
| * Sets the arc type, either {@link Arc2D#OPEN}, {@link Arc2D#CHORD}, or |
| * {@link Arc2D#PIE}. |
| * |
| * @param type |
| * the new arc type. |
| */ |
| public void setArcType(int type) { |
| if (type != OPEN && type != CHORD && type != PIE) { |
| // awt.205=Invalid type of Arc: {0} |
| throw new IllegalArgumentException(Messages.getString("awt.205", type)); //$NON-NLS-1$ |
| } |
| this.type = type; |
| } |
| |
| /** |
| * Gets the start point of the arc as a Point2D. |
| * |
| * @return the start point of the curved arc segment. |
| */ |
| public Point2D getStartPoint() { |
| double a = Math.toRadians(getAngleStart()); |
| return new Point2D.Double(getX() + (1.0 + Math.cos(a)) * getWidth() / 2.0, getY() |
| + (1.0 - Math.sin(a)) * getHeight() / 2.0); |
| } |
| |
| /** |
| * Gets the end point of the arc as a Point2D. |
| * |
| * @return the end point of the curved arc segment. |
| */ |
| public Point2D getEndPoint() { |
| double a = Math.toRadians(getAngleStart() + getAngleExtent()); |
| return new Point2D.Double(getX() + (1.0 + Math.cos(a)) * getWidth() / 2.0, getY() |
| + (1.0 - Math.sin(a)) * getHeight() / 2.0); |
| } |
| |
| public Rectangle2D getBounds2D() { |
| if (isEmpty()) { |
| return makeBounds(getX(), getY(), getWidth(), getHeight()); |
| } |
| double rx1 = getX(); |
| double ry1 = getY(); |
| double rx2 = rx1 + getWidth(); |
| double ry2 = ry1 + getHeight(); |
| |
| Point2D p1 = getStartPoint(); |
| Point2D p2 = getEndPoint(); |
| |
| double bx1 = containsAngle(180.0) ? rx1 : Math.min(p1.getX(), p2.getX()); |
| double by1 = containsAngle(90.0) ? ry1 : Math.min(p1.getY(), p2.getY()); |
| double bx2 = containsAngle(0.0) ? rx2 : Math.max(p1.getX(), p2.getX()); |
| double by2 = containsAngle(270.0) ? ry2 : Math.max(p1.getY(), p2.getY()); |
| |
| if (type == PIE) { |
| double cx = getCenterX(); |
| double cy = getCenterY(); |
| bx1 = Math.min(bx1, cx); |
| by1 = Math.min(by1, cy); |
| bx2 = Math.max(bx2, cx); |
| by2 = Math.max(by2, cy); |
| } |
| return makeBounds(bx1, by1, bx2 - bx1, by2 - by1); |
| } |
| |
| @Override |
| public void setFrame(double x, double y, double width, double height) { |
| setArc(x, y, width, height, getAngleStart(), getAngleExtent(), type); |
| } |
| |
| /** |
| * Sets the data that defines the arc. |
| * |
| * @param point |
| * the upper left corner of the bounding rectangle. |
| * @param size |
| * the size of the bounding rectangle. |
| * @param start |
| * the start angle of the arc in degrees. |
| * @param extent |
| * the angle width of the arc in degrees. |
| * @param type |
| * the closure type, either {@link Arc2D#OPEN}, |
| * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}. |
| */ |
| public void setArc(Point2D point, Dimension2D size, double start, double extent, int type) { |
| setArc(point.getX(), point.getY(), size.getWidth(), size.getHeight(), start, extent, type); |
| } |
| |
| /** |
| * Sets the data that defines the arc. |
| * |
| * @param rect |
| * the arc's bounding rectangle. |
| * @param start |
| * the start angle of the arc in degrees. |
| * @param extent |
| * the angle width of the arc in degrees. |
| * @param type |
| * the closure type, either {@link Arc2D#OPEN}, |
| * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}. |
| */ |
| public void setArc(Rectangle2D rect, double start, double extent, int type) { |
| setArc(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight(), start, extent, type); |
| } |
| |
| /** |
| * Sets the data that defines the arc by copying it from another Arc2D. |
| * |
| * @param arc |
| * the arc whose data is copied into this arc. |
| */ |
| public void setArc(Arc2D arc) { |
| setArc(arc.getX(), arc.getY(), arc.getWidth(), arc.getHeight(), arc.getAngleStart(), arc |
| .getAngleExtent(), arc.getArcType()); |
| } |
| |
| /** |
| * Sets the data for a circular arc by giving its center and radius. |
| * |
| * @param x |
| * the x coordinate of the center of the circle. |
| * @param y |
| * the y coordinate of the center of the circle. |
| * @param radius |
| * the radius of the circle. |
| * @param start |
| * the start angle of the arc in degrees. |
| * @param extent |
| * the angle width of the arc in degrees. |
| * @param type |
| * the closure type, either {@link Arc2D#OPEN}, |
| * {@link Arc2D#CHORD}, or {@link Arc2D#PIE}. |
| */ |
| public void setArcByCenter(double x, double y, double radius, double start, double extent, |
| int type) { |
| setArc(x - radius, y - radius, radius * 2.0, radius * 2.0, start, extent, type); |
| } |
| |
| /** |
| * Sets the arc data for a circular arc based on two tangent lines and the |
| * radius. The two tangent lines are the lines from p1 to p2 and from p2 to |
| * p3, which determine a unique circle with the given radius. The start and |
| * end points of the arc are the points where the circle touches the two |
| * lines, and the arc itself is the shorter of the two circle segments |
| * determined by the two points (in other words, it is the piece of the |
| * circle that is closer to the lines' intersection point p2 and forms a |
| * concave shape with the segments from p1 to p2 and from p2 to p3). |
| * |
| * @param p1 |
| * a point which determines one of the two tangent lines (with |
| * p2). |
| * @param p2 |
| * the point of intersection of the two tangent lines. |
| * @param p3 |
| * a point which determines one of the two tangent lines (with |
| * p2). |
| * @param radius |
| * the radius of the circular arc. |
| */ |
| public void setArcByTangent(Point2D p1, Point2D p2, Point2D p3, double radius) { |
| // Used simple geometric calculations of arc center, radius and angles |
| // by tangents |
| double a1 = -Math.atan2(p1.getY() - p2.getY(), p1.getX() - p2.getX()); |
| double a2 = -Math.atan2(p3.getY() - p2.getY(), p3.getX() - p2.getX()); |
| double am = (a1 + a2) / 2.0; |
| double ah = a1 - am; |
| double d = radius / Math.abs(Math.sin(ah)); |
| double x = p2.getX() + d * Math.cos(am); |
| double y = p2.getY() - d * Math.sin(am); |
| ah = ah >= 0.0 ? Math.PI * 1.5 - ah : Math.PI * 0.5 - ah; |
| a1 = getNormAngle(Math.toDegrees(am - ah)); |
| a2 = getNormAngle(Math.toDegrees(am + ah)); |
| double delta = a2 - a1; |
| if (delta <= 0.0) { |
| delta += 360.0; |
| } |
| setArcByCenter(x, y, radius, a1, delta, type); |
| } |
| |
| /** |
| * Sets a new start angle to be the angle given by the the vector from the |
| * current center point to the specified point. |
| * |
| * @param point |
| * the point that determines the new start angle. |
| */ |
| public void setAngleStart(Point2D point) { |
| double angle = Math.atan2(point.getY() - getCenterY(), point.getX() - getCenterX()); |
| setAngleStart(getNormAngle(-Math.toDegrees(angle))); |
| } |
| |
| /** |
| * Sets the angles in terms of vectors from the current arc center to the |
| * points (x1, y1) and (x2, y2). The start angle is given by the vector from |
| * the current center to the point (x1, y1) and the end angle is given by |
| * the vector from the center to the point (x2, y2). |
| * |
| * @param x1 |
| * the x coordinate of the point whose vector from the center |
| * point determines the new start angle of the arc. |
| * @param y1 |
| * the y coordinate of the point whose vector from the center |
| * point determines the new start angle of the arc. |
| * @param x2 |
| * the x coordinate of the point whose vector from the center |
| * point determines the new end angle of the arc. |
| * @param y2 |
| * the y coordinate of the point whose vector from the center |
| * point determines the new end angle of the arc. |
| */ |
| public void setAngles(double x1, double y1, double x2, double y2) { |
| double cx = getCenterX(); |
| double cy = getCenterY(); |
| double a1 = getNormAngle(-Math.toDegrees(Math.atan2(y1 - cy, x1 - cx))); |
| double a2 = getNormAngle(-Math.toDegrees(Math.atan2(y2 - cy, x2 - cx))); |
| a2 -= a1; |
| if (a2 <= 0.0) { |
| a2 += 360.0; |
| } |
| setAngleStart(a1); |
| setAngleExtent(a2); |
| } |
| |
| /** |
| * Sets the angles in terms of vectors from the current arc center to the |
| * points p1 and p2. The start angle is given by the vector from the current |
| * center to the point p1 and the end angle is given by the vector from the |
| * center to the point p2. |
| * |
| * @param p1 |
| * the point whose vector from the center point determines the |
| * new start angle of the arc. |
| * @param p2 |
| * the point whose vector from the center point determines the |
| * new end angle of the arc. |
| */ |
| public void setAngles(Point2D p1, Point2D p2) { |
| setAngles(p1.getX(), p1.getY(), p2.getX(), p2.getY()); |
| } |
| |
| /** |
| * Normalizes the angle by removing extra winding (past 360 degrees) and |
| * placing it in the positive degree range. |
| * |
| * @param angle |
| * the source angle in degrees. |
| * @return an angle between 0 and 360 degrees which corresponds to the same |
| * direction vector as the source angle. |
| */ |
| double getNormAngle(double angle) { |
| double n = Math.floor(angle / 360.0); |
| return angle - n * 360.0; |
| } |
| |
| /** |
| * Determines whether the given angle is contained in the span of the arc. |
| * |
| * @param angle |
| * the angle to test in degrees. |
| * @return true, if the given angle is between the start angle and the end |
| * angle of the arc. |
| */ |
| public boolean containsAngle(double angle) { |
| double extent = getAngleExtent(); |
| if (extent >= 360.0) { |
| return true; |
| } |
| angle = getNormAngle(angle); |
| double a1 = getNormAngle(getAngleStart()); |
| double a2 = a1 + extent; |
| if (a2 > 360.0) { |
| return angle >= a1 || angle <= a2 - 360.0; |
| } |
| if (a2 < 0.0) { |
| return angle >= a2 + 360.0 || angle <= a1; |
| } |
| return extent > 0.0 ? a1 <= angle && angle <= a2 : a2 <= angle && angle <= a1; |
| } |
| |
| public boolean contains(double px, double py) { |
| // Normalize point |
| double nx = (px - getX()) / getWidth() - 0.5; |
| double ny = (py - getY()) / getHeight() - 0.5; |
| |
| if ((nx * nx + ny * ny) > 0.25) { |
| return false; |
| } |
| |
| double extent = getAngleExtent(); |
| double absExtent = Math.abs(extent); |
| if (absExtent >= 360.0) { |
| return true; |
| } |
| |
| boolean containsAngle = containsAngle(Math.toDegrees(-Math.atan2(ny, nx))); |
| if (type == PIE) { |
| return containsAngle; |
| } |
| if (absExtent <= 180.0 && !containsAngle) { |
| return false; |
| } |
| |
| Line2D l = new Line2D.Double(getStartPoint(), getEndPoint()); |
| int ccw1 = l.relativeCCW(px, py); |
| int ccw2 = l.relativeCCW(getCenterX(), getCenterY()); |
| return ccw1 == 0 || ccw2 == 0 || ((ccw1 + ccw2) == 0 ^ absExtent > 180.0); |
| } |
| |
| public boolean contains(double rx, double ry, double rw, double rh) { |
| |
| if (!(contains(rx, ry) && contains(rx + rw, ry) && contains(rx + rw, ry + rh) && contains( |
| rx, ry + rh))) { |
| return false; |
| } |
| |
| double absExtent = Math.abs(getAngleExtent()); |
| if (type != PIE || absExtent <= 180.0 || absExtent >= 360.0) { |
| return true; |
| } |
| |
| Rectangle2D r = new Rectangle2D.Double(rx, ry, rw, rh); |
| |
| double cx = getCenterX(); |
| double cy = getCenterY(); |
| if (r.contains(cx, cy)) { |
| return false; |
| } |
| |
| Point2D p1 = getStartPoint(); |
| Point2D p2 = getEndPoint(); |
| |
| return !r.intersectsLine(cx, cy, p1.getX(), p1.getY()) |
| && !r.intersectsLine(cx, cy, p2.getX(), p2.getY()); |
| } |
| |
| @Override |
| public boolean contains(Rectangle2D rect) { |
| return contains(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight()); |
| } |
| |
| public boolean intersects(double rx, double ry, double rw, double rh) { |
| |
| if (isEmpty() || rw <= 0.0 || rh <= 0.0) { |
| return false; |
| } |
| |
| // Check: Does arc contain rectangle's points |
| if (contains(rx, ry) || contains(rx + rw, ry) || contains(rx, ry + rh) |
| || contains(rx + rw, ry + rh)) { |
| return true; |
| } |
| |
| double cx = getCenterX(); |
| double cy = getCenterY(); |
| Point2D p1 = getStartPoint(); |
| Point2D p2 = getEndPoint(); |
| Rectangle2D r = new Rectangle2D.Double(rx, ry, rw, rh); |
| |
| // Check: Does rectangle contain arc's points |
| if (r.contains(p1) || r.contains(p2) || (type == PIE && r.contains(cx, cy))) { |
| return true; |
| } |
| |
| if (type == PIE) { |
| if (r.intersectsLine(p1.getX(), p1.getY(), cx, cy) |
| || r.intersectsLine(p2.getX(), p2.getY(), cx, cy)) { |
| return true; |
| } |
| } else { |
| if (r.intersectsLine(p1.getX(), p1.getY(), p2.getX(), p2.getY())) { |
| return true; |
| } |
| } |
| |
| // Nearest rectangle point |
| double nx = cx < rx ? rx : (cx > rx + rw ? rx + rw : cx); |
| double ny = cy < ry ? ry : (cy > ry + rh ? ry + rh : cy); |
| return contains(nx, ny); |
| } |
| |
| public PathIterator getPathIterator(AffineTransform at) { |
| return new Iterator(this, at); |
| } |
| |
| } |
