/*******************************************************************************
 * Copyright (c) 2003, 2008 IBM Corporation 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:
 *    Junji MAEDA - initial API and implementation
 *******************************************************************************/
package org.eclipse.actf.visualization.engines.lowvision.image;

import java.awt.image.BufferedImage;
import java.io.PrintWriter;
import java.util.Vector;

import org.eclipse.actf.model.ui.editor.ImagePositionInfo;
import org.eclipse.actf.visualization.engines.lowvision.LowVisionCommon;
import org.eclipse.actf.visualization.engines.lowvision.LowVisionType;
import org.eclipse.actf.visualization.engines.lowvision.character.CandidateCharacter;
import org.eclipse.actf.visualization.engines.lowvision.character.CandidateUnderlinedCharacter;
import org.eclipse.actf.visualization.engines.lowvision.character.CharacterMS;
import org.eclipse.actf.visualization.engines.lowvision.character.CharacterSM;
import org.eclipse.actf.visualization.engines.lowvision.character.CharacterSS;
import org.eclipse.actf.visualization.engines.lowvision.checker.CharacterChecker;
import org.eclipse.actf.visualization.engines.lowvision.internal.util.DebugUtil;
import org.eclipse.actf.visualization.engines.lowvision.io.ImageReader;
import org.eclipse.actf.visualization.engines.lowvision.io.LowVisionIOException;
import org.eclipse.actf.visualization.engines.lowvision.problem.LowVisionProblemException;
import org.eclipse.actf.visualization.engines.lowvision.problem.LowVisionProblemGroup;
import org.eclipse.actf.visualization.engines.lowvision.util.DecisionMaker;

/*
 * Rednered image of Web page
 * 
 */
public class PageImage implements LowVisionCommon {
	private static final boolean DO_CHECK_CHARACTERS = false;

	private static final boolean DO_CHECK_IMAGES = true;

	// private static final boolean DO_CHAR_TEST = false;

	Int2D pixel = null;

	int numContainers; // containers.length;

	Container[] containers;

	int numNonContainedCharacters; // nonContainedCharacters.length

	CharacterSM[] nonContainedCharacters; // SM Char

	boolean extractedFlag = false; //

	ImagePositionInfo[] imagePositions = null;

	boolean useImagePositions = false;

	InteriorImage[] interiorImageArray = null;

	int currentContainerID = 1;

	int[][] containerMap = null;

	// for debug (TBD move back into extractCharacters())
	Vector<Container> containerVector = new Vector<Container>();

	Vector<CandidateCharacter> candidateCharacterVector = new Vector<CandidateCharacter>();

	Vector<CandidateUnderlinedCharacter> candidateUnderlinedCharacterVector = new Vector<CandidateUnderlinedCharacter>();

	PrintWriter writer = null;

	public PageImage() {
	}

	public PageImage(Int2D _i2d) {
		this(_i2d, true);
	}

	public PageImage(Int2D _i2d, boolean _removeScrollBar) {
		Int2D i2d = null;
		if (_removeScrollBar) {
			if (LowVisionCommon.REMOVE_SURROUNDINGS) {
				try {
					i2d = _i2d.cutMargin(LowVisionCommon.SURROUNDINGS_WIDTH);
				} catch (ImageException ie) {
					// ie.printStackTrace();
					i2d = _i2d;
				}
			} else {
				i2d = _i2d;
			}
			if (LowVisionCommon.REMOVE_SCROLL_BAR_AT_RIGHT) {
				Int2D tmpI2d = new Int2D(i2d.width
						- LowVisionCommon.SCROLL_BAR_WIDTH, i2d.height);
				for (int j = 0; j < tmpI2d.height; j++) {
					for (int i = 0; i < tmpI2d.width; i++) {
						tmpI2d.data[j][i] = i2d.data[j][i];
					}
				}
				i2d = tmpI2d;
			}
			if (LowVisionCommon.REMOVE_SCROLL_BAR_AT_BOTTOM) {
				Int2D tmpI2d = new Int2D(i2d.width, i2d.height
						- LowVisionCommon.SCROLL_BAR_WIDTH);
				for (int j = 0; j < tmpI2d.height; j++) {
					for (int i = 0; i < tmpI2d.width; i++) {
						tmpI2d.data[j][i] = i2d.data[j][i];
					}
				}
				i2d = tmpI2d;
			}
		} else {
			i2d = _i2d;
		}

		pixel = i2d.deepCopy();
		i2d = null;
	}

