I have an off-screen BufferedImage, constructed with the type
BufferedImage.TYPE_INT_ARGB. It can contain anything, and I’m looking for a way to (fairly efficiently) completely overwrite the image with transparent pixels, resulting in an ‘invisible’ image.
Using something like this:
(bufimg.getGraphics()).setColor(new Color(10, 10, 100, 0)); (bufimg.getGraphics()).fillRect (0, 0, x, y);
Has no effect. One possible method might be just to write over every pixel in the BufferedImage, but I’m not sure this is the best solution. How would you do it?
The Graphics documentation advises against using clearRect for off-screen images, but I have tried it with the same results as above.
After experimenting with MeBigFatGuy’s code (thanks!), it does clear an image. But it also stops further painting to that image (or appears to). This code for example:
BufferedImage img = new BufferedImage (600, 600, BufferedImage.TYPE_INT_ARGB); Graphics g = img.createGraphics () g.drawLine (100, 100, 500, 500); AlphaComposite composite = AlphaComposite.getInstance(AlphaComposite.CLEAR, 0.0f); g.setComposite(composite); g.setColor(new Color(0, 0, 0, 0)); g.fillRect(0, 0, 600, 600); graphicsAI.setColor(new Color (10, 10, 10, 255)); graphicsAI.drawLine (100, 100, 500, 500);
Results in nothing seen on the image (I’m drawing the image to a JPanel). Is this something to do with the addition of alpha values?
You could get the underlying
int array of your
BufferedImage (make sure to use a compatible format: that is, one that is backed by an
Then fill the
int with ints whose alpha value are 0 (0 will do ; )
System.arraycopy will be very fast.
You have to know that directly writing in the
int is a lot faster than using setRGB.
BufferedImage are a bit of a black art in Java: depending on what you’re doing and on which platform/JVM you’re doing it, you may lose hardware acceleration (which may never have been there in the first place anyway). In addition to that, you may very well not care at all about hardware acceleration anyway because you may not be working on, say, a game requiring 60+ FPS to be playable etc.
This is a very complicated topic and there’s more than one way to skin the
BufferedImage cat. As far as I’m concerned I work directly in the
int when I’ve got to mess at the pixel level because I think it makes much more sense than trying to use higher-level drawing primitives and I do really don’t care about the potential lost of hardware acceleration.