// DO NOT REPRODUCE WITHOUT PERMISSION - HMC JULY 2000

/* This applet illustrates the behaviour of a simple
   self-organizing map in organizing three-dimensional
   data.

   The data consist of randomly-generated triples of values
   of r, theta and phi, where the range of r is 0-355,
   theta is 0-8 and phi 0-3. These data are then used to
   calculate values for the Cartesian coordinates x, y and z.

   At each node in the map, a triplet of weights
   is stored. When the applet draws to the screen, a
   blob is placed at the coordinates of the node,
   drawn in a colour determined by (x, y, z), the
   weights developed at each node

   HMC July 2000. */
 
import java.applet.*;
import java.awt.*;
import java.util.Random;

public class coloursom extends Applet implements Runnable {
    
    double som_weights[][][] = new double[30][30][3];
    double a,xa,ya,za,mult1,mult2,adjustment,diff,bestdiff,scale,rubble;
    double r,theta,phi,complexity;
    int i,j,k,l,w,h,besti,bestj,cycle,mapsize,mapsize1,nodex,nodey;
    boolean paused, show_weights;
    boolean please_stop=false;

    Random rs = new Random();
    Choice choice;
    Button pausebutton,resetbutton; 
    Font font;
    Image offscreen;
    int imagewidth, imageheight;
    Thread animator = null;
   
    public void init() {

// Make the font and widgets

        font = new Font("Helvetica", Font.BOLD, 16);
        resetbutton=new Button(" Reset ");
        this.add(resetbutton);
        choice = new Choice();
        choice.add("Adjust parameters.....");
        choice.add("Mapsize: 10 x 10");
        choice.add("Mapsize: 20 x 20");
        choice.add("Mapsize: 30 x 30");
        choice.add("Data complexity: 1");
        choice.add("Data complexity: 1.5");
        choice.add("Data complexity: 3");
        choice.add("Data complexity: 5");
        complexity=1.0;
        this.add(choice);
        pausebutton = new Button("   Start   ");
        pausebutton.setForeground(Color.red);
        this.add(pausebutton);

//  Initialize miscellaneous values

        paused=true;
        show_weights=false; 
        rubble=1000.0;
        mapsize=30;
        restart(); 
    }

    public void restart()
    {

// Initialize the node weights with random values between 1 and mapsize
 
        cycle=0;   
        mapsize1=mapsize-1;   
        scale=400.0/mapsize;
        for (i=0; i<mapsize; i++)
        {
            for (j=0; j<mapsize; j++)
            {
                som_weights[i][j][0]=1+(mapsize1)*rs.nextFloat();
                som_weights[i][j][1]=1+(mapsize1)*rs.nextFloat();
                som_weights[i][j][2]=1+(mapsize1)*rs.nextFloat();
            }
        }       
    }

//  Start the animation

    public void start() 
    { 
        animator = new Thread(this);
        animator.start();
    }
    
//  Stop the animation

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

