import java.awt.*;

import java.applet.*;

import java.util.*;



/*

 A colourful demonstration of SOFM



 Written by Simon Lucas (email sml@essex.ac.uk)

 Permission is granted to copy and modify this code as desired.



 The aim here is to capture the spirit of SOFM - I've

 not really paid much attention to the details e.g.

 choice of neighbourhood function - you can play with

 this by modifying the weight equation in the synapse constructor.



 The design of this is quite neat and simple - but I lose

 marks for passing a Graphics object around the SOFM implementation.

 This was done for reasons of efficiency - better to just update

 the cell colours as they change rather repaint the entire map each

 time.



 A better way to do this would be to define cell, synapse and map without

 any reference to a Graphics object, then subclass them with graphical versions.



*/



class synapse {

  // this class models a weighted connection to a cell

  double weight;

  static double sharpness = 2.0; // higher values give sharper cutoff

  cell c;



  public static double sigmoid(double x) {

    return 1.0 / (1.0 + Math.exp(-x));

  }



  public synapse(cell c, double dist) {

    weight = 0.2 * sigmoid((sofm.limit - sharpness*dist)/sharpness);

    // weight = 0.2 / (1.0 + dist); // use simple function

    this.c = c;

  }



  public void update(double[] v, Graphics g) {

    c.update(v, map.rate*weight, g);

  }

}



class cell {

  // has three basic properties: a grid position (gridv)

  // an input space position (ipv)

  // and a set of neighbours (stored in a java.util.Vector)



  double[] gridv;

  double[] ipv;

  int d;

  static int neighboursEstimate = 30; // a rough estimate of number of neighbours - will grow automatically if needed to

  Vector neighbours;  // more of a list than a vector!



  public cell(int d, int x, int y) {

    // construct a cell with a d-dimensional randomly initialised vector at

    // point x,y on the grid

    ipv = new double[d];

    gridv = new double[2];

    gridv[0] = (double) x;

    gridv[1] = (double) y;

    this.d = d;

    randCell();

    neighbours = new Vector(neighboursEstimate);

  }



  public void randCell() {

    for (int i=0; i<d; i++)

      ipv[i] = Math.random();

  }



  public void addNeighbour(cell c) {

    neighbours.addElement(new synapse(c, dist(gridv, c.gridv)));

  }



  public void removeNeighbours() {

    neighbours.removeAllElements();

  }



  public void updateNeighbours(double[] v, Graphics g) {

    // iterate over set of neighbours updating them

    // in proportion to the connection weight

    // now clearly identify the winner i.e. this cell

    g.setColor(map.v2c(v));

    g.fillOval((int)gridv[0]*map.size, (int)gridv[1]*map.size, map.size, map.size);

    g.setColor(Color.black);

    g.drawOval(1+(int)gridv[0]*map.size, 1+(int)gridv[1]*map.size, map.size-2, map.size-2);

    try {Thread.sleep(100); }

    catch (Exception e) {}

    for (Enumeration e = neighbours.elements(); e.hasMoreElements(); )

      ((synapse) e.nextElement()).update(v, g);

  }



  public void update(double[] v, double w, Graphics g) {

    // updates the vector of this cell using a weighted average

    // of the current cell vector (ipv) and v

    for (int i=0; i<d; i++) {

      ipv[i] = (1.0 - w) * ipv[i] + w * v[i];

      g.setColor(map.v2c(ipv));

      g.fillRect((int)gridv[0]*map.size, (int)gridv[1]*map.size, map.size, map.size);

    }

  }



  public static double sqr (double x) {

    return x * x;

  }



  public static double dist(double[] x, double[] y) {

    double dis = 0.0;

    for (int i=0; i<x.length; i++)

      dis += sqr(x[i] - y[i]);

    return Math.sqrt(dis);

  }



  public double dist(double[] v) {

    return dist(ipv, v);

  }



}



class map {

  // this class is to model the 2-d map with the underlying vectors

  // can be set up to be a grid, each with a random neuron

  // then each time, update it according to the chosen input vector



  // this follows the cycle of pick winner, update neighbours

  // (each cell includes itself in its set of neighbours)



  int d; // d is the number of dimensions in input

  int n; // n is the number of points on the grid

  // cell[][] points;

  static int size = 40;  // number of pixels to use for each cell when drawing it

  static double rate;

  static double decayFac = 0.99; // no weight decay at present



  Vector cells;



  public map(int d, int n) {

    this.n = n;

    this.d = d;

    cells = new Vector(n*n);

    rate = 1.0;

    makeMap();

    setNeighbours();

  }



  public void makeMap() {

    for (int i=0; i<n; i++)

      for (int j=0; j<n; j++)

        cells.addElement(new cell(d, i, j));

  }



  public void reset() {

    rate = 1.0;

    for (Enumeration e = cells.elements(); e.hasMoreElements();)

      ((cell) e.nextElement()).randCell();

  }