	public void init(BufferedImage _bi) throws ImageException {
		pixel = ImageUtil.bufferedImageToInt2D(_bi);
	}

	// for debug
	public static PageImage readFromFile(String _fileName)
			throws LowVisionIOException {
		BufferedImage bi = ImageReader.readBufferedImage(_fileName);
		// PageImage pi = new PageImage( bi );
		Int2D i2d = new Int2D(bi);
		PageImage pi = new PageImage(i2d);
		return (pi);
	}

	public int getWidth() {
		return (pixel.width);
	}

	public int getHeight() {
		return (pixel.height);
	}

	public int[][] getPixelData() {
		return (pixel.data);
	}

	public BufferedImage getBufferedImage() {
		return (ImageUtil.int2DToBufferedImage(pixel));
	}

	public Int2D getInt2D() {
		return (pixel);
	}

	public void disposeInt2D() {
		pixel = new Int2D(0, 0);
	}

	public int getNumContainers() {
		return (numContainers);
	}

	public Container[] getContainers() {
		return (containers);
	}

	public int getNumSMCharacters() {
		return (numNonContainedCharacters);
	}

	public CharacterSM[] getSMCharacters() {
		return (nonContainedCharacters);
	}

	public int getNumNonContainedCharacters() {
		return numNonContainedCharacters;
	}

	public CharacterSM[] getNonContainedCharacters() {
		return nonContainedCharacters;
	}

	public void setWriter(PrintWriter _pw) {
		writer = _pw;
	}

	public ImagePositionInfo[] getInteriorImagePosition() {
		return (imagePositions);
	}

	public void setInteriorImagePosition(ImagePositionInfo[] infoArray) {
		if (infoArray != null) {
			imagePositions = infoArray;
		}
	}

	public boolean isInteriorImageArraySet() {
		if (interiorImageArray == null || interiorImageArray.length == 0) {
			return (false);
		} else {
			return (true);
		}
	}

	/*
	 * Estimate character/image positions in the PageImage.
	 */
	public void extractCharacters() throws ImageException {
		if (DO_CHECK_CHARACTERS) {
			extractAllCharacters();
		}

		if (DO_CHECK_IMAGES && imagePositions != null
				&& imagePositions.length > 0) {
			useImagePositions = true;

			// for memory (create InteriorImages for each time (degrade
			// performance))

			// extractInteriorImages();
		}
	}

	/*
	 * Extract all images in the page by using position info from DOM.
	 * 
	 */
	private void extractInteriorImages() {
		if (imagePositions == null)
			return;
		int numImages = imagePositions.length;
		Vector<InteriorImage> imageVector = new Vector<InteriorImage>();

		if (LowVisionCommon.REMOVE_SURROUNDINGS) {
			for (int k = 0; k < numImages; k++) {
				ImagePositionInfo pos = imagePositions[k];
				pos.setX(pos.getX() - LowVisionCommon.SURROUNDINGS_WIDTH);
				if (pos.getX() < 0) {
					pos.setX(0);
				}
				pos.setY(pos.getY() - LowVisionCommon.SURROUNDINGS_WIDTH);
				if (pos.getY() < 0) {
					pos.setY(0);
				}
			}
		}

		for (int k = 0; k < numImages; k++) {
			ImagePositionInfo curPos = imagePositions[k];

			// InteriorImagePosition contains all image info in the Web page.
			// However, PageImage only contains a part of Web page in the case
			// of partial image dump. So, select images within the dumped image.
			if (!isFullyContained(curPos)) {
				continue;
			}

			InteriorImage curIm = new InteriorImage(this, curPos);
			imageVector.addElement(curIm);
		}
		int size = imageVector.size();
		if (size > 0) {
			interiorImageArray = new InteriorImage[size];
			for (int k = 0; k < size; k++) {
				interiorImageArray[k] = (InteriorImage) (imageVector
						.elementAt(k));
			}
		}
	}

	private boolean isFullyContained(ImagePositionInfo _pos) {
		if (_pos.getX() + _pos.getWidth() > this.getWidth()) {
			return (false);
		}
		if (_pos.getY() + _pos.getHeight() > this.getHeight()) {
			return (false);
		}
		return (true);
	}

