Bouncing balls with trails - for fun and play

[Carey Brown]

Some time ago there was a thread on a bouncing balls program. The other day I added to that code so that the balls would have trails. I do this by each iteration blurring and darkening the previous image buffer before painting the new balls over it. HAPPY THANKSGIVING (USA)
Two lines of code were Java 8.
blur2() and darken2() were attempts at performance improvement and are not currently being called.

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.image.BufferedImage;
import java.awt.image.ConvolveOp;
import java.awt.image.Kernel;
import java.awt.image.RescaleOp;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.Timer;


//======================================================================
@SuppressWarnings("serial")
public class BouncingBallsWithTrails
extends JFrame
{
	private PlayScreen		ps;

	public BouncingBallsWithTrails()
	{
		setTitle( "Bouncing Balls With Trails" );
		setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
		setLayout( new BorderLayout() );
		ps = new PlayScreen( 1280, 720 );
		add( ps, BorderLayout.CENTER );
		pack();
		setVisible( true );
	}

	public static void main( String[] args )
	{
		SwingUtilities.invokeLater( () -> new BouncingBallsWithTrails() );
	}
}

//======================================================================
@SuppressWarnings("serial")
class PlayScreen
extends JPanel
implements ComponentListener
{
	private static final int	DARKEN = 6;
	float[] multipliers = {
			0.0625f, 0.1250f, 0.0625f,
			0.1250f, 0.2500f, 0.1250f,
			0.0625f, 0.1250f, 0.0625f };
	Kernel kernel = new Kernel(3,3,multipliers);
	Kernel kernelh = new Kernel(3,1,new float[]{0.25f,0.5f,0.25f});
	Kernel kernelv = new Kernel(1,3,new float[]{0.25f,0.5f,0.25f});
	ConvolveOp coph = new ConvolveOp(kernelh);
	ConvolveOp copv = new ConvolveOp(kernelv);

	private List<Ball>	balls = new ArrayList<>();
	private Timer		timer;
	private BufferedImage	image;

	public PlayScreen( int width, int height )
	{
		Dimension dim = new Dimension( width, height );
		
		image = new BufferedImage( width, height, BufferedImage.TYPE_INT_RGB );
		Graphics	g = image.getGraphics();
		g.setColor( Color.BLACK );
		g.fillRect( 0, 0, getWidth(), getHeight() );
		
		setPreferredSize( dim );
//		setMaximumSize( dim );
		setMinimumSize( dim );
		addComponentListener( this );
		
		for( int i=0 ; i < 200 ; i++ )
			balls.add( new Ball( width, height ) );
		
		timer = new Timer( 10,
			(evt) -> { balls.forEach( b -> b.advance( getWidth(), getHeight() ) ); repaint(); }
			);
	}

	private void darken()
	{
		for( int y=0 ; y < image.getHeight() ; y++ )
			for( int x=0 ; x < image.getWidth() ; x++ )
			{
				int rgb = image.getRGB( x, y );
				if( (rgb & 0xFFFFFF) == 0 )
					continue;
				
				int r = (rgb & 0xFF0000) >> 16;
				if( r < DARKEN )
					r = 0;
				else
					r -= DARKEN;
				int g = (rgb & 0x00FF00) >> 8;
				if( g < DARKEN )
					g = 0;
				else
					g -= DARKEN;
				int b = (rgb & 0x0000FF);
				if( b < DARKEN )
					b = 0;
				else
					b -= DARKEN;
				rgb = 0xFF000000 | (r << 16) | (g << 8) | b;
				image.setRGB( x, y, rgb );
			}
	}

	private void blur()
	{
		ConvolveOp cop = new ConvolveOp(kernel);
		image = cop.filter( image, null );
	}

	// horizontal and vertical
	private void blur2()
	{
		image = coph.filter( image, null );
		image = copv.filter( image, null );
	}
	
	// only works with image type RGB, not ARGB
	private void darken2()
	{
		RescaleOp op = new RescaleOp( 0.9f, 0, null );
		image = op.filter( image, null );
	}
	
	public void paintComponent( Graphics g )
	{
//		super.paintComponent( g );
//		g.setColor( Color.BLACK );
//		g.fillRect( 0, 0, getWidth(), getHeight() );
		blur();
		darken();
		Graphics ig = image.getGraphics();
		balls.forEach( b -> b.paint( ig ) );
		g.drawImage( image, 0, 0, null );
		timer.start();
	}

	@Override
	public void componentResized( ComponentEvent e )
	{
		image = new BufferedImage( getWidth(), getHeight(), BufferedImage.TYPE_INT_RGB );
		Graphics	g = image.getGraphics();
		g.setColor( Color.BLACK );
		g.fillRect( 0, 0, getWidth(), getHeight() );
		
		balls.forEach( b -> b.newRandomLocation( getWidth(), getHeight() ) );
	}

	@Override
	public void componentMoved( ComponentEvent e ) { }

	@Override
	public void componentShown( ComponentEvent e ) { }

	@Override
	public void componentHidden( ComponentEvent e ) { }
}

