| /******************************************************************************* |
| * Copyright (c) 2009 University of Manchester and Others |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Eleni Michailidou - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.actf.examples.simplevisualizer.vicramtest; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.StringTokenizer; |
| |
| import org.eclipse.actf.model.dom.dombycom.IElementEx; |
| import org.eclipse.actf.model.dom.dombycom.INodeEx; |
| import org.eclipse.actf.model.dom.dombycom.IStyle; |
| import org.eclipse.actf.model.ui.IModelService; |
| import org.eclipse.actf.model.ui.util.ModelServiceUtils; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| |
| /* |
| * Visualization Algorithm |
| * Divides the page in x*y grids and the complexity for each grid is calculated |
| * Colours for each grid is assigned based on the complexity score of each grid and the VCS of the overall page |
| * This class uses the Complexity.java methods while identifying each grid variables |
| * |
| * One could change the number of: rows, columns, and the colour array list defined in the class |
| */ |
| public class Visualization { |
| |
| private static int[][] newOverlayPixels; |
| private static int webPageHeight, webPageWidth; |
| private static IModelService modelService; |
| private static int TLC, wordCount, images; |
| private static Element docLiveElement; |
| private static ArrayList[][] nodeGridArray; |
| public static int gridSize = 200; |
| public static int rows = 10; |
| public static int columns = 10; |
| private static GridVariables[][] gridVarArray; |
| private static int gridColumn; |
| private static int gridRow; |
| private static boolean isTLC, visibleBorder; |
| private static boolean findName; |
| private static boolean singlesChildren; |
| private static boolean headingTLC; |
| private static boolean isLayout; |
| private static Rectangle TLCRec; |
| private static double[][] gridVCSarray; |
| private static double gridVCS; |
| private static double visVCS; |
| private static String words; |
| private static int gridTLC; |
| private static boolean flag; |
| private static GridVariables[][] calcVCS; |
| private static int gridHeight; |
| private static int gridWidth; |
| public static String gridDescription; |
| |
| /* |
| * int[][] findElements() returns an int array with the new overlay pixels |
| * that the PartControlVisualizer uses to draw the overlay on top of the |
| * screenshot. |
| * This method: |
| * 1. Runs the Complexity.calculate() to get the overall VCS of the page |
| * |
| * 2. Resets variables used in the analysis |
| * |
| * 3. Determine the gridCellWidth and height in order to get coordinates of |
| * each grid based on the rows and columns count |
| * |
| * 4. Initialises Model and Document (based on LiveDom) and GridVariablesArray |
| * |
| * 5. Uses GridVariable.java to create Objects that stores the data for each grid |
| * based on the row and column location |
| */ |
| public static int[][] findElements(int[][] overlayPixels, |
| Rectangle imageSize, boolean flag) { |
| // will need some variables from the complexity algorithm so we run it first here |
| Complexity.calculate(); |
| newOverlayPixels = overlayPixels; |
| webPageHeight = imageSize.height; |
| webPageWidth = imageSize.width; |
| isTLC = false; |
| headingTLC = false; |
| singlesChildren = false; |
| visibleBorder = false; |
| gridTLC = 0; |
| gridVCS = 0; |
| visVCS = 0; |
| gridWidth = webPageWidth / columns; |
| gridHeight = webPageHeight / rows; |
| modelService = ModelServiceUtils.getActiveModelService(); |
| Document docLive = modelService.getLiveDocument(); |
| if (docLive != null) { |
| docLiveElement = docLive.getDocumentElement(); |
| gridVarArray = new GridVariables[rows][columns]; |
| gridVCSarray = new double[rows][columns]; |
| // and initialize arrays |
| for (int i = 0; i < rows; i++) { |
| for (int j = 0; j < columns; j++) { |
| gridVarArray[i][j] = new GridVariables(0, 0, 0); |
| } |
| } |
| Node node = docLiveElement.getElementsByTagName("body").item(0); |
| NodeList NodeChildren = node.getChildNodes(); |
| if (NodeChildren != null) { |
| int len = NodeChildren.getLength(); |
| for (int i = 0; i < len; i++) { |
| findTypeLoc(NodeChildren.item(i)); |
| findName = true; |
| singlesChildren = false; |
| isTLC = false; |
| headingTLC = false; |
| gridTLC = 0; |
| findTLCLoc(NodeChildren.item(i)); |
| } |
| } |
| } |
| String gridInfo = ""; |
| gridDescription = "----- Complexity Visualization View -----" |
| + "\nColour range: Red - Orange - Yellow - YellowGreen - Green - DarkGreen\n " |
| + "\nThe more to the red colour, the more visually complex the grid is." |
| + " The colours depend on the overall visual complexity of the page. " |
| + "The grids with the highest complexity score reflect the overall page's VCS; " |
| + "the more to the red the more visually complex the page is.\n" |
| + "\n ----- Grid Description: -----\n"; |
| for (int i = 0; i < rows; i++) { |
| for (int j = 0; j < columns; j++) { |
| // sets the row and column in the gridVarArray |
| gridVarArray[i][j].setRow(i); |
| gridVarArray[i][j].setCol(j); |
| gridInfo = "Grid (row-column): " + i + "-" + j + " | Images: " |
| + gridVarArray[i][j].images + " | TLC: " |
| + gridVarArray[i][j].TLC + " | Word Count: " |
| + gridVarArray[i][j].wordCount + " | VCS = " |
| + gridVarArray[i][j].getGridVCS(); |
| gridDescription += "\n" + gridInfo; |
| } |
| } |
| determineColour(); |
| // create the grid lines |
| drawGridLines(); |
| return newOverlayPixels; |
| } |
| |
| /* |
| * findTypeLoc(node) - finds the type of the node and the location of the |
| * interested elements then it assigns the element by incrementing the |
| * appropriate counter in the appropriate grid |
| */ |
| public static void findTypeLoc(Node node) { |
| if (node == null) |
| return; |
| int type = node.getNodeType(); |
| if (type == Node.DOCUMENT_NODE) { |
| findTypeLoc(((Document) node).getDocumentElement()); |
| } |
| if (type == Node.ELEMENT_NODE) { |
| // checks and counts the type of element |
| String nodeName = node.getNodeName(); |
| if (nodeName.equalsIgnoreCase("img")) { |
| // find location of the image and assign to correct object and |
| // array position (grid array) |
| Rectangle imageRec = findGrid(node); |
| if (imageRec != null) { |
| if (imageRec.x >= 0 |
| && imageRec.y >= 0 |
| && (imageRec.x <= webPageWidth && imageRec.y <= webPageHeight)) { |
| if ((imageRec.height > gridHeight || imageRec.width > gridWidth)) { |
| // place and increament |
| gridVarArray[gridRow][gridColumn].images++; |
| } |
| } |
| } |
| }// ends node img |
| |
| // recurse to find the rest of the counters |
| NodeList children = node.getChildNodes(); |
| if (children != null) { |
| int len = children.getLength(); |
| for (int i = 0; i < len; i++) { |
| findTypeLoc(children.item(i)); |
| } |
| } |
| }// ends if (type == Node.ELEMENT_NODE) |
| // Get the word count |
| |
| if (type == Node.TEXT_NODE) { |
| // where the word count begins -need to get the number of rows and |
| // columns that the text node spans for (see below) |
| |
| String strWord = node.getNodeValue(); |
| int words = 0; |
| if (strWord != null) { |
| StringTokenizer total = new StringTokenizer(strWord, |
| "'?!@#$&*/-,:.<>()~;=_|"); |
| while (total.hasMoreTokens() == true) { |
| StringTokenizer token = new StringTokenizer(total |
| .nextToken()); |
| words += token.countTokens(); |
| if (words > 0) { |
| Rectangle textNodeRec = findGrid(node); |
| // System.out.println(textNodeRec); |
| if (textNodeRec != null) { |
| int spanCol = 0; |
| int spanRow = 0; |
| double wordsPerGrid = 0; |
| boolean spanWords = false; |
| // find the range of the words span: columns: |
| // words/width of rectangle, rows: words/height of rectangle |
| // need to check that the x and yth coordinate of the rectangle falls within the webpage height and width |
| if (textNodeRec.x >= 0 |
| && textNodeRec.y >= 0 |
| && (textNodeRec.x <= webPageWidth && textNodeRec.y <= webPageHeight)) { |
| if ((textNodeRec.height > gridHeight || textNodeRec.width > gridWidth) |
| && words > 1) { |
| spanWords = true; |
| spanCol = textNodeRec.width / gridWidth; |
| spanRow = textNodeRec.height / gridHeight; |
| int spanCol2 = spanCol; |
| int spanRow2 = spanRow; |
| if (spanCol == 0) |
| spanCol2 = 1; |
| if (spanRow == 0) |
| spanRow2 = 1; |
| if (words > 1) |
| wordsPerGrid = ((double) words / ((double) spanCol2 * (double) spanRow2)); |
| else if (words > 0 && words <= 1) |
| wordsPerGrid = words; |
| } |
| if (spanWords == true) { |
| int maxCol = gridColumn + spanCol; |
| int maxRow = gridRow + spanRow; |
| if (maxCol >= columns) |
| maxCol = columns - 1; |
| if (maxRow >= rows) |
| maxRow = rows - 1; |
| if (spanRow == 0) { |
| for (int j = gridColumn; j <= maxCol; j++) { |
| gridVarArray[gridRow][j].wordCount += wordsPerGrid; |
| } |
| } |
| if (spanCol == 0) { |
| for (int i = gridRow; i <= maxRow; i++) { |
| gridVarArray[i][gridColumn].wordCount += wordsPerGrid; |
| } |
| } else if (spanCol > 0 && spanRow > 0) { |
| for (int i = gridRow; i <= maxRow; i++) { |
| for (int j = gridColumn; j <= maxCol; j++) { |
| gridVarArray[i][j].wordCount += wordsPerGrid; |
| } |
| } |
| } |
| }// ends if span = true |
| else { |
| gridVarArray[gridRow][gridColumn].wordCount += words; |
| } |
| } |
| }// end if rec not null |
| }// ends if words>0 |
| }// ends while loop |
| } |
| }// ends if (type == Node.TEXT_NODE) |
| } |
| |
| /* |
| * Rectangle findGrid(node) - returns the rectangle that the node's top left |
| * point fits within in this method is used to find the row and column of |
| * the grid |
| */ |
| public static Rectangle findGrid(Node node) { |
| |
| gridColumn = 0; |
| gridRow = 0; |
| Rectangle nodeRectangle = null; |
| if (node instanceof IElementEx) { |
| nodeRectangle = ((IElementEx) node).getLocation(); |
| // if width or height are zero = return null |
| if (nodeRectangle.height == 0 || nodeRectangle.width == 0 |
| || nodeRectangle.x < 0 || nodeRectangle.x > webPageWidth |
| || nodeRectangle.y < 0 || nodeRectangle.y > webPageHeight) { |
| nodeRectangle = null; |
| } |
| |
| // need to check the x and y point and respectively assign to the |
| // appropriate grid's list |
| |
| else { |
| if (nodeRectangle.x < 1 && nodeRectangle.x >= 0 |
| && nodeRectangle.y > 0) { |
| gridColumn = 0; |
| gridRow = (nodeRectangle.y) / gridHeight; |
| } else if (nodeRectangle.y < 1 && nodeRectangle.y >= 0 |
| && nodeRectangle.x > 0) { |
| gridRow = 0; |
| gridColumn = (nodeRectangle.x) / gridWidth; |
| } else { |
| gridRow = (nodeRectangle.y) / gridHeight; |
| gridColumn = (nodeRectangle.x) / gridWidth; |
| } |
| } |
| }// ends if node an element |
| else if (node instanceof INodeEx) { |
| // for text nodes |
| /* |
| * Should calculate the word count 2. Find the width of the node and |
| * calculate the span range 3. by calculating the wordCount/ |
| */ |
| nodeRectangle = ((INodeEx) node).getLocation(); |
| if (nodeRectangle.height == 0 || nodeRectangle.width == 0 |
| || nodeRectangle.x < 0 || nodeRectangle.x > webPageWidth |
| || nodeRectangle.y < 0 || nodeRectangle.y > webPageHeight) { |
| nodeRectangle = null; |
| } |
| // need to check the x and y point and respectively assign to the |
| // appropriate grid's list |
| else { |
| if (nodeRectangle.x < 1 && nodeRectangle.x >= 0 |
| && nodeRectangle.y > 0) { |
| gridColumn = 0; |
| gridRow = (nodeRectangle.y) / gridHeight; |
| } else if (nodeRectangle.y < 1 && nodeRectangle.y >= 0 |
| && nodeRectangle.x > 0) { |
| gridRow = 0; |
| gridColumn = (nodeRectangle.x) / gridWidth; |
| } else { |
| gridRow = (nodeRectangle.y) / gridHeight; |
| gridColumn = (nodeRectangle.x) / gridWidth; |
| } |
| } |
| }// ends if node a TEXT_node |
| // need to check that the assign gridRow and gridColumn does not exceed |
| // the gridVarArray size |
| if (gridRow >= rows) |
| gridRow = rows - 1; |
| if (gridColumn >= columns) |
| gridColumn = columns - 1; |
| return nodeRectangle; |
| } |
| |
| /* |
| * findTLCLoc(node) This method mirrors the countTLC() method from |
| * Complexity.java. The addition is that we determine the grid location that |
| * the TLC belongs into FOR DESCRIPTION ON ALGORITHM SEE COMMENTS ON |
| * COMPLEXITY.JAVA' REPSECTIVE METHOD |
| */ |
| public static void findTLCLoc(Node node) { |
| |
| String display = null; |
| String borderWidth = null; |
| if (node == null) |
| return; |
| int type = node.getNodeType(); |
| if (type == Node.DOCUMENT_NODE) { |
| findTLCLoc(((Document) node).getDocumentElement()); |
| } |
| if (type == Node.ELEMENT_NODE) { |
| if (node instanceof IElementEx) { |
| IStyle style = ((IElementEx) node).getStyle(); |
| display = (String) style.get("display"); |
| borderWidth = (String) style.get("borderWidth"); |
| if (node.getNodeName().equalsIgnoreCase("div")) { |
| int borderLen = borderWidth.length(); |
| boolean isPx = borderWidth.contains("px"); |
| int px = 0; |
| if (isPx == true) { |
| StringTokenizer borderToken = new StringTokenizer( |
| borderWidth, " "); |
| String pixels = ""; |
| String borderPx = ""; |
| while (borderToken.hasMoreTokens() == true) { |
| String token = borderToken.nextToken(); |
| if (token.contains("px") == true) { |
| int tokenLength = token.length(); |
| borderPx = token.substring(0, tokenLength - 2); |
| } |
| } |
| px = Integer.parseInt(borderPx); |
| if (px > 0) { |
| visibleBorder = true; |
| } else |
| visibleBorder = false; |
| } |
| } |
| } |
| if (display == null) { |
| display = ""; |
| } |
| NodeList children = node.getChildNodes(); |
| int len = 0; |
| for (int i = 0; i < children.getLength(); i++) { |
| Node child = children.item(i); |
| int childType = child.getNodeType(); |
| if (childType == 1) |
| len++; |
| } |
| boolean blockChild = false; |
| boolean lastIsImg = false; |
| String nodeName = node.getNodeName(); |
| if (len == 1) { |
| for (int i = 0; i < children.getLength(); i++) { |
| Node child = children.item(i); |
| if (child.getNodeName().equalsIgnoreCase("img")) { |
| lastIsImg = true; |
| } |
| } |
| } |
| if (findName == true) { |
| if (children != null) { |
| Node childNode = children.item(0); |
| singlesChildren = Complexity.singleChildren(node, len); |
| for (int i = 0; i < len; i++) { |
| childNode = children.item(i); |
| NodeList childNodeList = childNode.getChildNodes(); |
| int length = childNodeList.getLength(); |
| singlesChildren = Complexity.singleChildren(node, len); |
| if (childNode instanceof IElementEx) { |
| IStyle childStyle = ((IElementEx) childNode) |
| .getStyle(); |
| String displayChild = (String) childStyle |
| .get("display"); |
| if (displayChild.equalsIgnoreCase("block") |
| || display.equalsIgnoreCase("table")) |
| blockChild = true; |
| } |
| }// end for-loop |
| }// end if not null children |
| if (display.equalsIgnoreCase("block") && blockChild == false) { |
| TLCRec = findGrid(node); |
| if (TLCRec != null) { |
| gridVarArray[gridRow][gridColumn].TLC++; |
| } |
| isTLC = true; |
| } |
| else if (singlesChildren == true && isTLC == false) { |
| TLCRec = findGrid(node); |
| if (TLCRec != null) { |
| gridVarArray[gridRow][gridColumn].TLC++; |
| } |
| isTLC = true; |
| } |
| findName = false; |
| } |
| else if (nodeName.equalsIgnoreCase("div")) { |
| if (visibleBorder == true) { |
| TLCRec = findGrid(node); |
| if (TLCRec != null) { |
| // place and increament |
| gridVarArray[gridRow][gridColumn].TLC++; |
| } |
| isTLC = true; |
| } |
| } |
| else if (display.equalsIgnoreCase("block") |
| || display.equalsIgnoreCase("table") |
| || display.startsWith("table")) { |
| if (nodeName.equalsIgnoreCase("div")) { |
| if (visibleBorder == true && isLayout == false) { |
| TLCRec = findGrid(node); |
| if (TLCRec != null) { |
| // place and increment |
| gridVarArray[gridRow][gridColumn].TLC++; |
| } |
| isTLC = true; |
| } |
| } |
| else if (nodeName.equalsIgnoreCase("h1") |
| || nodeName.equalsIgnoreCase("h2")) { |
| TLCRec = findGrid(node); |
| if (TLCRec != null) { |
| // place and increment |
| gridVarArray[gridRow][gridColumn].TLC++; |
| } |
| isTLC = true; |
| headingTLC = true; |
| }// ends if case 2 (if nodeName equals h1 or h2) |
| |
| else if (headingTLC == false && nodeName.equalsIgnoreCase("h3")) { |
| TLCRec = findGrid(node); |
| if (TLCRec != null) { |
| // place and increment |
| gridVarArray[gridRow][gridColumn].TLC++; |
| } |
| isTLC = true; |
| } |
| else if (headingTLC == false && nodeName.equalsIgnoreCase("h4")) { |
| TLCRec = findGrid(node); |
| if (TLCRec != null) { |
| // place and increment |
| gridVarArray[gridRow][gridColumn].TLC++; |
| } |
| isTLC = true; |
| } |
| else if (nodeName.equalsIgnoreCase("table") |
| || display.contains("table")) { |
| boolean dataTable = false; |
| boolean blockChilNodes = false; |
| NodeList tchildren = node.getChildNodes(); |
| if (tchildren != null) { |
| len = tchildren.getLength(); |
| for (int i = 0; i < len; i++) { |
| String tchildName = tchildren.item(i).getNodeName(); |
| if (tchildName.equalsIgnoreCase("thead") |
| || tchildName.equalsIgnoreCase("caption")) { |
| dataTable = true; |
| } |
| if (tchildren.item(i) instanceof IElementEx) { |
| IStyle childStyle = ((IElementEx) tchildren |
| .item(i)).getStyle(); |
| String displayChild = (String) childStyle |
| .get("display"); |
| if (displayChild.equalsIgnoreCase("block") |
| || display.equalsIgnoreCase("table")) |
| blockChilNodes = true; |
| } |
| }// ends for-loop |
| } |
| if (isTLC == false && dataTable == true) { |
| TLCRec = findGrid(node); |
| if (TLCRec != null) { |
| // place and increament |
| gridVarArray[gridRow][gridColumn].TLC++; |
| } |
| isTLC = true; |
| } |
| else if (dataTable == false) { |
| isLayout = Complexity.tableCellLayout(node); |
| if (isLayout == true) { |
| if (isTLC == false) { |
| TLCRec = findGrid(node); |
| if (TLCRec != null) { |
| // place and increament |
| gridVarArray[gridRow][gridColumn].TLC++; |
| } |
| isTLC = true; |
| } |
| }// ends if isLayout=true |
| else if (isLayout == false && blockChilNodes == true) { |
| // count if there are block level child nodes |
| TLCRec = findGrid(node); |
| if (TLCRec != null) { |
| // place and increament |
| gridVarArray[gridRow][gridColumn].TLC++; |
| } |
| isTLC = true; |
| } else if (nodeName.equalsIgnoreCase("div")) { |
| TLCRec = findGrid(node); |
| if (TLCRec != null) { |
| // place and increament |
| gridVarArray[gridRow][gridColumn].TLC++; |
| } |
| isTLC = true; |
| } |
| }// ends if dataTable=false |
| }// ends else-if table |
| }// ends else-if block |
| NodeList NodeChildren = node.getChildNodes(); |
| if (NodeChildren != null) { |
| len = NodeChildren.getLength(); |
| for (int i = 0; i < len; i++) { |
| visibleBorder = false; |
| findTLCLoc(NodeChildren.item(i)); |
| } |
| } |
| }// end if element node |
| }// ends findTLCLoc |
| |
| /* |
| * determineColour this method identifies the colour that each grid will be |
| * assigned with |
| * |
| * the colour depends on the ratio of gridVCS/complexity.VCS |
| * |
| * first we need to know the colour assigned overall based on the complexity.VCS: |
| * 0-3.5 Simple yellow |
| * |
| * 3.5 - 6.5 Medium green |
| * |
| * 6.5 - 10 Complex red |
| * |
| * then sort the gridVCSarray based on ascending order. The 5 grids with the highest score |
| * are assigned with the page's complexity VCS colour then the rest based on |
| * the colour scale |
| */ |
| public static void determineColour() { |
| // get complexity score of the whole page |
| double compVCS = Complexity.VCS; |
| String complexity = ""; |
| int startColour = 0xC0C0C0; |
| // determine page's complexity level array and starting colour |
| // colours: http://www.webmonkey.com/reference/Color_Charts |
| // colours array:red/orange/gold/yellow/yellowgreen/lime/green/darkgreen |
| // //{0xFF0000, 0xFFA500,0xFFD700,0xFFFF00,0x9ACD32,0x00FF00,0x008000, |
| // 0x006400}; |
| // darkgreen = the minScoreColour |
| int[] colours = { 0x3D1AED, 0x4CB7FF, 0x00D4FF, 0x00ff77, 0x00C000 }; |
| int minScoreColour = 0x006400;// for scores <=0.1743 |
| int colourLen = colours.length; |
| // if the length is even or odd |
| boolean colourLenEven = false; |
| if (colourLen % 2 == 0) |
| colourLenEven = true; |
| int pageColour = -1; |
| // assign initial colour of page based on its overall VCS complexity |
| if (compVCS < 3) { |
| complexity = "simple"; |
| if (colourLenEven) |
| pageColour = ((colourLen / 3) * 2) - 1; |
| else |
| pageColour = ((colourLen / 3) * 2); |
| startColour = colours[pageColour]; |
| } else if (compVCS >= 3 && compVCS < 6) { |
| complexity = "medium"; |
| if (colourLenEven) |
| pageColour = (colourLen / 3) - 1; |
| else |
| pageColour = (colourLen / 3); |
| startColour = colours[pageColour]; |
| } else if (compVCS >= 6) { |
| complexity = "complex"; |
| pageColour = 0;// always the first index |
| startColour = colours[pageColour]; |
| } |
| |
| double[][] sortVCSarray = new double[rows][columns]; |
| |
| // Create a single array now that is the size of the doubel array |
| GridVariables[] sortVCS = new GridVariables[rows * columns]; |
| // now populate by going through the double array and extracting the |
| // Data |
| // HERE we can find the number of grids that have the minimum value of |
| // VCS (<=0.1743) which |
| // will help later for the calculation of gridsPerColour. The dark green |
| // is only assigned to those |
| int counter = 0; |
| int minScore = 0; |
| for (int i = 0; i < rows; i++) { |
| for (int j = 0; j < columns; j++) { |
| sortVCS[counter] = gridVarArray[i][j]; |
| counter++; |
| if (gridVarArray[i][j].getGridVCS() <= 0.1743) |
| minScore++; |
| } |
| } |
| // sort the array - based on the sort method extended in |
| // GridVariables.java |
| Arrays.sort(sortVCS); |
| /* |
| * The following code decides the color for each grid based on the colorIndex of the page and the number of grids the colorIndex is |
| * calculated based on the VCS score of the page and is the starting color of the page then the number of grids per color depends on the |
| * location of the colorIndex on the colourArray colors[] |
| * numGridsPerColor = (numGrids/(color.length - ColorIndex - 1)) |
| */ |
| int numGrids = rows * columns; |
| int coloursBasedScore = colourLen - pageColour; |
| int gridsPerColour = (numGrids - minScore) / coloursBasedScore; |
| int counter2 = 0; |
| int counterMaxIndex = 0;// this can go up to 3 inclusive |
| int gridColour = pageColour; |
| // System.out.println(colourLen+"gridsPerColour= "+ gridsPerColour + |
| // ", coloursBasedScore = "+ coloursBasedScore+ ", page colour="+ |
| // pageColour); |
| for (int j = 0; j < sortVCS.length; j++) { |
| if (sortVCS[j].getGridVCS() <= 0.1743) { |
| // System.out.println("in <=0.1743"); |
| gridColour = minScoreColour; |
| colour(sortVCS[j].row, sortVCS[j].column, minScoreColour); |
| } else { |
| // System.out.println("in else"); |
| if (counter2 == gridsPerColour) { |
| counter2 = 0; |
| gridColour++; |
| } |
| if (gridColour == colourLen) { |
| gridColour = colourLen - 1;// the max colour |
| } |
| colour(sortVCS[j].row, sortVCS[j].column, colours[gridColour]); |
| } |
| counter2++; |
| } |
| } |
| |
| /* |
| * Colours the nodes based on the coordinates and colour |
| */ |
| public static void colour(int gRow, int gCol, int colour) { |
| // |
| // get the row and column of the grid |
| // gridRow |
| // colour = 0x00D4FF; |
| int x1 = gCol * gridWidth; |
| int y1 = gRow * gridHeight; |
| int x2 = gridWidth + x1; |
| int y2 = gridHeight + y1; |
| // System.out.println("Coordinates: x1 - "+ x1+ ", y1 - "+y1+",x2 - " + x2+", y2 - "+y2); |
| for (int b = y1; b < (y2); b++) { |
| for (int a = x1; a < (x2); a++) { |
| if (flag) { |
| newOverlayPixels[a][b] = colour; |
| } else { |
| newOverlayPixels[b][a] = colour; |
| } |
| } |
| } |
| } |
| /* |
| * drawGridLines() draws lines around the grids to easily differentiate |
| * between rectangles/grids |
| */ |
| public static void drawGridLines() { |
| // horizontal lines |
| int x1 = 0; |
| int x2 = webPageWidth; |
| int y1 = 0; |
| int y2 = webPageHeight; |
| for (int b = y1; b < rows; b++) { |
| for (int a = x1; a < (x2); a++) { |
| if (flag) { |
| newOverlayPixels[a][b * gridHeight] = 0x000000; |
| } else { |
| newOverlayPixels[b * gridHeight][a] = 0x000000; |
| } |
| } |
| } |
| // vertical lines |
| x2 = 0; |
| // b-Y, a - X |
| for (int b = y1; b < y2; b++) { |
| for (int a = x1; a < columns; a++) { |
| if (flag) { |
| newOverlayPixels[a * gridWidth][b] = 0x000000; |
| } else { |
| newOverlayPixels[b][a * gridWidth] = 0x000000; |
| } |
| } |
| } |
| } |
| } |