	private void extractAllCharacters() throws ImageException {
		if (extractedFlag) {
			return;
		}

		// TODO more improvement

		int numProcessedColors = 0;

		containerMap = new int[pixel.height][pixel.width];

		ColorHistogram histogram = ColorHistogram.makeColorHistogram(pixel);

		/*
		 * (1) estimate content type (container, char, etc.) from image by using
		 * connected components (each major color)
		 */
		int len = histogram.getSize();
		numProcessedColors = len;
		ColorHistogramBin[] histoArray = histogram.getSortedArrayByOccurrence();
		for (int i = 0; i < len; i++) {
			if (histoArray[i].occurrence < THRESHOLD_MIN_OCCURRENCES) {
				numProcessedColors = i;
				break;
			}
		}

		for (int i = 0; i < numProcessedColors; i++) {
			int curColor = histoArray[i].color;
			BinaryImage binaryByColor = new BinaryImage(pixel,
					BinaryImage.METHOD_SPECIFY_FOREGROUND, curColor);

			// connected components
			LabeledImage curLabeledImage = new LabeledImage(binaryByColor,
					LabeledImage.METHOD_8_CONNECTIVITY);

			int numComponents = curLabeledImage.numComponents;
			ConnectedComponent[] components = curLabeledImage.components;

			for (int j = 0; j < numComponents; j++) {
				ConnectedComponent cc = components[j];

				short type = DecisionMaker.judgeComponentType(cc, this, true);

				if (type == PageComponent.CONTAINER_TYPE) {
					Container tmpContainer = new Container(this,
							currentContainerID, cc, curColor);
					containerVector.addElement(tmpContainer);
					paintContainerMap(currentContainerID, cc);
					currentContainerID++;
				} else if (type == PageComponent.CANDIDATE_CHARACTER_TYPE) {
					CandidateCharacter tmpC = new CandidateCharacter(this, cc,
							curColor);
					candidateCharacterVector.addElement(tmpC);
				} else if (type == PageComponent.CANDIDATE_UNDERLINED_CHARACTER_TYPE) {
					CandidateUnderlinedCharacter tmpU = new CandidateUnderlinedCharacter(
							this, cc, curColor);
					candidateUnderlinedCharacterVector.addElement(tmpU);
				} else if (type == PageComponent.OTHER_TYPE) {
					;
				} else {
					throw new ImageException("Unexpected type = " + type);
				}
			}
		}

		// end (1)

		// mark out containerMap
		fillContainerMap(currentContainerID);

		/*
		 * (2) Assign CharacterCandidates to Container
		 */
		int numCandChar = candidateCharacterVector.size();
		for (int k = numCandChar - 1; k >= 0; k--) {
			CandidateCharacter cChar = (CandidateCharacter) (candidateCharacterVector
					.elementAt(k));
			int w = cChar.cc.shape.width;
			int i = 0;
			for (; i < w; i++) {
				if (cChar.cc.shape.data[0][i] != 0) {
					break;
				}
			}
			int id = containerMap[cChar.cc.top][cChar.cc.left + i];
			if (id > 0) {// id of Container starts from 1

				Container parentCont = containerVector.elementAt(id - 1);
				cChar.setContainer(parentCont);
				parentCont.candidateCharacterVector.addElement(cChar);
				candidateCharacterVector.removeElementAt(k);
			} // (id = 0) = does not belong to Container (= SM Char)
		}
		int numCandUnderChar = candidateUnderlinedCharacterVector.size();
		for (int k = numCandUnderChar - 1; k >= 0; k--) {
			CandidateUnderlinedCharacter cuChar = candidateUnderlinedCharacterVector
					.elementAt(k);
			int w = cuChar.cc.shape.width;
			int i = 0;
			for (; i < w; i++) {
				if (cuChar.cc.shape.data[0][i] != 0) {
					break;
				}
			}
			int id = containerMap[cuChar.cc.top][cuChar.cc.left + i];
			if (id > 0) {// id of Container starts from 1
				Container parentCont = containerVector.elementAt(id - 1);
				cuChar.setContainer(parentCont);
				parentCont.candidateUnderlinedCharacterVector
						.addElement(cuChar);
				candidateUnderlinedCharacterVector.removeElementAt(k);
			}// (id = 0) = does not belong to Container (= SM Char)
		}

		/*
		 * Other character candidates (do not belong to Container)
		 */
		Vector tmpSMCharacterVector = makeSMCharacterVector(
				candidateCharacterVector, candidateUnderlinedCharacterVector);
		this.candidateCharacterVector.removeAllElements();
		this.candidateUnderlinedCharacterVector.removeAllElements();
		int tmpTmpSMVecSize = tmpSMCharacterVector.size();
		for (int k = tmpTmpSMVecSize - 1; k >= 0; k--) {
			CharacterSM tmpSM = (CharacterSM) (tmpSMCharacterVector
					.elementAt(k));
			if (!(DecisionMaker.isSMCharacter(tmpSM))) {
				tmpSMCharacterVector.removeElementAt(k);
			}
		}
		this.numNonContainedCharacters = tmpSMCharacterVector.size();
		this.nonContainedCharacters = new CharacterSM[numNonContainedCharacters];
		for (int k = 0; k < numNonContainedCharacters; k++) {
			nonContainedCharacters[k] = (CharacterSM) (tmpSMCharacterVector
					.elementAt(k));
		}
		tmpSMCharacterVector.removeAllElements();
		tmpSMCharacterVector = null;

		/*
		 * (3) Container
		 */
		int numContainer = containerVector.size();
		for (int k = 0; k < numContainer; k++) {
			Container curCont = containerVector.elementAt(k);
			int contW = curCont.cc.shape.width;
			int contH = curCont.cc.shape.height;
			int contX = curCont.cc.left;
			int contY = curCont.cc.top;
			int contColor = curCont.getColor();
			BinaryImage contBin = new BinaryImage(contW, contH);

			// Container (filled hole)
			BinaryImage filledContBin = new BinaryImage(contW, contH);

			// HashMap contMap = new HashMap();
			// HashMap nonContMap = new HashMap();
			// Object dummy = new Object();
			for (int j = 0; j < contH; j++) {
				for (int i = 0; i < contW; i++) {
					int curPixel = pixel.data[j + contY][i + contX];
					// distinguishable from container color?
					try {
						if (curPixel == contColor) {// same
							contBin.data[j][i] = 1;
						}
						/*
						 * //TODO recover this? else{ Integer curInt = new
						 * Integer( curPixel ); if( contMap.get(curInt) != null ){ //
						 * similar contBin.data[j][i] = 1; continue; } if(
						 * nonContMap.get(curInt) != null ){ // differ continue; }
						 * //first time if(DecisionMaker.distinguishableColors(
						 * curPixel, contColor ) ){ // differ nonContMap.put(
						 * curInt, dummy ); } else{ // similar
						 * 
						 * contBin.data[j][i] = 1; contMap.put( curInt, dummy ); } }
						 */
					} catch (Exception e) {
						// e.printStackTrace();
						throw new ImageException(
								"An error occurred while making contBin.");
					}

					if (containerMap[j + contY][i + contX] == k + 1) {
						filledContBin.data[j][i] = 1;
					}
				}
			}
			BinaryImage fgBin = BinaryImage.subtract(filledContBin, contBin);

			// Find connected component
			LabeledImage curLabImg = new LabeledImage(fgBin,
					LabeledImage.METHOD_8_CONNECTIVITY);
			int numComponents = curLabImg.numComponents;
			if (numComponents == 0) {
				continue;
			}
			ConnectedComponent[] components = curLabImg.components;

			for (int l = numComponents - 1; l >= 0; l--) {
				ConnectedComponent cc2 = components[l];
				// convert to relative coordinates (Page)
				cc2.setLeft(cc2.getLeft() + contX);
				cc2.setTop(cc2.getTop() + contY);
				if (collateCandidates(curCont, cc2)) {
					// SS Char (or with underline)
					continue;
					// nothing to do here (already done in collateCandidates)
				} else if (DecisionMaker.isMSCharacter(cc2)) {
					int fg = -1;
					if ((fg = getForegroundColor(cc2)) == -1) {
						CharacterMS msc = new CharacterMS(this, cc2, curCont,
								pixel);
						curCont.msCharacterVector.addElement(msc);
					} else {
						/*
						 * to handle character written by using minor color in
						 * histogram
						 */
						short ssType = DecisionMaker.judgeComponentType(cc2,
								this);
						if (ssType == PageComponent.CANDIDATE_CHARACTER_TYPE) {
							CharacterSS ssc = new CharacterSS(this, cc2,
									curCont, fg);
							curCont.ssCharacterVector.addElement(ssc);
						} else if (ssType == PageComponent.CANDIDATE_UNDERLINED_CHARACTER_TYPE) {
							CandidateUnderlinedCharacter cuc = new CandidateUnderlinedCharacter(
									this, cc2, fg);
							cuc.setContainer(curCont);
							Vector sscVec = removeUnderlineAndGenerateSS(cuc);
							for (int m = 0; m < sscVec.size(); m++) {
								curCont.ssCharacterVector
										.addElement((CharacterSS) (sscVec
												.elementAt(m)));
							}
							sscVec.removeAllElements();
						}
					}
				}
			}

			// remaining candidates -> SM Character
			// TODO check more
			Vector tmpVec = makeSMCharacterVector(
					curCont.candidateCharacterVector,
					curCont.candidateUnderlinedCharacterVector);
			curCont.candidateCharacterVector.removeAllElements();
			curCont.candidateUnderlinedCharacterVector.removeAllElements();
			int tmpVecSize = tmpVec.size();
			for (int l = tmpVecSize - 1; l >= 0; l--) {
				CharacterSM smc = (CharacterSM) (tmpVec.elementAt(l));
				if (smc.getForegroundColor() == curCont.getColor()) {
					// remove elements (same color with Container)
					// (e.g., hole of 'A','R' etc.)
					tmpVec.removeElementAt(l);
				} else if (includingMSCharacter(smc, curCont) != null) {
					// remove elements contained in MS Char (*)
					tmpVec.removeElementAt(l);
				} else {
					// check SS Character which has similar fg/bg color
					// ((1)->OK but (3)->NG)
					if (getBackgroundColor(smc.cc) > -1) {
						CharacterSS ssc = new CharacterSS(this, smc.cc,
								smc.container, smc.getForegroundColor());
						curCont.ssCharacterVector.addElement(ssc);
						tmpVec.removeElementAt(l);
					}
				}
			}

			/*
			 * Check very small MS Char. Need to do it after (*)
			 */
			int msVecSize = curCont.msCharacterVector.size();
			for (int l = msVecSize - 1; l >= 0; l--) {
				CharacterMS curMS = (CharacterMS) (curCont.msCharacterVector
						.elementAt(l));
				if (DecisionMaker.isTooSmallThinedMSCharacter(curMS)) {
					curCont.msCharacterVector.removeElementAt(l);
				}
			}

			curCont.ssVector2Array(); // ssCharacterVector->ssCharacters

			curCont.msVector2Array(); // msCharacterVector->msCharacters

			int tmptmpVecSize = tmpVec.size();
			for (int l = tmptmpVecSize - 1; l >= 0; l--) {
				CharacterSM tmpSM = (CharacterSM) (tmpVec.elementAt(l));
				if (!(DecisionMaker.isSMCharacter(tmpSM))) {
					tmpVec.removeElementAt(l);
				}
			}

			curCont.numSMCharacters = tmpVec.size();
			curCont.smCharacters = new CharacterSM[curCont.numSMCharacters];
			for (int l = 0; l < curCont.numSMCharacters; l++) {
				curCont.smCharacters[l] = (CharacterSM) (tmpVec.elementAt(l));
			}
			tmpVec.removeAllElements();
			tmpVec = null;
		}
		// end (3)

		// remove Containers without Character
		for (int k = numContainer - 1; k >= 0; k--) {
			Container curCont = containerVector.elementAt(k);
			if (curCont.numSSCharacters == 0 && curCont.numMSCharacters == 0
					&& curCont.numSMCharacters == 0) {
				containerVector.removeElementAt(k);
			}
		}
		numContainers = containerVector.size();
		containers = new Container[numContainers];
		for (int k = 0; k < numContainers; k++) {
			containers[k] = containerVector.elementAt(k);
		}
		containerVector.removeAllElements();

		extractedFlag = true;

	}