//======================================================================
class Ball
{
	private int			x, y;
	private int			incrX, incrY;
	private int			width;
	private int			height;
	private Color		color;
	private Random		rand = new Random();

	// Construct random ball
	public Ball( int panelWidth, int panelHeight )
	{
		width = height = rand.nextInt( 50 ) + 10;
		x = rand.nextInt( panelWidth - width );
		y = rand.nextInt( panelHeight - height );
		incrX = rand.nextInt( 5 ) + 1;
		incrY = rand.nextInt( 5 ) + 1;
		color = new Color( rand.nextInt() & 0xffffff );
	}

	public void paint( Graphics g )
	{
		g.setColor( color );
		g.fillOval( x, y, width, height );
	}

	public void newRandomLocation( int panelWidth, int panelHeight )
	{
		x = rand.nextInt( panelWidth - width );
		y = rand.nextInt( panelHeight - height );
	}
	
	public void advance( int panelWidth, int panelHeight )
	{
		if( x >= panelWidth - width )	{ incrX = -incrX; x = panelWidth - width; }
		else if( x < 0 )				{ incrX = -incrX; x = 0; }
		if( y >= panelHeight - height )	{ incrY = -incrY; y = panelHeight - height; }
		else if( y < 0 )				{ incrY = -incrY; y = 0;}
		x += incrX;
		y += incrY;
	}
}

[Junilu Lacar]

It's quite mesmerizing. Now I have to figure out how it works and see if I can refactor it a little. Too bad we aren't able to give out turkeys today so have a cow instead.

[Carey Brown]

Some refactoring. Moved image processing into its own utility class.

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.image.BufferedImage;
import java.awt.image.ConvolveOp;
import java.awt.image.Kernel;
import java.awt.image.RescaleOp;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.Timer;


//======================================================================
@SuppressWarnings("serial")
public class BouncingBallsWithTrails
extends JFrame
{
	private PlayScreen		ps;

	public BouncingBallsWithTrails()
	{
		setTitle( "Bouncing Balls With Trails" );
		setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
		setLayout( new BorderLayout() );
		ps = new PlayScreen( 1280, 720 );
		add( ps, BorderLayout.CENTER );
		pack();
		setVisible( true );
	}

	public static void main( String[] args )
	{
		// Java 8
		SwingUtilities.invokeLater( () -> new BouncingBallsWithTrails() );
	}
}

//======================================================================
@SuppressWarnings("serial")
class PlayScreen
extends JPanel
implements ComponentListener
{
	private static final int	NUMBER_OF_BALLS = 200;
	
	private List<Ball>		balls = new ArrayList<>();
	private Timer			timer;
	private BufferedImage	image;

	public PlayScreen( int width, int height )
	{
		Dimension dim = new Dimension( width, height );
		
		image = new BufferedImage( width, height, BufferedImage.TYPE_INT_RGB );
		Graphics	g = image.getGraphics();
		g.setColor( Color.BLACK );
		g.fillRect( 0, 0, getWidth(), getHeight() );
		
		setPreferredSize( dim );
		setMinimumSize( dim );
		addComponentListener( this );
		
		for( int i=0 ; i < NUMBER_OF_BALLS ; i++ )
			balls.add( new Ball( width, height ) );
		
		// Java 8
		timer = new Timer( 10,
			(evt) -> { balls.forEach( b -> b.advance( getWidth(), getHeight() ) ); repaint(); }
			);
	}
	
	public void paintComponent( Graphics g )
	{
		image = ImageProcessing.blur( image );
		image = ImageProcessing.darken( image );
		Graphics ig = image.getGraphics();
		balls.forEach( b -> b.paint( ig ) ); // Java 8
		g.drawImage( image, 0, 0, null );
		timer.start();
	}

	@Override
	public void componentResized( ComponentEvent e )
	{
		image = new BufferedImage( getWidth(), getHeight(), BufferedImage.TYPE_INT_RGB );
		Graphics	g = image.getGraphics();
		g.setColor( Color.BLACK );
		g.fillRect( 0, 0, getWidth(), getHeight() );
		
		// Java 8
		balls.forEach( b -> b.newRandomLocation( getWidth(), getHeight() ) );
	}

	@Override
	public void componentMoved( ComponentEvent e ) { }

	@Override
	public void componentShown( ComponentEvent e ) { }

	@Override
	public void componentHidden( ComponentEvent e ) { }
}

