android/testSrc/com/android/tools/idea/rendering/ImageUtilsTest.java - platform/tools/adt/idea - Git at Google

 /*
  * Copyright (C) 2013 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.android.tools.idea.rendering;

 import junit.framework.TestCase;
 import org.jetbrains.android.AndroidTestCase;

 import javax.imageio.ImageIO;
 import java.awt.*;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;

 public class ImageUtilsTest extends TestCase {
   public void testScaleImage() throws Exception {
     @SuppressWarnings("UndesirableClassUsage")
     BufferedImage image = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB_PRE);
     Graphics g = image.getGraphics();
     g.setColor(new Color(0xFF00FF00, true));
     g.fillRect(0, 0, image.getWidth(), image.getHeight());
     g.setColor(new Color(0xFFFF0000, true));
     g.fillRect(25, 25, 50, 50);
     g.dispose();

     BufferedImage scaled = ImageUtils.scale(image, 0.5, 0.5);
     assertEquals(50, scaled.getWidth());
     assertEquals(50, scaled.getHeight());
     assertEquals(0xFF00FF00, scaled.getRGB(0, 0));
     assertEquals(0xFF00FF00, scaled.getRGB(49, 49));
     assertEquals(0xFFFF0000, scaled.getRGB(25, 25));

     scaled = ImageUtils.scale(image, 2.0, 2.0);
     assertEquals(200, scaled.getWidth());
     assertEquals(200, scaled.getHeight());
     assertEquals(0xFF00FF00, scaled.getRGB(0, 0));
     assertEquals(0xFF00FF00, scaled.getRGB(48, 48));
     assertEquals(0xFFFF0000, scaled.getRGB(100, 100));
     assertEquals(0xFF00FF00, scaled.getRGB(199, 199));

     scaled = ImageUtils.scale(image, 0.25, 0.25);
     assertEquals(25, scaled.getWidth());
     assertEquals(25, scaled.getHeight());
     assertEquals(0xFF00FF00, scaled.getRGB(0, 0));
     assertEquals(0xFF00FF00, scaled.getRGB(24, 24));
     assertEquals(0xFFFF0000, scaled.getRGB(13, 13));

     scaled = ImageUtils.scale(image, 0.25, 0.25, 75, 95);
     assertEquals(100, scaled.getWidth());
     assertEquals(120, scaled.getHeight());
     assertEquals(0xFF00FF00, scaled.getRGB(0, 0));
     assertEquals(0xFF00FF00, scaled.getRGB(24, 24));
     assertEquals(0xFFFF0000, scaled.getRGB(13, 13));
   }

   public void testRotation() throws IOException {
     String path = AndroidTestCase.getAbsoluteTestDataPath() + File.separator + "render" + File.separator + "imageutils";

     BufferedImage srcImage = readImage(path, "0.png");
     BufferedImage expected90 = readImage(path, "90.png");
     BufferedImage expected180 = readImage(path, "180.png");
     BufferedImage expected270 = readImage(path, "270.png");

     assertEqualsImage(expected90, ImageUtils.rotateByRightAngle(srcImage, 90));
     assertEqualsImage(expected180, ImageUtils.rotateByRightAngle(srcImage, 180));
     assertEqualsImage(expected270, ImageUtils.rotateByRightAngle(srcImage, 270));

     // verify that rotating the image 4 times by 90 degrees doesn't lose any data
     BufferedImage img = readImage(path, "0.png");
     for (int i = 0; i < 4; i++) {
       img = ImageUtils.rotateByRightAngle(img, 90);
     }
     assertEqualsImage(srcImage, img);
   }

   public void testAddMargin() {
     BufferedImage image = createTestImage(100, 200, BufferedImage.TYPE_INT_ARGB, Color.RED);

     BufferedImage zeroMargin = ImageUtils.addMargin(image, 0);
     assertEqualsImage(image, zeroMargin);

     BufferedImage margin1 = ImageUtils.addMargin(image, 1);
     assertEquals(margin1.getWidth(), image.getWidth() + 2);
     assertEquals(margin1.getHeight(), image.getHeight() + 2);

     image = createTestImage(50, 50, BufferedImage.TYPE_INT_RGB, Color.BLUE);
     margin1 = ImageUtils.addMargin(image, 1);
     assertFalse(image.getColorModel().hasAlpha());
     assertTrue(margin1.getColorModel().hasAlpha());
     assertEqualsImageExcludingMargin(image, margin1, 1);
   }

   private static BufferedImage createTestImage(int w, int h, int imageType, Color fill) {
     @SuppressWarnings("UndesirableClassUsage")
     BufferedImage image = new BufferedImage(w, h, imageType);
     Graphics g = image.getGraphics();
     g.setColor(fill);
     g.fillRect(0, 0, image.getWidth(), image.getHeight());
     g.dispose();
     return image;
   }

   private static BufferedImage readImage(String folder, String fileName) throws IOException {
     File f = new File(folder, fileName);
     return ImageIO.read(f);
   }

   private static void assertEqualsImage(BufferedImage expected, BufferedImage actual) {
     assertEqualsImageExcludingMargin(expected, actual, 0);
   }

   private static void assertEqualsImageExcludingMargin(BufferedImage expected, BufferedImage actual, int margin) {
     assertEquals(expected.getWidth(), actual.getWidth() - 2 * margin);
     assertEquals(expected.getHeight(), actual.getHeight() - 2 * margin);

     for (int x = 0; x < expected.getWidth(); x++) {
       for (int y = 0; y < expected.getHeight(); y++) {
         assertEquals(expected.getRGB(x, y), actual.getRGB(x + margin, y + margin));
       }
     }
   }

   public void testCropBlank() throws Exception {
     BufferedImage image = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB_PRE);
     Graphics g = image.getGraphics();
     g.setColor(new Color(0, true));
     g.fillRect(0, 0, image.getWidth(), image.getHeight());
     g.dispose();

     BufferedImage crop = ImageUtils.cropBlank(image, null);
     assertNull(crop);
   }

   public void testCropBlankPre() throws Exception {
     BufferedImage image = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB_PRE);
     Graphics g = image.getGraphics();
     g.setColor(new Color(0, true));
     g.fillRect(0, 0, image.getWidth(), image.getHeight());
     g.dispose();

     BufferedImage crop = ImageUtils.cropBlank(image, new Rectangle(5, 5, 80, 80));
     assertNull(crop);
   }

   public void testCropTopLine() throws Exception {
     BufferedImage image = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB_PRE);
     Graphics g = image.getGraphics();
     g.setColor(new Color(0, false));
     g.fillRect(0, 1, image.getWidth(), image.getHeight() - 1);
     g.dispose();

     BufferedImage crop = ImageUtils.cropBlank(image, null);
     assertNotNull(crop);
     assertEquals(image.getWidth(), crop.getWidth());
     assertEquals(image.getHeight() - 1, crop.getHeight());
   }

   public void testCropNonBlank() throws Exception {
     BufferedImage image = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB_PRE);
     Graphics g = image.getGraphics();
     g.setColor(new Color(0, false));
     g.fillRect(0, 0, image.getWidth(), image.getHeight());
     g.dispose();

     BufferedImage crop = ImageUtils.cropBlank(image, null);
     assertNotNull(crop);
     assertEquals(crop.getWidth(), image.getWidth());
     assertEquals(crop.getHeight(), image.getHeight());
   }

   public void testCropSomething() throws Exception {
     BufferedImage image = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB_PRE);
     Graphics g = image.getGraphics();
     g.setColor(new Color(0, true));
     g.fillRect(0, 0, image.getWidth(), image.getHeight());
     g.setColor(new Color(0xFF00FF00, true));
     g.fillRect(25, 25, 50, 50);
     g.dispose();

     BufferedImage crop = ImageUtils.cropBlank(image, null);
     assertNotNull(crop);
     assertEquals(50, crop.getWidth());
     assertEquals(50, crop.getHeight());
     assertEquals(0xFF00FF00, crop.getRGB(0, 0));
     assertEquals(0xFF00FF00, crop.getRGB(49, 49));
   }

   public void testCropSomethingPre() throws Exception {
     BufferedImage image = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB_PRE);
     Graphics g = image.getGraphics();
     g.setColor(new Color(0, true));
     g.fillRect(0, 0, image.getWidth(), image.getHeight());
     g.setColor(new Color(0xFF00FF00, true));
     g.fillRect(25, 25, 50, 50);
     g.dispose();

     BufferedImage crop = ImageUtils.cropBlank(image, new Rectangle(0, 0, 100, 100));
     assertNotNull(crop);
     assertEquals(50, crop.getWidth());
     assertEquals(50, crop.getHeight());
     assertEquals(0xFF00FF00, crop.getRGB(0, 0));
     assertEquals(0xFF00FF00, crop.getRGB(49, 49));
   }

   public void testCropSomethingPre2() throws Exception {
     BufferedImage image = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB_PRE);
     Graphics g = image.getGraphics();
     g.setColor(new Color(0, true));
     g.fillRect(0, 0, image.getWidth(), image.getHeight());
     g.setColor(new Color(0xFF00FF00, true));
     g.fillRect(25, 25, 50, 50);
     g.dispose();

     BufferedImage crop = ImageUtils.cropBlank(image, new Rectangle(5, 5, 80, 80));
     assertNotNull(crop);
     assertEquals(50, crop.getWidth());
     assertEquals(50, crop.getHeight());
     assertEquals(0xFF00FF00, crop.getRGB(0, 0));
     assertEquals(0xFF00FF00, crop.getRGB(49, 49));
   }

   /**
    * Paints a set of {@link Rectangle} object out of a rendered {@link BufferedImage}
    * such that the resulting image is transparent except for a minimum bounding
    * rectangle of the selected elements.
    *
    * @param image the source image
    * @param rectangles the set of rectangles to copy
    * @param boundingBox the bounding rectangle of the set of rectangles to copy, can be
    *            computed by {@link ImageUtils#getBoundingRectangle}
    * @param scale a scale factor to apply to the result, e.g. 0.5 to shrink the
    *            destination down 50%, 1.0 to leave it alone and 2.0 to zoom in by
    *            doubling the image size
    * @return a rendered image, or null
    */
   public static BufferedImage drawRectangles(BufferedImage image,
                                              java.util.List<Rectangle> rectangles, Rectangle boundingBox, double scale) {

     // This code is not a test. When I implemented image cropping, I first implemented
     // it for BufferedImages (since it's easier; easy image painting, easy scaling,
     // easy transparency handling, etc). However, this meant that we would need to
     // convert the SWT images from the ImageOverlay to BufferedImages, crop and convert
     // back; not ideal, so I rewrote it in SWT (see SwtUtils). However, I
     // don't want to throw away the code in case we start keeping BufferedImages rather
     // than SWT images or need it for other purposes, but rather than place it in the
     // production codebase I'm leaving this utility here in the associated ImageUtils
     // test class. It was used like this:
     // @formatter:off
     //
     //    BufferedImage wholeImage = SwtUtils.convertToAwt(image);
     //    BufferedImage result = ImageUtils.cropSelection(wholeImage,
     //        rectangles, boundingBox, scale);
     //    e.image = SwtUtils.convertToSwt(image.getDevice(), result, true,
     //        DRAG_TRANSPARENCY);
     //
     // @formatter:on

     if (boundingBox == null) {
       return null;
     }

     int destWidth = (int) (scale * boundingBox.width);
     int destHeight = (int) (scale * boundingBox.height);
     BufferedImage dest = new BufferedImage(destWidth, destHeight, image.getType());

     Graphics2D g = dest.createGraphics();

     for (Rectangle bounds : rectangles) {
       int dx1 = bounds.x - boundingBox.x;
       int dy1 = bounds.y - boundingBox.y;
       int dx2 = dx1 + bounds.width;
       int dy2 = dy1 + bounds.height;

       dx1 *= scale;
       dy1 *= scale;
       dx2 *= scale;
       dy2 *= scale;

       int sx1 = bounds.x;
       int sy1 = bounds.y;
       int sx2 = sx1 + bounds.width;
       int sy2 = sy1 + bounds.height;

       g.drawImage(image, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, null);
     }

     g.dispose();

     return dest;
   }
 }
	/*
	* Copyright (C) 2013 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.android.tools.idea.rendering;

	import junit.framework.TestCase;
	import org.jetbrains.android.AndroidTestCase;

	import javax.imageio.ImageIO;
	import java.awt.*;
	import java.awt.image.BufferedImage;
	import java.io.File;
	import java.io.IOException;

	public class ImageUtilsTest extends TestCase {
	public void testScaleImage() throws Exception {
	@SuppressWarnings("UndesirableClassUsage")
	BufferedImage image = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB_PRE);
	Graphics g = image.getGraphics();
	g.setColor(new Color(0xFF00FF00, true));
	g.fillRect(0, 0, image.getWidth(), image.getHeight());
	g.setColor(new Color(0xFFFF0000, true));
	g.fillRect(25, 25, 50, 50);
	g.dispose();

	BufferedImage scaled = ImageUtils.scale(image, 0.5, 0.5);
	assertEquals(50, scaled.getWidth());
	assertEquals(50, scaled.getHeight());
	assertEquals(0xFF00FF00, scaled.getRGB(0, 0));
	assertEquals(0xFF00FF00, scaled.getRGB(49, 49));
	assertEquals(0xFFFF0000, scaled.getRGB(25, 25));

	scaled = ImageUtils.scale(image, 2.0, 2.0);
	assertEquals(200, scaled.getWidth());
	assertEquals(200, scaled.getHeight());
	assertEquals(0xFF00FF00, scaled.getRGB(0, 0));
	assertEquals(0xFF00FF00, scaled.getRGB(48, 48));
	assertEquals(0xFFFF0000, scaled.getRGB(100, 100));
	assertEquals(0xFF00FF00, scaled.getRGB(199, 199));

	scaled = ImageUtils.scale(image, 0.25, 0.25);
	assertEquals(25, scaled.getWidth());
	assertEquals(25, scaled.getHeight());
	assertEquals(0xFF00FF00, scaled.getRGB(0, 0));
	assertEquals(0xFF00FF00, scaled.getRGB(24, 24));
	assertEquals(0xFFFF0000, scaled.getRGB(13, 13));

	scaled = ImageUtils.scale(image, 0.25, 0.25, 75, 95);
	assertEquals(100, scaled.getWidth());
	assertEquals(120, scaled.getHeight());
	assertEquals(0xFF00FF00, scaled.getRGB(0, 0));
	assertEquals(0xFF00FF00, scaled.getRGB(24, 24));
	assertEquals(0xFFFF0000, scaled.getRGB(13, 13));
	}

	public void testRotation() throws IOException {
	String path = AndroidTestCase.getAbsoluteTestDataPath() + File.separator + "render" + File.separator + "imageutils";

	BufferedImage srcImage = readImage(path, "0.png");
	BufferedImage expected90 = readImage(path, "90.png");
	BufferedImage expected180 = readImage(path, "180.png");
	BufferedImage expected270 = readImage(path, "270.png");

	assertEqualsImage(expected90, ImageUtils.rotateByRightAngle(srcImage, 90));
	assertEqualsImage(expected180, ImageUtils.rotateByRightAngle(srcImage, 180));
	assertEqualsImage(expected270, ImageUtils.rotateByRightAngle(srcImage, 270));

	// verify that rotating the image 4 times by 90 degrees doesn't lose any data
	BufferedImage img = readImage(path, "0.png");
	for (int i = 0; i < 4; i++) {
	img = ImageUtils.rotateByRightAngle(img, 90);
	}
	assertEqualsImage(srcImage, img);
	}

	public void testAddMargin() {
	BufferedImage image = createTestImage(100, 200, BufferedImage.TYPE_INT_ARGB, Color.RED);

	BufferedImage zeroMargin = ImageUtils.addMargin(image, 0);
	assertEqualsImage(image, zeroMargin);

	BufferedImage margin1 = ImageUtils.addMargin(image, 1);
	assertEquals(margin1.getWidth(), image.getWidth() + 2);
	assertEquals(margin1.getHeight(), image.getHeight() + 2);

	image = createTestImage(50, 50, BufferedImage.TYPE_INT_RGB, Color.BLUE);
	margin1 = ImageUtils.addMargin(image, 1);
	assertFalse(image.getColorModel().hasAlpha());
	assertTrue(margin1.getColorModel().hasAlpha());
	assertEqualsImageExcludingMargin(image, margin1, 1);
	}

	private static BufferedImage createTestImage(int w, int h, int imageType, Color fill) {
	@SuppressWarnings("UndesirableClassUsage")
	BufferedImage image = new BufferedImage(w, h, imageType);
	Graphics g = image.getGraphics();
	g.setColor(fill);
	g.fillRect(0, 0, image.getWidth(), image.getHeight());
	g.dispose();
	return image;
	}

	private static BufferedImage readImage(String folder, String fileName) throws IOException {
	File f = new File(folder, fileName);
	return ImageIO.read(f);
	}

	private static void assertEqualsImage(BufferedImage expected, BufferedImage actual) {
	assertEqualsImageExcludingMargin(expected, actual, 0);
	}

	private static void assertEqualsImageExcludingMargin(BufferedImage expected, BufferedImage actual, int margin) {
	assertEquals(expected.getWidth(), actual.getWidth() - 2 * margin);
	assertEquals(expected.getHeight(), actual.getHeight() - 2 * margin);

	for (int x = 0; x < expected.getWidth(); x++) {
	for (int y = 0; y < expected.getHeight(); y++) {
	assertEquals(expected.getRGB(x, y), actual.getRGB(x + margin, y + margin));
	}
	}
	}

	public void testCropBlank() throws Exception {
	BufferedImage image = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB_PRE);
	Graphics g = image.getGraphics();
	g.setColor(new Color(0, true));
	g.fillRect(0, 0, image.getWidth(), image.getHeight());
	g.dispose();

	BufferedImage crop = ImageUtils.cropBlank(image, null);
	assertNull(crop);
	}

	public void testCropBlankPre() throws Exception {
	BufferedImage image = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB_PRE);
	Graphics g = image.getGraphics();
	g.setColor(new Color(0, true));
	g.fillRect(0, 0, image.getWidth(), image.getHeight());
	g.dispose();

	BufferedImage crop = ImageUtils.cropBlank(image, new Rectangle(5, 5, 80, 80));
	assertNull(crop);
	}

	public void testCropTopLine() throws Exception {
	BufferedImage image = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB_PRE);
	Graphics g = image.getGraphics();
	g.setColor(new Color(0, false));
	g.fillRect(0, 1, image.getWidth(), image.getHeight() - 1);
	g.dispose();

	BufferedImage crop = ImageUtils.cropBlank(image, null);
	assertNotNull(crop);
	assertEquals(image.getWidth(), crop.getWidth());
	assertEquals(image.getHeight() - 1, crop.getHeight());
	}

	public void testCropNonBlank() throws Exception {
	BufferedImage image = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB_PRE);
	Graphics g = image.getGraphics();
	g.setColor(new Color(0, false));
	g.fillRect(0, 0, image.getWidth(), image.getHeight());
	g.dispose();

	BufferedImage crop = ImageUtils.cropBlank(image, null);
	assertNotNull(crop);
	assertEquals(crop.getWidth(), image.getWidth());
	assertEquals(crop.getHeight(), image.getHeight());
	}

	public void testCropSomething() throws Exception {
	BufferedImage image = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB_PRE);
	Graphics g = image.getGraphics();
	g.setColor(new Color(0, true));
	g.fillRect(0, 0, image.getWidth(), image.getHeight());
	g.setColor(new Color(0xFF00FF00, true));
	g.fillRect(25, 25, 50, 50);
	g.dispose();

	BufferedImage crop = ImageUtils.cropBlank(image, null);
	assertNotNull(crop);
	assertEquals(50, crop.getWidth());
	assertEquals(50, crop.getHeight());
	assertEquals(0xFF00FF00, crop.getRGB(0, 0));
	assertEquals(0xFF00FF00, crop.getRGB(49, 49));
	}

	public void testCropSomethingPre() throws Exception {
	BufferedImage image = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB_PRE);
	Graphics g = image.getGraphics();
	g.setColor(new Color(0, true));
	g.fillRect(0, 0, image.getWidth(), image.getHeight());
	g.setColor(new Color(0xFF00FF00, true));
	g.fillRect(25, 25, 50, 50);
	g.dispose();

	BufferedImage crop = ImageUtils.cropBlank(image, new Rectangle(0, 0, 100, 100));
	assertNotNull(crop);
	assertEquals(50, crop.getWidth());
	assertEquals(50, crop.getHeight());
	assertEquals(0xFF00FF00, crop.getRGB(0, 0));
	assertEquals(0xFF00FF00, crop.getRGB(49, 49));
	}

	public void testCropSomethingPre2() throws Exception {
	BufferedImage image = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB_PRE);
	Graphics g = image.getGraphics();
	g.setColor(new Color(0, true));
	g.fillRect(0, 0, image.getWidth(), image.getHeight());
	g.setColor(new Color(0xFF00FF00, true));
	g.fillRect(25, 25, 50, 50);
	g.dispose();

	BufferedImage crop = ImageUtils.cropBlank(image, new Rectangle(5, 5, 80, 80));
	assertNotNull(crop);
	assertEquals(50, crop.getWidth());
	assertEquals(50, crop.getHeight());
	assertEquals(0xFF00FF00, crop.getRGB(0, 0));
	assertEquals(0xFF00FF00, crop.getRGB(49, 49));
	}

	/**
	* Paints a set of {@link Rectangle} object out of a rendered {@link BufferedImage}
	* such that the resulting image is transparent except for a minimum bounding
	* rectangle of the selected elements.
	*
	* @param image the source image
	* @param rectangles the set of rectangles to copy
	* @param boundingBox the bounding rectangle of the set of rectangles to copy, can be
	* computed by {@link ImageUtils#getBoundingRectangle}
	* @param scale a scale factor to apply to the result, e.g. 0.5 to shrink the
	* destination down 50%, 1.0 to leave it alone and 2.0 to zoom in by
	* doubling the image size
	* @return a rendered image, or null
	*/
	public static BufferedImage drawRectangles(BufferedImage image,
	java.util.List<Rectangle> rectangles, Rectangle boundingBox, double scale) {

	// This code is not a test. When I implemented image cropping, I first implemented
	// it for BufferedImages (since it's easier; easy image painting, easy scaling,
	// easy transparency handling, etc). However, this meant that we would need to
	// convert the SWT images from the ImageOverlay to BufferedImages, crop and convert
	// back; not ideal, so I rewrote it in SWT (see SwtUtils). However, I
	// don't want to throw away the code in case we start keeping BufferedImages rather
	// than SWT images or need it for other purposes, but rather than place it in the
	// production codebase I'm leaving this utility here in the associated ImageUtils
	// test class. It was used like this:
	// @formatter:off
	//
	// BufferedImage wholeImage = SwtUtils.convertToAwt(image);
	// BufferedImage result = ImageUtils.cropSelection(wholeImage,
	// rectangles, boundingBox, scale);
	// e.image = SwtUtils.convertToSwt(image.getDevice(), result, true,
	// DRAG_TRANSPARENCY);
	//
	// @formatter:on

	if (boundingBox == null) {
	return null;
	}

	int destWidth = (int) (scale * boundingBox.width);
	int destHeight = (int) (scale * boundingBox.height);
	BufferedImage dest = new BufferedImage(destWidth, destHeight, image.getType());

	Graphics2D g = dest.createGraphics();

	for (Rectangle bounds : rectangles) {
	int dx1 = bounds.x - boundingBox.x;
	int dy1 = bounds.y - boundingBox.y;
	int dx2 = dx1 + bounds.width;
	int dy2 = dy1 + bounds.height;

	dx1 *= scale;
	dy1 *= scale;
	dx2 *= scale;
	dy2 *= scale;

	int sx1 = bounds.x;
	int sy1 = bounds.y;
	int sx2 = sx1 + bounds.width;
	int sy2 = sy1 + bounds.height;

	g.drawImage(image, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, null);
	}

	g.dispose();

	return dest;
	}
	}