    public boolean handleEvent(Event e) 
    {
        boolean mouseophandled;
        mouseophandled=false;

/* Handle the events. We need to check for an action
   event here, since merely moving the mouse over the
   display area generates an event, and if we do not filter
   those events out we shall get exceptions. */

        switch(e.id)
        {
            case e.ACTION_EVENT:
            if(e.target == choice) 
            {
               switch(choice.getSelectedIndex()-1)
               {
                   case 0: { mapsize=10; restart(); break;}
                   case 1: { mapsize=20; restart(); break;}
                   case 2: { mapsize=30; restart(); break;}
                   case 3: { complexity=1.0; break;}
                   case 4: { complexity=1.5; break; }
                   case 5: { complexity=3.0; break; }
                   case 6: { complexity=5.0; break; }
               } 
            }
            if(e.target == resetbutton) 
            {
                mouseophandled=true; // Mouse event handled
                restart();
            } 
           if (e.target == pausebutton)
           {
               mouseophandled=true;
               if (paused) 
               {
                   pausebutton.setLabel(" Pause ");
               }
               else
               {
                   pausebutton.setLabel(" Resume ");
               }
               paused=!paused;
           }
           case e.MOUSE_DOWN:
           {
               if(!mouseophandled) // Button pressed over map
               {

// e.x and e.y are the screen coordinates of the mouse

                   if (e.x>50 && e.x < 350 && e.y>50 && e.y<350)
                   {

// Find which node the mouse has been clicked on

                       nodex=(int)(((e.x-50)/300.0)*mapsize);
                       nodey=(int)(((e.y-50)/300.0)*mapsize);
                    }
                    show_weights=true;
                    return true;
                }
            }
        }
        super.handleEvent(e);
        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.fillRect(48,48,304,304);
        g.setColor(new Color(140,117,128));
        g.fillRect(49,49,303,302);
        g.setFont(font); 
        g.drawString("Cycle " + cycle, 40,375);
        if (show_weights) 
        {
            double wx,wy,wz;
            wx=((int)(som_weights[nodex][nodey][0]*10))/10.0;
            wy=((int)(som_weights[nodex][nodey][1]*10))/10.0;
            wz=((int)(som_weights[nodex][nodey][2]*10))/10.0;
            g.drawString("Node (" + nodex + "," + nodey + "): " + wx + "   " + wy
              + "   " + wz, 150, 375);
        }
        cycle++;

//  Cycle through all nodes, drawing them in the appropriate colour

        int jmul=300/mapsize;
        int c1,c2,c3;
        for (i=0; i<mapsize; i++)
        {
            for (j=0; j<mapsize; j++)
            {        
                c1=((int)(Math.abs(som_weights[i][j][0])))%255;
                c2=((int)(Math.abs(som_weights[i][j][1])))%255;
                c3=((int)(Math.abs(som_weights[i][j][2])))%255; 
                g.setColor(new Color(c1,c2,c3));
                g.fillRect(50+i*jmul,50+j*jmul,jmul-1,jmul-1);
            }
        }
    }

    public void run() 
    {
        while(!please_stop) 
        {
            Dimension d = this.size();
            if ((offscreen == null) || ((imagewidth != d.width) || (imageheight != d.height))) 
            {
                offscreen = this.createImage(d.width, d.height);
                imagewidth = d.width;
                imageheight = d.height;
            }
            
//  Here we evolve the map
   
            if (!paused)
            {
                adjustment=rubble/(200.0+(cycle*cycle)/150.0);
                for (int numbers=0; numbers<=5; numbers++)
                {

/* Generate values for r, theta and phi at random, then use
these to calculate the corresopndping Cartesian values xa, ya and za */

                    r=280.0*complexity*rs.nextFloat();
                    theta=8.0*rs.nextFloat();
                    phi=3.0*rs.nextFloat();
                    xa=r*Math.sin(theta)*Math.cos(phi);
                    ya=r*Math.sin(theta)*Math.sin(phi);
                    za=r*Math.cos(phi);
          
/* Find the winning node. We store its position
   in besti and bestj. */

                    besti=0;
                    bestj=0;
                    bestdiff=500.0;  // The best difference so far
                    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])
                              +Math.abs(za-som_weights[i][j][2]);
                            if (diff<bestdiff)
                            {
                                bestdiff=diff;
                                besti=i;
                                bestj=j;
                            }
                        }
                    }
                    mult1=0.5*adjustment;
            
/*  Update weights at the winning node and its neighbours. Obviously
  there is room to speed the code up, but speed of operation
  isn't important in this demonstration */

                    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;
                    som_weights[besti][bestj][2]=som_weights[besti][bestj][2]*(1.0-mult1)+mult1*za;
                    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;
                                    som_weights[i][j][2]=som_weights[i][j][2]*(1.0-mult1)+mult1*za;
                                }
                                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;
                                    som_weights[i][j][2]=som_weights[i][j][2]*(1.0-mult2)+mult1*za;
                                }
                            }
                        }
                    }
                }
          
// 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;
        }
    }
}