//======================================================================
class Ball
{
	private static final Random		rand = new Random();
	
	private int			x, y;
	private int			incrX, incrY;
	private int			width;
	private int			height;
	private Color		color;

	// Construct random ball
	public Ball( int panelWidth, int panelHeight )
	{
		width = height = rand.nextInt( 50 ) + 10;
		x = rand.nextInt( panelWidth - width );
		y = rand.nextInt( panelHeight - height );
		incrX = rand.nextInt( 5 ) + 1;
		incrY = rand.nextInt( 5 ) + 1;
		color = new Color( rand.nextInt() & 0xffffff );
	}

	public void paint( Graphics g )
	{
		g.setColor( color );
		g.fillOval( x, y, width, height );
	}

	public void newRandomLocation( int panelWidth, int panelHeight )
	{
		x = rand.nextInt( panelWidth - width );
		y = rand.nextInt( panelHeight - height );
	}
	
	public void advance( int panelWidth, int panelHeight )
	{
		// Handle balls at edge of JPanel
		if( x >= panelWidth - width )	{ incrX = -incrX; x = panelWidth - width; }
		else if( x < 0 )				{ incrX = -incrX; x = 0; }
		if( y >= panelHeight - height )	{ incrY = -incrY; y = panelHeight - height; }
		else if( y < 0 )				{ incrY = -incrY; y = 0;}
		
		x += incrX;
		y += incrY;
	}
}

//======================================================================
class ImageProcessing
{
	private static final int	DARKEN = 6;
	
	// 3x3 convolution for blur
	private static final float[] multipliers =
	{
		0.0625f, 0.1250f, 0.0625f,
		0.1250f, 0.2500f, 0.1250f,
		0.0625f, 0.1250f, 0.0625f
	};
	private static final Kernel kernel = new Kernel(3,3,multipliers);
	private static final ConvolveOp blur3x3 = new ConvolveOp(kernel);
	
	// 1x3 and 3x1 convolutions for blur2
	// A symmetric NxN convolution can be replaced by applying two
	// convolutions in turn, one horizontal and one vertical
	private static final Kernel kernel3x1 = new Kernel(3,1,new float[]{0.25f,0.5f,0.25f});
	private static final Kernel kernel1x3 = new Kernel(1,3,new float[]{0.25f,0.5f,0.25f});
	private static final ConvolveOp blur3x1 = new ConvolveOp(kernel3x1);
	private static final ConvolveOp blur1x3 = new ConvolveOp(kernel1x3);
	
	// for darken2
	private static final RescaleOp darkenOp = new RescaleOp( 0.9f, 0, null );

	//-------------------------
	
	public static BufferedImage darken( BufferedImage image )
	{
		for( int y=0 ; y < image.getHeight() ; y++ )
			for( int x=0 ; x < image.getWidth() ; x++ )
			{
				int rgb = image.getRGB( x, y );
				if( (rgb & 0xFFFFFF) == 0 ) // is BLACK ?
					continue;
				
				int r = (rgb & 0xFF0000) >> 16;
				if( r < DARKEN )
					r = 0;
				else
					r -= DARKEN;
				int g = (rgb & 0x00FF00) >> 8;
				if( g < DARKEN )
					g = 0;
				else
					g -= DARKEN;
				int b = (rgb & 0x0000FF);
				if( b < DARKEN )
					b = 0;
				else
					b -= DARKEN;
				rgb = 0xFF000000 | (r << 16) | (g << 8) | b;
				image.setRGB( x, y, rgb );
			}
		return image;
	}
	
	// only works with image type RGB, not ARGB
	public static BufferedImage darken2( BufferedImage image )
	{
		image = darkenOp.filter( image, null );
		return image;
	}