	// paint Container into ContainerMap
	private void paintContainerMap(int _id, ConnectedComponent _cc) {
		int w = _cc.shape.width;
		int h = _cc.shape.height;
		for (int j = 0; j < h; j++) {
			for (int i = 0; i < w; i++) {
				if (_cc.shape.data[j][i] != 0) {
					containerMap[_cc.top + j][_cc.left + i] = _id;
				}
			}
		}
	}

	/*
	 * fill hole of ContainerMap
	 */
	private void fillContainerMap(int _lastID) throws ImageException {
		// ID=0 -> not in Container
		for (int i = 1; i < _lastID; i++) {// Container ID starts from 1
			fillOneContainer(i);
		}
	}

	private void fillOneContainer(int _id) throws ImageException {
		Container curCont = (Container) (containerVector.elementAt(_id - 1));
		int curX0 = curCont.cc.left;
		int curY0 = curCont.cc.top;
		int curX1 = curX0 + curCont.cc.shape.width;
		int curY1 = curY0 + curCont.cc.shape.height;

		// left boundary=1,
		// right boundary=2,
		// both (1 pixel line)=3,
		// others=0
		int[][] workMap = new int[pixel.height][pixel.width];

		for (int j = curY0; j < curY1; j++) {
			// left boundary
			boolean mostLeftFound = false;
			boolean otherContainerLeft = false;
			for (int i = curX0; i < curX1; i++) {
				if (containerMap[j][i] == _id) {
					if (!mostLeftFound) {
						workMap[j][i] = 1;
						mostLeftFound = true;
						otherContainerLeft = false;
					} else if (otherContainerLeft) {
						workMap[j][i] = 1;
						otherContainerLeft = false;
					}
				} else if (containerMap[j][i] > 0) {
					otherContainerLeft = true;
				}
			}
			// right boundary
			boolean mostRightFound = false;
			boolean otherContainerRight = false;
			for (int i = curX1 - 1; i >= curX0; i--) {
				if (containerMap[j][i] == _id) {
					if (!mostRightFound) {
						if (workMap[j][i] != 1) {
							workMap[j][i] = 2;
						} else {
							workMap[j][i] = 3;
						}
						mostRightFound = true;
						otherContainerRight = false;
					} else if (otherContainerRight) {
						if (workMap[j][i] != 1) {
							workMap[j][i] = 2;
						} else {
							workMap[j][i] = 3;
						}
						otherContainerRight = false;
					}
				} else if (containerMap[j][i] > 0) {
					otherContainerRight = true;
				}
			}

			// fill between left/right boundary
			boolean inTheContainer = false;
			for (int i = curX0; i < curX1; i++) {
				if (workMap[j][i] == 0 && inTheContainer) {
					// debug (TBD remove this if sentence)
					if (containerMap[j][i] != 0 && containerMap[j][i] != _id) {
						DebugUtil.outMsg(this, "i = " + i + ", j = " + j);
						DebugUtil.outMsg(this, "Dumping containerMap");
						for (int k = 0; k < pixel.width; k++) {
							System.err.print("" + containerMap[j][k]);
						}
						System.err.println("");
						DebugUtil.outMsg(this, "Dumping workMap");
						for (int k = 0; k < pixel.width; k++) {
							System.err.print("" + workMap[j][k]);
						}
						System.err.println("");
						throw new ImageException("filling error 0: id = " + _id);
					}
					containerMap[j][i] = _id;
				} else if (workMap[j][i] == 1) {
					// debug (TBD remove this if sentence)
					if (inTheContainer) {
						throw new ImageException("filling error 1: id = " + _id);
					}
					inTheContainer = true;
				} else if (workMap[j][i] == 2) {
					inTheContainer = false;
				}
			}
		}
	}

