How can I process BufferedImage faster

I'm making a basic image editor to improve my image process skills. I have 12 filters(for now).
All filters have a clickable JLabel that has image
I update images of all of them when all filters apply with this function:

public static void buttonImagesUpdater(){
    for(int i = 0; i < effects.size(); i++){
        effects.get(i).getButton().setImage(new ImageIcon(effects.get(i).process(image)));
    }
}

All filters have a process function like that:

public BufferedImage process(BufferedImage base) {
    BufferedImage product = new BufferedImage(base.getWidth(), base.getHeight(), base.getType());
    for(int indisY = 0; indisY < base.getHeight(); indisY++){
        for(int indisX = 0; indisX < base.getWidth(); indisX++){
            Color currentColor = new Color(base.getRGB(indisX, indisY));
            int greyTone = 0;
            greyTone = (int) (currentColor.getRed()*0.315) +
                    (int) (currentColor.getGreen()*0.215) 
                    + (int) (currentColor.getBlue()*0.111);
            product.setRGB(indisX, indisY, new Color(greyTone,greyTone,greyTone).getRGB());
            
        }
    }
    return product;
}

Program works so slowly. When I click an effect's button it done 45 second later when I use 5000x3000 image. How can I fix this performance problem?

You have got to remember that 3000 * 5000 is 15,000,000 so you're creating 15,000,000 Color objects, you're calling setRGB 15,000,000 times. If I were you, I would look into potentially using ForkJoinPool for this.

I agree with @Jason - the problem is that you're creating (and destroying) 15 million Color objects.

However, I don't think that just using multiple threads is going to get you enough of a performance increase, because you are still going to be putting a lot of pressure on memory and the garbage collector, since you'll still be creating and destroying 15 million objects, you'll just be doing several in parallel.

I think that you can both stay away from creating Color objects entirely, and make fewer loops, by using the result of the BufferedImage class' getRGB() method directly, instead of creating a Color object. Further, you can use the overload of getRGB() that returns an array of ints, to get, say, a row of pixels (or more) at a time, to reduce the number of calls that you have to make inside the loop. You can similarly use the version of setRGB() that takes an array of pixel values.

The trick is to be able to convert the int color value to a gray value (or whatever else you need to do) without separating the R, G, and B values, or finding an efficient way to separate R, G, and B - more efficient than creating, using, and destroying a Color object.

For a lead on getting R, G, and B values from the int returned by getRGB(), note that the documentation for Color.getRGB() says,

> "Returns the RGB value representing the color in the default sRGB
> ColorModel. (Bits 24-31 are alpha, 16-23 are red, 8-15 are green, 0-7
> are blue)."

Once you have that working, you can think about parallelizing it.

You might try this to see if things speed up a little.

• This uses a DataBuffer from an Image Raster.
• And uses a map to retain previous converted colors. It may help over a period of time depending on the type of image.
• And works with doubles since the data buffer supports various types.

I also multiplied your values by powers of 2 to shift them in the proper position. The get* methods of Color return values between 0 and 255 inclusive. The RGB occupy lower 24 bits on an int (Alpha is in the left most byte).

All I see is a dark image but I tested this with other parameters and I know it works. The long pole in the tent seems to be reading and writing the images. I was using a 6637 3787 image and could read, alter, and write it in 12 seconds. For more advanced processing you may want to check on AffineTransformOp.

	static Map<Color, Double> colorMap = new HashMap<>();
	
	public BufferedImage process(BufferedImage base) {
		DataBuffer db = base.getRaster().getDataBuffer();
		for (int i = 0; i < db.getSize(); i++) {
			Color currentColor = new Color(db.getElem(i));
			double greyTone = colorMap.computeIfAbsent(currentColor, v-> 
		    currentColor.getRed() * .315 *256*256
						+ currentColor.getGreen() *.215 * 256
							+ currentColor.getBlue()*.115);
          	
			db.setElemDouble(i, greyTone);
			
		}
		return base;	
	}