	// 3x3 blur convolution
	public static BufferedImage blur( BufferedImage image )
	{
		image = blur3x3.filter( image, null );
		return image;
	}

	// horizontal and vertical blur convolutions
	public static BufferedImage blur2( BufferedImage image )
	{
		image = blur3x1.filter( image, null );
		image = blur1x3.filter( image, null );
		return image;
	}
}

[Junilu Lacar]

I'm not quite convinced that ImageProcessing is a good class to extract that stuff out to. Here's what I've done so far to clean up the code, mostly around the Ball class for now. Still reading up on Kernel and the darkening and blurring graphics stuff. I haven't done a lot of graphics programming so it may take me another day or two to figure out the rest of the code.

Summary of changes I made:

1. Gave the Ball class the responsibility of creating a random list of balls: static newList()

2. Changed newRandomLocation() to adjustBounds() so that the balls would stay on their current trajectories when window is resized. They now just "be like water" and adjust to their container size. I like watching what the balls do now when you resize the window.

3. Refactored for clarity: did a lot of extracting to methods.  I had created a bunch of constants for MIN/MAX_COUNT, MIN/MAX_RATE, MIN/MAX_SIZE but since they were only used in the one place, I just inlined the values back in their respective extracted methods.

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.image.BufferedImage;
import java.awt.image.ConvolveOp;
import java.awt.image.Kernel;
import java.awt.image.RescaleOp;
import java.util.Arrays;
import java.util.List;
import java.util.Random;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.Timer;

// https://coderanch.com/t/673124/java/Bouncing-balls-trails-fun-play

//======================================================================
@SuppressWarnings("serial")
public class BouncingBallsWithTrails extends JFrame {
	private PlayScreen ps;

	public BouncingBallsWithTrails() {
		setTitle("Bouncing Balls With Trails");
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setLayout(new BorderLayout());
		ps = new PlayScreen(1280, 720);
		add(ps, BorderLayout.CENTER);
		pack();
		setVisible(true);
	}

	public static void main(String[] args) {
		SwingUtilities.invokeLater(() -> new BouncingBallsWithTrails());
	}
}

// ======================================================================
@SuppressWarnings("serial")
class PlayScreen extends JPanel implements ComponentListener {
	private static final int DARKEN = 6;
	float[] multipliers = { 0.0625f, 0.1250f, 0.0625f, 0.1250f, 0.2500f, 0.1250f, 0.0625f, 0.1250f, 0.0625f };
	Kernel kernel = new Kernel(3, 3, multipliers);
	Kernel kernelh = new Kernel(3, 1, new float[] { 0.25f, 0.5f, 0.25f });
	Kernel kernelv = new Kernel(1, 3, new float[] { 0.25f, 0.5f, 0.25f });
	ConvolveOp coph = new ConvolveOp(kernelh);
	ConvolveOp copv = new ConvolveOp(kernelv);

	private List<Ball> balls;
	private Timer timer;
	private BufferedImage image;

	public PlayScreen(int width, int height) {
		initScreenImage(width, height);
		initDimensions(width, height);
		initBalls(width, height);
		
		addComponentListener(this);

	}

	public void initBalls(int width, int height) {
		balls = Ball.newList(width, height);

		timer = new Timer(10, (evt) -> {
			balls.forEach(b -> b.move());
			repaint();
		});
	}

	private final void initDimensions(int width, int height) {
		Dimension dim = new Dimension(width, height);
		setPreferredSize(dim);
		setMinimumSize(dim);
	}

	private final void initScreenImage(int width, int height) {
		image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
		Graphics g = image.getGraphics();
		g.setColor(Color.BLACK);
		g.fillRect(0, 0, width, height);
	}

	private void darken() {
		for (int y = 0; y < image.getHeight(); y++)
			for (int x = 0; x < image.getWidth(); x++) {
				int rgb = image.getRGB(x, y);
				if ((rgb & 0xFFFFFF) == 0)
					continue;

				int r = (rgb & 0xFF0000) >> 16;
				if (r < DARKEN)
					r = 0;
				else
					r -= DARKEN;
				
				int g = (rgb & 0x00FF00) >> 8;
				if (g < DARKEN)
					g = 0;
				else
					g -= DARKEN;
				
				int b = (rgb & 0x0000FF);
				if (b < DARKEN)
					b = 0;
				else
					b -= DARKEN;
				
				rgb = 0xFF000000 | (r << 16) | (g << 8) | b;
				image.setRGB(x, y, rgb);
			}
	}