  public void setNeighbours() {

    for (Enumeration e = cells.elements(); e.hasMoreElements();)

      cellNeighbours((cell) e.nextElement());

  }



  public void cellNeighbours(cell c) {

    c.removeNeighbours();

    for (Enumeration e = cells.elements(); e.hasMoreElements();) {

      cell cand = (cell) e.nextElement(); // cand is current candidate

      if (cell.dist(c.gridv, cand.gridv) < sofm.limit)

        c.addNeighbour(cand);

    }

  }



  public cell getWinner(double[] v) {

    double minDist = 100000.0; // choose this to be much bigger than a feasible distance

    cell choice = null;

    for (Enumeration e = cells.elements(); e.hasMoreElements();) {

      cell cand = (cell) e.nextElement(); // cand is current candidate

      double curDist = cand.dist(v);

      if (curDist < minDist) {

        choice = cand;

        minDist = curDist;

      }

    }

    return choice;

  }



  public void updateMap(Color c, Graphics g) {

    update(c2v(c), g); // convert the colour to a vector

  }



  public void update(double[] v, Graphics g) {

    cell winner = getWinner(v);

    winner.updateNeighbours(v, g); // query this

    rate *= decayFac;

  }



  public static double[] c2v(Color c) {

    double[] v = new double[3];

    v[0] = (double) c.getRed() / 255.0;

    v[1] = (double) c.getGreen() / 255.0;

    v[2] = (double) c.getBlue() / 255.0;

    return v;

  }



  public static Color v2c(double[] v) {

    return new Color((float) v[0], (float) v[1], (float) v[2]);

  }



  public void paint(Graphics g) {

    for (Enumeration e = cells.elements(); e.hasMoreElements();) {

      cell c = (cell) e.nextElement();

      g.setColor(v2c(c.ipv));

      g.fillRect((int)c.gridv[0]*size, (int)c.gridv[1]*size, size, size);

    }

  }

}



public class sofm extends Applet implements Runnable {

  map sorg;

  Thread animator;



  int nCols = 8;

  Color[] cols = new Color[8];

  static double limit=5.0;

  int sleepTime = 10;



  Button start, stop, reset;

  Choice neighbourhood, decay, speed; // decay not used

  Panel buttons;







  public void init() {

    setControlPanel();

    initColors();

    sorg = new map(3,10);

    animator = new Thread(this);

    animator.start();

  }



  public void setControlPanel() {

    setLayout(new BorderLayout());

    buttons = new Panel();

    start = new Button("start");

    stop = new Button("stop");

    reset = new Button("reset");



    neighbourhood = new Choice();

    neighbourhood.addItem("1.0");

    neighbourhood.addItem("2.0");

    neighbourhood.addItem("3.0");

    neighbourhood.addItem("5.0");

    neighbourhood.addItem("7.0");

    neighbourhood.addItem("10.0");

    neighbourhood.select("5.0");



    speed = new Choice();

    speed.addItem("fast");

    speed.addItem("slow");

    speed.select("fast");



    buttons.add(new Label("Radius"));

    buttons.add(neighbourhood);

    buttons.add(start);

    buttons.add(stop);

    buttons.add(reset);

    buttons.add(speed);

    add("South", buttons);

  }



  public void initColors() {

    cols[0] = Color.red;

    cols[1] = Color.blue;

    cols[2] = Color.green;

    cols[3] = Color.white;

    cols[4] = Color.black;

    cols[5] = Color.magenta;

    cols[6] = Color.pink;

    cols[7] = Color.yellow;

  }



  public static int randInt(int range) {

    return (int) (Math.random() * (double) range);

  }



  public void paint(Graphics g) {

    validate();

    sorg.paint(g);

  }



  public boolean handleEvent(Event event) {

    // use 1.0 event model for maxmimum browser compatibilty

    if (event.id == Event.ACTION_EVENT) {

      if (event.target == start) {

        // System.out.println("start");

        animator.resume();

        return true;

      }

      if (event.target == stop) {

        animator.suspend();

        return true;

      }

      if (event.target == reset) {

        sorg.reset();

        repaint();

        return true;

      }

      if (event.target == speed) {

        String s = speed.getSelectedItem();

        if (s.equals("slow"))

          sleepTime = 1000;

        else

          sleepTime = 10;

        return true;

      }



      if (event.target == neighbourhood) {

        limit = new Double(neighbourhood.getSelectedItem()).doubleValue();

        // System.out.println(limit);

        sorg.setNeighbours();

        return true;

      }

    }

    return super.handleEvent(event);

  }



  public void run() {

    sorg.paint(getGraphics());

    while(true) {

      Color current = cols[randInt(nCols)];

      Graphics g = getGraphics();

      g.setColor(current);

      g.fillRect(180, 410, 40, 30); // lazy - ouch!

      sorg.updateMap(current, g);

      try { Thread.sleep(sleepTime); }

      catch (Exception e) {

        System.out.println(e);

      }

    }

  }

}