plugins/org.eclipse.actf.visualization.engines.lowvision/src/org/eclipse/actf/visualization/engines/lowvision/operator/CVDOp.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.operator;

 import java.awt.image.BufferedImage;
 import java.awt.image.DataBufferInt;
 import java.awt.image.WritableRaster;
 import java.util.HashMap;

 import org.eclipse.actf.visualization.engines.lowvision.LowVisionException;
 import org.eclipse.actf.visualization.engines.lowvision.color.ColorException;
 import org.eclipse.actf.visualization.engines.lowvision.color.ColorIRGB;
 import org.eclipse.actf.visualization.engines.lowvision.color.ColorSRGB;
 import org.eclipse.actf.visualization.engines.lowvision.color.ColorYXY;
 import org.eclipse.actf.visualization.engines.lowvision.image.Int2D;

 /*
  * simulate color vision deficiency
  */
 public class CVDOp implements ILowVisionOperator{
 	// keep Y(0.299R+0.587G+0.114B) in sRGB (I in HSI) or not
 	// false is better
     private static final boolean PRESERVE_SRGB_Y = false;

     // see ColorValue.java
     // these values are for (Y,x,y) (not for (x,y,z))
     // (Y,x,y)space : (x,y,z)space
     // Y(YY) : y
     // x : x/(x+y+z)
     // y : y/(x+y+z)

     // sRGB->CIEXYZ->Yxy
     @SuppressWarnings("unused")
     private static final float R_YY = 0.21347046f,
     R_X  = 0.6524872f,
     R_Y  = 0.32519758f,
     G_YY = 0.71173096f,
     G_X  = 0.3305722f,
     G_Y  = 0.5944182f,
     B_YY = 0.07168579f,
     B_X  = 0.1482494f,
     B_Y  = 0.07736899f,
     W_YY = 0.9963379f,
     W_X  = 0.34579438f,
     W_Y  = 0.35854465f;

     private static final float C1_X = 0.747f;  // Protan line
     private static final float C1_Y = 0.253f;  //
     private static final float C2_X = 1.080f;  // Deutan line
     private static final float C2_Y = -0.080f; //
     private static final float C3_X = 0.171f;  // Tritan line
     private static final float C3_Y = 0.000f;  //

 	private static float BW_A = (B_Y-W_Y)/(B_X-W_X);// blue-white line in (x,y)
 	private static float BW_B = B_Y-BW_A*B_X;
 	// private static float BR_A = (B_Y-R_Y)/(B_X-R_X);//blue-red line in (x,y)
 	// private static float BR_B = B_Y-BR_A*B_X;
 	private static float BR_A = -0.5f;  // blue-red line (cross white)
 	private static float BR_B = 0.525f; //

     private int type = 0;

     public CVDOp( int _type ){
 		type = _type;
     }

     public BufferedImage filter( BufferedImage _src, BufferedImage _dest ) throws LowVisionException{
 		if( type != 1 && type != 2 && type != 3 ){
 			throw new LowVisionException( "Invalid type: " + type );
 		}

 		WritableRaster srcRaster = _src.copyData( null );
 		DataBufferInt srcBufInt = (DataBufferInt)(srcRaster.getDataBuffer());
 		int[] srcArray = srcBufInt.getData();
 		int srcSize = srcArray.length;

 		BufferedImage destImage = _dest;
 		if( _dest == null ){
 		    destImage = new BufferedImage( _src.getWidth(), _src.getHeight(), BufferedImage.TYPE_INT_RGB );
 		}
 		WritableRaster destRaster = destImage.copyData( null );
 		DataBufferInt destBufInt = (DataBufferInt)(destRaster.getDataBuffer());
 		int[] destArray = destBufInt.getData();
 		int destSize = destArray.length;
 		if( srcSize != destSize ){
 		    throw new LowVisionException( "Sizes of src and dest images differ." );
 		}

 		HashMap<Integer, Integer> pixelMap = new HashMap<Integer, Integer>();
 		for( int i=0; i<srcSize; i++ ){
 		    Integer srcPixel = new Integer( srcArray[i] );
 		    Integer destPixel = null;
 		    if( (destPixel=(Integer)(pixelMap.get(srcPixel))) == null ){
 		    	destPixel = new Integer( convertColor(srcArray[i],type) );
 				pixelMap.put( srcPixel, destPixel );
 		    }
 		    destArray[i] = destPixel.intValue();
 		}

 		destImage.setData( destRaster );
 		return( destImage );
     } // filter( BufferedImage, BufferedImage )

 	public Int2D filter( Int2D _src, Int2D _dest ) throws LowVisionException{
 		if( type != 1 && type != 2 && type != 3 ){
 			throw new LowVisionException( "Invalid type: " + type );
 		}

 		Int2D destImage = _dest;
 		if( _dest == null ){
 			destImage = new Int2D( _src.width, _src.height );
 		}

 		HashMap<Integer, Integer> pixelMap = new HashMap<Integer, Integer>();
 		for( int j=0; j<_src.height; j++ ){
 			for( int i=0; i<_src.width; i++ ){
 				int srcColor =_src.data[j][i];
 				Integer srcPixel = new Integer( srcColor );
 				Integer destPixel  = (Integer)(pixelMap.get(srcPixel));
 				if( destPixel == null ){
 					int destColor = convertColor( srcColor, type );
 					destImage.data[j][i] = destColor;
 					pixelMap.put( srcPixel, new Integer(destColor) );
 				}
 				else{
 					destImage.data[j][i] = destPixel.intValue();
 				}
 			}
 		}
 		return( destImage );
 	}

 	public static int convertColor( int _src, int _type ) throws LowVisionException{
 		try{
 			if( PRESERVE_SRGB_Y ){
 				ColorSRGB srgb = (new ColorIRGB( _src )).toSRGB();
 				// float preservedY = 0.299f*srgb.getR() + 0.587f*srgb.getG() +
 				// 0.114f*srgb.getB();
 				float preservedY = Math.max( srgb.getR(), Math.max( srgb.getG(), srgb.getB() ) );
 				ColorYXY yxy = srgb.toYXY();
 				// move (x,y) while keeping brightness (yy)
 				ColorYXY newYXY = moveXY( yxy, _type );
 				ColorSRGB newSRGB = newYXY.toSRGB();
 				float newR = newSRGB.getR();
 				float newG = newSRGB.getG();
 				float newB = newSRGB.getB();
 				// float newY = 0.299f*newR + 0.587f*newG + 0.114f*newB;
 				float newY = Math.max( newR, Math.max( newG, newB ) );
 				float ratio = 0.0f;
 				if( newY != 0.0f )
 					ratio = preservedY/newY;
 				else
 					ratio = 1.0f; // black
 				newSRGB.setR( newR*ratio );
 				newSRGB.setG( newG*ratio );
 				newSRGB.setB( newB*ratio );
 				return( newSRGB.toIRGB().toInt() );
 			}
 			else{
 				ColorIRGB irgb = new ColorIRGB( _src );
 				ColorYXY yxy = irgb.toYXY();
 				// move (x,y) while keeping brightness (yy)
 				ColorYXY newYXY = moveXY( yxy, _type );
 				ColorIRGB newIRGB = newYXY.toIRGB();
 				return( newIRGB.toInt() );
 			}
 		}catch( ColorException ce ){
 			ce.printStackTrace();
 			throw new LowVisionException( "ColorException occurred while converting color.");
 		}
 	}

 	// move (x,y) while keeping brightness (yy)
     private static ColorYXY moveXY( ColorYXY _src, int _type ) throws LowVisionException, ColorException{
 		float srcYY = _src.getYY();
 		float srcX = _src.getX();
 		float srcY = _src.getY();
 		float confuseX = 0.0f;
 		float confuseY = 0.0f;
 		float locusA = 0.0f;
 		float locusB = 0.0f;
 		if( _type == 1 ){
 		    confuseX = C1_X;
 		    confuseY = C1_Y;
 		    locusA = BW_A;
 		    locusB = BW_B;
 		}
 		else if( _type == 2 ){
 		    confuseX = C2_X;
 		    confuseY = C2_Y;
 		    locusA = BW_A;
 		    locusB = BW_B;
 		}
 		else if( _type == 3 ){
 		    confuseX = C3_X;
 		    confuseY = C3_Y;
 		    locusA = BR_A;
 		    locusB = BR_B;
 		}
 		else{
 		    throw new LowVisionException( "Invalid type : " + _type );
 		}

 		float destYY = srcYY;
 		float destX = 0.0f;
 		float destY = 0.0f;
 		if( confuseX != srcX ){
 		    float confuseA = (confuseY-srcY)/(confuseX-srcX); // slope
 		    float confuseB = confuseY - confuseA*confuseX;    // y-intercept

 		    if( confuseA != locusA ){
 			destX = (confuseB-locusB)/(locusA-confuseA);
 			destY = (locusA*confuseB-confuseA*locusB)/(locusA-confuseA);
 		    }
 		    else{
 		    	// TBD use polar coordinates, etc.
    			    /*
 				 * destX = srcX; destY = srcY; debugUtil.errMsg( this, "(x,y) is
 				 * out of sRGB's range. (x,y) = " + srcX + ", " + srcY );
 				 */
 			throw new LowVisionException( "(x,y) is out of sRGB's range. (x,y) = " + srcX + ", " + srcY );
 		    }
 		} else{
 		    destX = confuseX;
 		    destY = confuseX*locusA + locusB;
 		}

 		return( new ColorYXY( destYY, destX, destY ) );
    }
 }
	/*******************************************************************************
	* 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.operator;

	import java.awt.image.BufferedImage;
	import java.awt.image.DataBufferInt;
	import java.awt.image.WritableRaster;
	import java.util.HashMap;

	import org.eclipse.actf.visualization.engines.lowvision.LowVisionException;
	import org.eclipse.actf.visualization.engines.lowvision.color.ColorException;
	import org.eclipse.actf.visualization.engines.lowvision.color.ColorIRGB;
	import org.eclipse.actf.visualization.engines.lowvision.color.ColorSRGB;
	import org.eclipse.actf.visualization.engines.lowvision.color.ColorYXY;
	import org.eclipse.actf.visualization.engines.lowvision.image.Int2D;

	/*
	* simulate color vision deficiency
	*/
	public class CVDOp implements ILowVisionOperator{
	// keep Y(0.299R+0.587G+0.114B) in sRGB (I in HSI) or not
	// false is better
	private static final boolean PRESERVE_SRGB_Y = false;

	// see ColorValue.java
	// these values are for (Y,x,y) (not for (x,y,z))
	// (Y,x,y)space : (x,y,z)space
	// Y(YY) : y
	// x : x/(x+y+z)
	// y : y/(x+y+z)

	// sRGB->CIEXYZ->Yxy
	@SuppressWarnings("unused")
	private static final float R_YY = 0.21347046f,
	R_X = 0.6524872f,
	R_Y = 0.32519758f,
	G_YY = 0.71173096f,
	G_X = 0.3305722f,
	G_Y = 0.5944182f,
	B_YY = 0.07168579f,
	B_X = 0.1482494f,
	B_Y = 0.07736899f,
	W_YY = 0.9963379f,
	W_X = 0.34579438f,
	W_Y = 0.35854465f;

	private static final float C1_X = 0.747f; // Protan line
	private static final float C1_Y = 0.253f; //
	private static final float C2_X = 1.080f; // Deutan line
	private static final float C2_Y = -0.080f; //
	private static final float C3_X = 0.171f; // Tritan line
	private static final float C3_Y = 0.000f; //

	private static float BW_A = (B_Y-W_Y)/(B_X-W_X);// blue-white line in (x,y)
	private static float BW_B = B_Y-BW_A*B_X;
	// private static float BR_A = (B_Y-R_Y)/(B_X-R_X);//blue-red line in (x,y)
	// private static float BR_B = B_Y-BR_A*B_X;
	private static float BR_A = -0.5f; // blue-red line (cross white)
	private static float BR_B = 0.525f; //

	private int type = 0;

	public CVDOp( int _type ){
	type = _type;
	}

	public BufferedImage filter( BufferedImage _src, BufferedImage _dest ) throws LowVisionException{
	if( type != 1 && type != 2 && type != 3 ){
	throw new LowVisionException( "Invalid type: " + type );
	}

	WritableRaster srcRaster = _src.copyData( null );
	DataBufferInt srcBufInt = (DataBufferInt)(srcRaster.getDataBuffer());
	int[] srcArray = srcBufInt.getData();
	int srcSize = srcArray.length;

	BufferedImage destImage = _dest;
	if( _dest == null ){
	destImage = new BufferedImage( _src.getWidth(), _src.getHeight(), BufferedImage.TYPE_INT_RGB );
	}
	WritableRaster destRaster = destImage.copyData( null );
	DataBufferInt destBufInt = (DataBufferInt)(destRaster.getDataBuffer());
	int[] destArray = destBufInt.getData();
	int destSize = destArray.length;
	if( srcSize != destSize ){
	throw new LowVisionException( "Sizes of src and dest images differ." );
	}

	HashMap<Integer, Integer> pixelMap = new HashMap<Integer, Integer>();
	for( int i=0; i<srcSize; i++ ){
	Integer srcPixel = new Integer( srcArray[i] );
	Integer destPixel = null;
	if( (destPixel=(Integer)(pixelMap.get(srcPixel))) == null ){
	destPixel = new Integer( convertColor(srcArray[i],type) );
	pixelMap.put( srcPixel, destPixel );
	}
	destArray[i] = destPixel.intValue();
	}

	destImage.setData( destRaster );
	return( destImage );
	} // filter( BufferedImage, BufferedImage )

	public Int2D filter( Int2D _src, Int2D _dest ) throws LowVisionException{
	if( type != 1 && type != 2 && type != 3 ){
	throw new LowVisionException( "Invalid type: " + type );
	}

	Int2D destImage = _dest;
	if( _dest == null ){
	destImage = new Int2D( _src.width, _src.height );
	}

	HashMap<Integer, Integer> pixelMap = new HashMap<Integer, Integer>();
	for( int j=0; j<_src.height; j++ ){
	for( int i=0; i<_src.width; i++ ){
	int srcColor =_src.data[j][i];
	Integer srcPixel = new Integer( srcColor );
	Integer destPixel = (Integer)(pixelMap.get(srcPixel));
	if( destPixel == null ){
	int destColor = convertColor( srcColor, type );
	destImage.data[j][i] = destColor;
	pixelMap.put( srcPixel, new Integer(destColor) );
	}
	else{
	destImage.data[j][i] = destPixel.intValue();
	}
	}
	}
	return( destImage );
	}

	public static int convertColor( int _src, int _type ) throws LowVisionException{
	try{
	if( PRESERVE_SRGB_Y ){
	ColorSRGB srgb = (new ColorIRGB( _src )).toSRGB();
	// float preservedY = 0.299fsrgb.getR() + 0.587fsrgb.getG() +
	// 0.114f*srgb.getB();
	float preservedY = Math.max( srgb.getR(), Math.max( srgb.getG(), srgb.getB() ) );
	ColorYXY yxy = srgb.toYXY();
	// move (x,y) while keeping brightness (yy)
	ColorYXY newYXY = moveXY( yxy, _type );
	ColorSRGB newSRGB = newYXY.toSRGB();
	float newR = newSRGB.getR();
	float newG = newSRGB.getG();
	float newB = newSRGB.getB();
	// float newY = 0.299fnewR + 0.587fnewG + 0.114f*newB;
	float newY = Math.max( newR, Math.max( newG, newB ) );
	float ratio = 0.0f;
	if( newY != 0.0f )
	ratio = preservedY/newY;
	else
	ratio = 1.0f; // black
	newSRGB.setR( newR*ratio );
	newSRGB.setG( newG*ratio );
	newSRGB.setB( newB*ratio );
	return( newSRGB.toIRGB().toInt() );
	}
	else{
	ColorIRGB irgb = new ColorIRGB( _src );
	ColorYXY yxy = irgb.toYXY();
	// move (x,y) while keeping brightness (yy)
	ColorYXY newYXY = moveXY( yxy, _type );
	ColorIRGB newIRGB = newYXY.toIRGB();
	return( newIRGB.toInt() );
	}
	}catch( ColorException ce ){
	ce.printStackTrace();
	throw new LowVisionException( "ColorException occurred while converting color.");
	}
	}

	// move (x,y) while keeping brightness (yy)
	private static ColorYXY moveXY( ColorYXY _src, int _type ) throws LowVisionException, ColorException{
	float srcYY = _src.getYY();
	float srcX = _src.getX();
	float srcY = _src.getY();
	float confuseX = 0.0f;
	float confuseY = 0.0f;
	float locusA = 0.0f;
	float locusB = 0.0f;
	if( _type == 1 ){
	confuseX = C1_X;
	confuseY = C1_Y;
	locusA = BW_A;
	locusB = BW_B;
	}
	else if( _type == 2 ){
	confuseX = C2_X;
	confuseY = C2_Y;
	locusA = BW_A;
	locusB = BW_B;
	}
	else if( _type == 3 ){
	confuseX = C3_X;
	confuseY = C3_Y;
	locusA = BR_A;
	locusB = BR_B;
	}
	else{
	throw new LowVisionException( "Invalid type : " + _type );
	}

	float destYY = srcYY;
	float destX = 0.0f;
	float destY = 0.0f;
	if( confuseX != srcX ){
	float confuseA = (confuseY-srcY)/(confuseX-srcX); // slope
	float confuseB = confuseY - confuseA*confuseX; // y-intercept

	if( confuseA != locusA ){
	destX = (confuseB-locusB)/(locusA-confuseA);
	destY = (locusAconfuseB-confuseAlocusB)/(locusA-confuseA);
	}
	else{
	// TBD use polar coordinates, etc.
	/*
	* destX = srcX; destY = srcY; debugUtil.errMsg( this, "(x,y) is
	* out of sRGB's range. (x,y) = " + srcX + ", " + srcY );
	*/
	throw new LowVisionException( "(x,y) is out of sRGB's range. (x,y) = " + srcX + ", " + srcY );
	}
	} else{
	destX = confuseX;
	destY = confuseX*locusA + locusB;
	}

	return( new ColorYXY( destYY, destX, destY ) );
	}
	}