	/*
	 * Collate candidates from (1) and (3) (-> SS Character)
	 */
	private boolean collateCandidates(Container _cont, ConnectedComponent _cc)
			throws ImageException {
		int numCand = _cont.candidateCharacterVector.size();
		for (int k = numCand - 1; k >= 0; k--) {
			CandidateCharacter cChar = _cont.candidateCharacterVector
					.elementAt(k);
			if (_cc.equals(cChar.cc)) {
				// (confirmed) SS Character
				CharacterSS ssc = new CharacterSS(cChar);
				_cont.ssCharacterVector.addElement(ssc);
				_cont.candidateCharacterVector.removeElementAt(k);
				return (true);
			}
		}
		int numUCand = _cont.candidateUnderlinedCharacterVector.size();
		for (int k = numUCand - 1; k >= 0; k--) {
			CandidateUnderlinedCharacter cuChar = _cont.candidateUnderlinedCharacterVector
					.elementAt(k);
			if (_cc.equals(cuChar.cc)) {
				// (confirmed) Underlined SS Character
				Vector sscVec = removeUnderlineAndGenerateSS(cuChar);
				for (int l = 0; l < sscVec.size(); l++) {
					_cont.ssCharacterVector.addElement((CharacterSS) (sscVec
							.elementAt(l)));
				}
				_cont.candidateUnderlinedCharacterVector.removeElementAt(k);
				return (true);
			}
		}
		return (false);
	}

