1. /*

  2.  * @(#)ArcIterator.java	1.11 00/02/02

  3.  *

  4.  * Copyright 1997-2000 Sun Microsystems, Inc. All Rights Reserved.

  5.  * 

  6.  * This software is the proprietary information of Sun Microsystems, Inc.  

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. 

  11. package java.awt.geom;

  12. 

  13. import java.util.*;

  14. 

  15. /**

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

  17.  * through the PathIterator interface.

  18.  *

  19.  * @version 10 Feb 1997

  20.  * @author	Jim Graham

  21.  */

  22. class ArcIterator implements PathIterator {

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

  24.     AffineTransform affine;

  25.     int index;

  26.     int arcSegs;

  27.     int lineSegs;

  28. 

  29.     ArcIterator(Arc2D a, AffineTransform at) {

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

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

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

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

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

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

  36. 	this.affine = at;

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

  38. 	if (ext >= 360.0) {

  39. 	    arcSegs = 4;

  40. 	} else {

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

  42. 	}

  43. 	switch (a.getArcType()) {

  44. 	case Arc2D.OPEN:

  45. 	    lineSegs = 0;

  46. 	    break;

  47. 	case Arc2D.CHORD:

  48. 	    lineSegs = 1;

  49. 	    break;

  50. 	case Arc2D.PIE:

  51. 	    lineSegs = 2;

  52. 	    break;

  53. 	}

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

  55. 	    arcSegs = lineSegs = -1;

  56. 	}

  57.     }

  58. 

  59.     /**

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

  61.      * path.

  62.      * @see #WIND_EVEN_ODD

  63.      * @see #WIND_NON_ZERO

  64.      */

  65.     public int getWindingRule() {

  66. 	return WIND_NON_ZERO;

  67.     }

  68. 

  69.     /**

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

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

  72.      */

  73.     public boolean isDone() {

  74. 	return index > arcSegs + lineSegs;

  75.     }

  76. 

  77.     /**

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

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

  80.      * more points in that direction.

  81.      */

  82.     public void next() {

  83. 	index++;

  84.     }

  85. 

  86.     private static double btan(double increment) {

  87. 	increment /= 2.0;

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

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

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

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

  92.     }

  93. 

  94.     /**

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

  96.      * the iteration.

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

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

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

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

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

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

  103.      * SEG_QUADTO will return two points,

  104.      * SEG_CUBICTO will return 3 points

  105.      * and SEG_CLOSE will not return any points.

  106.      * @see #SEG_MOVETO

  107.      * @see #SEG_LINETO

  108.      * @see #SEG_QUADTO

  109.      * @see #SEG_CUBICTO

  110.      * @see #SEG_CLOSE

  111.      */

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

  113. 	if (isDone()) {

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

  115. 	}

  116. 	double angle = angStRad;

  117. 	if (index == 0) {

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

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

  120. 	    if (affine != null) {

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

  122. 	    }

  123. 	    return SEG_MOVETO;

  124. 	}

  125. 	if (index > arcSegs) {

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

  127. 		return SEG_CLOSE;

  128. 	    }

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

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

  131. 	    if (affine != null) {

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

  133. 	    }

  134. 	    return SEG_LINETO;

  135. 	}

  136. 	double increment = angExtDeg;

  137. 	if (increment > 360.0) {

  138. 	    increment = 360.0;

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

  140. 	    increment = -360.0;

  141. 	}

  142. 	increment /= arcSegs;

  143. 	increment = Math.toRadians(increment);

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

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

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

  147. 	double z = btan(increment);

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

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

  150. 	angle += increment;

  151. 	relx = Math.cos(angle);

  152. 	rely = Math.sin(angle);

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

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

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

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

  157. 	if (affine != null) {

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

  159. 	}

  160. 	return SEG_CUBICTO;

  161.     }

  162. 

  163.     /**

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

  165.      * the iteration.

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

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

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

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

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

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

  172.      * SEG_QUADTO will return two points,

  173.      * SEG_CUBICTO will return 3 points

  174.      * and SEG_CLOSE will not return any points.

  175.      * @see #SEG_MOVETO

  176.      * @see #SEG_LINETO

  177.      * @see #SEG_QUADTO

  178.      * @see #SEG_CUBICTO

  179.      * @see #SEG_CLOSE

  180.      */

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

  182. 	if (isDone()) {

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

  184. 	}

  185. 	double angle = angStRad;

  186. 	if (index == 0) {

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

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

  189. 	    if (affine != null) {

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

  191. 	    }

  192. 	    return SEG_MOVETO;

  193. 	}

  194. 	if (index > arcSegs) {

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

  196. 		return SEG_CLOSE;

  197. 	    }

  198. 	    coords[0] = x;

  199. 	    coords[1] = y;

  200. 	    if (affine != null) {

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

  202. 	    }

  203. 	    return SEG_LINETO;

  204. 	}

  205. 	double increment = angExtDeg;

  206. 	if (increment > 360.0) {

  207. 	    increment = 360.0;

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

  209. 	    increment = -360.0;

  210. 	}

  211. 	increment /= arcSegs;

  212. 	increment = Math.toRadians(increment);

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

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

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

  216. 	double z = btan(increment);

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

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

  219. 	angle += increment;

  220. 	relx = Math.cos(angle);

  221. 	rely = Math.sin(angle);

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

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

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

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

  226. 	if (affine != null) {

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

  228. 	}

  229. 	return SEG_CUBICTO;

  230.     }

  231. }