Is it possible to draw a line with a semi-transparent color opaquely on top of other pixels in a BufferedImage?

I try to prepare a BufferedImage with semi-transparency so that whereever this image is painted on top of the background will partially shine through. For this purpose I use among other things Graphics.drawLine() with a stroke > 1 and colors that have an alpha component < 255, i.e. are semi-transparent. Lines I draw will often overlap or intersect to make sure there will be no gaps. When such intersections occur, the colors of the lines will stack, i.e. the color that was there before and the semi-transparent color I am painting with will result in a new color. Which is logical.

That is not what I want, however. If possible, I would like to paint with my semi-transparent color as if it was completely opaque and the alpha component of the color just a fourth color component. I would like to copy the color I am painting with - including the alpha component - exactly to the image, replacing everything that was there before.

Is there a way to do this?

The following code produces a simple semi-transparent red X, that will let the background partially shine through wherever it is painted on top of. It will have, however, a darker part where both lines intersect. I would like to be able to paint the X without this darker part. Is that possible (while still using Graphics.drawLine())?

import java.awt.*;
import java.awt.image.*;
import java.io.*;
import javax.imageio.*;

public class Test {
	
	public static void main(String[] args) {
		// create a new BufferedImage with alpha channel
		BufferedImage img = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB);
		Graphics2D g = img.createGraphics();
		// set a semi-transparent color and a stroke wider than one pixel
		g.setColor(new Color(255, 0, 0, 128 /* alpha; semi-transparent */));
		g.setStroke(new BasicStroke(2));
		// draw a cross; where the lines cross the color will (logically) be darker
		g.drawLine(0, 0, 100, 100);
		g.drawLine(0, 100, 100, 0);
		// use the image somehow, in this case write it to file
		writeImage(img, "test.png");
	}
	
	private static void writeImage(BufferedImage img, String fileName) {
		try {
			ImageIO.write(img, "png", new File(fileName));
		}
		catch (IOException e) {
			System.out.println(e);
		}
	}
}

I could, of course, solve this manually by implementing my own line drawing method and manipulate the pixels directly. (Not sure if that would create new problems with clipping which I also need.) However, that would increase the effort substantially which I would like to avoid.

A further constraint: I am restricted to Java 7.

• Create a second image.
• Draw on that second image with opaque colors.
• Copy that second image onto your original image using translucent alpha.

import java.io.*;
import javax.imageio.*;
public class TranslucentX {
public static void main(String[] args) {
BufferedImage x = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB);
Graphics2D g = x.createGraphics();
g.setColor(new Color(255, 0, 0));
g.setStroke(new BasicStroke(2));
// draw a cross; where the lines cross the color will (logically) be darker
g.drawLine(0, 0, 100, 100);
g.drawLine(0, 100, 100, 0);
g.dispose();
// create a new BufferedImage with alpha channel
BufferedImage img = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB);
g = img.createGraphics();
// Draw opaque image using translucency.
g.setComposite(
AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f));
g.drawImage(x, 0, 0, null);
g.dispose();
// use the image somehow, in this case write it to file
writeImage(img, "test.png");
}
private static void writeImage(BufferedImage img, String fileName) {
try {
ImageIO.write(img, "png", new File(fileName));
}
catch (IOException e) {
System.out.println(e);
}
}
}