	/*
	 * Returns fg color of connected component (int) color: single fg color -1:
	 * multiple fg color/no fg color
	 */
	private int getForegroundColor(ConnectedComponent _cc) {
		int fg = -1;
		for (int j = 0; j < _cc.shape.height; j++) {
			for (int i = 0; i < _cc.shape.width; i++) {
				if (_cc.shape.data[j][i] != 0) {
					if (fg == -1) {
						fg = pixel.data[j + _cc.top][i + _cc.left];
					} else if (fg != pixel.data[j + _cc.top][i + _cc.left]) {
						return (-1);
					}
				}
			}
		}
		return (fg);
	}

	/*
	 * Returns bg color of connected component (int) color: single bg color -1:
	 * multiple bg color/no bg color
	 */
	private int getBackgroundColor(ConnectedComponent _cc) {
		int bg = -1;
		for (int j = 0; j < _cc.shape.height; j++) {
			for (int i = 0; i < _cc.shape.width; i++) {
				if (_cc.shape.data[j][i] == 0) {
					if (bg == -1) {
						bg = pixel.data[j + _cc.top][i + _cc.left];
					} else if (bg != pixel.data[j + _cc.top][i + _cc.left]) {
						return (-1);
					}
				}
			}
		}
		return (bg);
	}

	// Create SM Characters from candidateCharacter/candidateUnderlinedCharacter
	private Vector makeSMCharacterVector(Vector<CandidateCharacter> _cVec,
			Vector<CandidateUnderlinedCharacter> _uVec) throws ImageException {
		Vector<CharacterSM> tmpVec = new Vector<CharacterSM>();
		int numRemainingChar = _cVec.size();
		for (int k = 0; k < numRemainingChar; k++) {
			CandidateCharacter cChar = _cVec.elementAt(k);
			CharacterSM smc = new CharacterSM(cChar, pixel);
			tmpVec.addElement(smc);
		}

		int numRemainingUnderlinedChar = _uVec.size();
		for (int k = 0; k < numRemainingUnderlinedChar; k++) {
			CandidateUnderlinedCharacter cuChar = _uVec.elementAt(k);
			Vector smcVec = removeUnderlineAndGenerateSM(cuChar);
			for (int l = 0; l < smcVec.size(); l++) {
				tmpVec.addElement((CharacterSM) (smcVec.elementAt(l)));
			}
		}

		return (tmpVec);
	}

