/* * Copyright (c) 2000 David Flanagan.  All rights reserved. * This code is from the book Java Examples in a Nutshell, 2nd Edition. * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied. * You may study, use, and modify it for any non-commercial purpose. * You may distribute it non-commercially as long as you retain this notice. * For a commercial use license, or to purchase the book (recommended), * visit http://www.davidflanagan.com/javaexamples2. */package com.davidflanagan.examples.graphics;import java.awt.*;import java.awt.geom.*;/** This Shape implementation represents a spiral curve */public class Spiral implements Shape {    double centerX, centerY;            // The center of the spiral    double startRadius, startAngle;     // The spiral starting point    double endRadius, endAngle;         // The spiral ending point    double outerRadius;                 // the bigger of the two radii    int angleDirection;                 // 1 if angle increases, -1 otherwise    /**     * The constructor.  It takes arguments for the center of the shape, the     * start point, and the end point.  The start and end points are specified     * in terms of angle and radius.  The spiral curve is formed by varying     * the angle and radius smoothly between the two end points.     **/    public Spiral(double centerX, double centerY,		  double startRadius, double startAngle,		  double endRadius, double endAngle)    {	// Save the parameters that describe the spiral	this.centerX = centerX; 	this.centerY = centerY;	this.startRadius = startRadius;	this.startAngle = startAngle;	this.endRadius = endRadius;	this.endAngle = endAngle;	// figure out the maximum radius, and the spiral direction	this.outerRadius = Math.max(startRadius, endRadius);	if (startAngle < endAngle) angleDirection = 1;	else angleDirection = -1;		if ((startRadius < 0) || (endRadius < 0))	    throw new IllegalArgumentException("Spiral radii must be >= 0");    }    /**      * The bounding box of a Spiral is the same as the bounding box of a     * circle with the same center and the maximum radius     **/    public Rectangle getBounds() {	return new Rectangle((int)(centerX-outerRadius),			     (int)(centerY-outerRadius),			     (int)(outerRadius*2), (int)(outerRadius*2));    }    /** Same as getBounds(), but with floating-point coordinates */    public Rectangle2D getBounds2D() {	return new Rectangle2D.Double(centerX-outerRadius, centerY-outerRadius,				      outerRadius*2, outerRadius*2);    }    /**      * A spiral is an open curve, not a not a closed area; it does not have an     * inside and an outsize, so the contains() methods always return false.     **/    public boolean contains(double x, double y) { return false; }    public boolean contains(Point2D p) { return false; }    public boolean contains(Rectangle2D r) { return false; }    public boolean contains(double x, double y, double w, double h) {	return false;    }    /**     * This method is allowed to approximate if it would be too computationally     * intensive to determine an exact answer.  Therefore, we check whether     * the rectangle intersects a circle of the outer radius.  This is a good     * guess for a tight spiral, but less good for a "loose" spiral.      **/    public boolean intersects(double x, double y, double w, double h) {	Shape approx = new Ellipse2D.Double(centerX-outerRadius,					    centerY-outerRadius,					    outerRadius*2, outerRadius*2);	return approx.intersects(x, y, w, h);    }    /** This version of intersects() just calls the one above */    public boolean intersects(Rectangle2D r) {	return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());    }    /**     * This method is the heart of all Shape implementations.  It returns a     * PathIterator that describes the shape in terms of the line and curve     * segments that comprise it.  Our iterator implementation approximates     * the shape of the spiral using line segments only.  We pass in a     * "flatness" argument that tells it how good the approximation must be.     * (smaller numbers mean a better approximation).     */    public PathIterator getPathIterator(AffineTransform at) {	return new SpiralIterator(at, outerRadius/500.0);    }    /**     * Return a PathIterator that describes the shape in terms of line     * segments only, with an approximation quality specified by flatness.     **/    public PathIterator getPathIterator(AffineTransform at, double flatness) {	return new SpiralIterator(at, flatness);    }    /**     * This inner class is the PathIterator for our Spiral shape.  For     * simplicity, it does not describe the spiral path in terms of Bezier     * curve segments, but simply approximates it with line segments.  The     * flatness property specifies how far the approximation is allowed to     * deviate from the true curve.     **/    class SpiralIterator implements PathIterator {	AffineTransform transform;    // How to transform generated coordinates	double flatness;              // How close an approximation	double angle = startAngle;    // Current angle	double radius = startRadius;  // Current radius	boolean done = false;         // Are we done yet?	/** A simple constructor.  Just store the parameters into fields */	public SpiralIterator(AffineTransform transform, double flatness) {	    this.transform = transform;	    this.flatness = flatness;	}	/** 	 * All PathIterators have a "winding rule" that helps to specify what	 * is the inside of a area and what is the outside.  If you fill a	 * spiral (which you're not supposed to do) the winding rule returned	 * here yields better results than the alternative, WIND_EVEN_ODD	 **/	public int getWindingRule() { return WIND_NON_ZERO; }	/** Returns true if the entire path has been iterated */	public boolean isDone() { return done; }	/**	 * Store the coordinates of the current segment of the path into the	 * specified array, and return the type of the segment.  Use	 * trigonometry to compute the coordinates based on the current angle	 * and radius.  If this was the first point, return a MOVETO segment,	 * otherwise return a LINETO segment. Also, check to see if we're done.	 **/	public int currentSegment(float[] coords) {	    // given the radius and the angle, compute the point coords	    coords[0] = (float)(centerX + radius*Math.cos(angle));	    coords[1] = (float)(centerY - radius*Math.sin(angle));	    // If a transform was specified, use it on the coordinates	    if (transform != null) transform.transform(coords, 0, coords, 0,1);	    // If we've reached the end of the spiral remember that fact	    if (angle == endAngle) done = true;	    // If this is the first point in the spiral then move to it	    if (angle == startAngle) return SEG_MOVETO;	    // Otherwise draw a line from the previous point to this one	    return SEG_LINETO;	}	/** This method is the same as above, except using double values */	public int currentSegment(double[] coords) {	    coords[0] = centerX + radius*Math.cos(angle);	    coords[1] = centerY - radius*Math.sin(angle);	    if (transform != null) transform.transform(coords, 0, coords, 0,1);	    if (angle == endAngle) done = true;	    if (angle == startAngle) return SEG_MOVETO;	    else return SEG_LINETO;	}	/** 	 * Move on to the next segment of the path.  Compute the angle and	 * radius values for the next point in the spiral.	 **/	public void next() {	    if (done) return;	    // First, figure out how much to increment the angle.  This	    // depends on the required flatness, and also upon the current	    // radius.  When drawing a circle (which we'll use as our	    // approximation) of radius r, we can maintain a flatness f by	    // using angular increments given by this formula:	    //      a = acos(2*(f/r)*(f/r) - 4*(f/r) + 1)	    // Use this formula to figure out how much we can increment the	    // angle for the next segment.  Note that the formula does not	    // work well for very small radii, so we special case those.	    double x = flatness/radius;	    if (Double.isNaN(x) || (x > .1))		angle += Math.PI/4*angleDirection; 	    else {		double y = 2*x*x - 4*x + 1;		angle += Math.acos(y)*angleDirection;	    }			    // Check whether we've gone past the end of the spiral	    if ((angle-endAngle)*angleDirection > 0) angle = endAngle;	    // Now that we know the new angle, we can use interpolation to	    // figure out what the corresponding radius is.	    double fractionComplete = (angle-startAngle)/(endAngle-startAngle);	    radius = startRadius + (endRadius-startRadius)*fractionComplete;	}    }}