source: trunk/gsdl/src/java/org/nzdl/gsdl/GsdlCollageApplet/DisplayImages.java@ 6816

package org.nzdl.gsdl.GsdlCollageApplet;

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

/** 
 *  @author Katrina Edgar
 *  @author David Bainbridge
 *
 *  Retrieves images from the download thread, determines an appropriate position
 *  for these images onscreen ensuring maximum whitespace coverage and minimal overlap
 *  when possible. Draws images using advanced image processing techniques when applicable,
 *  such as fading the edges of an image and discolouring backgrounds. Also re-uses images
 *  from those that have previously been displayed, or are aging onscreen, in order to
 *  to create movement when no new images have been downloaded. */
public class DisplayImages extends Thread {

    /** Decrements the alpha value between adjacent rows on the edge of an image<br>
     *  Used to fade the edges faster than the rest of the image <br>
     *  Only used when java2 parameter is true and advanced image processing
     *  techniques may be applied */
    static final int FADEVALUE = 3;
    /** Defines the number of shades of white used to colour the backgrounds of white images <br>
     *  These colours are used because when several white images appear in the collage
     *  simultaneously it is difficult to distinguish their edges<br>
     *  Only used when java2 parameter is true and advanced image processing
     *  techniques may be applied */
    static final int NO_OF_COLORS = 7;

    /** Will fire a removal operation when 4 images in the collage overlap a single area */
    static final int NO_IMAGES_OF_OVERLAP = 4;
    
    /** To determine if there are several images overlapped, can remove the
     *  layers underneath to save time in repainting */
    boolean overlap = false;

    /** Refers to download thread */
    DownloadImages download_images_ = null;
    /** Refers to applet */
    GsdlCollageApplet app_ = null;
    /** Applets width on screen */
    public static int app_x_dim_  = 0;
    /** Applets height on screen */
    public static int app_y_dim_  = 0;
    
    /** Background colour of the applet screen */
    Color bgcolor_        = null;
    /** Indicates whether java2 functionality should be used <br>
     *  If true will allow advanced image processing techniques to occur, 
     *  such as fading and colouring using pixel manipulation <br>
     *  If false, images will maintain an alpha value of 1 (appear solid), 
     *  newer images will simply be pasted on top of existing images <br> */
    boolean is_java2_     = false;
    /** Holds images currently on display in the applet */
    Vector inuse_    = null;
    /** Holds previously displayed images for re-use */
    Vector notinuse_ = null;
   
    Image      screen_buffer_  = null;
    Graphics screen_graphic_   = null;
    Image    finished_buffer_  = null;
    Graphics finished_graphic_ = null;

    /** Used to determine where to place new images on the applet to optimize
     *  whitespace coverage <br>
     *  A co-ordinate in the applet has a value of zero if it is whitespace,
     *  one if it is covered by one image, two if it is covered by two images,
     *  and so on. New images will be placed such that they cover the largest
     *  area of whitespace (zero valued co-ordinates) */
    public static int [] [] used_space = null;
    
    /** Defines the shades of white used to colour the backgrounds of white images <br>
     *  These colours are used because when several white images appear in the collage
     *  simultaneously it is difficult to distinguish their edges<br>
     *  Only used when java2 parameter is true and advanced image processing
     *  techniques may be applied */
    int colorMask [] = {0xF8FFFF, 0xFFF8FF, 0xFFFFF8, 0xF8F8FF, 0xFFF8F8, 0xF8FFF8, 0xFAFAFA};