	// target SM Char is contained within MS Char in the Container?
	private CharacterMS includingMSCharacter(CharacterSM _smc, Container _cont) {
		for (int k = 0; k < _cont.msCharacterVector.size(); k++) {
			CharacterMS curMS = (CharacterMS) (_cont.msCharacterVector
					.elementAt(k));
			if (_smc.cc.isIncludedBy(curMS.cc)) {
				return (curMS);
			}
		}
		return (null);
	}

	public LowVisionProblemGroup[] checkCharacters(LowVisionType _lvType)
			throws ImageException, LowVisionProblemException {
		LowVisionProblemGroup[] charProblemGroupArray = null;
		LowVisionProblemGroup[] imgProblemGroupArray = null;
		LowVisionProblemGroup[] answerArray = null;

		if (DO_CHECK_CHARACTERS) {
			CharacterChecker charChecker = new CharacterChecker(this);
			charProblemGroupArray = charChecker.checkAllCharacters(_lvType);
		}

		if (DO_CHECK_IMAGES && useImagePositions) {

			// for memory (create InteriorImages for each time (degrade
			// performance))
			extractInteriorImages();

			imgProblemGroupArray = checkInteriorImages(_lvType);

			// for memory
			interiorImageArray = null;
		}

		if (charProblemGroupArray == null) {
			if (imgProblemGroupArray == null) {
				answerArray = new LowVisionProblemGroup[0];
			} else {
				answerArray = imgProblemGroupArray;
			}
		} else {
			if (imgProblemGroupArray == null) {
				answerArray = charProblemGroupArray;
			} else {
				int charLen = charProblemGroupArray.length;
				int imgLen = imgProblemGroupArray.length;
				int allLen = charLen + imgLen;
				LowVisionProblemGroup[] allProblemGroupArray = new LowVisionProblemGroup[allLen];
				for (int i = 0; i < charLen; i++) {
					allProblemGroupArray[i] = charProblemGroupArray[i];
				}
				for (int i = 0; i < imgLen; i++) {
					allProblemGroupArray[charLen + i] = imgProblemGroupArray[i];
				}
				answerArray = allProblemGroupArray;
			}
		}

		return (answerArray);
	}

