AOO410/test/testcommon/source/org/openoffice/test/common/GraphicsUtil.java - openoffice - Git at Google

 /**************************************************************
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you 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 org.openoffice.test.common;

 import java.awt.AWTException;
 import java.awt.Color;
 import java.awt.Graphics;
 import java.awt.Point;
 import java.awt.Rectangle;
 import java.awt.Robot;
 import java.awt.Toolkit;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;

 import javax.imageio.ImageIO;


 /**
  * Utilities related to graphics
  *
  */
 public class GraphicsUtil {
 	/**
 	 * Error tolerance for rectangle
 	 */
 	static final double ERR_RANGLE_RECTANGLE = 0.0;

 	/**
 	 * Error tolerance for ellipse
 	 */
 	static final double ERR_RANGLE_ELLIPSE = 1;

 	static Robot robot = null;

 	static {
 		try {
 			robot = new Robot();
 		} catch (AWTException e) {
 			e.printStackTrace();
 		}
 	}

 	/**
 	 * Load a image file as buffered image
 	 * @param file
 	 * @return
 	 */
 	public static BufferedImage loadImage(String file) {
 		BufferedImage image = null;
 		FileInputStream in = null;
 		try {
 			in = new FileInputStream(file);
 			image = ImageIO.read(in);
 		} catch (Exception e) {
 			e.printStackTrace();
 		} finally {
 			try {
 				if (in != null)
 					in.close();
 			} catch (IOException e) {
 				// ignore
 			}
 		}
 		return image;
 	}

 	/**
 	 * Store a buffered image in the given file
 	 *
 	 * @param image
 	 * @param imgFile
 	 */
 	public static void storeImage(BufferedImage image, String imgFile) {
 		File file = new File(imgFile);
 		if (!file.getParentFile().exists())
 			file.getParentFile().mkdirs();
 		FileOutputStream fos = null;
 		try {
 			fos = new FileOutputStream(file);
 			ImageIO.write(image, FileUtil.getFileExtName(imgFile), fos);
 		} catch (Exception e) {
 			//
 			e.printStackTrace();
 		} finally {
 			try {
 				if (fos != null)
 					fos.close();
 			} catch (IOException e) {
 				//ignore
 			}
 		}

 	}

 	public static Rectangle getScreenRectangle() {
 		return new Rectangle(Toolkit.getDefaultToolkit().getScreenSize());
 	}

 	/**
 	 * Get a BufferedImage including the full current screen shot
 	 * @return
 	 */
 	public static BufferedImage screenshot() {
 		return screenshot(null, null);
 	}

 	/**
 	 * Get a BufferedImage including the area of current screen shot
 	 * @param area
 	 * @return
 	 */
 	public static BufferedImage screenshot(Rectangle area) {
 		return screenshot(null, area);
 	}


 	/**
 	 *  Store the screen shot as a image file
 	 * @param filename
 	 */
 	public static BufferedImage screenShot(String filename) {
 		return screenshot(filename, null);
 	}

 	/**
 	 * Store the specified area of the screen as a image file
 	 * @param filename
 	 * @param area
 	 */
 	public static BufferedImage screenshot(String filename, Rectangle area) {
 		if (area == null)
 			area = getScreenRectangle();
 		BufferedImage capture = robot.createScreenCapture(area);
 		if (filename != null)
 			storeImage(capture, filename);
 		return capture;
 	}


 	/**
 	 * Find a rectangle in the screen.
 	 * Note: The rectangle must be filled with solid color and the color must be different from the background color
 	 *
 	 * @param rect the area in the screen to search
 	 * @param color the rectangle color.
 	 * @return The found rectangle's location and size. If no rectangle is
 	 *         found, return null
 	 */
 	public static Rectangle findRectangle(Rectangle rect, int color) {
 		return findRectangle(screenshot(rect), color);
 	}

 	/**
 	 * find a rectangle in an image
 	 * Note: The rectangle must be filled with solid color and the color must be different from the background color
 	 * @param src
 	 * @param color
 	 *            the rectangle color.
 	 * @return The found rectangle's location and size. If no rectangle is
 	 *         found, return null
 	 */
 	public static Rectangle findRectangle(BufferedImage src, int color) {
 		Rectangle re = new Rectangle();

 		BufferedImage dst = new BufferedImage(src.getWidth(), src.getHeight(),
 				BufferedImage.TYPE_INT_ARGB);

 		for (int x = 0; x < dst.getWidth(); x++) {
 			for (int y = 0; y < dst.getHeight(); y++) {
 				dst.setRGB(x, y, 0xFFFFFFFF);
 			}
 		}

 		Graphics g = dst.getGraphics();
 		g.setColor(Color.black);

 		int sx = -1, sy = 0, ex = 0, ey = 0;
 		for (int x = 0; x < src.getWidth(); x++) {
 			for (int y = 0; y < src.getHeight(); y++) {
 				int rgbSrc = src.getRGB(x, y);
 				if (rgbSrc == color) {
 					if (sx == -1) {
 						sx = x;
 						sy = y;
 					}
 					ex = x;
 					ey = y;
 				}
 			}
 		}

 		g.fillRect(sx, sy, ex - sx + 1, ey - sy + 1);
 		// g.fillRect(0, 0, dst.getWidth(), dst.getHeight());
 		int perimeter = 2 * (ex - sx + ey - sy);
 		int errMax = (int)(perimeter * ERR_RANGLE_RECTANGLE);

 		if (!(detect(src, color, dst, 0xff000000, errMax) && detect(dst, 0xff000000,
 				src, color, errMax)))
 			return null;
 		re.setBounds(sx, sy, ex - sx, ey - sy);
 		if (re.width < 2 || re.height < 2) {
 			return null;
 		}
 		return re;
 	}


 	protected static boolean detect(BufferedImage src, int colorSrc,
 			BufferedImage dst, int colorDst, double errMax) {
 		int errCount = 0;
 		for (int x = 0; x < src.getWidth(); x++) {
 			for (int y = 0; y < src.getHeight(); y++) {
 				int rgbSrc = src.getRGB(x, y);
 				if (rgbSrc == colorSrc) {
 					int rgbDst = dst.getRGB(x, y);
 					if (!(rgbDst == colorDst)) {
 						errCount++;
 					}
 				}
 			} // end for y
 		}// end for x
 		// System.out.println(errCount);
 		if (errCount <= errMax)
 			return true;
 		return false;
 	}


 	public static Rectangle getBoundingBox(BufferedImage image, int color) {
 		return getBoundingBox(image, color, true);
 	}

 	public static Rectangle getBoundingBox(BufferedImage image, int color, boolean include) {
 		int w = image.getWidth();
 		int h = image.getHeight();
 		int left=w, top=h, right = -1, bottom = -1;
 		for (int i = 0; i < w; i++) {
 			for (int j = 0; j < h; j++) {
 				if ((color == image.getRGB(i, j)) == include) {
 					if (j < top)
 						top = j;
 					if (j > bottom)
 						bottom = j;
 					if (i < left)
 						left = i;
 					if (i > right)
 						right = i;
 				}
 			}


 		}
 		if (right == -1)
 			return null;
 		return new Rectangle(left, top, right - left + 1, bottom - top + 1);
 	}

 	/**
 	 * Check if the rectangle in screen is filled with the given color
 	 *
 	 * @param color
 	 * @param rect
 	 * @return
 	 */
 	public static boolean isFilledWith(int color, Rectangle rect) {
 		BufferedImage capture = screenshot(rect);
 		int w = capture.getWidth();
 		int h = capture.getHeight();
 		for (int i = 0; i < w; i++) {
 			for (int j = 0; j < h; j++) {
 				if (color != capture.getRGB(i, j))
 					return false;
 			}
 		}

 		return true;
 	}

 	/**
 	 * Find a image on the current screen
 	 * @param image
 	 * @param rect
 	 * @return
 	 */
 	public static Point findImage(BufferedImage image, Rectangle rect) {
 		BufferedImage capture = screenshot(rect);
 		int w = capture.getWidth();
 		int h = capture.getHeight();
 		int iw = image.getWidth();
 		int ih = image.getHeight();

 		for (int i = 0; i < w; i++) {
 			out: for (int j = 0; j < h; j++) {
 				for (int m = 0; m < iw; m++) {
 					for (int n = 0; n < ih; n++) {
 						if (image.getRGB(m, n) != capture.getRGB(i + m, j + n))
 							continue out;
 					}
 				}
 				return new Point(i, j);
 			}
 		}

 		return null;
 	}

 	/**
 	 * Find a color on the current screen
 	 * @param color
 	 * @param rect
 	 * @return
 	 */
 	public static Point findColor(int color, Rectangle rect) {
 		BufferedImage capture = screenshot(rect);
 		int w = capture.getWidth();
 		int h = capture.getHeight();
 		for (int i = 0; i < w; i++) {
 			for (int j = 0; j < h; j++) {
 				if (color == capture.getRGB(i, j))
 					return new Point(i, j);
 			}
 		}
 		return null;
 	}


 	/**
 	 * Check if two BufferedImages equal
 	 *
 	 * @param expected
 	 * @param actual
 	 * @return
 	 */
 	public static boolean imageEquals(BufferedImage expected, BufferedImage actual) {
 		if (expected == null || actual == null)
 			return false;

 		if (expected.getHeight() != actual.getHeight() || expected.getWidth() != actual.getWidth())
 			return false;

 		for (int y = 0; y < expected.getHeight(); ++y) {
 			for (int x = 0; x < expected.getWidth(); ++x) {
 				if (expected.getRGB(x, y) != actual.getRGB(x, y))
 					return false;
 			}
 		}

 		return true;
 	}

 	/**
 	 * Check if two image files equal
 	 *
 	 * @param expectedImage
 	 * @param actualImage
 	 * @return
 	 */
 	public static boolean imageEquals(String expectedImage, String actualImage) {
 		BufferedImage expected = loadImage(expectedImage), actual = loadImage(actualImage);
 		return imageEquals(expected, actual);
 	}

 }
	/**************************************************************
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you 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 org.openoffice.test.common;

	import java.awt.AWTException;
	import java.awt.Color;
	import java.awt.Graphics;
	import java.awt.Point;
	import java.awt.Rectangle;
	import java.awt.Robot;
	import java.awt.Toolkit;
	import java.awt.image.BufferedImage;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileOutputStream;
	import java.io.IOException;

	import javax.imageio.ImageIO;


	/**
	* Utilities related to graphics
	*
	*/
	public class GraphicsUtil {
	/**
	* Error tolerance for rectangle
	*/
	static final double ERR_RANGLE_RECTANGLE = 0.0;

	/**
	* Error tolerance for ellipse
	*/
	static final double ERR_RANGLE_ELLIPSE = 1;

	static Robot robot = null;

	static {
	try {
	robot = new Robot();
	} catch (AWTException e) {
	e.printStackTrace();
	}
	}

	/**
	* Load a image file as buffered image
	* @param file
	* @return
	*/
	public static BufferedImage loadImage(String file) {
	BufferedImage image = null;
	FileInputStream in = null;
	try {
	in = new FileInputStream(file);
	image = ImageIO.read(in);
	} catch (Exception e) {
	e.printStackTrace();
	} finally {
	try {
	if (in != null)
	in.close();
	} catch (IOException e) {
	// ignore
	}
	}
	return image;
	}

	/**
	* Store a buffered image in the given file
	*
	* @param image
	* @param imgFile
	*/
	public static void storeImage(BufferedImage image, String imgFile) {
	File file = new File(imgFile);
	if (!file.getParentFile().exists())
	file.getParentFile().mkdirs();
	FileOutputStream fos = null;
	try {
	fos = new FileOutputStream(file);
	ImageIO.write(image, FileUtil.getFileExtName(imgFile), fos);
	} catch (Exception e) {
	//
	e.printStackTrace();
	} finally {
	try {
	if (fos != null)
	fos.close();
	} catch (IOException e) {
	//ignore
	}
	}

	}

	public static Rectangle getScreenRectangle() {
	return new Rectangle(Toolkit.getDefaultToolkit().getScreenSize());
	}

	/**
	* Get a BufferedImage including the full current screen shot
	* @return
	*/
	public static BufferedImage screenshot() {
	return screenshot(null, null);
	}

	/**
	* Get a BufferedImage including the area of current screen shot
	* @param area
	* @return
	*/
	public static BufferedImage screenshot(Rectangle area) {
	return screenshot(null, area);
	}


	/**
	* Store the screen shot as a image file
	* @param filename
	*/
	public static BufferedImage screenShot(String filename) {
	return screenshot(filename, null);
	}

	/**
	* Store the specified area of the screen as a image file
	* @param filename
	* @param area
	*/
	public static BufferedImage screenshot(String filename, Rectangle area) {
	if (area == null)
	area = getScreenRectangle();
	BufferedImage capture = robot.createScreenCapture(area);
	if (filename != null)
	storeImage(capture, filename);
	return capture;
	}


	/**
	* Find a rectangle in the screen.
	* Note: The rectangle must be filled with solid color and the color must be different from the background color
	*
	* @param rect the area in the screen to search
	* @param color the rectangle color.
	* @return The found rectangle's location and size. If no rectangle is
	* found, return null
	*/
	public static Rectangle findRectangle(Rectangle rect, int color) {
	return findRectangle(screenshot(rect), color);
	}

	/**
	* find a rectangle in an image
	* Note: The rectangle must be filled with solid color and the color must be different from the background color
	* @param src
	* @param color
	* the rectangle color.
	* @return The found rectangle's location and size. If no rectangle is
	* found, return null
	*/
	public static Rectangle findRectangle(BufferedImage src, int color) {
	Rectangle re = new Rectangle();

	BufferedImage dst = new BufferedImage(src.getWidth(), src.getHeight(),
	BufferedImage.TYPE_INT_ARGB);

	for (int x = 0; x < dst.getWidth(); x++) {
	for (int y = 0; y < dst.getHeight(); y++) {
	dst.setRGB(x, y, 0xFFFFFFFF);
	}
	}

	Graphics g = dst.getGraphics();
	g.setColor(Color.black);

	int sx = -1, sy = 0, ex = 0, ey = 0;
	for (int x = 0; x < src.getWidth(); x++) {
	for (int y = 0; y < src.getHeight(); y++) {
	int rgbSrc = src.getRGB(x, y);
	if (rgbSrc == color) {
	if (sx == -1) {
	sx = x;
	sy = y;
	}
	ex = x;
	ey = y;
	}
	}
	}

	g.fillRect(sx, sy, ex - sx + 1, ey - sy + 1);
	// g.fillRect(0, 0, dst.getWidth(), dst.getHeight());
	int perimeter = 2 * (ex - sx + ey - sy);
	int errMax = (int)(perimeter * ERR_RANGLE_RECTANGLE);

	if (!(detect(src, color, dst, 0xff000000, errMax) && detect(dst, 0xff000000,
	src, color, errMax)))
	return null;
	re.setBounds(sx, sy, ex - sx, ey - sy);
	if (re.width < 2 \|\| re.height < 2) {
	return null;
	}
	return re;
	}


	protected static boolean detect(BufferedImage src, int colorSrc,
	BufferedImage dst, int colorDst, double errMax) {
	int errCount = 0;
	for (int x = 0; x < src.getWidth(); x++) {
	for (int y = 0; y < src.getHeight(); y++) {
	int rgbSrc = src.getRGB(x, y);
	if (rgbSrc == colorSrc) {
	int rgbDst = dst.getRGB(x, y);
	if (!(rgbDst == colorDst)) {
	errCount++;
	}
	}
	} // end for y
	}// end for x
	// System.out.println(errCount);
	if (errCount <= errMax)
	return true;
	return false;
	}


	public static Rectangle getBoundingBox(BufferedImage image, int color) {
	return getBoundingBox(image, color, true);
	}

	public static Rectangle getBoundingBox(BufferedImage image, int color, boolean include) {
	int w = image.getWidth();
	int h = image.getHeight();
	int left=w, top=h, right = -1, bottom = -1;
	for (int i = 0; i < w; i++) {
	for (int j = 0; j < h; j++) {
	if ((color == image.getRGB(i, j)) == include) {
	if (j < top)
	top = j;
	if (j > bottom)
	bottom = j;
	if (i < left)
	left = i;
	if (i > right)
	right = i;
	}
	}


	}
	if (right == -1)
	return null;
	return new Rectangle(left, top, right - left + 1, bottom - top + 1);
	}

	/**
	* Check if the rectangle in screen is filled with the given color
	*
	* @param color
	* @param rect
	* @return
	*/
	public static boolean isFilledWith(int color, Rectangle rect) {
	BufferedImage capture = screenshot(rect);
	int w = capture.getWidth();
	int h = capture.getHeight();
	for (int i = 0; i < w; i++) {
	for (int j = 0; j < h; j++) {
	if (color != capture.getRGB(i, j))
	return false;
	}
	}

	return true;
	}

	/**
	* Find a image on the current screen
	* @param image
	* @param rect
	* @return
	*/
	public static Point findImage(BufferedImage image, Rectangle rect) {
	BufferedImage capture = screenshot(rect);
	int w = capture.getWidth();
	int h = capture.getHeight();
	int iw = image.getWidth();
	int ih = image.getHeight();

	for (int i = 0; i < w; i++) {
	out: for (int j = 0; j < h; j++) {
	for (int m = 0; m < iw; m++) {
	for (int n = 0; n < ih; n++) {
	if (image.getRGB(m, n) != capture.getRGB(i + m, j + n))
	continue out;
	}
	}
	return new Point(i, j);
	}
	}

	return null;
	}

	/**
	* Find a color on the current screen
	* @param color
	* @param rect
	* @return
	*/
	public static Point findColor(int color, Rectangle rect) {
	BufferedImage capture = screenshot(rect);
	int w = capture.getWidth();
	int h = capture.getHeight();
	for (int i = 0; i < w; i++) {
	for (int j = 0; j < h; j++) {
	if (color == capture.getRGB(i, j))
	return new Point(i, j);
	}
	}
	return null;
	}


	/**
	* Check if two BufferedImages equal
	*
	* @param expected
	* @param actual
	* @return
	*/
	public static boolean imageEquals(BufferedImage expected, BufferedImage actual) {
	if (expected == null \|\| actual == null)
	return false;

	if (expected.getHeight() != actual.getHeight() \|\| expected.getWidth() != actual.getWidth())
	return false;

	for (int y = 0; y < expected.getHeight(); ++y) {
	for (int x = 0; x < expected.getWidth(); ++x) {
	if (expected.getRGB(x, y) != actual.getRGB(x, y))
	return false;
	}
	}

	return true;
	}

	/**
	* Check if two image files equal
	*
	* @param expectedImage
	* @param actualImage
	* @return
	*/
	public static boolean imageEquals(String expectedImage, String actualImage) {
	BufferedImage expected = loadImage(expectedImage), actual = loadImage(actualImage);
	return imageEquals(expected, actual);
	}

	}