Review of Raster Displays

• Display synchronized with CRT sweep
• Special memory for screen update
• Pixels are the discrete elements displayed
• Generally, updates are visible

High-end Graphics Display System

• Adds a second frame buffer
• Swaps durring vertical blanking
• Updates are invisible
• Costly

Implementing a Memory Raster Object

• Maintains a copy of the screen (or some part of it) in memory
• Relys on a fast copy
• Updates are nearly invisible
• Conceptual model of a physical object

A Java model of a memory raster:

import java.awt.*;
import java.awt.image.*;
import java.util.*;

• Indicates that we will use some of the classes (objects) in these packages
• Corresponds to a directory structure
• Directory hierarchies might be zipped up

class Raster implements ImageConsumer {
    public int width, height;
    public int pixel[];
    private ImageProducer producer;

• Define a new class (extends Object by default)
• Declare instance variables
• Permissions (public, protected, private, private protected, default)
  Flanagan pg. 73

    ///////////////////////// Constructors //////////////////////

    /**
     *  This constructor which takes no arguments
     *  allows for future extension.
     */
    public Raster()
    {
    }

    /**
     *  This constructor creates an uninitialized
     *  Raster Object of a given size (w x h).
     */
    public Raster(int w, int h)
    {
        width = w;
        height = h;
        pixel = new int[w*h];
    }

• Constructors are called when an instance of this class is created (via new)
• Example of Overloading
• You should almost always have a constructor that takes no arguments

Lets talk about Pixels

• We're going to store them as ints in the array called pixel[]
• We're using Java's standard model of a pixel

    /**
     *  This constructor creates an Raster initialized
     *  with the contents of an image.
     */
    public Raster(Image img)
    {
        producer = img.getSource();
        producer.addConsumer(this);
        producer.startProduction(this);
        waitForImage();
    }

• Images in Java are produced asynchronously (sometimes you don't care)
• Producers go get the bytes out of an image. Actually they avoid getting the bytes.
• Consumers care about the bytes in images and would like to some of them.
• Observers care about general the attributes of images (how big they are, if they are actually in memory yet), but often not what is inside of images.

    public synchronized void waitForImage() {
	    try {
	        wait( );
	    } catch (Exception e) {
	    };
    }

We're not leaving this construtor until we get an image!
But, well let some other Thread compute while we're waiting.

    public synchronized void imageComplete(int status)
    {
        producer.removeConsumer(this);
        notifyAll();
    }

    public void setProperties(Hashtable props)
    {
    }

    public void setColorModel(ColorModel model)
    {
    }

    public void setHints(int hintflags)
    {
    }

    public void setDimensions(int w, int h) {
        width = w;
        height = h;
        pixel = new int[w*h];
    }

Next we fulfill our obligations as an ImageConsumer
In other words we must implement these functions that are specified as part of the ImageConsumer interface (Flanagan pg. 274) in order to call ourselves an ImageConsumer.


• A interface is a contract
• It's okay to have empty methods.
• Interfaces don't have instace variables (but they might have final static class variables)

    public void setPixels(int x, int y, int w, int h, ColorModel cm, byte p[], int offset, int stride) {
        int i, j, delta;

        i = y*width+x;
        delta = width - w;
        while (h > 0) {
            for (j = 0; j < w; j++) {
                pixel[i++] = cm.getRGB(p[offset+j] & 255);
            }
            offset += stride;
            i += delta;
            h -= 1;
        }
    }

    public void setPixels(int x, int y, int w, int h, ColorModel cm, int p[], int offset, int stride) {
        int i, j, delta;

        i = y*width+x;
        delta = width - w;
        while (h > 0) {
            for (j = 0; j < w; j++) {
                pixel[i++] = cm.getRGB(p[offset+j]);
            }
            offset += stride;
            i += delta;
            h -= 1;
        }
    }

Here's where the work is done


• An ImageProducer might call these routines over and over again
• The p[] arrays are not necessarily the image sized
• Why a byte version, and a int version?
• ColorModel Objects
• Study this code, understand how it works.

    ////////////////////////// Methods //////////////////////////

    /**
     *  Returns the number of pixels in the Raster
     */
    public final int size( )
    {
        return width*height;
    }

    /**
     *  Fills a Raster with a solid color
     */
    public final void fill(Color c)
    {
        int s = size();
        int rgb = c.getRGB();
        for (int i = 0; i < s; i++)
            pixel[i] = rgb;
    }

These two simple methods add capabilites to our Raster Object.


• Notice that the fill() method calls the size() method
• We don't really need this call to size. Why?
• A Color object is passed

    /**
     *  Converts Rasters to Images
     */
    public final Image toImage(Component root)
    {
        return root.createImage(new MemoryImageSource(width, height, pixel, 0, width));
    }

This method makes an Image out of our pixel[] array


• You have to pass it an ImageObserver (somebody who cares)
• The MemoryImageSource object that we create here is an ImageProducer.

    /**
     *  Gets a pixel from a Raster
     */
    public final int getPixel(int x, int y)
    {
        return pixel[y*width+x];
    }

    /**
     *  Gets a color from a Raster
     */
    public final Color getColor(int x, int y)
    {
        return new Color(pixel[y*width+x]);
    }

    /**
     *  Sets a pixel to a given value
     */
    public final boolean setPixel(int pix, int x, int y)
    {
        pixel[y*width+x] = pix;
        return true;
    }

    /**
     *  Sets a pixel to a given color
     */
     public final boolean setColor(Color c, int x, int y)
     {
        pixel[y*width+x] = c.getRGB();
        return true;
     }

These last few methods allow us to get or modify specific pixels in our raster object.
• Notice the pixel address calculations
• A trade-off has been made between efficiency and correctness
  Do you see it? You might want to make a different choice in you code.

}

Here is a link to the java code for this Raster object. And here is an applet that uses it. Along with an HTML page that invokes the applet. You can go here to actually see it run.

Sprites...