	private void blur() {
		ConvolveOp cop = new ConvolveOp(kernel);
		image = cop.filter(image, null);
	}

	// horizontal and vertical
	private void blur2() {
		image = coph.filter(image, null);
		image = copv.filter(image, null);
	}

	// only works with image type RGB, not ARGB
	private void darken2() {
		RescaleOp op = new RescaleOp(0.9f, 0, null);
		image = op.filter(image, null);
	}

	public void paintComponent(Graphics g) {
		// super.paintComponent( g );
		// g.setColor( Color.BLACK );
		// g.fillRect( 0, 0, getWidth(), getHeight() );
		blur();
		darken();
		Graphics ig = image.getGraphics();
		balls.forEach(b -> b.paint(ig));
		g.drawImage(image, 0, 0, null);
		timer.start();
	}

	@Override
	public void componentResized(ComponentEvent e) {
		initScreenImage(getWidth(), getHeight());
		balls.forEach(b -> b.adjustBounds(getWidth(), getHeight()));
	}

	@Override
	public void componentMoved(ComponentEvent e) {
	}

	@Override
	public void componentShown(ComponentEvent e) {
	}

	@Override
	public void componentHidden(ComponentEvent e) {
	}
}

// ======================================================================
class Ball {
	private static final Random rand = new Random();
	
	static final List<Ball> newList(int width, int height) {
		Ball[] balls = new Ball[randomCount()];
		for (int i = 0; i < balls.length; i++) {
			balls[i] = new Ball(width, height);
		}
		return Arrays.asList(balls);
	}

	private static final int randomCount() {
		return rand.nextInt(90) + 10;
	}
	
	private static final int randomVelocity() {
		return randomRate() * randomDirection(); 
	}
	
	private static final int randomRate() {
		return rand.nextInt(5) + 1;
	}
	
	private static final int randomDirection() {
		return rand.nextBoolean() ? 1 : -1;
	}
	
	private int x, y;
	private int maxX, maxY;
	private int incrX, incrY;
	private int width;
	private int height;
	private Color color;
	
	// Creates a ball with random attributes
	public Ball(int panelWidth, int panelHeight) {
		maxX = panelWidth;
		maxY = panelHeight;
		
		width = height = rand.nextInt(50) + 10;
		
		x = rand.nextInt(panelWidth - width);
		y = rand.nextInt(panelHeight - height);
		
		incrX = randomVelocity();
		incrY = randomVelocity();
		
		color = new Color(rand.nextInt() & 0xffffff);
	}

	public void paint(Graphics g) {
		g.setColor(color);
		g.fillOval(x, y, width, height);
	}

	void adjustBounds(int width, int height) {
		maxX = width;
		maxY = height;
	}
	
	public void move() {
		moveX();
		moveY();
	}

	private void moveY() {
		y += incrY;
		if (y > maxY - height) {
			y = maxY - height;
			incrY = -incrY;
		} else if (y < 0) {
			y = 0;
			incrY = -incrY;
		}
	}

	private void moveX() {
		x += incrX;
		if (x > maxX - width) {
			x = maxX - width;
			incrX = -incrX;
		} else if (x < 0) {
			x = 0;
			incrX = -incrX;
		}
	}
}

[Junilu Lacar]

I think I understand most of what the program is doing now. I tried using RescaleOp to darken the trails but it produced really long trails, no matter how much I tried increasing the scale factor. I guess it's the same deal with the problem of never ever getting there if you only step 1/2 of the way closer each time.

Below is the refactoring that I have done this morning. Have to go out for some late Thanksgiving day shopping with the wife but thanks, Carey, for the exercise. It was fun.

package com.javaranch.beginner;

import static com.javaranch.beginner.RGB.*;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.image.BufferedImage;
import java.awt.image.ConvolveOp;
import java.awt.image.Kernel;
import java.awt.image.RescaleOp;
import java.util.Arrays;
import java.util.List;
import java.util.Random;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.Timer;

// https://coderanch.com/t/673124/java/Bouncing-balls-trails-fun-play

//======================================================================
@SuppressWarnings("serial")
public class BouncingBallsWithTrails extends JFrame {
	
	public static void main(String[] args) {
		SwingUtilities.invokeLater(() -> new BouncingBallsWithTrails());
	}
	
