Hi, what do people think about moving Graydon's GdkGraphics2D.BitwiseXORComposite class into gnu.java.awt? Emulating bitwise XOR in a Composite could be useful for many Graphics implementations, and the code does not depend on GDK.
A proposal is attached. I've taken the liberty to write a bit of JavaDoc around Graydon's class, and I've made an optimization for INT_RGB rasters, reducing execution time by about 90% in the common case. There's also a small modification to Graydon's general-case code that saves 1-2% execution time (search for "rpPix"). 'BitwiseXORCompositeTest' is a benchmark/test application. Feel free to include this into whatever other testing code there may be floating around. I'd be quite glad if someone familiar with java.awt.image could review my code, especially the IntContext.isSupported method at the very end of the file "BitwiseXORComposite.java". Best regards, -- Sascha Sascha Brawer, [EMAIL PROTECTED], http://www.dandelis.ch/people/brawer/
/* BitwiseXORComposite.java -- Composite for emulating old-style XOR.
Copyright (C) 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.awt;
import java.awt.Color;
import java.awt.Composite;
import java.awt.CompositeContext;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.image.ColorModel;
import java.awt.image.DataBuffer;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;
/**
* A composite for emulating traditional bitwise XOR of pixel values.
*
* <p><img src="doc-files/BitwiseXORComposite-1.png" width="545"
* height="138" alt="A screen shot of BitwiseXORComposite in action"
* />
*
* <p>The above screen shot shows the result of applying six different
* BitwiseXORComposites. They were constructed with the colors colors
* white, blue, black, orange, green, and brown, respectively. With
* each composite, a fully white rectangle was painted on top of the
* blue bar in the background.
*
* <p>The purpose of this composite is to support the [EMAIL PROTECTED]
* Graphics#setXORMode(Color)} method in composite-aware graphics
* implementations. A concrete <code>Graphics2D</code> would contain
* the following code:
*
* <p><pre>public void setXORMode(Color xorColor)
* {
* setComposite(new gnu.java.awt.BitwiseXORComposite(xorColor));
* }
*
* public void setPaintMode()
* {
* setComposite(java.awt.AlphaComposite.SrcOver);
* }</pre>
*
* @author Graydon Hoare ([EMAIL PROTECTED])
* @author Sascha Brawer ([EMAIL PROTECTED])
*/
public class BitwiseXORComposite
implements Composite
{
/**
* The color whose RGB value is xor-ed with the values of each
* pixel.
*/
protected Color xorColor;
/**
* Constructs a new composite for xor-ing the pixel value.
*
* @param xorColor the color whose pixel value will be bitwise
* xor-ed with the source and destination pixels.
*/
public BitwiseXORComposite(Color xorColor)
{
this.xorColor = xorColor;
}
/**
* Creates a context object for performing the compositing
* operation. Several contexts may co-exist for one composite; each
* context may simultaneously be called from concurrent threads.
*
* @param srcColorModel the color model of the source.
* @param dstColorModel the color model of the destination.
* @param hints hints for choosing between rendering alternatives.
*/
public CompositeContext createContext(ColorModel srcColorModel,
ColorModel dstColorModel,
RenderingHints hints)
{
if (IntContext.isSupported(srcColorModel, dstColorModel, hints))
return new IntContext(srcColorModel, xorColor);
return new GeneralContext(srcColorModel, dstColorModel, xorColor);
}
/**
* A fallback CompositeContext that performs bitwise XOR of pixel
* values with the pixel value of the specified <code>xorColor</code>.
*
* <p>Applying this CompositeContext on a 1024x1024 BufferedImage of
* <code>TYPE_INT_RGB</code> took 611 ms on a lightly loaded 2.4 GHz
* Intel Pentium 4 CPU running Sun J2SE 1.4.1_01 on GNU/Linux
* 2.4.20. The timing is the average of ten runs on the same
* BufferedImage. Since the measurements were taken with [EMAIL PROTECTED]
* System#currentTimeMillis()}, they are rather inaccurate.
*
* @author Graydon Hoare ([EMAIL PROTECTED])
*/
private static class GeneralContext
implements CompositeContext
{
ColorModel srcColorModel;
ColorModel dstColorModel;
Color xorColor;
public GeneralContext(ColorModel srcColorModel,
ColorModel dstColorModel,
Color xorColor)
{
this.srcColorModel = srcColorModel;
this.dstColorModel = dstColorModel;
this.xorColor = xorColor;
}
public void compose(Raster src, Raster dstIn, WritableRaster dstOut)
{
Rectangle srcRect = src.getBounds();
Rectangle dstInRect = dstIn.getBounds();
Rectangle dstOutRect = dstOut.getBounds();
int xp = xorColor.getRGB();
int w = Math.min(Math.min (srcRect.width, dstOutRect.width),
dstInRect.width);
int h = Math.min(Math.min (srcRect.height, dstOutRect.height),
dstInRect.height);
Object srcPix = null, dstPix = null, rpPix = null;
// Re-using the rpPix object saved 1-2% of execution time in
// the 1024x1024 pixel benchmark.
for (int y = 0; y < h; y++)
{
for (int x = 0; x < w; x++)
{
srcPix = src.getDataElements(x + srcRect.x, y + srcRect.y, srcPix);
dstPix = dstIn.getDataElements(x + dstInRect.x, y + dstInRect.y,
dstPix);
int sp = srcColorModel.getRGB(srcPix);
int dp = dstColorModel.getRGB(dstPix);
int rp = sp ^ xp ^ dp;
dstOut.setDataElements(x + dstOutRect.x, y + dstOutRect.y,
dstColorModel.getDataElements(rp, rpPix));
}
}
}
/**
* Disposes any cached resources. The default implementation does
* nothing because no resources are cached.
*/
public void dispose()
{
}
}
/**
* An optimized CompositeContext that performs bitwise XOR of
* <code>int</code> pixel values with the pixel value of a specified
* <code>xorColor</code>. This CompositeContext working only for
* rasters whose transfer format is [EMAIL PROTECTED] DataBuffer#TYPE_INT}.
*
* <p>Applying this CompositeContext on a 1024x1024 BufferedImage of
* <code>TYPE_INT_RGB</code> took 69 ms on a lightly loaded 2.4 GHz
* Intel Pentium 4 CPU running Sun J2SE 1.4.1_01 on GNU/Linux
* 2.4.20. The timing is the average of ten runs on the same
* BufferedImage. Since the measurements were taken with [EMAIL PROTECTED]
* System#currentTimeMillis()}, they are rather inaccurate.
*
* @author Sascha Brawer ([EMAIL PROTECTED])
*/
private static class IntContext
extends GeneralContext
{
public IntContext(ColorModel colorModel, Color xorColor)
{
super(colorModel, colorModel, xorColor);
}
public void compose(Raster src, Raster dstIn,
WritableRaster dstOut)
{
int aX, bX, dstX, aY, bY, dstY, width, height;
int xorPixel, transferType;
int[] srcLine, dstLine;
aX = src.getMinX();
aY = src.getMinY();
bX = dstIn.getMinX();
bY = dstIn.getMinY();
dstX = dstOut.getMinX();
dstY = dstOut.getMinY();
width = Math.min(Math.min(src.getWidth(), dstIn.getWidth()),
dstOut.getWidth());
height = Math.min(Math.min(src.getHeight(), dstIn.getHeight()),
dstOut.getHeight());
if ((width < 1) || (height < 1))
return;
srcLine = new int[width];
dstLine = new int[width];
/* We need an int[] array with at least one element here;
* srcLine is as good as any other.
*/
srcColorModel.getDataElements(xorColor.getRGB(), srcLine);
xorPixel = srcLine[0];
for (int y = 0; y < height; y++)
{
src.getDataElements(aX, y + aY, width, 1, srcLine);
dstIn.getDataElements(bX, y + bY, width, 1, dstLine);
for (int x = 0; x < width; x++)
dstLine[x] ^= srcLine[x] ^ xorPixel;
dstOut.setDataElements(dstX, y + dstY, width, 1, dstLine);
}
}
/**
* Determines whether an instance of this CompositeContext would
* be able to process the specified color models.
*/
public static boolean isSupported(ColorModel srcColorModel,
ColorModel dstColorModel,
RenderingHints hints)
{
// FIXME: It would be good if someone could review these checks.
// They probably need to be more restrictive.
int transferType;
transferType = srcColorModel.getTransferType();
if (transferType != dstColorModel.getTransferType())
return false;
if (transferType != DataBuffer.TYPE_INT)
return false;
return true;
}
}
}
<<attachment: BitwiseXORComposite-1.png>>
// FIXME: Into which package should this go?
// FIXME: Which license is appropriate for such test code?
import gnu.java.awt.BitwiseXORComposite;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
/**
* A little test application for testing the GNU BitwiseXORComposite
* class. This code is a bit messy, but it would be best cleaned up
* once it is integrated into a larger Java2D testing application.
*
* @author Sascha Brawer ([EMAIL PROTECTED])
*/
public class BitwiseXORCompositeTest
{
private static class XORTestComponent
extends Component
{
/**
* If this is <code>true</code>, the display is split in two
* halves. The upper half is painted with the GNU
* BitwiseXORComposite, the lower half is painted using
* <code>setXORMode</code> of the graphics that is passed to
* <code>paint</code>.
*
* <p>If this is <code>false</code>, the display is not split, and
* the GNU BitwiseXORComposite is always used.
*/
protected boolean compareWithXORMode = true;
private void d(Graphics g, Color col, int i)
{
int width = getWidth();
int height = getHeight();
int w = (width - 10) / 8;
int stripeWidth = 3 * w / 4;
int stripeHeight = 3 * height / 8 ;
int x = i * w + w / 4;
Graphics2D g2 = (Graphics2D) g;
g2.setComposite(new BitwiseXORComposite(col));
if (compareWithXORMode)
{
paintStripe(g, x, 5, stripeWidth, stripeHeight);
g.setXORMode(col);
paintStripe(g, x, height - stripeHeight - 5,
stripeWidth, stripeHeight);
}
else
paintStripe(g, x, 5, stripeWidth, height - 10);
}
private void paintStripe(Graphics g, int x, int y, int w, int h)
{
g.setColor(Color.WHITE);
g.fillRect(x, y, w, h);
g.setPaintMode();
g.setColor(Color.BLACK);
g.drawRect(x, y, w, h);
g.drawLine(x + 3, y + h + 1, x + w + 1, y + h + 1);
g.drawLine(x + w + 1, y + 3, x + w + 1, y + h);
}
public void paint(Graphics g)
{
int width = getWidth();
int height = getHeight();
BufferedImage img = new BufferedImage(width, height,
BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = (Graphics2D) img.getGraphics();
g2.setColor(Color.WHITE);
g2.fillRect(0, 0, width, height);
width -= 10;
g2.setColor(Color.BLUE);
g2.fillRect(20, 20, width - 40, height - 40);
g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
g2.setFont(new Font("Lucida", Font.PLAIN, 80));
g2.setColor(Color.WHITE);
g2.drawString("Bitwise XOR", 40, 30 + height/2);
d(g2, Color.WHITE, 1);
d(g2, Color.BLUE, 2);
d(g2, Color.BLACK, 3);
d(g2, Color.ORANGE, 4);
d(g2, Color.GREEN, 5);
d(g2, new Color(200,100,50), 6);
g2.dispose();
g.drawImage(img, 0, 0, null);
}
}
public static int getTimeForRun(BufferedImage img)
{
long time;
Composite comp;
Graphics2D g2;
int width = img.getWidth();
int height = img.getHeight();
g2 = (Graphics2D) img.getGraphics();
comp = new gnu.java.awt.BitwiseXORComposite(Color.red);
g2.setComposite(comp);
g2.setColor(Color.green);
time = System.currentTimeMillis();
g2.fillRect(0, 0, width, height);
time = System.currentTimeMillis() - time;
g2.dispose();
return (int) time;
}
private static void runTests(int numRuns)
{
int[] runs = new int[numRuns];
double sum = 0.0;
System.out.println("Running the 1024x1024 benchmark " + numRuns
+ " times...");
BufferedImage img = new BufferedImage(1024, 1024,
BufferedImage.TYPE_INT_RGB);
for (int i = 0; i < numRuns; i++)
{
runs[i] = getTimeForRun(img);
sum += runs[i];
}
for (int i = 0; i < numRuns; i++)
System.out.print(" " + runs[i]);
System.out.println(", avg=" + sum/numRuns + " ms");
}
public static void main(String[] args)
{
runTests(10);
Frame f = new Frame("BitwiseXORComposite");
Component xt = new XORTestComponent();
f.setSize(new Dimension(560,160));
f.add(xt);
f.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
});
f.setVisible(true);
}
}
_______________________________________________ Classpath mailing list [EMAIL PROTECTED] http://mail.gnu.org/mailman/listinfo/classpath
