class KohonenSet{
  float learningRate= .5;
  int numNodes, numWeights;
  int vNodes, hNodes;
  float MAX_ITERATIONS = 500;
  int iterationCounter = 0;
  float neighborDist;
  float weightArray[][]; //an array of 'node' by 'weight' dimensions
  float kset[][];  //values to be sorted
  Integer ksetRandomOrder[];
  final float mapHeight= 730;

  void KohonenSet(){
  }

  void initWeights(int hNodes, int vNodes, int numWeights){
    weightArray = new float[vNodes*hNodes][numWeights];
    numNodes = vNodes*hNodes;
    this.hNodes = hNodes;
    this.vNodes = vNodes;
    this.numWeights = numWeights;
    for (int i=0; i<numNodes; i++){
      for (int j=0; j<numWeights; j++){
        weightArray[i][j] = random(255);
      }
    }
    ksetRandomOrder = new Integer[kset.length];
    for (int i=0; i<kset.length; i++){
      ksetRandomOrder[i] = new Integer(i);
    }
  }

  //Takes whatever values kset has and smooths each into a 0-255 scale
  //this makes each criteria in the sort equally weighted.
  void equalizeSortData(){
    float multiplier[] = new float[numWeights];
    float MAX[] = new float[numWeights];
    float MIN[] = new float[numWeights];
    for (int i=0; i<numWeights; i++){ //initialize MIN & MAX
      MAX[i]=0; //arbitrarily low
      MIN[i]=999999; //arbitrarily high
    }
    for (int item=0; item<kset.length; item++){ //find the MIN & MAX for each weight in the set
      for (int weight=0; weight<numWeights; weight++){
        if (kset[item][weight] > MAX[weight]) MAX[weight] = kset[item][weight];
        if (kset[item][weight] < MIN[weight]) MIN[weight] = kset[item][weight];
      }
    }
    for (int weight=0; weight<numWeights; weight++){ //get multiplier for each weight
      multiplier[weight] = 255/(MAX[weight] - MIN[weight]);
    }
    for (int item=0; item<kset.length; item++){ //adjust values in the set to a 0-255 scale
      for (int weight=0; weight<numWeights; weight++){
        kset[item][weight] = kset[item][weight] * multiplier[weight];
      }
    }
  }

  void train(){
    Collections.shuffle(Arrays.asList(ksetRandomOrder));    
    if (iterationCounter<MAX_ITERATIONS){
      //      neighborDist = 30+100-(100*(iterationCounter/MAX_ITERATIONS));  //alternate neighborDist
      neighborDist = 35+constrain(height/2-2*iterationCounter,0,height);
      for (int k=0; k<kset.length; k++){
        int bmu = bestMatchingUnit(ksetRandomOrder[k].intValue());
        crop[ksetRandomOrder[k].intValue()].bmu = bmu;   //  <------------
        for (int node=0; node<numNodes; node++){
          float nodeX = mapHeight/hNodes*(node%hNodes);
          float nodeY = mapHeight/vNodes*(node/hNodes);
          float bmuX = mapHeight/hNodes*(bmu%hNodes);
          float bmuY = mapHeight/vNodes*(bmu/hNodes);
          float nodeDist = constrain(dist(nodeX,nodeY,bmuX, bmuY),0,neighborDist);
          for (int i=0; i<numWeights; i++){
            if (nodeDist == 0){
              weightArray[node][i] = kset[ksetRandomOrder[k].intValue()][i];
            }
            else {
              float percent = learningRate*(1-(nodeDist/neighborDist));
              weightArray[node][i] = (1-percent)*weightArray[node][i] + percent*kset[ksetRandomOrder[k].intValue()][i];
            }
          }
        }
      }
    }
    iterationCounter++;
  }

  int bestMatchingUnit(int inputNode){
    int bmu=0; //arbitrary
    float bestFitDistance = 1000; //arbitrarily high
    for (int node=0; node<numNodes; node++){
      float sum = 0;
      for (int i=0; i<numWeights; i++){
        sum += sq(kset[inputNode][i]-weightArray[node][i]);
      }
      float distance = sqrt(sum);
      if (distance <= bestFitDistance){
        bestFitDistance = distance;
        bmu = node;
      }
    }
    return(bmu);
  }
  
  //This is the map i drew for the crop project.  each weight is drawn in a column.
  void drawListMap(color colorArray[]){
    background(BACKGROUND);
    float m=.5; //a multiplier for scaling output
    for(int node=0; node<numNodes; node++){
      pushMatrix();
      translate(0,mapHeight/vNodes*(node/hNodes));
      for (int i=0; i<numWeights; i++){
        fill(colorArray[i]);
        rect(i*130,0,m*weightArray[node][i],mapHeight/vNodes);
      }
      popMatrix();
    }
  }

  void drawBmuLabels(){
    float yInterval = mapHeight/kset.length;
    Crop orderList[] = new Crop[kset.length];
    for (int i=0; i<kset.length; i++){
     orderList[i] = crop[i];
    }
    Arrays.sort(orderList, bmuComp);
    for (int i=0; i<kset.length; i++){
      int place = i;
      float nodeY = (mapHeight/(2*vNodes))+mapHeight/vNodes*(orderList[i].bmu/hNodes);
      float placeY = (1+place)*yInterval;
      if (abs(mouseY-placeY-yInterval) <= yInterval/2) {
        textAlign(RIGHT);
        stroke(230,0,0);
        fill(255);
        pushMatrix();
        translate(255, nodeY-2);
        textSize(13);
        text(orderList[i].spn.size(), 0, 0);
        text(orderList[i].geono.size(), 130, 0);
        text(orderList[i].id.size(), 260, 0);
        text(f.format(100*(orderList[i].wild/(float)orderList[i].id.size()))+"%", 390, 0);
        text(f.format(100*(orderList[i].bred/(float)orderList[i].id.size()))+"%", 520, 0);
        text(f.format(100*(orderList[i].cultivar/(float)orderList[i].id.size()))+"%", 650, 0);
        popMatrix();
      }
      else {
        stroke(255, 30);
      }
      textSize(10);
      fill(255);
      textAlign(LEFT);
      text(orderList[i].name,0,placeY);
      line(0, 2+placeY, 50, 2+placeY);
      line(50, 2+placeY, 120, nodeY);
      line(120, nodeY, width-50, nodeY);
      noStroke();
    }
  }
}