	private LowVisionProblemGroup[] checkInteriorImages(LowVisionType _lvType)
			throws ImageException {
		if (!useImagePositions) {
			return (new LowVisionProblemGroup[0]);
		}

		Vector<LowVisionProblemGroup> problemVector = new Vector<LowVisionProblemGroup>();

		int numInteriorImages = 0;
		if (interiorImageArray != null && interiorImageArray.length > 0) {
			numInteriorImages = interiorImageArray.length;
		}
		for (int k = 0; k < numInteriorImages; k++) {
			InteriorImage curIm = interiorImageArray[k];

			LowVisionProblemGroup[] probArray = curIm.checkColors(_lvType);
			if (probArray != null) {
				int numProb = probArray.length;
				for (int l = 0; l < numProb; l++) {
					problemVector.addElement(probArray[l]);
				}
			}
		}

		int size = problemVector.size();
		if (size > 0) {
			LowVisionProblemGroup[] allProbArray = new LowVisionProblemGroup[size];
			for (int k = 0; k < size; k++) {
				allProbArray[k] = problemVector.elementAt(k);
			}
			problemVector = null;
			return (allProbArray);
		} else {
			problemVector = null;
			return (new LowVisionProblemGroup[0]);
		}
	}

	private LabeledImage removeUnderlineAndCCL(
			CandidateUnderlinedCharacter _cuChar) throws ImageException {
		BinaryImage origImage = _cuChar.cc.shape;
		BinaryImage lineImage = origImage.drawUnderline();

		BinaryImage removedImage = origImage.subtract(lineImage);
		LabeledImage li = new LabeledImage(removedImage,
				LabeledImage.METHOD_8_CONNECTIVITY);

		return (li);
	}

	private Vector removeUnderlineAndGenerateSS(
			CandidateUnderlinedCharacter _cuChar) throws ImageException {
		Vector<CharacterSS> ssVec = new Vector<CharacterSS>();
		int offsetX = _cuChar.cc.left;
		int offsetY = _cuChar.cc.top;
		short conn = _cuChar.cc.connectivity;
		LabeledImage li = removeUnderlineAndCCL(_cuChar);
		int numCC = li.numComponents;
		for (int k = 0; k < numCC; k++) {
			ConnectedComponent cc = li.components[k];
			cc.left += offsetX;
			cc.top += offsetY;
			cc.connectivity = conn;
			if (DecisionMaker.judgeComponentType(cc, this) == PageComponent.CANDIDATE_CHARACTER_TYPE) {
				CharacterSS ssc = new CharacterSS(this, cc, _cuChar.container,
						_cuChar.getForegroundColor());
				ssVec.addElement(ssc);
			}
		}
		return (ssVec);
	}

	private Vector removeUnderlineAndGenerateSM(
			CandidateUnderlinedCharacter _cuChar) throws ImageException {
		Vector<CharacterSM> smVec = new Vector<CharacterSM>();
		int offsetX = _cuChar.cc.left;
		int offsetY = _cuChar.cc.top;
		short conn = _cuChar.cc.connectivity;
		LabeledImage li = removeUnderlineAndCCL(_cuChar);
		int numCC = li.numComponents;
		for (int k = 0; k < numCC; k++) {
			ConnectedComponent cc = li.components[k];
			cc.left += offsetX;
			cc.top += offsetY;
			cc.connectivity = conn;
			if (DecisionMaker.judgeComponentType(cc, this) == PageComponent.CANDIDATE_CHARACTER_TYPE) {
				CharacterSM smc = new CharacterSM(this, cc, _cuChar.container,
						_cuChar.getForegroundColor(), pixel);
				smVec.addElement(smc);
			}
		}
		return (smVec);
	}
}