	private PlayScreen ps;

	public BouncingBallsWithTrails() {
		setTitle("Bouncing Balls With Trails");
		initDisplayAttributes();
		initPlayScreen();
	}

	private void initDisplayAttributes() {
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setLayout(new BorderLayout());
	}

	private void initPlayScreen() {
		ps = new PlayScreen(1280, 720);
		add(ps, BorderLayout.CENTER);
		pack();
		setVisible(true);
	}
}

// ======================================================================
@SuppressWarnings("serial")
class PlayScreen extends JPanel implements ComponentListener {
	
	float[] multipliers = { 0.0625f, 0.1250f, 0.0625f, 0.1250f, 0.2500f, 0.1250f, 0.0625f, 0.1250f, 0.0625f };
	
	Kernel kernel = new Kernel(3, 3, multipliers);
	Kernel kernelh = new Kernel(3, 1, new float[] { 0.25f, 0.5f, 0.25f });
	Kernel kernelv = new Kernel(1, 3, new float[] { 0.25f, 0.5f, 0.25f });
	
	ConvolveOp coph = new ConvolveOp(kernelh);
	ConvolveOp copv = new ConvolveOp(kernelv);
	
	private BufferedImage image;
	private Timer timer;
	private List<Ball> balls;

	public PlayScreen(int width, int height) {
		initScreenImage(width, height);
		initDimensions(width, height);
		initBalls(width, height);
		initTimer();
		
		addComponentListener(this);
	}

	private void initScreenImage(int width, int height) {
		image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
		Graphics g = image.getGraphics();
		g.setColor(Color.BLACK);
		g.fillRect(0, 0, width, height);
	}
	
	private void initDimensions(int width, int height) {
		Dimension dim = new Dimension(width, height);
		setPreferredSize(dim);
		setMinimumSize(dim);
	}
	
	private void initBalls(int width, int height) {
		balls = Ball.newList(width, height);
	}

	private void initTimer() {
		timer = new Timer(10, (onTick) -> {
			balls.forEach(Ball::move);
			repaint();
		});
	}
	
	private void darken() {
		for (int y = 0; y < image.getHeight(); y++) {
			for (int x = 0; x < image.getWidth(); x++) {
				int rgb = image.getRGB(x, y);
				if (!RGB.isBlack(rgb)) {
					image.setRGB(x, y, fadeToBlack(rgb));
				}
			}
		}
	}

	private int fadeToBlack(int rgb) {
		return 0xFF000000 | RED.fadeToBlack(rgb) | GREEN.fadeToBlack(rgb) | BLUE.fadeToBlack(rgb);
	}

	private void blur() {
		ConvolveOp cop = new ConvolveOp(kernel);
		image = cop.filter(image, null);
	}

	// horizontal and vertical
	private void blur2() {
		image = coph.filter(image, null);
		image = copv.filter(image, null);
	}

	// only works with image type RGB, not ARGB
	private void darken2() {
		RescaleOp op = new RescaleOp(0.9f, 0, null);
		image = op.filter(image, null);
	}

	public void paintComponent(Graphics g) {
		// super.paintComponent( g );
		// g.setColor( Color.BLACK );
		// g.fillRect( 0, 0, getWidth(), getHeight() );
		blur();
		darken();
		Graphics ig = image.getGraphics();
		balls.forEach(b -> b.paint(ig));
		g.drawImage(image, 0, 0, null);
		timer.start();
	}

	@Override
	public void componentResized(ComponentEvent e) {
		initScreenImage(getWidth(), getHeight());
		balls.forEach(b -> b.adjustBounds(getWidth(), getHeight()));
	}

	@Override
	public void componentMoved(ComponentEvent e) {
	}

	@Override
	public void componentShown(ComponentEvent e) {
	}

	@Override
	public void componentHidden(ComponentEvent e) {
	}
}

enum RGB {
	RED(16), GREEN(8), BLUE(0);
	
	private final int mask;
	private final int shift;
	
	private RGB(int shift) {
		this.shift = shift;
		this.mask = 0xFF << shift;
	}
	
	private static final int FADE_STEP = 6;
	
	static boolean isBlack(int rgb) {
		return (rgb & 0xFFFFFF) == 0;
	}
	
	int toInt(int rgb) {
		return (rgb & mask) >> shift;
	}
	
