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)
======================================================================