    /**
     *  Starts the display images thread. Initialises variables using parameters and
     *  static values. Creates the blank applet screen, initialises the used space
     *  2D array to indicate that there are no images onscreen
     *
     *  @param app the applet to display the images on
     *  @param download_images thread from which to retrieve downloaded images
     *  @param is_java2 whether advanced image processing techniques should be used
     *  @param bgcolor the background colour of the applet screen */
    public DisplayImages(GsdlCollageApplet app, 
             DownloadImages download_images, boolean is_java2, Color bgcolor)
    {
    super("DisplayImages");

    // parameters saved locally
    app_             = app;
    download_images_ = download_images;
    is_java2_        = is_java2;
    bgcolor_         = bgcolor;

    inuse_    = new Vector();
    notinuse_ = new Vector();

    // sets width and height
    if (is_java2_)
    {
        app_x_dim_  = app_.getWidth();
        app_y_dim_  = app_.getHeight();
    }
    else
    {
        app_x_dim_  = 645;
        app_y_dim_  = 780;
    }

    // creates initial screen
    screen_buffer_ = app_.createImage(app_x_dim_, app_y_dim_); 
    screen_graphic_ = screen_buffer_.getGraphics();
    screen_graphic_.setColor(bgcolor_);
    screen_graphic_.fillRect(0,0,app_x_dim_,app_y_dim_);
    
    finished_buffer_  = app_.createImage(app_x_dim_, app_y_dim_);
    finished_graphic_ = finished_buffer_.getGraphics();
    
    // initialises used space array to indicate an empty screen
    used_space = new int [app_x_dim_][app_y_dim_];  
    for (int n=0; n < app_x_dim_; n++)
        for (int m=0; m < app_y_dim_; m++)
        used_space[n][m] = 0;

    }

    /** Determines what the user has clicked on in the applet, either an image or whitespace
     *  @param x the x co-ordinate of the mouse
     *  @param y the y co-ordinate of the mouse
     *  @return the image that the user has clicked on or null if the user has clicked whitespace */
    public CollageImage clickedOnImage(int x, int y)
    {
    if (app_.verbosity() > 1)
    {
        System.err.print("Checking for clicked on image: ("+x+","+y+")");
    }

    int no_images = inuse_.size() - 1;
    // checks from last image down, as last images place will be at the top of the collage
    for (int i= no_images; i >= 0; i--)
    {
        CollageImage collage_image = (CollageImage)inuse_.elementAt(i);
        if (collage_image.inside(x,y))
        {
        return collage_image;
        }
    }
    // no image at these co-ordinates, just whitespace
    return null;
    }

    /** Generates the images onscreen.
     *  Loops through the vector of currently displayed images and draws each one in turn.
     *  If the image is being drawn for the first time, its position will be determined
     *  and its alpha channel set as solid prior to drawing. <br>
     *  Drawing of the image will depend on whether or not java2 is enabled. If so then
     *  the image will be processed so that fading occurs with age, so that the edges 
     *  fade faster than the rest of the image and so that white images are slightly 
     *  discoloured to allow distinction. If java2 is not enabled, new images will simply
     *  be pasted on top of existing images without any special effects occuring<br>
     *  This function also deletes old images. If java2 is enabled then images are deleted
     *  once they have faded to a suitably low alpha value. If java2 is not enabled then
     *  images will be removed once there are greater than 25 images onscreen, to ensure
     *  the applet cannot be overloaded. */
    public synchronized void display_collage() 
    {
    // get the number of images currently in the collage
    final int no_images = inuse_.size();

    // if there is nothing new to add
    if (no_images==0) return;
    
    
    // otherwise need to re-generate images
    if (app_.verbosity() > 3)
    {
        System.err.print("Regenerating images:");
    }
    
    // get each image currently onscreen inturn
    for (int i=0; i<no_images; i++)
    {
        CollageImage collage_image = (CollageImage)inuse_.elementAt(i);

        Image image = collage_image.image_;
        // images x and y dimensions
        int image_x_dim = image.getWidth(app_);
        int image_y_dim = image.getHeight(app_);

        if ((image_x_dim>0) && (image_y_dim>0))
        {
        // the first time the image is painted, determine its position and size
        if (collage_image.fresh == true)
            {
            // first time => randomly place doc
            collage_image.setDimensions(image_x_dim,image_y_dim);
            
            // places and sizes the image
            MyAffineTransform af = new MyAffineTransform(image_x_dim,image_y_dim);
            
            // sets location & size of collage image
            collage_image.setAffineTransform(af, is_java2_);
            
            if (is_java2_) {
                
                collage_image.image_ = restoreAlpha(collage_image.image_, 0, 0, 
                                collage_image.image_x_dim_, collage_image.image_y_dim_); 
            }
            
            
            }
        
        // advanced image processing may be used
        if (is_java2_)
        {
            // conducts fading and colouring of image
            Image img = handlepixels(collage_image.image_, 0, 0, collage_image.image_x_dim_, 
                         collage_image.image_y_dim_, i, collage_image.fresh ); 
            collage_image.image_ = img;
           
        }
        if (collage_image.fresh)
                collage_image.fresh = false;
           
        }
        //finished_graphic_.drawImage(screen_buffer_,0,0,app_);
    
    }   
    
    // draws the finished image onscreen
    finished_graphic_.drawImage(screen_buffer_,0,0,app_);
    remove_old_images();
    }

