// DO NOT REPRODUCE WITHOUT PERMISSION - HMC JULY 2000

/* Self-organizing map - square grid problem
   =========================================

   This applet illustrates the behaviour of a simple
   self-organizing map in the square grid problem.

   The data consist of randomly-generated pairs of values
   in the range 1 to mapsize, where the map is square,
   and of dimension mapsize x mapsize.

   At each node in the map, a pair of weights (wx,wy)
   is stored. When the applet draws to the screen, a
   red blob is placed at coordinates (wx,wy), and a line
   is drawn from each node to its neighbours on the
   map, wherever their own node weights have placed
   them.

   As the weights at neighbouring nodes become
   more alike, the nodes move towards each other, and
   the connecting lines grow shorter. Ultimately, if
   the parameters for the map have been chosen reasonably,
   the map should converge to a roughly square pattern.

   However, satisfactory convergence to a square depends
   strongly upon the size of the map, the rate of
   diminution of node weight changes, and other factors.

   HMC May 2000.
*/

import java.applet.*;
import java.awt.*;
import java.util.Random;

public class squaresom extends Applet implements Runnable {
    
// Define the variables

    double som_weights[][][] = new double[21][21][2];
    Random rs = new Random();
    double a,xa,ya,mult1,mult2,adjustment,diff,bestdiff,scale,rubble;
    int i,j,k,l,w,h,besti,bestj,cycle,mapsize,mapsize1,displacement;
    Choice choice;
    Button resetbutton, pausebutton;
    Font font;
    Image offscreen;
    Thread animator = null;
    boolean please_stop = false;
    boolean zeroweights, paused;
   
    public void init() 
    {

//  Make the widgets and the Font

        font = new Font("Helvetica", Font.BOLD, 20);
        resetbutton=new Button("Reset");
        this.add(resetbutton);
        choice = new Choice();
        choice.add("Adjust parameters.....");
        choice.add("Mapsize: 10");
        choice.add("Mapsize: 15");
        choice.add("Mapsize: 20");
        choice.add("Weight adjustment per cycle: 1");
        choice.add("Weight adjustment per cycle: 3");
        choice.add("Weight adjustment per cycle: 8");
        choice.add("Random initial weights");
        choice.add("Zero initial weights");
        this.add(choice);
        pausebutton = new Button("   Start   ");
        pausebutton.setForeground(Color.red);
        paused=true;
        this.add(pausebutton);

//  Initialize miscellaneous values
   
        rubble=300.0;
        mapsize=10; 
        displacement=80;
        zeroweights=false;
        restart(); 
    }

    public void restart()
    {

/* Set values of parameters which are revalued each run
   ====================================================

   Initialize the node weights with random values between 1 and mapsize.
   The first weight at each node corresponds to the x co-ordinate in the
   data, the second to the y co-ordinate. */
 
        cycle=0;
        mapsize1=mapsize-1;  
        scale=260.0/mapsize;  // chosen to keep the map on screen
        for (i=0; i<mapsize; i++)
        {
            for (j=0; j<mapsize; j++)
            {
                if (zeroweights)  // Nodes start with identical weights
                {
                    som_weights[i][j][0]= mapsize1/2;
                    som_weights[i][j][1]= mapsize1/2;
                }
                else              // Nodes start with random weights
                {
                    som_weights[i][j][0]=1+(mapsize1)*rs.nextFloat();
                    som_weights[i][j][1]=1+(mapsize1)*rs.nextFloat();
                }
            }
        }       
    }

    public void start() 
    { 
        animator = new Thread(this);
        animator.start();
    }

    public void stop() 
    { 
        if (animator != null) animator.stop();
        animator = null;
    }

    public boolean handleEvent(Event e) 
    {

// Handle any relevant events

        switch(e.id)
        {
            case e.ACTION_EVENT:
            if(e.target == resetbutton) 
            { 
                restart(); 
            }
            if (e.target == pausebutton)
            {
                if(paused) 
                {
                    pausebutton.setLabel(" Pause ");
                }
                else
                {
                    pausebutton.setLabel(" Resume ");
                }
                paused=!paused;
            }
            if(e.target == choice)
            {
                switch(choice.getSelectedIndex()-1)
                {
                    case 0: {mapsize=10; restart(); break;}
                    case 1: {mapsize=15; restart(); break;}
                    case 2: {mapsize=20; restart(); break;}
                    case 3: {rubble=100; break;}
                    case 4: {rubble=300; break;}
                    case 5: {rubble=800; break;}
                    case 6: {zeroweights=false; restart(); }
                    case 7: {zeroweights=true; restart(); }
                }
            }
            
        }
        return true;
    }

