I. Java2D graphics allows a programmer to represent objects in user
	coordinates and then transform user coordinates to pixels.

    A. Java AWT package is an integer, pixel-based model.

    B. Java2D graphics is a real-number, user-coordinate based model

    C. Other enhancements over the AWT

	1. Arbitrary line sizes

	2. Arbitrary line styles

	3. Three types of fill options

	    a. solid colors

	    b. gradiant colors

	    c. texture fills

	4. Area objects that use boolean operations to form complex objects
	    out of simpler objects

II. Use information

    A. java.awt.geom: package name for the java 2D graphics package

    B. Graphics2D class: A subclass of Graphics that implements many of the
	Java2D drawing and context setting commands.

	1. Downcast the Graphics object passed in as a parameter to 
	   paintComponent to Graphics2D

    C. Rendering methods

	1. draw: renders the outline of any geometry primitive, using the 
		stroke and paint attributes

	2. fill: renders any geometry primitive by filling its interior 
	    	with the color or pattern specified by the paint attribute.

III. New Objects: 

    A. Point2D, Dimension2D: Location and size objects
	1. Point2D is an abstract class. 
	    a. Point is an integer subclass that allows the creation
		of a point with integer coordinates
	    b. Point2D.Double and Point2D.Float are 
		static, nested subclasses that allow for the creation of
		float or double objects. 
	    c. Point2D contains useful distance methods for calculating the distance
			between two points

	2. Dimension2D is an abstract class
	    a. Dimension is a subclass that allows the creation of integer
	    b. Unlike Point2D, there are no Java provided classes for
		real numbered sizes

    B. Shape interface.

        1. Useful methods

	    a. contains(Point2D or Rectangle2D or x,y): indicates whether the
	    	Shape contains the indicated object: good for determining if
		the shape contains a mouse point

	    b. intersects(Rectangle2D or x,y,w,h): indicates whether the
	    	Shape intersects the indicated rectangle: good for determining
		if the Shape intersects a clipping region

 	    c. Rectangle getBounds(), Rectangle2D getBounds2D(): return the
		bounding box of a Shape

 	2. Useful objects that implement the Shape interface: Note that many
	 	of these classes have useful methods that do complicated
		intersection tests and distance computations for you. For
		example, many of these objects have methods that determine
		whether or not they intersect a line and the line class has
		methods for determining the shortest distance between a point
		and the line.

	    a. Rectangle2D

	    b. RoundRectangle2D

	    c. Line2D

	    d. Ellipse2D

	    e. Arc2D

		1. Uses degrees, not radians. The rest of the Java2D package
			uses radians. 

		2. Positive degrees are measured in a counter-clockwise direction

		3. Three types

		    a. pie: draws the entire portion of the circle represented by
			the arc

		    b. chord: only draws an arc that is closed by drawing a line
			segment between the start and end arc segments. When the
			draw method is used, the line segment is drawn.

		    c. open: similar to chord except that when the draw method is
			used, the line segment is not drawn

		4. setArcByCenter(centerX, centerY, radius, start angle, angle
			extent, arc type): this method is the best one to use to
			set an arc's attributes. Note that an arc is defined by
			a start angle and an angle extent rather than a start angle
			and an end angle.

	    f. Area: Allows you to combine simple shapes into more complicated
		shapes using intersection, union, subtraction, and exclusive or.

		1. Resulting shape can be filled and/or stroked
		2. Resulting shape has intersection and contains tests
		3. Composition methods
		    a. intersect(Area)
		    b. subtract(Area): difference operation
		    c. add(Area): union operation
		    d. exclusiveOr(Area) = add - intersect: effectively the 
		    	same as taking the union of two objects and then
			removing their intersected area