    /** loops through removing oldest images and reduces number of images if excessive overlap is occuring */
    void remove_old_images() {

    // loops through removing oldest images that have almost faded completely
    // and restricting the size of a simple collage to 25 images
    int i=0;
    while (i<inuse_.size())
    {
        CollageImage collage_image = (CollageImage)inuse_.elementAt(i);
        
        // if we remove when images have faded too much
        if (is_java2_) {
        if (checkFaded(collage_image.image_, 0, 0, collage_image.image_x_dim_, collage_image.image_y_dim_) || overlap)
            {
            overlap = false;

            CollageImage removed_image = (CollageImage)inuse_.elementAt(i);
            inuse_.removeElementAt(i);

            // restores alpha channel to represent a solid image
            Image img = restoreAlpha(removed_image.image_, 0, 0, removed_image.image_x_dim_, removed_image.image_y_dim_); 
            
            // indicates space for this image is no longer used
            for (int n = removed_image.xl_; n < (removed_image.xl_ + removed_image.image_x_dim_); n++)
                for (int m = removed_image.yt_; m < (removed_image.yt_ + removed_image.image_y_dim_); m++)
                if(used_space[n][m] != 0) {
                    used_space[n][m]--;
                    if (used_space[n][m] > NO_IMAGES_OF_OVERLAP)
                    overlap = true;
                }

            // sets the image as fresh and adds it to the vector of images previously seen
            removed_image.image_ = img;
            removed_image.fresh = true;
            notinuse_.addElement(removed_image);
            }
        else {
            i++;
        }
        }
        // if we remove to prevent too many images being displayed simultaneously
        else {
        if (inuse_.size() > 25 || overlap) {
            overlap = false;

            CollageImage removed_image = (CollageImage)inuse_.elementAt(i);
            inuse_.removeElementAt(i);

            // indicates space for this image is no longer used
            for (int n = removed_image.xl_; n < (removed_image.xl_ + removed_image.image_x_dim_); n++)
            for (int m = removed_image.yt_; m < (removed_image.yt_ + removed_image.image_y_dim_); m++)
                if(used_space[n][m] != 0) {
                used_space[n][m]--;
                if (used_space[n][m] > NO_IMAGES_OF_OVERLAP)
                    overlap = true;
                }
            
            // sets the image as fresh and adds it to the vector of images previously seen
            removed_image.fresh = true;
            notinuse_.addElement(removed_image);
        }
        else {
            i++;
        }
        }
    }

    }