	int fadeToBlack(int rgb) {
		int tint = toInt(rgb) - FADE_STEP;
		return (tint < FADE_STEP) ? 0 : tint << shift;
	}
}

// ======================================================================
class Ball {
	private static final Random rand = new Random();
	
	static final List<Ball> newList(int width, int height) {
		Ball[] balls = new Ball[randomCount()];
		for (int i = 0; i < balls.length; i++) {
			balls[i] = new Ball(width, height);
		}
		return Arrays.asList(balls);
	}

	private static final int randomCount() {
		return rand.nextInt(90) + 10;
	}
	
	private static final int randomVelocity() {
		return randomRate() * randomDirection(); 
	}
	
	private static final int randomRate() {
		return rand.nextInt(5) + 1;
	}
	
	private static final int randomDirection() {
		return rand.nextBoolean() ? 1 : -1;
	}
	
	private static final int randomSize() {
		return rand.nextInt(50) + 10;
	}
	
	private static final Color randomColor() {
		return new Color(rand.nextInt() & 0xffffff);
	}
	
	private int x, y;
	private int maxX, maxY;
	private int incrX, incrY;
	private int width;
	private int height;
	private Color color;
	
	// Creates a ball with random attributes
	public Ball(int panelWidth, int panelHeight) {
		maxX = panelWidth;
		maxY = panelHeight;
		
		width = height = randomSize();
		
		incrX = randomVelocity();
		incrY = randomVelocity();
		
		color = randomColor();
		
		x = rand.nextInt(panelWidth - width);
		y = rand.nextInt(panelHeight - height);
	}

	public void paint(Graphics g) {
		g.setColor(color);
		g.fillOval(x, y, width, height);
	}

	void adjustBounds(int width, int height) {
		maxX = width;
		maxY = height;
	}
	
	public void move() {
		moveX();
		moveY();
	}

	private void moveY() {
		y += incrY;
		if (y > maxY - height) {
			y = maxY - height;
			incrY = -incrY;
		} else if (y < 0) {
			y = 0;
			incrY = -incrY;
		}
	}

	private void moveX() {
		x += incrX;
		if (x > maxX - width) {
			x = maxX - width;
			incrX = -incrX;
		} else if (x < 0) {
			x = 0;
			incrX = -incrX;
		}
	}
}

[Junilu Lacar]

Couldn't resist one more refactoring, although this one violates my "don't do evil premature optimization" rule and actually in that sense, it's not truly a "refactoring":

	@Override
	public void componentResized(ComponentEvent e) {
		final int panelWidth = getWidth();
		final int panelHeight = getHeight();
		initScreenImage(panelWidth, panelHeight);
		balls.forEach(b -> b.adjustBounds(panelWidth, panelHeight));
	}

I don't know if this will even result in any significant performance gains or not; I'd be curious to find out but my wife is calling out to me to knock it off and get ready... C'ya later!

[Carey Brown]

I'm glad you enjoyed this Junilu. I enjoyed seeing your refactoring, especially the RGB enum. Thanks for the cow.

[Carey Brown]

How did you get this to compile?

    private int fadeToBlack(int rgb) {
        return 0xFF000000 | RED.fadeToBlack(rgb) | GREEN.fadeToBlack(rgb) | BLUE.fadeToBlack(rgb);
    }

I had to do this

     private int fadeToBlack(int rgb) {
        return 0xFF000000 | RGB.RED.fadeToBlack(rgb) | RGB.GREEN.fadeToBlack(rgb) | RGB.BLUE.fadeToBlack(rgb);
    }

[Junilu Lacar]

See the static import, line 3 in the code that I posted.

In fact, if you also static imported RGB. isBlack, you'll also just write

if (!isBlack(rgb)) {...} 

[Carey Brown]

When I add
import static RGB.*;

I get
The import RGB cannot be resolved

I have a playpen project in Eclipse with no packages. RGB resides in the same .java file as the rest of the code.

[Carey Brown]

Never mind. Seems like import static and default packages are incompatible.

[Junilu Lacar]

I got the RescaleOp working for darkening. It seems to work if you only have one RescaleOp that you reuse over and over instead of creating one every time you call darken().

A somewhat challenging enhancement to this program might be to simulate the balls bouncing off each other in addition to bouncing off the boundaries. Then you can add momentum/inertia based on ball size. I'm going to try it. Will have to research or dig up some of my old physics and mechanics/dynamics knowledge to implement it. Probably call the program Entropy or Chaos.