--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/javauis/eswt_qt/eswtuitestutils/javasrc/com/nokia/mj/impl/uitestutils/ImageTestUtils.java Fri Jun 11 13:33:44 2010 +0300
@@ -0,0 +1,639 @@
+package com.nokia.mj.impl.uitestutils;
+
+import org.eclipse.swt.internal.qt.graphics.Image;
+import java.util.Arrays;
+
+/**
+ * Image utils for verifying image pixels against mask
+ * plus some other helpers for verifying image properties.
+ *
+ * NOTE. Currently only CGFX images are supported however eSWT images
+ * can be verified by using org.eclipse.swt.internal.qt.graphics.Image internal_getImage()
+ * to obtain wrapped CGFX image.
+ *
+ * Usage example
+ *
+ * create a mask from mask data and then mask by giving data and scanlenght.
+ * <code>
+ * int[] maskData = {
+ * 0,0,0,0,0,0,0,0,0,
+ * 0,0,0,0,1,0,0,0,0,
+ * 0,0,0,0,1,0,0,0,0,
+ * 0,0,0,0,1,0,0,0,0,
+ * 0,0,0,0,1,0,0,0,0,
+ * 0,0,0,0,1,0,0,0,0,
+ * 0,0,0,0,1,0,0,0,0,
+ * 0,0,0,0,0,0,0,0,0
+ * };
+ *
+ * Mask mask = new Mask(maskData, 9);
+ * </code>
+ *
+ * Then image pixels can be validated with ImageTestUtils. That is where there is 1 in mask it is
+ * compared against maskArgb and all where there is 0 in mask it is compared against bgArgb.
+ * <code>
+ * ImageTestUtils.validatePixels(imageToValidate, mask, maskArgb, bgArgb);
+ * </code>
+ *
+ * @author sampkaar
+ *
+ */
+public class ImageTestUtils {
+
+ /**
+ * This pixel is rendering target image background color.
+ */
+ public static final int IMAGE_BACKGROUND_COLOR = 0;
+
+ /**
+ * This pixel is foreground color set to GC.
+ */
+ public static final int GC_FOREGROUND_COLOR = 1;
+
+ /**
+ * This pixel is either foreground or image background color.
+ * Used for example in drawRoundRect and drawEllipse tests.
+ */
+ public static final int FOREGROUND_OR_IMAGE_BACKGROUND_COLOR = 2;
+
+ /**
+ * This pixel is background color set to GC.
+ * Used for example in fillGradientRect test.
+ */
+ public static final int GC_BACKGROUND_COLOR = 3;
+
+ /**
+ * This pixel is neither foreground nor gc background color.
+ * Used for example in fillGradientRect test.
+ */
+ public static final int NEITHER_FOREGROUND_NOR_GC_BACKGROUND_COLOR = 4;
+
+ /**
+ * This pixel can be ignored.
+ * Used for example in fillGradientRect test.
+ */
+ public static final int IGNORE_COLOR = 5;
+
+ /**
+ * Validates image dimensions against reference width and height.
+ * Prints possible problems to System.out.
+ *
+ * @param img - The image to check
+ * @param refWidth - The reference width
+ * @param refHeight - The reference height
+ */
+ public static final boolean validateImageDimensions(Image img, int refWidth, int refHeight) {
+ if ((refWidth != img.getWidth()) || (refHeight != img.getHeight())) {
+ System.out.println("Image size should be ("+refWidth+","+refHeight+"), "+
+ "but is ("+img.getWidth()+","+img.getHeight()+")");
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Validates image pixels which are outside specified rectangle ingoreRect against given reference color.
+ *
+ * @param ignoreRect The area that is to be ingnored
+ * @param img Image to validate
+ * @param argb The reference color
+ * @return true if all pixels outside ingoreRect have reference color orherwise false
+ */
+ public static final boolean validatePixels(Rect ignoreRect, Image img, int argb) {
+ final int width = img.getWidth();
+ final int height = img.getHeight();
+ final int pixels = width * height;
+ final int scanlength = img.getWidth();
+
+ // data array for image data
+ int[] imageData = new int[pixels];
+
+ // get data for whole image
+ img.getRGB(imageData, 0, width, 0, 0, width, height);
+
+ // calculate start index
+ int start = scanlength*ignoreRect.y();
+ for(int y = 0; y<ignoreRect.height();y++) {
+ Arrays.fill(imageData, start+ignoreRect.x(), start+ignoreRect.width()+ignoreRect.x(), argb);
+ // move start to next line
+ start += scanlength;
+ }
+
+ // validate array
+ for(int i=0; i < pixels; i++) {
+ if(!(imageData[i] == argb)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Validates that there is at least one pixel with foreground color inside the specified rectangle
+ * and that image pixels which are outside specified rectangle has background color.
+ *
+ * @param rect The area that is to be checked
+ * @param img Image to validate
+ * @param fgColor The color that must exist inside the rect
+ * @param bgColor The color which must be outside the rect
+ * @return true if all pixels outside rect have background color and at least one pixel inside the rect has foreground color
+ * orherwise false
+ */
+ public static final boolean validatePixels(Rect rect, Image img, int fgColor, int bgColor) {
+ final int width = img.getWidth();
+ final int height = img.getHeight();
+ final int pixels = width * height;
+ final int scanlength = img.getWidth();
+ boolean foundFgColor = false;
+
+ // data array for image data
+ int[] imageData = new int[pixels];
+
+ // get data for whole image
+ img.getRGB(imageData, 0, width, 0, 0, width, height);
+
+ Rect imageRect = new Rect(0,0,width, height);
+ rect = rect.intersection(imageRect);
+
+ // Check that foreground color was found inside the rect
+ foundFgColor = isAtleastOnePixelWithRefColor(img, rect, fgColor);
+ if(!foundFgColor){
+ return false;
+ }
+
+ int start = scanlength*rect.y();
+ // Fill the rect with background color
+ for(int y = 0; y<rect.height();y++) {
+ Arrays.fill(imageData, start+rect.x(), start+rect.width()+rect.x(), bgColor);
+ // move start to next line
+ start += scanlength;
+ }
+
+ // validate array, now all pixels should have background color
+ for(int i=0; i < pixels; i++) {
+ if(!(imageData[i] == bgColor)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Validates that there is at least one pixel with foreground color inside the specified rectangle
+ * and that image pixels which are outside specified rectangle has background color.
+ *
+ * @param rect The area that is to be checked
+ * @param img Image to validate
+ * @param fgColor The color that must exist inside the rect
+ * @param textRectColor The background color of the rect
+ * @param bgColor The color which must be outside the rect
+ * @param textRectColorOn true if textRectColor must exist inside the rect, false if textRectColor shouldn't be found inside the rect
+ * @return true if all pixels outside rect have background color and at least one pixel inside the rect has foreground color
+ * orherwise false
+ */
+ public static final boolean validatePixels(Rect rect, Image img, int fgColor, int textRectColor, int bgColor, boolean textRectColorOn) {
+
+ if(textRectColorOn){
+ // Check that text background color was found inside the rect
+ if(!isAtleastOnePixelWithRefColor(img, rect, textRectColor)){
+ return false;
+ }
+ } else {
+ // Check that text background color is not found inside the rect
+ if(isAtleastOnePixelWithRefColor(img, rect, textRectColor)){
+ return false;
+ }
+ }
+
+ return validatePixels(rect, img, fgColor, bgColor);
+ }
+
+ /**
+ * Validates that there is at least one pixel with foreground color inside the specified rectangles
+ * and that image pixels which are outside specified rectangles has background color.
+ *
+ * @param rects The areas that is to be checked
+ * @param img Image to validate
+ * @param fgColor The color that must exist inside the rects
+ * @param bgColor The color which must be outside the rects
+ * @return true if all pixels outside rects have background color and at least one pixel inside the rects has foreground color
+ * orherwise false
+ */
+ public static final boolean validatePixels(Rect[] rects, Image img, int fgColor, int bgColor) {
+ final int width = img.getWidth();
+ final int height = img.getHeight();
+ final int pixels = width * height;
+ final int scanlength = img.getWidth();
+ boolean foundFgColor = false;
+ final int rectCount = rects.length;
+
+ Rect imageRect = new Rect(0,0,width, height);
+ // Check that foreground color is found inside each rect
+ for(int i=0; i<rectCount; i++){
+ rects[i] = rects[i].intersection(imageRect);
+ foundFgColor = isAtleastOnePixelWithRefColor(img, rects[i], fgColor);
+ if(!foundFgColor){
+ return false;
+ }
+ }
+
+ // Check that background color is found outside the rects
+
+ // data array for image data
+ int[] imageData = new int[pixels];
+ // get data for whole image
+ img.getRGB(imageData, 0, width, 0, 0, width, height);
+
+ int start;
+ // Fill the rects with background color
+ for(int i=0; i<rectCount; i++){
+ start = scanlength*rects[i].y();
+ for(int y = 0; y<rects[i].height();y++) {
+ Arrays.fill(imageData, start+rects[i].x(), start+rects[i].width()+rects[i].x(), bgColor);
+ // move start to next line
+ start += scanlength;
+ }
+ }
+
+ // validate array, now all pixels should have background color
+ for(int i=0; i < pixels; i++) {
+ if(!(imageData[i] == bgColor)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Checks is there at least one pixel with reference color inside the specified rectangle in Image.
+ *
+ * @param rect The area that is to be checked
+ * @param refColor The color that must exist inside the rect
+ * @return true if at least one pixel inside the rect has reference color orherwise false
+ */
+ public static final boolean isAtleastOnePixelWithRefColor(Image img, Rect rect, int refColor) {
+
+ final int width = img.getWidth();
+ final int height = img.getHeight();
+ final int pixels = width * height;
+ final int scanlength = img.getWidth();
+
+ // data array for image data
+ int[] imageData = new int[pixels];
+
+ // get data for whole image
+ img.getRGB(imageData, 0, width, 0, 0, width, height);
+
+ // calculate start index
+ int start = scanlength*rect.y();
+
+ // Check that is at least one pixel has foreground color inside the rect
+ for(int y = 0; y<rect.height();y++) {
+ for(int i=start+rect.x(); i < start+rect.width()+rect.x(); i++) {
+ if((imageData[i] == refColor)) {
+ return true;
+ }
+ }
+ // move start to next line
+ start += scanlength;
+ }
+ return false;
+ }
+
+ /**
+ * Validates that every pixel in given image has
+ * given referense color value argb.
+ *
+ * @param img - The image to check
+ * @param argb - The referece color to compare
+ */
+ public static final boolean validatePixels(Image img, int argb) {
+
+ final int width = img.getWidth();
+ final int height = img.getHeight();
+ final int pixels = width * height;
+
+ // get color components from reference
+ final int refAlpha = (argb >> 24) & 0xff;
+ final int refRed = (argb >> 16) & 0xff;
+ final int refGreen = (argb >> 8) & 0xff;
+ final int refBlue = (argb) & 0xff;
+
+ // data array for image data
+ int[] imageData = new int[pixels];
+
+ // get data for whole image
+ img.getRGB(imageData, 0, width, 0, 0, width, height);
+
+ // check each pixel in image, break if pixel does not match
+ for(int i=0; i < pixels; i++) {
+ if (refAlpha != ((imageData[i] >> 24) & 0xff)) return false;
+ if (refRed != ((imageData[i] >> 16) & 0xff)) return false;
+ if (refGreen != ((imageData[i] >> 8 ) & 0xff)) return false;
+ if (refBlue != ( imageData[i] & 0xff)) return false;
+ }
+ return true;
+ }
+
+ /**
+ * Validates that given pixels are equal to
+ * reference pixel color (argb) and background color in given rgb data
+ *
+ * @param rgbdata - The image data to be checked
+ * @param mask - the reference mask
+ * @param maskArgb - The reference color for pixels with value 1 in mask
+ * @param bgArgb - The reference color for pixels with value 0 in mask
+ *
+ */
+ public static final boolean validatePixels(int[] rgbdata, Mask mask, int maskArgb, int bgArgb) {
+ return doCheckPixels(rgbdata, mask, maskArgb, bgArgb, 0, false);
+ }
+
+ /**
+ * Validates that given pixels are equal to
+ * reference pixel color (argb) and background color in given rgb data
+ *
+ * @param rgbdata - The image data to be checked
+ * @param dataOffset The offset from beginning of rgbdata where image data starts
+ * @param dataLength The lenght of image data after offset
+ * @param mask - the reference mask
+ * @param maskArgb - The reference color for pixels with value 1 in mask
+ * @param bgArgb - The reference color for pixels with value 0 in mask
+ *
+ */
+ public static final boolean validatePixels(int[] rgbdata, int dataOffset, int dataLength, Mask mask, int maskArgb, int bgArgb) {
+
+ // create array for data
+ int[] data = new int[dataLength];
+
+ // copy from rgbdata to data
+ for(int i=dataOffset; i < rgbdata.length; i++) {
+ data[i-dataOffset] = rgbdata[i];
+ }
+
+ //System.out.println("\n mask size: " + mask.getData().length+", dataSize: " + rgbdata.length);
+ return doCheckPixels(data, mask, maskArgb, bgArgb, 0, false);
+ }
+
+ /**
+ * Validates that given pixels are equal to
+ * reference pixel color (argb) and background color in image
+ *
+ * @param img - The image to check
+ * @param mask - the reference mask
+ * @param maskArgb - The reference color for pixels with value 1 in mask
+ * @param bgArgb - The reference color for pixels with value 0 in mask
+ *
+ */
+ public static final boolean validatePixels(Image img, Mask mask, int maskArgb, int bgArgb) {
+
+ // data array for image data
+ int[] imageData = new int[img.getWidth()*img.getHeight()];
+
+ // get data for whole image
+ img.getRGB(imageData, 0, img.getWidth(), 0, 0, img.getWidth(), img.getHeight());
+
+ // check pixels
+ return doCheckPixels(imageData, mask, maskArgb, bgArgb, 0, false);
+ }
+
+ /**
+ * Validates that given pixels are equal to
+ * reference pixel color (argb) and background color in image
+ *
+ * @param img - The image to check
+ * @param mask - the reference mask
+ * @param maskArgb - The reference color for pixels with value 1 in mask
+ * @param bgArgb - The reference color for pixels with value 0 in mask
+ * @param ingoreAlpha If true alpha value is not validated
+ * @return true if mask and image match otherwise false
+ */
+ public static final boolean validatePixels(Image img, Mask mask, int maskArgb, int bgArgb, boolean ignoreAlpha) {
+
+ // data array for image data
+ int[] imageData = new int[img.getWidth()*img.getHeight()];
+
+ // get data for whole image
+ img.getRGB(imageData, 0, img.getWidth(), 0, 0, img.getWidth(), img.getHeight());
+
+ // check pixels
+ return doCheckPixels(imageData, mask, maskArgb, bgArgb, 0, ignoreAlpha);
+ }
+
+ /**
+ * Validates that given pixels are equal to
+ * foreground color (argb), image background color and gc background color in image
+ *
+ * @param img - The image to check
+ * @param mask - the reference mask
+ * @param fgArgb - The reference color for pixels with value 1 GC_FOREGROUND_COLOR in mask
+ * @param gcBgArgb - The reference color for pixels with value 3 GC_BACKGROUND_COLOR in mask
+ * @param imgBgArgb - The reference color for pixels with value 0 IMAGE_BACKGROUND_COLOR in mask
+ * @param ingoreAlpha If true alpha value is not validated
+ * @return true if mask and image match otherwise false
+ */
+ public static final boolean validatePixels(Image img, Mask mask, int fgArgb, int gcBgArgb, int imgBgArgb, boolean ignoreAlpha) {
+
+ // data array for image data
+ int[] imageData = new int[img.getWidth()*img.getHeight()];
+
+ // get data for whole image
+ img.getRGB(imageData, 0, img.getWidth(), 0, 0, img.getWidth(), img.getHeight());
+
+ // check pixels
+ return doCheckPixels(imageData, mask, fgArgb, imgBgArgb, gcBgArgb, ignoreAlpha);
+ }
+
+ /*
+ * method for checking pixels against mask
+ * The imageData and the data in mask must be same size.
+ */
+ private static final boolean doCheckPixels(int[] imageData, Mask mask, int fgColorArgb, int imgBgColorArgb, int gcBgColorArgb, boolean ignoreAlpha ) {
+
+ // get color components for GC foreground color
+ final int fgAlpha = (fgColorArgb >> 24) & 0xff;
+ final int fgRed = (fgColorArgb >> 16) & 0xff;
+ final int fgGreen = (fgColorArgb >> 8) & 0xff;
+ final int fgBlue = (fgColorArgb) & 0xff;
+
+ // get color components for image background color
+ final int imgBgAlpha = (imgBgColorArgb >> 24) & 0xff;
+ final int imgBgRed = (imgBgColorArgb >> 16) & 0xff;
+ final int imgBgGreen = (imgBgColorArgb >> 8) & 0xff;
+ final int imgBgBlue = (imgBgColorArgb) & 0xff;
+
+ // get color components for GC background color
+ int gcBgAlpha = 0;
+ int gcBgRed = 0;
+ int gcBgGreen = 0;
+ int gcBgBlue = 0;
+ if (gcBgColorArgb != 0){ // GC Background color is defined
+ gcBgAlpha = (gcBgColorArgb >> 24) & 0xff;
+ gcBgRed = (gcBgColorArgb >> 16) & 0xff;
+ gcBgGreen = (gcBgColorArgb >> 8) & 0xff;
+ gcBgBlue = (gcBgColorArgb) & 0xff;
+ }
+
+ // get mask data
+ int[] maskdata = mask.getData();
+
+ // verify background & pixels
+ for(int i=0; i < imageData.length; i++) {
+
+ // if mask pixel is GC_FOREGROUND_COLOR (1), check against fgArgb
+ if(maskdata[i] == GC_FOREGROUND_COLOR) {
+ if (!ignoreAlpha) {
+ if (fgAlpha != ((imageData[i] >> 24) & 0xff)) return false;
+ }
+ if (fgRed != ((imageData[i] >> 16) & 0xff)) return false;
+ if (fgGreen != ((imageData[i] >> 8 ) & 0xff)) return false;
+ if (fgBlue != ( imageData[i] & 0xff)) return false;
+ }
+ // if mask pixel is FOREGROUND_OR_IMAGE_BACKGROUND_COLOR (2), this pixel is either
+ // foreground or image background color.
+ // Used for example in drawRoundRect and drawEllipse tests.
+ else if(maskdata[i] == FOREGROUND_OR_IMAGE_BACKGROUND_COLOR) {
+ if (!ignoreAlpha) {
+ if (fgAlpha != ((imageData[i] >> 24) & 0xff) &&
+ imgBgAlpha != ((imageData[i] >> 24) & 0xff)) return false;
+ }
+ if (fgRed != ((imageData[i] >> 16) & 0xff) &&
+ imgBgRed != ((imageData[i] >> 16) & 0xff)) return false;
+
+ if (fgGreen != ((imageData[i] >> 8 ) & 0xff) &&
+ imgBgGreen != ((imageData[i] >> 8 ) & 0xff)) return false;
+
+ if (fgBlue != ( imageData[i] & 0xff) &&
+ imgBgBlue != ( imageData[i] & 0xff)) return false;
+ }
+ // if mask pixel is GC_BACKGROUND_COLOR (3), this pixel is background color set to GC.
+ // Used for example in fillGradientRect test.
+ else if(maskdata[i] == GC_BACKGROUND_COLOR) {
+ if (!ignoreAlpha) {
+ if (gcBgAlpha != ((imageData[i] >> 24) & 0xff)) return false;
+ }
+ if (gcBgRed != ((imageData[i] >> 16) & 0xff)) return false;
+ if (gcBgGreen != ((imageData[i] >> 8 ) & 0xff)) return false;
+ if (gcBgBlue != ( imageData[i] & 0xff)) return false;
+ }
+ // if mask pixel is NEITHER_FOREGROUND_NOR_GC_BACKGROUND_COLOR (4), this pixel is neither
+ // foreground nor gc background color.
+ // Used for example in fillGradientRect test.
+ else if(maskdata[i] == NEITHER_FOREGROUND_NOR_GC_BACKGROUND_COLOR) {
+ if (!ignoreAlpha) {
+ if (fgAlpha != gcBgAlpha){
+ if (fgAlpha == ((imageData[i] >> 24) & 0xff) ||
+ gcBgAlpha == ((imageData[i] >> 24) & 0xff)) return false;
+ }
+ }
+
+ if (fgRed != gcBgRed){
+ if (fgRed == ((imageData[i] >> 16) & 0xff) ||
+ gcBgRed == ((imageData[i] >> 16) & 0xff)) return false;
+ }
+ if (fgGreen != gcBgGreen){
+ if (fgGreen == ((imageData[i] >> 8 ) & 0xff) ||
+ gcBgGreen == ((imageData[i] >> 8 ) & 0xff)) return false;
+ }
+ if (fgBlue != gcBgBlue){
+ if (fgBlue == ( imageData[i] & 0xff) ||
+ gcBgBlue == ( imageData[i] & 0xff)) return false;
+ }
+ }
+ else if(maskdata[i] == IGNORE_COLOR) {
+ // skip the pixel
+ }
+ // if mask pixel is IMAGE_BACKGROUND_COLOR (1), check against imgBg
+ else if(maskdata[i] == IMAGE_BACKGROUND_COLOR) {
+ if (!ignoreAlpha) {
+ if (imgBgAlpha != ((imageData[i] >> 24) & 0xff)) return false;
+ }
+ if (imgBgRed != ((imageData[i] >> 16) & 0xff)) return false;
+ if (imgBgGreen != ((imageData[i] >> 8 ) & 0xff)) return false;
+ if (imgBgBlue != ( imageData[i] & 0xff)) return false;
+ }
+ // If mask pixel is something else that's error
+ else {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * prints black & white image to console.
+ * black is printed as 1 and white as 0.
+ */
+ public static final void print(Image img) {
+
+ final int width = img.getWidth();
+ final int height = img.getHeight();
+ final int pixels = img.getWidth() * img.getHeight();
+
+ // data array for image data
+ int[] imageData = new int[pixels];
+
+ // get data for whole image
+ img.getRGB(imageData, 0, width, 0, 0, width, height);
+
+ String output = "Image("+img.getWidth()+","+img.getHeight()+"):\n";
+ int y = 0;
+ for(int i = 0; i < imageData.length; i++) {
+
+ int a = ((imageData[i] >> 24) & 0xff);
+ int r = ((imageData[i] >> 16) & 0xff);
+ int b = ((imageData[i] >> 8 ) & 0xff);
+ int g = ( imageData[i] & 0xff);
+
+ if (a == 255 && r == 0 && g == 0 && b == 0) {
+ output += "1,";
+ } else if (a == 255 && r == 255 && g == 255 && b == 255) {
+ output += "0,";
+ }
+ else {
+ output += "("+a+","+r+","+b+","+g+")";
+ }
+
+ if(i==((y*width) + (width-1))) {
+ output += "\n";
+ y++;
+ }
+ }
+ System.out.println(output);
+ }
+
+ public static final void print(int[] array, int scanlength) {
+ final int width = scanlength;
+ String output = "";
+
+ int y = 0;
+ for(int i = 0; i < array.length; i++) {
+
+ int a = ((array[i] >> 24) & 0xff);
+ int r = ((array[i] >> 16) & 0xff);
+ int b = ((array[i] >> 8 ) & 0xff);
+ int g = ( array[i] & 0xff);
+
+ if (a == 255 && r == 0 && g == 0 && b == 0) {
+ output += "1,";
+ } else if (a == 255 && r == 255 && g == 255 && b == 255) {
+ output += "0,";
+ }
+ else {
+ output += "x,";
+ }
+
+ if(i==((y*width) + (width-1))) {
+ output += "\n";
+ y++;
+ }
+ }
+ System.out.println(output);
+ }
+
+ private int getIndexForPoint(int scanlength, int x, int y) {
+ return y*scanlength+x;
+ }
+
+
+}