    /** Alters the images currently on display in the applet <br>
     *  Changes are prioritised in the following way:
     *  1. If there are images that have been downloaded and are yet to be displayed 
     *  they will be added to the list of images in use. <br>
     *  2. Otherwise if there are images that have previously been displayed but
     *  are not currently on the applet screen, re-use one of these images. <br>
     *  3. Otherwise if there are any images on screen at all, take the oldest and
     *  repaint it as the newest. <br>
     *  Then the collage is asked to display and repaint with the new image set. */
    void next_frame()
    {
    double random = Math.random();
    
    // if there is a new image in the downloaded vector
    if (download_images_.size()>0)
    {
        int position = (int) ((download_images_.size() - 1) * random);
        Image image;

        // get the image and it's associated url
        DownloadImages.ImageUrlTriple iutriple = download_images_.retrieve(position);
        image = iutriple.image();
        String from_url = iutriple.url();
        String img_name = iutriple.name();
        
        // prepare the image for collaging
        app_.prepareImage(image,app_);
        CollageImage collage_image = new CollageImage(image,from_url,img_name);
        
        // add it to the vector of images currently in use
        inuse_.addElement(collage_image);       
        
        if (app_.verbosity()>3)
        {
        System.err.println("Using a downloaded image");
        }
    }
    // use an image that has already been displayed but is no longer in the collage
    else if (notinuse_.size()>0)
    {
        int position = (int) ((notinuse_.size() - 1) * random);
        Image image;

        CollageImage collage_image = (CollageImage)notinuse_.elementAt(position);
        notinuse_.removeElementAt(position);
        inuse_.addElement(collage_image);

        if (app_.verbosity()>3)
        {
        System.err.println("Re-using an image not on screen");
        }
    }
    // otherwise repaint the first image as the last image
    else if (inuse_.size() > 0)
    {
        CollageImage removed_image = (CollageImage)inuse_.elementAt(0);
        
        // empty the picture from the grid
        for (int n = removed_image.xl_; n < (removed_image.xl_ + removed_image.image_x_dim_); n++)
        for (int m = removed_image.yt_; m < (removed_image.yt_ + removed_image.image_y_dim_); m++)
            used_space[n][m]--;

        // reset the alpha and add it
        removed_image.fresh = true;
        
        if (is_java2_) {
        removed_image.image_ = restoreAlpha(removed_image.image_, 0, 0, 
                            removed_image.image_x_dim_, removed_image.image_y_dim_); 
        }

        notinuse_.addElement(removed_image);
        inuse_.removeElementAt(0);
        
        if (app_.verbosity()>3)
        {
        System.err.println("Removing oldest image");
        }
    }
    else
        {
        if (app_.verbosity()>3)
            System.err.println("no images in download area");
        }
    
    display_collage();
    }

    /** Adjusts the colour and alpha value of an individual pixel <br>
     *  If the image is being drawn for the first time, the RGB values are
     *  extracted. If the pixel is close to white (RGB > 250) then an offwhite
     *  colour is applied to this pixel.
     *  This is done because when several white images appear in the collage
     *  simultaneously it is difficult to distinguish their edges. <br>
     *  This function also fades the alpha value of the pixel as the image ages.
     *  The alpha value is more heavily decremented as pixels get closer to the
     *  edge of the image
     *
     *  @param pixel the pixel to manipulate
     *  @param p the position of the image in collage (representative of age)
     *  @param fresh indicates whether or not the image is being drawn for the first time
     *  @param edge indicates whether or not this pixel is near the edge of the image
     *  @param fade the amount by which to fade this pixel
     *  @return the adjusted pixel as an int */
    public int handlesinglepixel(int pixel, int p, boolean fresh, boolean edge, int fade) {
    
    int newpixel = 0;

        //changes the colour of the picture, only when first drawn
    //and only if the pixel is close to white
    if (fresh) {
        
        int red   = (pixel >> 16) & 0xff;
        int green = (pixel >>  8) & 0xff;
        int blue  = (pixel      ) & 0xff;
        
        if (red >= 250 && green >= 250 && blue >= 250) {
        
        int c = colorMask[((int) (p%NO_OF_COLORS))];

        red = (c >> 16) & 0xff;
        green = (c >> 8) & 0xff;
        blue  = (c) & 0xff;
        }

        newpixel |= (red << 16) & 0x00ff0000;
        newpixel |= (green << 8) & 0x0000ff00;
        newpixel |= blue & 0x000000ff;
    }

    else {
        newpixel |= pixel & 0x00ffffff;
    }

    int alpha = (pixel >> 24) & 0xff;

    if (edge) {
        // fade the edges more...
        alpha = fade;
    }
    else if (alpha > 10 && !fresh) {
        alpha -= 10;
    }

    newpixel |= (alpha << 24) & 0xff000000;
    
    return (newpixel);
    }
    