    public void paint(Graphics g) 
    {
        Dimension size = this.size();
        w=size.width;
        h=size.height;
        g.setColor(Color.white);
        g.fillRect(0, 0, w, h);
        g.setColor(Color.blue);
        g.drawRect(50,50,350,350);
        g.setFont(font);
        cycle++;

/* Draw the current set of node weights
   ====================================

   Cycle through all nodes, drawing lines between
   neighbouring nodes, and blobs for each node */

        for (i=0; i<mapsize; i++)
        {
            for (j=0; j<mapsize; j++)
            {
                xa=displacement+scale*som_weights[i][j][0];
                ya=displacement+scale*som_weights[i][j][1];
                k=i+1;
                if (k<mapsize)
                {
                    g.drawLine((int)xa,(int)ya,(int)(displacement+scale*som_weights[k][j][0]),
                      (int)(displacement+scale*som_weights[k][j][1]));
                    g.setColor(Color.red);
                    g.fillOval((int)xa-2,(int)ya-2,5,5);
                    g.setColor(Color.blue);
                }
                l=j+1;
                if (l<mapsize)
                {
                    g.drawLine((int)xa,(int)ya,(int)(displacement+scale*som_weights[i][l][0]),
                       (int)(displacement+scale*som_weights[i][l][1]));
                    g.setColor(Color.red);
                    g.fillOval((int)xa-2,(int)ya-2,5,5);
                    g.setColor(Color.blue);
                }    
            }
        }
        xa=displacement+scale*som_weights[0][0][0];
        ya=displacement+scale*som_weights[0][0][1];
        g.setColor(Color.red);
        g.fillOval((int)xa-2,(int)ya-2,5,5);
        xa=displacement+scale*som_weights[mapsize1][mapsize1][0];
        ya=displacement+scale*som_weights[mapsize1][mapsize1][1];
        g.fillOval((int)xa-2,(int)ya-2,5,5);
        g.setColor(Color.black);
        g.drawString("Cycle " + cycle, 80,390);
    }

    public void run() 
    {

// In this routine we perform the main calculation

        while(!please_stop)     // Loop forever
        {
            Dimension d = this.size();
            if ((offscreen == null))
            {
                offscreen = this.createImage(d.width, d.height);
            }

/* We have a 50 ms delay per cycle to slow down the calculation so we
   can see what is happening on fast machines. */

            Thread thread =  new Thread(this);
            try {Thread.sleep(50);} catch (InterruptedException e){}
            if (!paused) 
            {

/* The size of the adjustment to the weights each cycle depends
   upon an (arbitrarily-chosen) constant called rubble. It also depends
   on the number of cycles, since we wish the size of the adjustment to
   gradually diminish as the calculation proceeds. The form of
   the expression which defines the variable adjustment is not prescribed,
   and the values 200.0 and 150.0 in the line below, as well as the dependence 
   upon the square of the cycle number, can all be modified in order
   to test how convergence of the map is affected. */

                adjustment=rubble/(200.0+(cycle*cycle)/150.0);

/* Evolution of the map is rapid for small map sizes, so we only draw
   the state of the map every half dozen cycles. This "numbers" loop
   is included to do that, ensuring that we only reach the instructions
   to draw the map - which are included at the end of this routine - evry
   sixth cycle. */

                for (int numbers=0; numbers<=5; numbers++)
                {

/* Generate a random data point to feed into the map. */

                    xa=1.0+mapsize1*rs.nextFloat();
                    ya=1.0+mapsize1*rs.nextFloat();
          
/* Find the winning node
   =====================

   Its position is besti, bestj. */

                    besti=0;
                    bestj=0;

/* bestdiff is the smallest difference found in the current cycle between the
   mode weights and the current data point.  We start by setting it
   to a number much larger than any difference in the actual calculation
   will be. In this calculation we define the value of diff simply as
   the modulus of the difference between node weights and sample values,
   but we could alternatively use a Cartesian distance, for example. */

                    bestdiff=500.0; 
                    for (i=0; i<mapsize; i++)
                    {
                        for (j=0; j<mapsize; j++)
                        {
                            diff=Math.abs(xa-som_weights[i][j][0])+Math.abs(ya-som_weights[i][j][1]);

/* If diff is smaller than the best difference so far, update 
   bestdiff, and store the position of the winning node. */

                            if (diff<bestdiff)
                            {
                                bestdiff=diff;
                                besti=i;
                                bestj=j;
                            }
                        }
                    }
                    mult1=0.5*adjustment;
            
/*  Update the winning node and its neighbours
    ===========================================

   Weights at the winning node are updated by the largest amount, 
   the nearest and next nearest neighbours by smaller amounts.
   The code is very crude, but simple programming. Obviously
   there is room to speed the code up, but speed of operation
   isn't important in this demonstration. 

   In many SOMs the "neighbourhood" around each node within
   which weights are updated consists of the entire map at 
   the start of the calculation, and diminishes with time. 
   In this example the size of the neighbourhood remains 
   unchanged, although the size of the weight adjustment 
   diminishes as the calculation proceeds. */

                    som_weights[besti][bestj][0]=som_weights[besti][bestj][0]*(1.0-mult1)+mult1*xa;
                    som_weights[besti][bestj][1]=som_weights[besti][bestj][1]*(1.0-mult1)+mult1*ya;
                    mult1=0.3*adjustment;
                    mult2=0.06*adjustment;
                    for (i=besti-2; i<=besti+2; i++)
                    {
                        for (j=bestj-2; j<=bestj+2; j++)
                        {
                            if (i>=0 && i<mapsize && j>=0 && j<mapsize && !(besti==i && bestj==j))
                            {
                                if (i>besti-2 && i<besti+2 && j>bestj-2 && j<bestj+2)
                                {
                                    som_weights[i][j][0]=som_weights[i][j][0]*(1.0-mult1)+mult1*xa;
                                    som_weights[i][j][1]=som_weights[i][j][1]*(1.0-mult1)+mult1*ya;
                                }
                                else 
                                {
                                    som_weights[i][j][0]=som_weights[i][j][0]*(1.0-mult2)+mult2*xa;
                                    som_weights[i][j][1]=som_weights[i][j][1]*(1.0-mult2)+mult2*ya;
                                }
                            }
                        }
                    }
                }  
          
// Draw into the off-screen image, then copy it to the screen

                paint(offscreen.getGraphics());
                Graphics g = this.getGraphics();
                g.drawImage(offscreen, 0, 0, this);
            }
            animator = null;
        }
    }
}