Creating and manipulating a variant number of bufferedImages for vision algorithm I'm developing an algorithm that takes structured light patterns to determine 3D properties of objects.  This class builds the structured light objects.  It creates a buffered image, and based upon initialization parameters and the needed iteration step, manipulates the image to form a structured light pattern that will be be projected.  After the total space has been iteratively exhausted a 3D model of the surface will be constructed.  The projection process is then repeated.

The manipulation step of this class constructs different versions of the same image (the pixels will converge towards the center at each step).  

Any suggestions on how I can speed this up, make it smoother, or more readable?

class ImageCollection implements Iterable&lt;BufferedImage&gt; {

private ArrayList&lt;BufferedImage&gt; ImageList = new ArrayList&lt;&gt;();
private static int width;
private static int height;
private static double pointXResolution;
private static double pointYResolution;
private static final Color red = new Color(255, 0, 0);
private static final Color green = new Color(0, 255, 0);
private static final Color blue = new Color(0, 0, 255);
private static final Color white = new Color(255, 255, 255);
private static final ArrayList&lt;Color&gt; colorList = new ArrayList&lt;&gt;();
private static double amountOfSets;

public ImageCollection(int numberOfRows, int numberOfColumns, double xResolution, double yResolution) {
    int typeIntRGB = 1;
    colorList.add(red);
    colorList.add(green);
    colorList.add(blue);
    colorList.add(white);
    ImageCollection.pointYResolution = Math.floor(yResolution / numberOfRows);
    ImageCollection.pointXResolution = Math.floor(xResolution / numberOfColumns);
    ImageCollection.width = (int) xResolution;
    ImageCollection.height = (int) yResolution;
    ImageCollection.height = (int) yResolution;
    int amountOfXPoints = numberOfRows;
    double amountOfYPoints = numberOfColumns;
    int rightPosition = width;
    int leftPosition = 0;
    ImageCollection.amountOfSets = Math.floor(height / (2 * (colorList.size()) * pointYResolution));
    for (int i = 0; i &lt; amountOfSets; i++) {
        BufferedImage image = new BufferedImage(width, height, typeIntRGB);
        for (Color currentColor : colorList) {
            rightPosition-=pointXResolution;
            leftPosition+=pointXResolution;
            int otherPointer = 0;
            for (int k = 1; k &lt; amountOfYPoints + 1; k++) {
                image.setRGB(leftPosition, (int) (k * pointYResolution), currentColor.getRGB());
                image.setRGB(rightPosition, (int) (k * pointYResolution), currentColor.getRGB());
            }
        }
        ImageList.add(image);
    }
}

@Override
public Iterator&lt;BufferedImage&gt; iterator() {
    Iterator&lt;BufferedImage&gt; nextImage = ImageList.iterator();
    return nextImage;
}
}
Skip the object wrapper. Generate the images list in a static function or a method and return it as is or return its iterator or stream if that is how you like it. Or return a custom iterator or stream that generates the images.

Consider re-factoring the looping code. Three loops is a bit too much in the same place. Extract the outer one to a function/method.

Several values are computed multiple times. '(k * pointYResolution)' and 'currentColor.getRGB()' for example. Store them in variables.

'ImageList' should be 'imageList' in java naming. 

Add final to all variables that re not changing.

JavaDoc do you use it?

Make sure buffered image can hold the size of data you need. Some graphics buffers will scale up to a rectangle with a side power of 2 greater than what you ask and can potentially eat a lot of memory. I have no idea if this is applicable to this case here.