    /** Fades and colours the image on a pixel-by-pixel basis <br>
     *  First it grabs the pixels of the entire image and stores them in a 2D array.
     *  Then a bound is calculated to indicate the point from which edge
     *  fading should occur. The position of the bound will change in proportion
     *  to the age of the image so that older images have a larger faded edge.
     *  The area within the bounds, that forms the center of the image, is processed
     *  first and faded by a standard alpha value. Then each edge of the image
     *  is processed separately, creating a gradient fade from the true edge to the
     *  position of the bound. <br>
     *  The faded pixel array is then turned into a new image a returned.
     *
     *  @param img the image that requires processing
     *  @param x the x co-ordinate of the image
     *  @param y the y co-ordinate of the image
     *  @param w the width of the image
     *  @param h the height of the image
     *  @param p the position of the image in the applet (indicates age)
     *  @param fresh whether the image is being processed for the first time */
    public Image handlepixels(Image img, int x, int y, int w, int h, int p, boolean fresh) {
    
    // declare an array to hold the pixels
    int[] pixels = new int[w * h];

    // get the pixels of the image into the pixels array
    PixelGrabber pg = new PixelGrabber(img, x, y, w, h, pixels, 0, w);
    try {
        pg.grabPixels();
    
    } catch (InterruptedException e) {
        System.err.println("interrupted waiting for pixels!");
        return img;
    }
    // check for any failures
    if ((pg.getStatus() & ImageObserver.ABORT) != 0) {
        System.err.println("image fetch aborted or errored");
        return img;
    }

    // calculates the bound from which fading should begin
    double bound = (inuse_.size() - p) * 0.01;
    if (w > h)
        bound *= w;
    else
        bound *= h;
    int upperboundheight = h - (int) bound;
    int upperboundwidth = w - (int) bound;
    int lowerbound = (int) bound;

    // loop through every pixel in the picture and handle it
    for (int j = lowerbound; j < upperboundheight; j++) {
        for (int i = lowerbound; i < upperboundwidth; i++) {
        // width and height: x+i y+j
        pixels[j * w + i] = handlesinglepixel(pixels[j * w + i], p, fresh, false, 255);
        }
    }

    int fade = 0;
    int fader = 0;
    int corealpha = (pixels[(h/2) * w + (w/2)] >> 24) & 0xff;
    
    // top edge
    for (int n = lowerbound; n >= 0; n--) {
        fader = corealpha - fade;
        if (fader < 0)
        fader = 0;
        
        for (int m = 0; m < w; m++)
        pixels[n * w + m] = handlesinglepixel(pixels[n * w + m], p, fresh, true, fader);
        
        fade+= FADEVALUE;
    }

    // bottom edge
    fade = 0;
    for (int n = upperboundheight; n < h; n++) {
        fader = corealpha - fade;
        if (fader < 0)
        fader = 0;
        for (int m = 0; m < w; m++)
        pixels[n * w + m] = handlesinglepixel(pixels[n * w + m], p, fresh, true, fader);
        
        fade += FADEVALUE;
    }

    // left edge
    fade = 0;
    for (int n = lowerbound; n >= 0; n--) {
        fader = corealpha - fade;
        if (fader < 0)
        fader = 0;
        for (int m = 0; m < h; m++) {
        if ( m < lowerbound && n > m);
        else if ( m > upperboundheight && n > (h - m));
        else 
            pixels[m * w + n] = handlesinglepixel(pixels[m * w + n], p, fresh, true, fader);
        }
        fade += FADEVALUE;    
    }
    
    // right edge
    fade = 0;
    for (int n = upperboundwidth; n < w; n++) {
        fader = corealpha - fade;
        if (fader < 0)
        fader = 0;
        for (int m = 0; m < h; m++) {
        if ( m < lowerbound && (w - n) > m);
        else if ( m > upperboundheight && (w - n) > (h - m));
        else 
            pixels[m * w + n] = handlesinglepixel(pixels[m * w + n], p, fresh, true, fader);
        }
        
        fade += FADEVALUE;
    }
   
    // set the pixels of the whole picture to the pixels array
    pg.setPixels(0, 0, w, h, pg.getColorModel(), pixels, 0, w);

    // create the new image and return it
    return( app_.createImage(new MemoryImageSource(w, h, pixels, 0, w)) );
    
    }

