Loading an image in to createImage()

Question

Hello, I am trying to load an image in to the createImage() method so that I can rotate it on a panel (without the whole panel rotating!!). Basically I just want to copy all the pixels from one image and paste them in to another.
Hope someone can help
Andrew
Btw, why do I get a runtime error with image.getGraphics() when when intialising an image using getImage(getDocumentBase(),filename) ?

Answer 1

You have the Image object? If so...
      * Rotates the specified image the specified number of degrees.  The
      * rotation is performed around the center point of the image. 
      * @param  img         the image to rotate
      * @param  degrees     the degrees to rotate
      * @param  bbm         the bounding box mode, default is EXACT_BOUNDING_BOX
      * @param  background  the background paint (texture, color or gradient),
      *                     can be null
      * @return  the image
      * @see  #NO_BOUNDING_BOX
      * @see  #EXACT_BOUNDING_BOX
      * @see  #LARGEST_BOUNDING_BOX
     public static BufferedImage rotateDegrees(Image img, double degrees, int bbm, Paint background) {
          return rotateRadians(img, Math.toRadians(degrees), bbm, background);
      * Rotates the specified image the specified number of radians.  The
      * rotation is performed around the center point of the image.  This
      * method is provided for convenience of applications using radians. 
      * For most people, degrees is simpler to use. 
      * @param  img         the image to rotate
      * @param  radians     the radians to rotate
      * @param  bbm         the bounding box mode, default is EXACT_BOUNDING_BOX
      * @param  background  the background paint (texture, color or gradient),
      *                     can be null
      * @return  the image
      * @see  #NO_BOUNDING_BOX
      * @see  #EXACT_BOUNDING_BOX
      * @see  #LARGEST_BOUNDING_BOX
     public static BufferedImage rotateRadians(Image img, double radians, int bbm, Paint background) {
          // get the original image's width and height
          int iw = img.getWidth(null);
          int ih = img.getHeight(null);
          // calculate the new image's size based on bounding box mode
          Dimension dim;
          if(bbm == NO_BOUNDING_BOX) {
               dim = new Dimension(iw, ih);
          } else if(bbm == LARGEST_BOUNDING_BOX) {
               dim = getLargestBoundingBox(iw, ih);
          } else { // EXACT_BOUNDING_BOX
               dim = getBoundingBox(iw, ih, Math.toDegrees(radians));
          // get the new image's width and height
          int w = dim.width;
          int h = dim.height;
          // get the location to draw the original image on the new image
          int x = (w/2)-(iw/2);
          int y = (h/2)-(ih/2);
          // need to copy the given image to a new BufferedImage because
          // it is, in most cases, going to be a larger image so it
          // needs to be drawn centered on the larger image
          BufferedImage bi = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
          Graphics2D g2d = bi.createGraphics();
          // set some rendering hints for better looking images
          g2d.setRenderingHints(renderingHints);
          // draw the background paint, if necessary
          if(background != null) {
               g2d.setPaint(background);
               g2d.fillRect(0, 0, w, h);
          // if not rotating, just draw it normally, else create a transform
          if(radians == 0.0) {
               g2d.drawImage(img, x, y, iw, ih, null);
          } else {
               g2d.rotate(radians, w/2, h/2);
               g2d.translate(x, y);
               g2d.drawImage(img, 0, 0, iw, ih, null);
          g2d.dispose();
          return bi;
      * Gets the largest bounding box size that can hold an image of the
      * specified size at any angle of rotation. 
      * @param  width   the image width
      * @param  height  the image height
      * @return  the bounding box size
     public static Dimension getLargestBoundingBox(int width, int height) {
          // The largest bounding box is the largest area needed to fit the
          // specified image at any angle or rotation.  This is simpler then
          // getting the bounding box for a given angle because the largest
          // box will put the corner of the image box directly along the
          // vertical or horizontal axis from the image center point.  The
          // distance between the image rectangle's center and any corner
          // is the hypotenuse of a right triangle who's other sides are
          // half the width (a) and half the height (b) of the rectangle. 
          // A little a^2 + b^2 = c^2 calculation and we get the length of
          // the hypotenuse.  Double that to get a square within which the
          // image can be rotated at any angle without clipping the image. 
          double a = (double)width / 2.0;
          double b = (double)height / 2.0;
          // use Math.ceil() to round up to an int value
          int c = (int)Math.ceil(Math.sqrt((a * a) + (b * b)) * 2.0);
          return new Dimension(c, c);
      * Gets the optimal/smallest bounding box size that can hold an image of
      * the specified size at the specified angle of rotation. 
      * @param  width   the image width
      * @param  height  the image height
      * @return  the bounding box size
     public static Dimension getBoundingBox(int width, int height, double degrees) {
          degrees = normalizeDegrees(degrees);
          // if no rotation or 180 degrees, the size won't change
          if(degrees == 0.0 || degrees == 180.0) {
               return new Dimension(width, height);
          // if 90 or 270 (quarter or 3-quarter rotations) the width becomes
          // the height, and vice versa
          if(degrees == 90.0 || degrees == 270.0) {
               return new Dimension(height, width);
          // for any other rotation, we need to do some trigonometry,
          // derived from description found at: 
          // http://www.codeproject.com/csharp/rotateimage.asp
          double radians = Math.toRadians(degrees);
          double aW = Math.abs(Math.cos(radians) * width);
          double oW = Math.abs(Math.sin(radians) * width);
          double aH = Math.abs(Math.cos(radians) * height);
          double oH = Math.abs(Math.sin(radians) * height);
          // use Math.ceil() to round up to an int value
          int w = (int)Math.ceil(aW + oH);
          int h = (int)Math.ceil(oW + aH);
          return new Dimension(w, h);