plugins/org.eclipse.actf.visualization.engines.lowvision/src/org/eclipse/actf/visualization/engines/lowvision/LowVisionType.java - gerrit/actf/org.eclipse.actf.visualization - Git at Google

 /*******************************************************************************
  * 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;

 import java.io.BufferedReader;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 import java.util.StringTokenizer;

 import org.eclipse.actf.visualization.engines.lowvision.operator.CVDOp;
 import org.eclipse.actf.visualization.engines.lowvision.operator.ColorFilterOp;
 import org.eclipse.actf.visualization.engines.lowvision.operator.GlareOp;

 /*
  * Define lowvision simulation type
  */
 public class LowVisionType {

 	public static final String COLOR_FILTER_STR = "senior_color";

 	public static final String CVD_STR = "color";

 	public static final String EYESIGHT_STR = "focus";

 	public static final String GLARE_STR = "glare";

 	// private static final String FIELD_STR = "field";

 	private static final double EYESIGHT_DEGREE_MARGIN = 0.1;

 	private final int DISPLAY_RESOLUTION = 1024; // Y

 	private final double DISPLAY_HEIGHT = 20.8; // 14.1 inches

 	// public static final double DISPLAY_HEIGHT = 26.5; // 19 inches
 	private final double EYE_DISPLAY_DISTANCE = 30.0;

 	private boolean eyesight = false;

 	private float eyesightDegree;

 	// radius of blur array (exclude center, 3x3 -> 1)
 	private int eyesightRadius;

 	// undistinguishable pixel size for the target person
 	private double eyesightPixel;

 	// undistinguishable length(mm) for thetarget person
 	private double eyesightLength;

 	// color vision deficiency
 	private boolean CVD = false;

 	private int CVDType;

 	// color filter
 	private boolean colorFilter = false;

 	private float colorFilterR; // [0.0, 1.0]

 	private float colorFilterG; // [0.0, 1.0]

 	private float colorFilterB; // [0.0, 1.0]

 	// glare
 	private boolean glare = false;

 	private float glareDegree = 0.0f;

 	private int displayResolution = DISPLAY_RESOLUTION;

 	private double displayHeight = DISPLAY_HEIGHT;

 	private double eyeDisplayDistance = EYE_DISPLAY_DISTANCE;

 	public LowVisionType() {
 	}

 	public LowVisionType(String _fileName) throws LowVisionException {
 		BufferedReader br = null;
 		try {
 			br = new BufferedReader(new FileReader(_fileName));
 		} catch (FileNotFoundException fne) {
 			fne.printStackTrace();
 			throw new LowVisionException("File not found.");
 		}
 		read(br);
 	}

 	public LowVisionType(BufferedReader _br) throws LowVisionException {
 		read(_br);
 	}

 	public boolean getEyesight() {
 		return (eyesight);
 	}

 	public void setEyesight(boolean _b) {
 		eyesight = _b;
 	}

 	public float getEyesightDegree() {
 		return (eyesightDegree);
 	}

 	public void setEyesightDegree(float _deg) throws LowVisionException {
 		if (_deg <= 0.0) {
 			throw new LowVisionException("Eyesight degree must be positive.");
 		}
 		eyesightDegree = _deg;
 		eyesightPixel = calcUndistinguishablePixel(eyesightDegree);
 		eyesightRadius = calcRadius(eyesightPixel);
 		eyesightLength = calcUndistinguishableLength(eyesightDegree);
 	}

 	public double getEyesightPixel() {
 		return (eyesightPixel);
 	}

 	public int getEyesightRadius() {
 		return (eyesightRadius);
 	}

 	public double getEyesightLength() {
 		return (eyesightLength);
 	}

 	private double calcUndistinguishablePixel(double _degree) {
 		double degree = _degree + EYESIGHT_DEGREE_MARGIN;
 		double thetaD = 1.0 / degree; // distinguishable degree (arcmin)
 		double thetaR = thetaD * Math.PI / 10800.0; // distinguishable degree(radian)
 		return (2.0 * Math.tan(thetaR / 2.0) * displayResolution
 				* eyeDisplayDistance / displayHeight);
 	}

 	private int calcRadius(double _pixel) {
 		return ((int) (Math.ceil(_pixel)));
 	}

 	private double calcUndistinguishableLength(double _degree) {
 		double degree = _degree + EYESIGHT_DEGREE_MARGIN;
 		double thetaD = 1.0 / degree;
 		double thetaR = thetaD * Math.PI / 10800.0;
 		return (20.0 * Math.tan(thetaR / 2.0) * eyeDisplayDistance);
 		/*
 		 * 20.0 = 10.0*2.0 2.0 equals in calcPixel() 10.0-> cm to mm
 		 */
 	}

 	public boolean getCVD() {
 		return (CVD);
 	}

 	public void setCVD(boolean _b) {
 		CVD = _b;
 	}

 	public int getCVDType() {
 		return (CVDType);
 	}

 	public void setCVDType(int _i) throws LowVisionException {
 		if (_i != 1 && _i != 2 && _i != 3) {
 			throw new LowVisionException("CVD type must be 1,2, or 3");
 		}
 		CVDType = _i;
 	}

 	public boolean getColorFilter() {
 		return (colorFilter);
 	}

 	public void setColorFilter(boolean _b) {
 		colorFilter = _b;
 	}

 	public float[] getColorFilterRGB() {
 		float[] rgb = { colorFilterR, colorFilterG, colorFilterB };
 		return (rgb);
 	}

 	public void setColorFilterRGB(float _r, float _g, float _b)
 			throws LowVisionException {
 		if (_r < 0.0 || 1.0 < _r)
 			throw new LowVisionException("Value of R(" + _r
 					+ ") is out of range.");
 		colorFilterR = _r;
 		if (_g < 0.0 || 1.0 < _g)
 			throw new LowVisionException("Value of G(" + _g
 					+ ") is out of range.");
 		colorFilterG = _g;
 		if (_b < 0.0 || 1.0 < _b)
 			throw new LowVisionException("Value of B(" + _b
 					+ ") is out of range.");
 		colorFilterB = _b;
 	}

 	public void setColorFilterRGB(float[] rgb) throws LowVisionException {
 		if (rgb.length != 3) {
 			throw new LowVisionException("The parameter's length must be 3.");
 		}
 		setColorFilterRGB(rgb[0], rgb[1], rgb[2]);
 	}


 	public void setColorFilterDegree(float _degree) throws LowVisionException {
 		// TODO check color filter values
 		float bDegree = _degree;
 		// float bDegree = 1.0f-(1.0f-_degree)*0.9f;
 		float rgDegree = 1 - (1 - bDegree) / 2.0f;
 		setColorFilterRGB(rgDegree, rgDegree, bDegree);
 	}

 	public boolean getGlare() {
 		return (glare);
 	}

 	public void setGlare(boolean _g) {
 		glare = _g;
 	}

 	public float getGlareDegree() {
 		return (glareDegree);
 	}

 	public void setGlareDegree(float _deg) {
 		glareDegree = _deg;
 	}

 	//read simulation type from config file
 	public void read(BufferedReader _br) throws LowVisionException {
 		String oneLine = null;
 		try {
 			while ((oneLine = _br.readLine()) != null) {
 				StringTokenizer st = new StringTokenizer(oneLine);
 				String typeName = st.nextToken().toLowerCase();
 				if (typeName.equals(COLOR_FILTER_STR)) {
 					readColorFilter(st);
 				} else if (typeName.equals(CVD_STR)) {
 					readCVD(st);
 				} else if (typeName.equals(EYESIGHT_STR)) {
 					readEyesight(st);
 				} else if (typeName.equals(GLARE_STR)) {
 					readGlare(st);
 				} else {
 					throw new LowVisionException("Unknown type: " + typeName);
 				}
 			}
 		} catch (IOException e) {
 			e.printStackTrace();
 			throw new LowVisionException("IO Error occurred while reading.");
 		}
 	}

 	private void readColorFilter(StringTokenizer _st) throws LowVisionException {
 		if (_st.countTokens() != 3) {
 			throw new LowVisionException("Color filter needs three parameters.");
 		}
 		float tmpR = Float.parseFloat(_st.nextToken());
 		float tmpG = Float.parseFloat(_st.nextToken());
 		float tmpB = Float.parseFloat(_st.nextToken());
 		setColorFilterRGB(tmpR, tmpG, tmpB);
 		colorFilter = true;
 	}

 	private void readCVD(StringTokenizer _st) throws LowVisionException {
 		if (_st.countTokens() != 1) {
 			throw new LowVisionException("CVD needs only one parameter(type).");
 		}
 		int type = Integer.parseInt(_st.nextToken());
 		setCVDType(type);
 		CVD = true;
 	}

 	private void readEyesight(StringTokenizer _st) throws LowVisionException {
 		if (_st.countTokens() != 1) {
 			throw new LowVisionException(
 					"Eyesight needs only one parameter(degree).");
 		}
 		float tmp = Float.parseFloat(_st.nextToken());
 		setEyesightDegree(tmp);
 		eyesight = true;
 	}

 	private void readGlare(StringTokenizer _st) throws LowVisionException {
 		if (_st.countTokens() != 1) {
 			throw new LowVisionException(
 					"Glare needs only one parameter(degree).");
 		}
 		float tmp = Float.parseFloat(_st.nextToken());
 		setGlareDegree(tmp);
 		glare = true;
 	}

 	public int countTypes() {
 		int num = 0;

 		if (eyesight)
 			num++;
 		if (CVD)
 			num++;
 		if (colorFilter)
 			num++;
 		if (glare)
 			num++;

 		return (num);
 	}

 	public boolean doBlur() {
 		return (eyesight);
 	}

 	public boolean doChangeColors() {
 		return (CVD || colorFilter || glare);
 	}

 	// need to use same order as in the LowVisionFilter
 	public int convertColor(int _src) throws LowVisionException {
 		int dest = _src;
 		if (colorFilter) {
 			dest = ColorFilterOp.convertColor(dest, colorFilterR, colorFilterG,
 					colorFilterB);
 		}
 		if (glare) {
 			dest = GlareOp.convertColor(dest, glareDegree);
 		}
 		if (CVD) {
 			dest = CVDOp.convertColor(dest, CVDType);
 		}
 		return (dest);
 	}

 	public static int convertColor(int _src, LowVisionType _lvt)
 			throws LowVisionException {
 		return (_lvt.convertColor(_src));
 	}

 	public LowVisionType extractColorTypes() {
 		if (!doChangeColors()) {
 			return (null);
 		}
 		LowVisionType lv = null;
 		try {
 			lv = new LowVisionType();
 			if (this.colorFilter) {
 				lv.setColorFilter(true);
 				lv.setColorFilterRGB(this.getColorFilterRGB());
 			}
 			if (this.CVD) {
 				lv.setCVD(true);
 				lv.setCVDType(this.getCVDType());
 			}
 			if (this.glare) {
 				lv.setGlare(true);
 				lv.setGlareDegree(this.glareDegree);
 			}
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 		return (lv);
 	}

 	public String toString() {
 		StringBuffer sb = new StringBuffer();
 		if (eyesight) {
 			sb.append("Eyesight:on Degree=");
 			sb.append("" + eyesightDegree);
 		} else {
 			sb.append("Eyesight:off,");
 		}
 		if (CVD) {
 			sb.append("  CVD:on Type=" + CVDType + ",");
 		} else {
 			sb.append("  CVD: off,");
 		}
 		if (colorFilter) {
 			sb.append("  ColorFilter:on Degree=" + colorFilterB);
 		} else {
 			sb.append("  ColorFilter:off");
 		}
 		return (sb.toString());
 	}

 	public double getDisplayHeight() {
 		return displayHeight;
 	}

 	public int getDisplayResolution() {
 		return displayResolution;
 	}

 	public double getEyeDisplayDistance() {
 		return eyeDisplayDistance;
 	}

 	public void setDisplayHeight(double displayHeight) {
 		this.displayHeight = displayHeight;
 	}

 	public void setDisplayResolution(int displayResolution) {
 		this.displayResolution = displayResolution;
 	}

 	public void setEyeDisplayDistance(double eyeDisplayDistance) {
 		this.eyeDisplayDistance = eyeDisplayDistance;
 	}
 }
	/*******************************************************************************
	* 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;

	import java.io.BufferedReader;
	import java.io.FileNotFoundException;
	import java.io.FileReader;
	import java.io.IOException;
	import java.util.StringTokenizer;

	import org.eclipse.actf.visualization.engines.lowvision.operator.CVDOp;
	import org.eclipse.actf.visualization.engines.lowvision.operator.ColorFilterOp;
	import org.eclipse.actf.visualization.engines.lowvision.operator.GlareOp;

	/*
	* Define lowvision simulation type
	*/
	public class LowVisionType {

	public static final String COLOR_FILTER_STR = "senior_color";

	public static final String CVD_STR = "color";

	public static final String EYESIGHT_STR = "focus";

	public static final String GLARE_STR = "glare";

	// private static final String FIELD_STR = "field";

	private static final double EYESIGHT_DEGREE_MARGIN = 0.1;

	private final int DISPLAY_RESOLUTION = 1024; // Y

	private final double DISPLAY_HEIGHT = 20.8; // 14.1 inches

	// public static final double DISPLAY_HEIGHT = 26.5; // 19 inches
	private final double EYE_DISPLAY_DISTANCE = 30.0;

	private boolean eyesight = false;

	private float eyesightDegree;

	// radius of blur array (exclude center, 3x3 -> 1)
	private int eyesightRadius;

	// undistinguishable pixel size for the target person
	private double eyesightPixel;

	// undistinguishable length(mm) for thetarget person
	private double eyesightLength;

	// color vision deficiency
	private boolean CVD = false;

	private int CVDType;

	// color filter
	private boolean colorFilter = false;

	private float colorFilterR; // [0.0, 1.0]

	private float colorFilterG; // [0.0, 1.0]

	private float colorFilterB; // [0.0, 1.0]

	// glare
	private boolean glare = false;

	private float glareDegree = 0.0f;

	private int displayResolution = DISPLAY_RESOLUTION;

	private double displayHeight = DISPLAY_HEIGHT;

	private double eyeDisplayDistance = EYE_DISPLAY_DISTANCE;

	public LowVisionType() {
	}

	public LowVisionType(String _fileName) throws LowVisionException {
	BufferedReader br = null;
	try {
	br = new BufferedReader(new FileReader(_fileName));
	} catch (FileNotFoundException fne) {
	fne.printStackTrace();
	throw new LowVisionException("File not found.");
	}
	read(br);
	}

	public LowVisionType(BufferedReader _br) throws LowVisionException {
	read(_br);
	}

	public boolean getEyesight() {
	return (eyesight);
	}

	public void setEyesight(boolean _b) {
	eyesight = _b;
	}

	public float getEyesightDegree() {
	return (eyesightDegree);
	}

	public void setEyesightDegree(float _deg) throws LowVisionException {
	if (_deg <= 0.0) {
	throw new LowVisionException("Eyesight degree must be positive.");
	}
	eyesightDegree = _deg;
	eyesightPixel = calcUndistinguishablePixel(eyesightDegree);
	eyesightRadius = calcRadius(eyesightPixel);
	eyesightLength = calcUndistinguishableLength(eyesightDegree);
	}

	public double getEyesightPixel() {
	return (eyesightPixel);
	}

	public int getEyesightRadius() {
	return (eyesightRadius);
	}

	public double getEyesightLength() {
	return (eyesightLength);
	}

	private double calcUndistinguishablePixel(double _degree) {
	double degree = _degree + EYESIGHT_DEGREE_MARGIN;
	double thetaD = 1.0 / degree; // distinguishable degree (arcmin)
	double thetaR = thetaD * Math.PI / 10800.0; // distinguishable degree(radian)
	return (2.0 * Math.tan(thetaR / 2.0) * displayResolution
	* eyeDisplayDistance / displayHeight);
	}

	private int calcRadius(double _pixel) {
	return ((int) (Math.ceil(_pixel)));
	}

	private double calcUndistinguishableLength(double _degree) {
	double degree = _degree + EYESIGHT_DEGREE_MARGIN;
	double thetaD = 1.0 / degree;
	double thetaR = thetaD * Math.PI / 10800.0;
	return (20.0 * Math.tan(thetaR / 2.0) * eyeDisplayDistance);
	/*
	* 20.0 = 10.0*2.0 2.0 equals in calcPixel() 10.0-> cm to mm
	*/
	}

	public boolean getCVD() {
	return (CVD);
	}

	public void setCVD(boolean _b) {
	CVD = _b;
	}

	public int getCVDType() {
	return (CVDType);
	}

	public void setCVDType(int _i) throws LowVisionException {
	if (_i != 1 && _i != 2 && _i != 3) {
	throw new LowVisionException("CVD type must be 1,2, or 3");
	}
	CVDType = _i;
	}

	public boolean getColorFilter() {
	return (colorFilter);
	}

	public void setColorFilter(boolean _b) {
	colorFilter = _b;
	}

	public float[] getColorFilterRGB() {
	float[] rgb = { colorFilterR, colorFilterG, colorFilterB };
	return (rgb);
	}

	public void setColorFilterRGB(float _r, float _g, float _b)
	throws LowVisionException {
	if (_r < 0.0 \|\| 1.0 < _r)
	throw new LowVisionException("Value of R(" + _r
	+ ") is out of range.");
	colorFilterR = _r;
	if (_g < 0.0 \|\| 1.0 < _g)
	throw new LowVisionException("Value of G(" + _g
	+ ") is out of range.");
	colorFilterG = _g;
	if (_b < 0.0 \|\| 1.0 < _b)
	throw new LowVisionException("Value of B(" + _b
	+ ") is out of range.");
	colorFilterB = _b;
	}

	public void setColorFilterRGB(float[] rgb) throws LowVisionException {
	if (rgb.length != 3) {
	throw new LowVisionException("The parameter's length must be 3.");
	}
	setColorFilterRGB(rgb[0], rgb[1], rgb[2]);
	}


	public void setColorFilterDegree(float _degree) throws LowVisionException {
	// TODO check color filter values
	float bDegree = _degree;
	// float bDegree = 1.0f-(1.0f-_degree)*0.9f;
	float rgDegree = 1 - (1 - bDegree) / 2.0f;
	setColorFilterRGB(rgDegree, rgDegree, bDegree);
	}

	public boolean getGlare() {
	return (glare);
	}

	public void setGlare(boolean _g) {
	glare = _g;
	}

	public float getGlareDegree() {
	return (glareDegree);
	}

	public void setGlareDegree(float _deg) {
	glareDegree = _deg;
	}

	//read simulation type from config file
	public void read(BufferedReader _br) throws LowVisionException {
	String oneLine = null;
	try {
	while ((oneLine = _br.readLine()) != null) {
	StringTokenizer st = new StringTokenizer(oneLine);
	String typeName = st.nextToken().toLowerCase();
	if (typeName.equals(COLOR_FILTER_STR)) {
	readColorFilter(st);
	} else if (typeName.equals(CVD_STR)) {
	readCVD(st);
	} else if (typeName.equals(EYESIGHT_STR)) {
	readEyesight(st);
	} else if (typeName.equals(GLARE_STR)) {
	readGlare(st);
	} else {
	throw new LowVisionException("Unknown type: " + typeName);
	}
	}
	} catch (IOException e) {
	e.printStackTrace();
	throw new LowVisionException("IO Error occurred while reading.");
	}
	}

	private void readColorFilter(StringTokenizer _st) throws LowVisionException {
	if (_st.countTokens() != 3) {
	throw new LowVisionException("Color filter needs three parameters.");
	}
	float tmpR = Float.parseFloat(_st.nextToken());
	float tmpG = Float.parseFloat(_st.nextToken());
	float tmpB = Float.parseFloat(_st.nextToken());
	setColorFilterRGB(tmpR, tmpG, tmpB);
	colorFilter = true;
	}

	private void readCVD(StringTokenizer _st) throws LowVisionException {
	if (_st.countTokens() != 1) {
	throw new LowVisionException("CVD needs only one parameter(type).");
	}
	int type = Integer.parseInt(_st.nextToken());
	setCVDType(type);
	CVD = true;
	}

	private void readEyesight(StringTokenizer _st) throws LowVisionException {
	if (_st.countTokens() != 1) {
	throw new LowVisionException(
	"Eyesight needs only one parameter(degree).");
	}
	float tmp = Float.parseFloat(_st.nextToken());
	setEyesightDegree(tmp);
	eyesight = true;
	}

	private void readGlare(StringTokenizer _st) throws LowVisionException {
	if (_st.countTokens() != 1) {
	throw new LowVisionException(
	"Glare needs only one parameter(degree).");
	}
	float tmp = Float.parseFloat(_st.nextToken());
	setGlareDegree(tmp);
	glare = true;
	}

	public int countTypes() {
	int num = 0;

	if (eyesight)
	num++;
	if (CVD)
	num++;
	if (colorFilter)
	num++;
	if (glare)
	num++;

	return (num);
	}

	public boolean doBlur() {
	return (eyesight);
	}

	public boolean doChangeColors() {
	return (CVD \|\| colorFilter \|\| glare);
	}

	// need to use same order as in the LowVisionFilter
	public int convertColor(int _src) throws LowVisionException {
	int dest = _src;
	if (colorFilter) {
	dest = ColorFilterOp.convertColor(dest, colorFilterR, colorFilterG,
	colorFilterB);
	}
	if (glare) {
	dest = GlareOp.convertColor(dest, glareDegree);
	}
	if (CVD) {
	dest = CVDOp.convertColor(dest, CVDType);
	}
	return (dest);
	}

	public static int convertColor(int _src, LowVisionType _lvt)
	throws LowVisionException {
	return (_lvt.convertColor(_src));
	}

	public LowVisionType extractColorTypes() {
	if (!doChangeColors()) {
	return (null);
	}
	LowVisionType lv = null;
	try {
	lv = new LowVisionType();
	if (this.colorFilter) {
	lv.setColorFilter(true);
	lv.setColorFilterRGB(this.getColorFilterRGB());
	}
	if (this.CVD) {
	lv.setCVD(true);
	lv.setCVDType(this.getCVDType());
	}
	if (this.glare) {
	lv.setGlare(true);
	lv.setGlareDegree(this.glareDegree);
	}
	} catch (Exception e) {
	e.printStackTrace();
	}
	return (lv);
	}

	public String toString() {
	StringBuffer sb = new StringBuffer();
	if (eyesight) {
	sb.append("Eyesight:on Degree=");
	sb.append("" + eyesightDegree);
	} else {
	sb.append("Eyesight:off,");
	}
	if (CVD) {
	sb.append(" CVD:on Type=" + CVDType + ",");
	} else {
	sb.append(" CVD: off,");
	}
	if (colorFilter) {
	sb.append(" ColorFilter:on Degree=" + colorFilterB);
	} else {
	sb.append(" ColorFilter:off");
	}
	return (sb.toString());
	}

	public double getDisplayHeight() {
	return displayHeight;
	}

	public int getDisplayResolution() {
	return displayResolution;
	}

	public double getEyeDisplayDistance() {
	return eyeDisplayDistance;
	}

	public void setDisplayHeight(double displayHeight) {
	this.displayHeight = displayHeight;
	}

	public void setDisplayResolution(int displayResolution) {
	this.displayResolution = displayResolution;
	}

	public void setEyeDisplayDistance(double eyeDisplayDistance) {
	this.eyeDisplayDistance = eyeDisplayDistance;
	}
	}