Name: rmT116609			Date: 11/06/2003


FULL PRODUCT VERSION :
java version "1.4.2_02"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.2
Java HotSpot(TM) Client VM (build 1.4.2_02-b03, mixed mode)

ADDITIONAL OS VERSION INFORMATION :
Microsoft Windows 2000 [Versione 5.00.2195]

A DESCRIPTION OF THE PROBLEM :
I'm making deep use of java2d (I simply love it) for the creation of animated desktop video graphics and video titling.
 
During the development of my applications I have discovered a bug in drawImage() http://developer.java.sun.com/developer/bugParade/bugs/4916948.html that causes incorrect results when drawing images with a translation-only AffineTransform. I also found a workaround for the problem, but I still hope that SUN fixes it asap.

drawImage() bilinear interpolation gives ugly results on ARGB images.
 
consider the 2x2 bitmap pixels :
 
  X0
  00
 
where X is completely transparent (let's say a transparent RED -> 0x00FF0000) and 0 is opaque (let's say an opaque WHITE -> 0xFFFFFFFF).
 
The pixel bilinear interpolation takes the color of the X pixel into consideration. That's completely wrong because the pixel is transparent. When drawing the bitmap at 0.5,0.5 over a clean graphics (0x00000000) the pixel interpolator of java2d gives ugly red artifacts.
 

STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
consider the 2x2 bitmap pixels :
 
  X0
  00
 
where X is completely transparent (let's say a transparent RED -> 0x00FF0000) and 0 is opaque (let's say an opaque WHITE -> 0xFFFFFFFF).
 
The pixel bilinear interpolation takes the color of the X pixel into consideration. That's completely wrong because the pixel is transparent. When drawing the bitmap at 0.5,0.5 over a clean graphics (0x00000000) the pixel interpolator of java2d gives ugly red artifacts.

EXPECTED VERSUS ACTUAL BEHAVIOR :
EXPECTED -
Red artifacts should not appear.

Take a look at
http://www.classx.it/public/bilerp_test.png
http://www.classx.it/public/bilerp_test1.png
http://www.classx.it/public/bilerp_test.jar

Note that MacOSX Java 1.4.1 works correctly.
ACTUAL -
Ugly red artifacts.

REPRODUCIBILITY :
This bug can be reproduced always.

---------- BEGIN SOURCE ----------
package test.bug;

import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;

public class ImageInterpolationBug extends Panel implements java.awt.event.MouseMotionListener
{
	// storage
	private final static int WIDTH = 250;
	private final static int HEIGHT = 90;
	private static int[] pix = new int[WIDTH * HEIGHT];
	private static BufferedImage src = createBufferedImage(pix,WIDTH, HEIGHT, WIDTH,0);
	private float mx = 0, my = 0;

	// create some test gfx
	static
	{
		// the rendering hints
		java.util.HashMap map = new java.util.HashMap();
		map.put(RenderingHints.KEY_ALPHA_INTERPOLATION,	RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
		map.put(RenderingHints.KEY_TEXT_ANTIALIASING,  	RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
		map.put(RenderingHints.KEY_INTERPOLATION,    	RenderingHints.VALUE_INTERPOLATION_BILINEAR);
		map.put(RenderingHints.KEY_DITHERING,	    	RenderingHints.VALUE_DITHER_ENABLE);
		map.put(RenderingHints.KEY_FRACTIONALMETRICS,	RenderingHints.VALUE_FRACTIONALMETRICS_ON);
		map.put(RenderingHints.KEY_ANTIALIASING,		RenderingHints.VALUE_ANTIALIAS_ON);
		map.put(RenderingHints.KEY_RENDERING,			RenderingHints.VALUE_RENDER_QUALITY);
		map.put(RenderingHints.KEY_COLOR_RENDERING,		RenderingHints.VALUE_COLOR_RENDER_QUALITY);

		// set bitmap to all transparent red
		for(int i=0; i<WIDTH*HEIGHT; i++)
		{
			pix[i]=0x00FF0000;
		}

		// the graphics
		Graphics2D g2 = (Graphics2D) src.getGraphics();
		g2.setRenderingHints(map);
		g2.setComposite(AlphaComposite.Src);

		// draw a glyph (this creates a correct test image)
		g2.setFont(new Font("dialog",-1,80));
		java.awt.font.GlyphVector gv = g2.getFont().createGlyphVector(g2.getFontRenderContext(),"J2D");
		g2.translate(10,70);
		g2.setColor(Color.gray);
		g2.fill(gv.getOutline());
		g2.translate(2,2);
		g2.setColor(Color.black);
		g2.fill(gv.getOutline());
	}

	// create the dest raster
	BufferedImage raster = createBufferedImage(new int[640*400],640,400, 640,0);
	public ImageInterpolationBug()
	{
		super();
		setBackground(Color.gray);
	}
	// utility: create a new INT_ARGB bufferedimage with rowints support
	private static final BufferedImage createBufferedImage(int[] pixels, int width, int height, int rowints, int pixoffset)
	{
		// the RGBA color masks
		int[] bm = new int[]{0x00FF0000,0x0000FF00,0x000000FF,0xFF000000};
		// the colormodel
		ColorModel cm = new DirectColorModel(32,bm[0],bm[1],bm[2],bm[3]);
		// allocate bitmap data
		DataBufferInt db = new DataBufferInt(pixels,pixels.length,pixoffset);
		WritableRaster wr = WritableRaster.createPackedRaster(db,width,height,rowints,bm,null);
		// the image
		return new BufferedImage(cm,wr,false,null);
	}
	public static void main(String args[])
	{
		System.out.println("Starting test");

		ImageInterpolationBug canvas = new ImageInterpolationBug();
		Frame frame = new Frame(canvas.getClass().getName());

		frame.addWindowListener(new java.awt.event.WindowAdapter()
		{
			public void windowClosing(java.awt.event.WindowEvent e)
			{
				System.exit(0);
			};
		});

		
		frame.setSize(640, 480);

		canvas.addMouseMotionListener(canvas);

		frame.add("Center", canvas);
		frame.requestFocus();
		frame.setEnabled(true);

		frame.show();
	}
	//
	public void mouseDragged(java.awt.event.MouseEvent e)
	{
	}
	//
	public void mouseMoved(java.awt.event.MouseEvent e)
	{
		mx = e.getX();
		my = e.getY();
		repaint();
	}
	//
	public void paint(Graphics g)
	{
		// get graphics from the raster
		Graphics2D g2d = (Graphics2D) raster.getGraphics();

		// set hints
		g2d.setColor(Color.darkGray);
		g2d.fillRect(0, 0, raster.getWidth(), raster.getHeight());
		
		// draw
		g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
		g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);

		AffineTransform at0 = AffineTransform.getRotateInstance(mx/50f,src.getWidth()/2,src.getHeight()/2);
		g2d.translate(320-WIDTH/2,200-HEIGHT/2);
		g2d.drawImage(src, at0, null);

		g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
		g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
	

		AffineTransform at1 = AffineTransform.getRotateInstance(mx/50f,src.getWidth()/2,src.getHeight()/2);
		g2d.translate(-100,0);
		g2d.drawImage(src,at1, this);
		
		// paint raster on canvas
		g.drawImage(raster, 0, 0, null);
		//g.drawImage(raster, 0, 0, getWidth(), getHeight(), 0,0,raster.getWidth()-200,raster.getHeight()-200, this);

	}
	// avoid flickering, please
	public void update(Graphics g)
	{
		paint(g);
	}
}

---------- END SOURCE ----------
(Incident Review ID: 223638) 
======================================================================