    /** Resets the alpha channel of an image so that it appears solid
     *
     *  @param img the image to restore
     *  @param x the x co-ordinate of the image
     *  @param y the y co-ordinate of the image
     *  @param w the width of the image
     *  @param h the height of the image */
    public Image restoreAlpha(Image img, int x, int y, int w, int h) {
    
    // declare an array to hold the pixels
    int[] pixels = new int[w * h];

    // get the pixels of the image into the pixels array
    PixelGrabber pg = new PixelGrabber(img, x, y, w, h, pixels, 0, w);
    try {
        pg.grabPixels();
    
    } catch (InterruptedException e) {
        System.err.println("interrupted waiting for pixels!");
        return img;
    }
    // check for any failures
    if ((pg.getStatus() & ImageObserver.ABORT) != 0) {
        System.err.println("image fetch aborted or errored");
        return img;
    }

    // loop through every pixel in the picture and handle it
    for (int j = 0; j < h; j++) {
        for (int i = 0; i < w; i++) {
        pixels[j * w + i] |= (255 << 24) & 0xff000000;
        }
    }

    // set the pixels of the whole picture to the pixels array
    pg.setPixels(0, 0, w, h, pg.getColorModel(), pixels, 0, w);

    // create the new image and return it
    return( app_.createImage(new MemoryImageSource(w, h, pixels, 0, w)) );
    
    }

    /** Checks whether an image has faded to the point where it must be removed
     *  from the collage.
     *
     *  @param img the image to restore
     *  @param x the x co-ordinate of the image
     *  @param y the y co-ordinate of the image
     *  @param w the width of the image
     *  @param h the height of the image */
    public boolean checkFaded (Image img, int x, int y, int w, int h) {

     if (w == 0 || h == 0) 
         return false;
    
    // declare an array to hold the pixels
    int[] pixels = new int[w * h];

    // get the pixels of the image into the pixels array
    PixelGrabber pg = new PixelGrabber(img, x, y, w, h, pixels, 0, w);
    try {
        pg.grabPixels();
    
    } catch (InterruptedException e) {
        System.err.println("interrupted waiting for pixels!");
        return false;
    }
    // check for any failures
    if ((pg.getStatus() & ImageObserver.ABORT) != 0) {
        System.err.println("image fetch aborted or errored");
        return false;
    }

    // get the alpha value of the middle pixel of the image
    int corealpha = (pixels[(h/2) * w + (w/2)] >> 24) & 0xff;
    
    if (corealpha < 50)
        return true;

    return false;
    
    }

    /** Paints the applet on the screen */
    public synchronized void paint(Graphics g)
    {
    //System.err.println("......" + is_java2_);

    screen_graphic_.setColor(bgcolor_);
    screen_graphic_.fillRect(0,0,app_x_dim_,app_y_dim_);
    
    int n = inuse_.size();
    
    // get each image currently onscreen inturn
    for (int i=0; i < n; i++)
        {
        CollageImage collage_image = (CollageImage)inuse_.elementAt(i);
        // don't paint new images yet
        if (collage_image.fresh)
            System.err.println("doing nothing... " + i + " " + n);

        // advanced image processing may be used
        else if (is_java2_)
            {
            // the alphacomposite controls the blending of these two images.
            Graphics2D sg2d = (Graphics2D)screen_graphic_;
            //sg2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
            sg2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, 
                          RenderingHints.VALUE_ANTIALIAS_ON); 
            collage_image.expand();
            sg2d.drawImage(collage_image.image_, collage_image.af_, app_);
            }
        // simple image collage
        else
            {
            // System.err.println("patu");
            // add the image to the collage
            screen_graphic_.drawImage(collage_image.image_, 
                          collage_image.xl_, collage_image.yt_,
                          collage_image.xr_, collage_image.yb_,
                          0,0,collage_image.image_x_dim_-1,
                          collage_image.image_y_dim_-1,  app_);
       
            }
        
        
        }
    
        
    finished_graphic_.drawImage(screen_buffer_,0,0,app_);
    
    if (finished_buffer_ != null)
        {
        g.drawImage(finished_buffer_, 0, 0, app_);
        }
    }

    /** Runs display thread by repeatedly calling the next frame,
     *  waiting for a specified delay period between calls */
    public void run() 
    {
    try {

        System.err.println("Running display thread");

        Thread curr_thread = Thread.currentThread();
        
        //long tm = System.currentTimeMillis();
    
        while (curr_thread == this) {
        next_frame();
        //tm += app_.refreshDelay();
        //Thread.sleep(Math.max(0, tm - System.currentTimeMillis()));
        Thread.sleep(app_.refreshDelay());
        //Thread.sleep(2);
        curr_thread = Thread.currentThread();
        }

        System.err.println("Display thread finished");
        
    } catch (Exception e) {
        e.printStackTrace();
    }
    }
}