IV. Image Handling 
    A. Image: An abstract class that defines basic methods for manipulating images. 
	1. BufferedImage: A mutable image buffer that may be written to using
	   a Graphics object
	   a. Provides a createGraphics method for creating a Graphics2D
		object tht can be used to write into the buffer
    	   b. You can draw a BufferedImage directly to the screen using the drawImage 
    B. Images and Swing: Unfortunately, Java's Swing components, such as a JLabel, cannot
         handle Images directly.
	1. Swing components want to be passed an Icon object. 
	2. An Icon is an interface defined by Java for use by Swing
	3. The ImageIcon class is the most common instantiation for an
      	 	Icon object, and is basically a container object for an Image. 
    C. Loading Image Objects: You can load an image either by creating an
       ImageIcon or by using the ImageIO class to read an image

       1. ImageIcon: This is the easy way to load an image, but it does not
	  easily allow you to extract a BufferedImage. 

	  try {
            Image bvzImage = new ImageIcon("/home/bvz/www-home/bvz.gif")

       2. ImageIO: To get a BufferedImage, it is better to try the following

          import java.io.File;
          import javax.image.ImageIO;

          BufferedImage image = null;
          try {
	    image = ImageIO.read(new File("/home/bvz/www-home/bvz.gif"));
    	  } catch (IOException e) {

III. Line Styles

    A. Java2D introduces a new interface called Stroke and a new
	class called BasicStroke for implementing line styles

	1. Graphics2D.setStroke(Stroke): sets the stroke attribute to the
	    indicated stroke object

    B. Stroke attributes

	1. line width: the thickness of a line

	2. join style: the decoration applied when two lines meet

	    a. options 
		i. join_bevel: Joins lines by connecting the outer corners of 
		    their edges with a straight segment
		ii. join_miter: Joins lines by extending their outside edges 
		    until they meet.
		iii. join_round: Joins lines by rounding off the corner at a 
		     radius of half the line width.

	    b. when join_miter is specified you also need to specify 
		something called a miter limit. The 
		miter limit specifies the maximum extent for this joining 
		(i.e., for the length of the miter). If the miter would exceed
		this limit, then java trims the miter so that it becomes a
		bevel. See the java docs for more information.

	3. end-cap style: the decoration applied at the end of a line
	    segment (it does not intersect anything)

	    a. options 
	        i. cap_butt: Ends lines and dash segments with no added 
		ii. cap_round: Ends lines and dash segments with a round 
		    decoration that has a radius equal to half of the line width
		iii. cap_square: Ends lines and dash segments with a square 
		    projection that extends beyond the end of the segment to 
		    a distance equal to half of the line width

	4. dash style: the pattern of opaque and transparent sections applied
	    along the length of a line

	    a. dash array: defines the dash pattern. Alternating elements 
		in the array represent the dash length and the length of the 
		space between dashes in user coordinate units. Element 0 
		represents the first dash, element 1 the first space, and so 

		i. Java treats its array index as a counter that monotonically
		   increases. It mods the counter by the size of the array to
		   find its next dash length. That means that if the size of
		   the array is odd, then the dashes will look odd. For example,
		   if the array is {10.0f, 2.0f, 5.0f} then the first three
		   parts of the line will be as expected--a dash of length
		   10, a space of length 2, and a dash of length 5. However,
		   the index will now wrap around to the beginning of the
		   array so the next three parts will be a space of length 10,
		   a dash of length 2, and a space of length 5. 

		ii. Moral: make the length of your dash array be even

		iii. Exception: if you want equal length dashes and spaces 
			then you only need an array of length 1. For example,
			a dash array of {10.0f} will create dashes and spaces
			that are each 10 units long.

	    b. dash phase: an offset into the dash pattern, specified in 
		user coordinate units. The dash phase indicates what part of 
		the dash pattern is applied to the beginning of the line. For
		example, if the dash array is {10.0f, 15.0f, 5.0f} and the
		dash phase is 5.0f, then the line will start with a dash of
		length 5 (omitting the first 5 units of the 10 unit dash), 
		followed by a space of length 15, etc. Similarly if
		the dash phase is 20, then the line will start with a space
		of length 5 (omitting the dash of length 10 and the first
		10 units of the space), then a dash of length 5, then a space
		of length 10 (because the dash index wraps to the beginning
		of the array).

    C. Commonly used constructors for BasicStroke

        1. BasicStroke(float width): Constructs a solid BasicStroke with the 
	   specified line width and with default values for the cap and join 

	2. BasicStroke(float width, int cap, int join) 

	3. BasicStroke(float width, int cap, int join, float miterlimit) 
	4. BasicStroke(float width, int cap, int join, float miterlimit, 
	               float[] dash, float dash_phase) 
IV. Fill Styles

    A. Paint interface: interface implemented by the three types of fill

	1. Graphics2D.setPaint(Paint): sets the paint attribute to the
		indicated paint object

	2. Types of fill objects

	    a. Color: The color class has useful pre-defined constants
		for commonly used colors plus methods that will 
		convert HSV values to RGB values

	    b. GradientPaint(P1, C1, P2, C2, cyclic?)

		i. the user specifies two points, P1 and P2, in user space
			and associates a color, C1 and C2, with each point.
			Colors can be arbitrary colors (e.g., red to white or
			red to blue).

		ii. Java proportionately changes the color on the P1-P2 line
			segment from C1 to C2

		iii. The color of points on the extension to the line segment
			depend on whether the gradient paint's cycle parameter
			is true or false

		    1) true (i.e., cyclic): The colors repeat themselves in
			reverse. For example, after going from C1 to C2, the
			color will reverse itself and go from C2 to C1, then
			from C1 to C2, etc.

		    2) false (i.e., acyclic): Any point before P1 is colored
			C1 and any point after P2 is colored C2

		iv. Color of points that do not lie on the line

	 	    1) draw an imaginary perpendicular line from the point 
			to the P1-P2 line (or to its extension).

		    2) The color at the point where the imaginary line 
			intersects the line segment or its extension is 
			the color assigned to the point.

		Example: The picture to the left was drawn using 
		    r1, r2, and r3 are all drawn with cyclic gradient

		    r1: the line goes from the upper left corner to
		    	the lower right corner

		    r2: the line goes from the upper left corner to the center.
			Note how the color reverses at the center

		    r3: the line goes from the upper left corner to 1/3 of
			the way into the rectangle. Note that there are two
			color reversals (white to blue, blue to white, white
			to blue).

		    r4, r5, and r6 are drawn with  acyclic gradient paints.

		    r4: the line goes from the upper left corner to the
			lower right corner. r4 and r1 look identical because
			there is no repetition.

		    r5: the line goes from the 1/4 to 3/4 point of the
			rectangle. Note that the color is completely white
			before the 1/4 point and complete blue after the 3/4

		    r6: the line goes from the center of the rectangle to the
			bottom right corner. Note that the color is completely
			white before the center of the rectangle.

		    r7: r7 is drawn with the same acyclic gradient paint as
			r5. Note how you can determine the color of a point
			by drawing an imaginary perpendicular line from the 
			point to the line segment used to specify the gradient

		    r8, r9: both r8 and r9 are drawn with a cyclic gradient
			paint that goes from (0, 0) to (50, 50). Note the
			alternation of colors and the unpredictability of what
			will be drawn. 

		Bottom Line: When using a gradient paint you will normally want
			to anchor it at the same points where the object is 
			being drawn

	    c. TexturePaint(BufferedImage image, Rectangle2D anchorRect): A
		texture paint object scales the image to the size of the
		anchorRect and starts drawing on the screen at the anchor 
		rectangle's position. 
		i. Additional rectangles are replicated in each direction 
			from the anchor. 
		ii. The location of the anchor rectangle specifies a position 
			on the screen, not an offset into the image.

		iii. Generally it is a good idea to start texturing at the upper,
			left corner of the object, otherwise the results may
			be unpredictable.

		iv. In order to extract a portion of an image and embed it
			in a BufferedImage you need to:

		    1) create a BufferedImage object with one of the predefined
			ways of interpreting the image (typically you will
			use BufferedImage.TYPE_INT_ARGB)
		    2) request a Graphics2D object from the BufferedImage object
			using the createGraphics command

		    3) draw images, colors, etc. into the BufferedImage using
			the fill, draw, drawImage, and drawString commands of
			the graphics object

	  	Example: the picture below was drawn by texture.java.