1. /*

  2.  * @(#)ArcIterator.java	1.10 01/11/29

  3.  *

  4.  * Copyright 2002 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. package java.awt.geom;

  9. 

  10. import java.util.*;

  11. 

  12. /**

  13.  * A utility class to iterate over the path segments of an arc

  14.  * through the PathIterator interface.

  15.  *

  16.  * @version 10 Feb 1997

  17.  * @author	Jim Graham

  18.  */

  19. class ArcIterator implements PathIterator {

  20.     double x, y, w, h, angStRad, angExtDeg;

  21.     AffineTransform affine;

  22.     int index;

  23.     int arcSegs;

  24.     int lineSegs;

  25. 

  26.     ArcIterator(Arc2D a, AffineTransform at) {

  27. 	this.w = a.getWidth() / 2;

  28. 	this.h = a.getHeight() / 2;

  29. 	this.x = a.getX() + w;

  30. 	this.y = a.getY() + h;

  31. 	this.angStRad = -Math.toRadians(a.getAngleStart());

  32. 	this.angExtDeg = -a.getAngleExtent();

  33. 	this.affine = at;

  34. 	double ext = Math.abs(angExtDeg);

  35. 	if (ext >= 360.0) {

  36. 	    arcSegs = 4;

  37. 	} else {

  38. 	    arcSegs = (int) Math.ceil(ext / 90.0);

  39. 	}

  40. 	switch (a.getArcType()) {

  41. 	case Arc2D.OPEN:

  42. 	    lineSegs = 0;

  43. 	    break;

  44. 	case Arc2D.CHORD:

  45. 	    lineSegs = 1;

  46. 	    break;

  47. 	case Arc2D.PIE:

  48. 	    lineSegs = 2;

  49. 	    break;

  50. 	}

  51. 	if (w < 0 || h < 0) {

  52. 	    arcSegs = lineSegs = -1;

  53. 	}

  54.     }

  55. 

  56.     /**

  57.      * Return the winding rule for determining the insideness of the

  58.      * path.

  59.      * @see #WIND_EVEN_ODD

  60.      * @see #WIND_NON_ZERO

  61.      */

  62.     public int getWindingRule() {

  63. 	return WIND_NON_ZERO;

  64.     }

  65. 

  66.     /**

  67.      * Tests if there are more points to read.

  68.      * @return true if there are more points to read

  69.      */

  70.     public boolean isDone() {

  71. 	return index > arcSegs + lineSegs;

  72.     }

  73. 

  74.     /**

  75.      * Moves the iterator to the next segment of the path forwards

  76.      * along the primary direction of traversal as long as there are

  77.      * more points in that direction.

  78.      */

  79.     public void next() {

  80. 	index++;

  81.     }

  82. 

  83.     private static double btan(double increment) {

  84. 	increment /= 2.0;

  85. 	double a = 1.0 - Math.cos(increment);

  86. 	double b = Math.tan(increment);

  87. 	double c = Math.sqrt(1.0 + b * b) - 1.0 + a;

  88. 	return 4.0 / 3.0 * a * b / c;

  89.     }

  90. 

  91.     /**

  92.      * Returns the coordinates and type of the current path segment in

  93.      * the iteration.

  94.      * The return value is the path segment type:

  95.      * SEG_MOVETO, SEG_LINETO, SEG_QUADTO, SEG_CUBICTO, or SEG_CLOSE.

  96.      * A float array of length 6 must be passed in and may be used to

  97.      * store the coordinates of the point(s).

  98.      * Each point is stored as a pair of float x,y coordinates.

  99.      * SEG_MOVETO and SEG_LINETO types will return one point,

  100.      * SEG_QUADTO will return two points,

  101.      * SEG_CUBICTO will return 3 points

  102.      * and SEG_CLOSE will not return any points.

  103.      * @see #SEG_MOVETO

  104.      * @see #SEG_LINETO

  105.      * @see #SEG_QUADTO

  106.      * @see #SEG_CUBICTO

  107.      * @see #SEG_CLOSE

  108.      */

  109.     public int currentSegment(float[] coords) {

  110. 	if (isDone()) {

  111. 	    throw new NoSuchElementException("arc iterator out of bounds");

  112. 	}

  113. 	double angle = angStRad;

  114. 	if (index == 0) {

  115. 	    coords[0] = (float) (x + Math.cos(angle) * w);

  116. 	    coords[1] = (float) (y + Math.sin(angle) * h);

  117. 	    if (affine != null) {

  118. 		affine.transform(coords, 0, coords, 0, 1);

  119. 	    }

  120. 	    return SEG_MOVETO;

  121. 	}

  122. 	if (index > arcSegs) {

  123. 	    if (index == arcSegs + lineSegs) {

  124. 		return SEG_CLOSE;

  125. 	    }

  126. 	    coords[0] = (float) x;

  127. 	    coords[1] = (float) y;

  128. 	    if (affine != null) {

  129. 		affine.transform(coords, 0, coords, 0, 1);

  130. 	    }

  131. 	    return SEG_LINETO;

  132. 	}

  133. 	double increment = angExtDeg;

  134. 	if (increment > 360.0) {

  135. 	    increment = 360.0;

  136. 	} else if (increment < -360.0) {

  137. 	    increment = -360.0;

  138. 	}

  139. 	increment /= arcSegs;

  140. 	increment = Math.toRadians(increment);

  141. 	angle += increment * (index - 1);

  142. 	double relx = Math.cos(angle);

  143. 	double rely = Math.sin(angle);

  144. 	double z = btan(increment);

  145. 	coords[0] = (float) (x + (relx - z * rely) * w);

  146. 	coords[1] = (float) (y + (rely + z * relx) * h);

  147. 	angle += increment;

  148. 	relx = Math.cos(angle);

  149. 	rely = Math.sin(angle);

  150. 	coords[2] = (float) (x + (relx + z * rely) * w);

  151. 	coords[3] = (float) (y + (rely - z * relx) * h);

  152. 	coords[4] = (float) (x + relx * w);

  153. 	coords[5] = (float) (y + rely * h);

  154. 	if (affine != null) {

  155. 	    affine.transform(coords, 0, coords, 0, 3);

  156. 	}

  157. 	return SEG_CUBICTO;

  158.     }

  159. 

  160.     /**

  161.      * Returns the coordinates and type of the current path segment in

  162.      * the iteration.

  163.      * The return value is the path segment type:

  164.      * SEG_MOVETO, SEG_LINETO, SEG_QUADTO, SEG_CUBICTO, or SEG_CLOSE.

  165.      * A double array of length 6 must be passed in and may be used to

  166.      * store the coordinates of the point(s).

  167.      * Each point is stored as a pair of double x,y coordinates.

  168.      * SEG_MOVETO and SEG_LINETO types will return one point,

  169.      * SEG_QUADTO will return two points,

  170.      * SEG_CUBICTO will return 3 points

  171.      * and SEG_CLOSE will not return any points.

  172.      * @see #SEG_MOVETO

  173.      * @see #SEG_LINETO

  174.      * @see #SEG_QUADTO

  175.      * @see #SEG_CUBICTO

  176.      * @see #SEG_CLOSE

  177.      */

  178.     public int currentSegment(double[] coords) {

  179. 	if (isDone()) {

  180. 	    throw new NoSuchElementException("arc iterator out of bounds");

  181. 	}

  182. 	double angle = angStRad;

  183. 	if (index == 0) {

  184. 	    coords[0] = x + Math.cos(angle) * w;

  185. 	    coords[1] = y + Math.sin(angle) * h;

  186. 	    if (affine != null) {

  187. 		affine.transform(coords, 0, coords, 0, 1);

  188. 	    }

  189. 	    return SEG_MOVETO;

  190. 	}

  191. 	if (index > arcSegs) {

  192. 	    if (index == arcSegs + lineSegs) {

  193. 		return SEG_CLOSE;

  194. 	    }

  195. 	    coords[0] = x;

  196. 	    coords[1] = y;

  197. 	    if (affine != null) {

  198. 		affine.transform(coords, 0, coords, 0, 1);

  199. 	    }

  200. 	    return SEG_LINETO;

  201. 	}

  202. 	double increment = angExtDeg;

  203. 	if (increment > 360.0) {

  204. 	    increment = 360.0;

  205. 	} else if (increment < -360.0) {

  206. 	    increment = -360.0;

  207. 	}

  208. 	increment /= arcSegs;

  209. 	increment = Math.toRadians(increment);

  210. 	angle += increment * (index - 1);

  211. 	double relx = Math.cos(angle);

  212. 	double rely = Math.sin(angle);

  213. 	double z = btan(increment);

  214. 	coords[0] = x + (relx - z * rely) * w;

  215. 	coords[1] = y + (rely + z * relx) * h;

  216. 	angle += increment;

  217. 	relx = Math.cos(angle);

  218. 	rely = Math.sin(angle);

  219. 	coords[2] = x + (relx + z * rely) * w;

  220. 	coords[3] = y + (rely - z * relx) * h;

  221. 	coords[4] = x + relx * w;

  222. 	coords[5] = y + rely * h;

  223. 	if (affine != null) {

  224. 	    affine.transform(coords, 0, coords, 0, 3);

  225. 	}

  226. 	return SEG_CUBICTO;

  227.     }

  228. }